---

yaml
---
r: 92783
b: refs/heads/auto
c: c48335e
h: refs/heads/master
i:
  92781: 7793e51
  92779: 645cc57
  92775: 24d1519
  92767: 24978ff
v: v3

Author: pcwalton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 47846110a469d7682189e75b3bfe35f9ff02a9aa
+refs/heads/auto: c48335e334ccacc0f18b8d3dd9cad2ffc7a0a72d
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/librustc/middle/resolve.rs

@@ -420,7 +420,7 @@ struct Module {
     is_public: bool,
 
     children: RefCell<HashMap<Name, @NameBindings>>,
-    imports: @mut ~[@ImportDirective],
+    imports: RefCell<~[@ImportDirective]>,
 
     // The external module children of this node that were declared with
     // `extern mod`.
@@ -470,7 +470,7 @@ impl Module {
             kind: Cell::new(kind),
             is_public: is_public,
             children: RefCell::new(HashMap::new()),
-            imports: @mut ~[],
+            imports: RefCell::new(~[]),
             external_module_children: RefCell::new(HashMap::new()),
             anonymous_children: RefCell::new(HashMap::new()),
             import_resolutions: RefCell::new(HashMap::new()),
@@ -481,8 +481,8 @@ impl Module {
     }
 
     fn all_imports_resolved(&self) -> bool {
-        let imports = &mut *self.imports;
-        return imports.len() == self.resolved_import_count.get();
+        let mut imports = self.imports.borrow_mut();
+        return imports.get().len() == self.resolved_import_count.get();
     }
 }
 
@@ -1951,7 +1951,11 @@ impl Resolver {
         let directive = @ImportDirective::new(module_path,
                                               subclass, span, id,
                                               is_public);
-        module_.imports.push(directive);
+
+        {
+            let mut imports = module_.imports.borrow_mut();
+            imports.get().push(directive);
+        }
 
         // Bump the reference count on the name. Or, if this is a glob, set
         // the appropriate flag.
@@ -2069,11 +2073,11 @@ impl Resolver {
             return;
         }
 
-        let imports = &mut *module.imports;
-        let import_count = imports.len();
+        let mut imports = module.imports.borrow_mut();
+        let import_count = imports.get().len();
         while module.resolved_import_count.get() < import_count {
             let import_index = module.resolved_import_count.get();
-            let import_directive = imports[import_index];
+            let import_directive = imports.get()[import_index];
             match self.resolve_import_for_module(module, import_directive) {
                 Failed => {
                     // We presumably emitted an error. Continue.
@@ -2149,7 +2153,7 @@ impl Resolver {
     fn resolve_import_for_module(&mut self,
                                  module_: @Module,
                                  import_directive: @ImportDirective)
-                                     -> ResolveResult<()> {
+                                 -> ResolveResult<()> {
         let mut resolution_result = Failed;
         let module_path = &import_directive.module_path;
 
@@ -3230,16 +3234,20 @@ impl Resolver {
 
     fn report_unresolved_imports(&mut self, module_: @Module) {
         let index = module_.resolved_import_count.get();
-        let imports: &mut ~[@ImportDirective] = &mut *module_.imports;
-        let import_count = imports.len();
+        let mut imports = module_.imports.borrow_mut();
+        let import_count = imports.get().len();
         if index != import_count {
-            let sn = self.session.codemap.span_to_snippet(imports[index].span).unwrap();
+            let sn = self.session
+                         .codemap
+                         .span_to_snippet(imports.get()[index].span)
+                         .unwrap();
             if sn.contains("::") {
-                self.resolve_error(imports[index].span, "unresolved import");
+                self.resolve_error(imports.get()[index].span,
+                                   "unresolved import");
             } else {
                 let err = format!("unresolved import (maybe you meant `{}::*`?)",
                                sn.slice(0, sn.len()));
-                self.resolve_error(imports[index].span, err);
+                self.resolve_error(imports.get()[index].span, err);
             }
         }