---

yaml
---
r: 94703
b: refs/heads/try
c: 9253df1
h: refs/heads/master
i:
  94701: f6d7974
  94699: 6138b49
  94695: 21dc745
  94687: 39933b8
v: v3

Author: pcwalton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 0da105a8b7b6b1e0568e8ff20f6ff4b13cc7ecc2
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: a6d3e57dca68fde4effdda3e4ae2887aa535fcd6
-refs/heads/try: c10d7177db81bd207705a92f6453f82ab11521a7
+refs/heads/try: 9253df1844985ded53a3d5353b506b5ec8a33131
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

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

@@ -361,7 +361,7 @@ struct ImportResolution {
     value_id: Cell<NodeId>,
 
     /// The type that this `use` directive names, if there is one.
-    type_target: Option<Target>,
+    type_target: RefCell<Option<Target>>,
     /// The source node of the `use` directive leading to the type target
     /// being non-none
     type_id: NodeId,
@@ -374,15 +374,15 @@ impl ImportResolution {
             value_id: Cell::new(id),
             outstanding_references: Cell::new(0),
             value_target: RefCell::new(None),
-            type_target: None,
+            type_target: RefCell::new(None),
             is_public: Cell::new(is_public),
         }
     }
 
     fn target_for_namespace(&self, namespace: Namespace)
                                 -> Option<Target> {
         match namespace {
-            TypeNS      => return self.type_target,
+            TypeNS      => return self.type_target.get(),
             ValueNS     => return self.value_target.get(),
         }
     }
@@ -2433,8 +2433,8 @@ impl Resolver {
             BoundResult(target_module, name_bindings) => {
                 debug!("(resolving single import) found type target: {:?}",
                         name_bindings.type_def.get().unwrap().type_def);
-                import_resolution.type_target =
-                    Some(Target::new(target_module, name_bindings));
+                import_resolution.type_target.set(
+                    Some(Target::new(target_module, name_bindings)));
                 import_resolution.type_id = directive.id;
                 used_public = name_bindings.defined_in_public_namespace(TypeNS);
             }
@@ -2445,7 +2445,7 @@ impl Resolver {
         }
 
         if import_resolution.value_target.get().is_none() &&
-           import_resolution.type_target.is_none() {
+           import_resolution.type_target.get().is_none() {
             let msg = format!("unresolved import: there is no \
                                `{}` in `{}`",
                               self.session.str_of(source),
@@ -2472,7 +2472,7 @@ impl Resolver {
             }
             None => {}
         }
-        match import_resolution.type_target {
+        match import_resolution.type_target.get() {
             Some(target) => {
                 let def = target.bindings.def_for_namespace(TypeNS).unwrap();
                 self.def_map.insert(directive.id, def);
@@ -2519,7 +2519,7 @@ impl Resolver {
                                                                    .iter() {
             debug!("(resolving glob import) writing module resolution \
                     {:?} into `{}`",
-                   target_import_resolution.type_target.is_none(),
+                   target_import_resolution.type_target.get().is_none(),
                    self.module_to_str(module_));
 
             if !target_import_resolution.is_public.get() {
@@ -2537,8 +2537,8 @@ impl Resolver {
                         @mut ImportResolution::new(id, is_public);
                     new_import_resolution.value_target.set(
                         target_import_resolution.value_target.get());
-                    new_import_resolution.type_target =
-                        target_import_resolution.type_target;
+                    new_import_resolution.type_target.set(
+                        target_import_resolution.type_target.get());
 
                     import_resolutions.get().insert
                         (*ident, new_import_resolution);
@@ -2556,13 +2556,13 @@ impl Resolver {
                                 Some(value_target));
                         }
                     }
-                    match target_import_resolution.type_target {
+                    match target_import_resolution.type_target.get() {
                         None => {
                             // Continue.
                         }
                         Some(type_target) => {
-                            dest_import_resolution.type_target =
-                                Some(type_target);
+                            dest_import_resolution.type_target.set(
+                                Some(type_target));
                         }
                     }
                     dest_import_resolution.is_public.set(is_public);
@@ -2602,8 +2602,8 @@ impl Resolver {
             }
             if name_bindings.defined_in_public_namespace(TypeNS) {
                 debug!("(resolving glob import) ... for type target");
-                dest_import_resolution.type_target =
-                    Some(Target::new(containing_module, name_bindings));
+                dest_import_resolution.type_target.set(
+                    Some(Target::new(containing_module, name_bindings)));
                 dest_import_resolution.type_id = id;
             }
             dest_import_resolution.is_public.set(is_public);