---

yaml
---
r: 6088
b: refs/heads/master
c: 4e9b8a2
h: refs/heads/master
v: v3

Author: marijnh

[refs]

@@ -1,2 +1,2 @@
 ---
-refs/heads/master: 7ed7e7fa7975205a0c45e94909c812e231083457
+refs/heads/master: 4e9b8a28f7c9e85080dd57715e8583c23a3ef802

trunk/src/comp/middle/resolve.rs

@@ -107,6 +107,7 @@ type env =
      ext_map: hashmap<def_id, [ident]>,
      ext_cache: ext_hash,
      mutable reported: [{ident: str, sc: scope}],
+     mutable currently_resolving: node_id,
      sess: session};
 
 
@@ -127,6 +128,7 @@ fn resolve_crate(sess: session, amap: ast_map::map, crate: @ast::crate) ->
           ext_map: new_def_hash::<[ident]>(),
           ext_cache: new_ext_hash(),
           mutable reported: [],
+          mutable currently_resolving: -1,
           sess: sess};
     map_crate(e, crate);
     resolve_imports(*e);
@@ -218,11 +220,6 @@ fn map_crate(e: @env, c: @ast::crate) {
             }
         }
         alt vi.node {
-
-
-
-
-
           //if it really is a glob import, that is
           ast::view_item_import_glob(path, _) {
             let imp = follow_import(*e, sc, path, vi.span);
@@ -435,73 +432,62 @@ fn resolve_constr(e: @env, c: @ast::constr, sc: scopes, _v: vt<scopes>) {
 
 // Import resolution
 fn resolve_import(e: env, defid: ast::def_id, name: ast::ident,
-                  ids: [ast::ident], sp: codemap::span, sc_in: scopes) {
+                  ids: [ast::ident], sp: codemap::span, sc: scopes) {
+    fn register(e: env, id: node_id, sc: scopes, sp: codemap::span,
+                name: ast::ident, lookup: block(namespace) -> option::t<def>){
+        let val = lookup(ns_value), typ = lookup(ns_type),
+            md = lookup(ns_module);
+        if is_none(val) && is_none(typ) && is_none(md) {
+            unresolved_err(e, sc, sp, name, "import");
+        } else {
+            e.imports.insert(id, resolved(val, typ, md));
+        }
+    }
+    // This function has cleanup code at the end. Do not return without going
+    // through that.
     e.imports.insert(defid.node, resolving(sp));
+    let previously_resolving = e.currently_resolving;
+    e.currently_resolving = defid.node;
     let n_idents = vec::len(ids);
     let end_id = ids[n_idents - 1u];
-    // Ignore the current scope if this import would shadow itself.
-    let sc =
-        if str::eq(name, ids[0]) { std::list::cdr(sc_in) } else { sc_in };
     if n_idents == 1u {
-        register(e, defid, sp, end_id, sc_in,
-                 lookup_in_scope(e, sc, sp, end_id, ns_value),
-                 lookup_in_scope(e, sc, sp, end_id, ns_type),
-                 lookup_in_scope(e, sc, sp, end_id, ns_module));
-        remove_if_unresolved(e.imports, defid.node);
+        register(e, defid.node, sc, sp, name,
+                 {|ns| lookup_in_scope(e, sc, sp, end_id, ns) });
     } else {
-        let dcur =
-            alt lookup_in_scope(e, sc, sp, ids[0], ns_module) {
-              some(dcur) { dcur }
-              none. {
-                unresolved_err(e, sc, sp, ids[0], ns_name(ns_module));
-                remove_if_unresolved(e.imports, defid.node);
-                ret;
-              }
-            };
-        let i = 1u;
-        while true {
-            if i == n_idents - 1u {
-                register(e, defid, sp, end_id, sc_in,
-                         lookup_in_mod(e, dcur, sp, end_id, ns_value,
-                                       outside),
-                         lookup_in_mod(e, dcur, sp, end_id, ns_type, outside),
-                         lookup_in_mod(e, dcur, sp, end_id, ns_module,
-                                       outside));
-                remove_if_unresolved(e.imports, defid.node);
-                break;
-            } else {
-                dcur = alt lookup_in_mod(e, dcur, sp, ids[i], ns_module,
-                                         outside) {
-                  some(dcur) { dcur }
-                  none. {
-                    unresolved_err(e, sc, sp, ids[i], ns_name(ns_module));
-                    remove_if_unresolved(e.imports, defid.node);
-                    ret;
-                  }
-                };
-                i += 1u;
+        alt lookup_in_scope(e, sc, sp, ids[0], ns_module) {
+          none. { unresolved_err(e, sc, sp, ids[0], ns_name(ns_module)); }
+          some(dcur_) {
+            let dcur = dcur_, i = 1u;
+            while true {
+                if i == n_idents - 1u {
+                    register(e, defid.node, sc, sp, name, {|ns|
+                        lookup_in_mod(e, dcur, sp, end_id, ns, outside)
+                    });
+                    break;
+                } else {
+                    dcur = alt lookup_in_mod(e, dcur, sp, ids[i], ns_module,
+                                             outside) {
+                      some(dcur) { dcur }
+                      none. {
+                        unresolved_err(e, sc, sp, ids[i], ns_name(ns_module));
+                        break;
+                      }
+                    };
+                    i += 1u;
+                }
             }
+          }
         }
     }
-    fn register(e: env, defid: def_id, sp: span, name: ident, sc: scopes,
-                val: option::t<def>, typ: option::t<def>,
-                md: option::t<def>) {
-        if is_none(val) && is_none(typ) && is_none(md) {
-            unresolved_err(e, sc, sp, name, "import");
-        } else { e.imports.insert(defid.node, resolved(val, typ, md)); }
-    }
-    fn remove_if_unresolved(imports: hashmap<ast::node_id, import_state>,
-                            node_id: ast::node_id) {
-
-        // If we couldn't resolve the import, don't leave it in a partially
-        // resolved state, to avoid having it reported later as a cyclic
-        // import
-        if imports.contains_key(node_id) {
-            alt imports.get(node_id) {
-              resolving(_) { imports.remove(node_id); }
-              _ { }
-            }
-        }
+    e.currently_resolving = previously_resolving;
+    // If we couldn't resolve the import, don't leave it in a partially
+    // resolved state, to avoid having it reported later as a cyclic
+    // import
+    alt e.imports.find(defid.node) {
+      some(resolving(_)) {
+        e.imports.insert(defid.node, resolved(none, none, none));
+      }
+      _ { }
     }
 }
 
@@ -937,7 +923,13 @@ fn lookup_import(e: env, defid: def_id, ns: namespace) -> option::t<def> {
         resolve_import(e, local_def(node_id), name, path, span, scopes);
         ret lookup_import(e, defid, ns);
       }
-      resolving(sp) { e.sess.span_err(sp, "cyclic import"); ret none; }
+      resolving(sp) {
+        // Imports are simply ignored when resolving themselves.
+        if e.currently_resolving != defid.node {
+            e.sess.span_err(sp, "cyclic import");
+        }
+        ret none;
+      }
       resolved(val, typ, md) {
         ret alt ns { ns_value. { val } ns_type. { typ } ns_module. { md } };
       }