FIXME Fallout from changes to rules for lifetimes and Drop.

It would be good revisit all of these changes after I get the whole PR
into a good state, to see if some/all of them can be returned to their
prior state.

Also, a real FIXME: the current spans being generated for the
borrow-check errors related to this are terrible; they tend to point
one at a sub-expression of the actual expression that needs to be
factored out (or, in some cases, an earlier expression entirely? Need
to double check that).

Author: pnkfelix

src/librustc/middle/resolve.rs

@@ -1403,7 +1403,8 @@ impl<'a> Resolver<'a> {
                         // a trait and the name of an impl of that trait.
                         let mod_name = path.segments.last().unwrap().identifier.name;
 
-                        let parent_opt = parent.module().children.borrow()
+                        let parent_mod = parent.module();
+                        let parent_opt = parent_mod.children.borrow()
                                                .get(&mod_name).cloned();
                         let new_parent = match parent_opt {
                             // It already exists
@@ -1767,11 +1768,12 @@ impl<'a> Resolver<'a> {
                                                               true));
                     debug!("(build reduced graph for item) found extern `{}`",
                             self.module_to_string(&*external_module));
+                    let parent_mod = parent.module();
                     self.check_for_conflicts_between_external_crates(
-                        &*parent.module(),
+                        &*parent_mod,
                         name.name,
                         view_item.span);
-                    parent.module().external_module_children.borrow_mut()
+                    parent_mod.external_module_children.borrow_mut()
                                    .insert(name.name, external_module.clone());
                     self.build_reduced_graph_for_external_crate(external_module);
                 }
@@ -2301,7 +2303,8 @@ impl<'a> Resolver<'a> {
             }
         }
 
-        for (_, child_module) in module_.anonymous_children.borrow().iter() {
+        let children = module_.anonymous_children.borrow();
+        for (_, child_module) in children.iter() {
             self.resolve_imports_for_module_subtree(child_module.clone());
         }
     }
@@ -3458,7 +3461,8 @@ impl<'a> Resolver<'a> {
 
         // Search for external modules.
         if namespace == TypeNS {
-            match module_.external_module_children.borrow().get(&name).cloned() {
+            let children = module_.external_module_children.borrow().get(&name).cloned();
+            match children {
                 None => {}
                 Some(module) => {
                     let name_bindings =
@@ -3743,7 +3747,8 @@ impl<'a> Resolver<'a> {
 
         // Finally, search through external children.
         if namespace == TypeNS {
-            match module_.external_module_children.borrow().get(&name).cloned() {
+            let children = module_.external_module_children.borrow().get(&name).cloned();
+            match children {
                 None => {}
                 Some(module) => {
                     let name_bindings =
@@ -3795,7 +3800,8 @@ impl<'a> Resolver<'a> {
             }
         }
 
-        for (_, module_) in module_.anonymous_children.borrow().iter() {
+        let children = module_.anonymous_children.borrow();
+        for (_, module_) in children.iter() {
             self.report_unresolved_imports(module_.clone());
         }
     }
@@ -3855,7 +3861,8 @@ impl<'a> Resolver<'a> {
             }
         }
 
-        for (_, child_module) in module_.anonymous_children.borrow().iter() {
+        let children = module_.anonymous_children.borrow();
+        for (_, child_module) in children.iter() {
             self.record_exports_for_module_subtree(child_module.clone());
         }
     }

src/librustc/middle/typeck/check/method/probe.rs

@@ -486,12 +486,14 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
                                                             trait_def_id);
 
         let trait_impls = self.tcx().trait_impls.borrow();
-        let impl_def_ids = match trait_impls.get(&trait_def_id) {
+        let impl_for_def = trait_impls.get(&trait_def_id);
+        let impl_def_ids = match impl_for_def {
             None => { return; }
             Some(impls) => impls,
         };
 
-        for &impl_def_id in impl_def_ids.borrow().iter() {
+        let impl_def_ids = impl_def_ids.borrow();
+        for &impl_def_id in impl_def_ids.iter() {
             debug!("assemble_extension_candidates_for_trait_impl: trait_def_id={} impl_def_id={}",
                    trait_def_id.repr(self.tcx()),
                    impl_def_id.repr(self.tcx()));
@@ -901,8 +903,8 @@ impl<'a,'tcx> ProbeContext<'a,'tcx> {
         // if there are any.
         assert_eq!(substs.types.len(subst::FnSpace), 0);
         assert_eq!(substs.regions().len(subst::FnSpace), 0);
-        let mut substs = substs;
         let placeholder;
+        let mut substs = substs;
         if
             !method.generics.types.is_empty_in(subst::FnSpace) ||
             !method.generics.regions.is_empty_in(subst::FnSpace)

src/librustc/middle/typeck/coherence/mod.rs

@@ -432,7 +432,8 @@ impl<'a, 'tcx> CoherenceChecker<'a, 'tcx> {
             Some(found_impls) => found_impls
         };
 
-        for &impl_did in trait_impls.borrow().iter() {
+        let trait_impls = trait_impls.borrow();
+        for &impl_did in trait_impls.iter() {
             let items = &(*impl_items)[impl_did];
             if items.len() < 1 {
                 // We'll error out later. For now, just don't ICE.

src/librustc/middle/typeck/infer/error_reporting.rs

@@ -867,6 +867,8 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
         let scope_id = same_regions[0].scope_id;
         let parent = self.tcx.map.get_parent(scope_id);
         let parent_node = self.tcx.map.find(parent);
+        let taken = lifetimes_in_scope(self.tcx, scope_id);
+        let life_giver = LifeGiver::with_taken(taken.as_slice());
         let node_inner = match parent_node {
             Some(ref node) => match *node {
                 ast_map::NodeItem(ref item) => {
@@ -909,8 +911,6 @@ impl<'a, 'tcx> ErrorReporting<'tcx> for InferCtxt<'a, 'tcx> {
         };
         let (fn_decl, generics, fn_style, ident, expl_self, span)
                                     = node_inner.expect("expect item fn");
-        let taken = lifetimes_in_scope(self.tcx, scope_id);
-        let life_giver = LifeGiver::with_taken(taken.as_slice());
         let rebuilder = Rebuilder::new(self.tcx, fn_decl, expl_self,
                                        generics, same_regions, &life_giver);
         let (fn_decl, expl_self, generics) = rebuilder.rebuild();