Rewrite comp/middle/resolve.rs

* Cleans up the algorithm
 * Move first pass to walk (second still folds)
 * Support part of a type/value namespace split
   (crate metadata and module indices still need to be taught about this)
 * Remove a few blatant inefficiencies (import tables being recreated for
   every lookup, most importantly)

src/comp/front/ast.rs

@@ -403,7 +403,7 @@ type variant = spanned[variant_];
 type view_item = spanned[view_item_];
 tag view_item_ {
     view_item_use(ident, vec[@meta_item], def_id, Option.t[int]);
-    view_item_import(ident, vec[ident], def_id, Option.t[def]);
+    view_item_import(ident, vec[ident], def_id);
     view_item_export(ident);
 }
 
@@ -432,7 +432,7 @@ fn index_view_item(mod_index index, @view_item it) {
         case(ast.view_item_use(?id, _, _, _)) {
             index.insert(id, ast.mie_view_item(it));
         }
-        case(ast.view_item_import(?def_ident,_,_,_)) {
+        case(ast.view_item_import(?def_ident,_,_)) {
             index.insert(def_ident, ast.mie_view_item(it));
         }
         case(ast.view_item_export(_)) {
@@ -488,7 +488,7 @@ fn index_native_item(native_mod_index index, @native_item it) {
 
 fn index_native_view_item(native_mod_index index, @view_item it) {
     alt (it.node) {
-        case(ast.view_item_import(?def_ident,_,_,_)) {
+        case(ast.view_item_import(?def_ident,_,_)) {
             index.insert(def_ident, ast.nmie_view_item(it));
         }
         case(ast.view_item_export(_)) {

src/comp/front/creader.rs

@@ -635,14 +635,8 @@ fn list_crate_metadata(vec[u8] bytes, IO.writer out) {
 
 fn describe_def(&EBML.doc items, ast.def_id id) -> str {
     if (id._0 != 0) {ret "external";}
-    alt (maybe_find_item(id._1 as int, items)) {
-        case (Option.some[EBML.doc](?item)) {
-            ret item_kind_to_str(item_kind(item));
-        }
-        case (Option.none[EBML.doc]) {
-            ret "??"; // Native modules don't seem to get item entries.
-        }
-    }
+    auto item = find_item(id._1, items);
+    ret item_kind_to_str(item_kind(item));
 }
 
 fn item_kind_to_str(u8 kind) -> str {

src/comp/front/parser.rs

@@ -2309,8 +2309,7 @@ fn parse_rest_import_name(parser p, ast.ident first,
         }
     }
     auto import_decl = ast.view_item_import(defined_id, identifiers,
-                                            p.next_def_id(),
-                                            none[ast.def]);
+                                            p.next_def_id());
     ret @spanned(lo, hi, import_decl);
 }
 

src/comp/middle/fold.rs

@@ -291,8 +291,7 @@ type ast_fold[ENV] =
 
      (fn(&ENV e, &span sp, &ident i,
          &vec[ident] idents,
-         &def_id id,
-         &Option.t[def]) -> @view_item)           fold_view_item_import,
+         &def_id id) -> @view_item)               fold_view_item_import,
 
      (fn(&ENV e, &span sp,
          &ident i) -> @view_item)                 fold_view_item_export,
@@ -981,10 +980,9 @@ fn fold_view_item[ENV](&ENV env, &ast_fold[ENV] fld, &@view_item vi)
             ret fld.fold_view_item_use(env_, vi.span, ident, meta_items,
                                        def_id, cnum);
         }
-        case (ast.view_item_import(?def_ident, ?idents, ?def_id,
-                                   ?target_def)) {
+        case (ast.view_item_import(?def_ident, ?idents, ?def_id)) {
             ret fld.fold_view_item_import(env_, vi.span, def_ident, idents,
-                                          def_id, target_def);
+                                          def_id);
         }
 
         case (ast.view_item_export(?def_ident)) {
@@ -1538,10 +1536,9 @@ fn identity_fold_view_item_use[ENV](&ENV e, &span sp, &ident i,
 }
 
 fn identity_fold_view_item_import[ENV](&ENV e, &span sp, &ident i,
-                                       &vec[ident] is, &def_id id,
-                                       &Option.t[def] target_def)
+                                       &vec[ident] is, &def_id id)
     -> @view_item {
-    ret @respan(sp, ast.view_item_import(i, is, id, target_def));
+    ret @respan(sp, ast.view_item_import(i, is, id));
 }
 
 fn identity_fold_view_item_export[ENV](&ENV e, &span sp, &ident i)
@@ -1747,7 +1744,7 @@ fn new_identity_fold[ENV]() -> ast_fold[ENV] {
          fold_view_item_use =
              bind identity_fold_view_item_use[ENV](_,_,_,_,_,_),
          fold_view_item_import =
-             bind identity_fold_view_item_import[ENV](_,_,_,_,_,_),
+             bind identity_fold_view_item_import[ENV](_,_,_,_,_),
          fold_view_item_export =
              bind identity_fold_view_item_export[ENV](_,_,_),
 

src/comp/middle/metadata.rs

@@ -513,7 +513,7 @@ fn encode_info_for_item(@trans.crate_ctxt cx, &EBML.writer ebml_w,
             encode_kind(ebml_w, 'm' as u8);
             EBML.end_tag(ebml_w);
         }
-        case (ast.item_native_mod(_, _, ?did)) {
+        case (ast.item_native_mod(?id, _, ?did)) {
             EBML.start_tag(ebml_w, tag_items_data_item);
             encode_def_id(ebml_w, did);
             encode_kind(ebml_w, 'n' as u8);

src/comp/middle/trans.rs

@@ -7044,6 +7044,9 @@ fn collect_item_1(&@crate_ctxt ccx, @walk_ctxt wcx, &@ast.item i) {
         case (ast.item_mod(?name, ?m, ?mid)) {
             ccx.items.insert(mid, i);
         }
+        case (ast.item_native_mod(_, _, ?mid)) {
+            ccx.items.insert(mid, i);
+        }
         case (ast.item_ty(_, _, _, ?did, _)) {
             ccx.items.insert(did, i);
         }

src/comp/pretty/pprust.rs

@@ -846,7 +846,7 @@ fn print_view_item(ps s, @ast.view_item item) {
                 pclose(s);
             }
         }
-        case (ast.view_item_import(?id,?ids,_,_)) {
+        case (ast.view_item_import(?id,?ids,_)) {
             wrd1(s, "import");
             if (!Str.eq(id, ids.(Vec.len[str](ids)-1u))) {
                 wrd1(s, id);

src/lib/List.rs

@@ -56,6 +56,17 @@ fn length[T](&list[T] ls) -> uint {
   ret foldl[T,uint](ls, 0u, bind count[T](_, _));
 }
 
+fn cdr[T](&list[T] ls) -> list[T] {
+    alt (ls) {
+        case (cons[T](_, ?tl)) {ret *tl;}
+    }
+}
+fn car[T](&list[T] ls) -> T {
+    alt (ls) {
+        case (cons[T](?hd, _)) {ret hd;}
+    }
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/test/compile-fail/export-import.rs

@@ -1,5 +1,6 @@
 // xfail-boot
-// error-pattern: unresolved name
+// xfail-stage0
+// error-pattern: unresolved import
 
 import m.unexported;
 

src/test/compile-fail/import.rs

@@ -1,5 +1,5 @@
 // xfail-boot
-// error-pattern: unresolved name: baz
+// error-pattern: unresolved import: baz
 import zed.bar;
 import zed.baz;
 mod zed {

src/test/compile-fail/import2.rs

@@ -1,5 +1,5 @@
 // xfail-boot
-// error-pattern: unresolved name: zed
+// error-pattern: unresolved name
 import baz.zed.bar;
 mod baz {
 }