remove ROOT_CODE_EXTENT and DUMMY_CODE_EXTENT

Instead, thread around `Option<CodeExtent>` where applicable.

Author: nikomatsakis

src/librustc/infer/error_reporting/mod.rs

@@ -69,6 +69,7 @@ use traits::{ObligationCause, ObligationCauseCode};
 use ty::{self, TyCtxt, TypeFoldable};
 use ty::{Region, Issue32330};
 use ty::error::TypeError;
+use syntax::ast::DUMMY_NODE_ID;
 use syntax_pos::{Pos, Span};
 use errors::{DiagnosticBuilder, DiagnosticStyledString};
 
@@ -183,7 +184,8 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
                     }
                 };
 
-                let node = fr.scope.node_id(&self.region_maps());
+                let node = fr.scope.map(|s| s.node_id(&self.region_maps()))
+                                   .unwrap_or(DUMMY_NODE_ID);
                 let unknown;
                 let tag = match self.hir.find(node) {
                     Some(hir_map::NodeBlock(_)) |

src/librustc/infer/region_inference/mod.rs

@@ -938,18 +938,19 @@ impl<'a, 'gcx, 'tcx> RegionVarBindings<'a, 'gcx, 'tcx> {
                 // A "free" region can be interpreted as "some region
                 // at least as big as the block fr.scope_id".  So, we can
                 // reasonably compare free regions and scopes:
-                let r_id = self.tcx.region_maps().nearest_common_ancestor(fr.scope, s_id);
-
-                if r_id == fr.scope {
-                    // if the free region's scope `fr.scope_id` is bigger than
-                    // the scope region `s_id`, then the LUB is the free
-                    // region itself:
-                    self.tcx.mk_region(ReFree(fr))
-                } else {
-                    // otherwise, we don't know what the free region is,
-                    // so we must conservatively say the LUB is static:
-                    self.tcx.types.re_static
+                if let Some(fr_scope) = fr.scope {
+                    let r_id = self.tcx.region_maps().nearest_common_ancestor(fr_scope, s_id);
+                    if r_id == fr_scope {
+                        // if the free region's scope `fr.scope_id` is bigger than
+                        // the scope region `s_id`, then the LUB is the free
+                        // region itself:
+                        return self.tcx.mk_region(ReFree(fr));
+                    }
                 }
+
+                // otherwise, we don't know what the free region is,
+                // so we must conservatively say the LUB is static:
+                self.tcx.types.re_static
             }
 
             (&ReScope(a_id), &ReScope(b_id)) => {

src/librustc/middle/free_region.rs

@@ -138,9 +138,14 @@ impl FreeRegionMap {
                 (&ty::ReScope(sub_scope), &ty::ReScope(super_scope)) =>
                     tcx.region_maps().is_subscope_of(sub_scope, super_scope),
 
-                (&ty::ReScope(sub_scope), &ty::ReFree(fr)) =>
-                    tcx.region_maps().is_subscope_of(sub_scope, fr.scope) ||
-                    self.is_static(fr),
+                (&ty::ReScope(sub_scope), &ty::ReFree(fr)) => {
+                    // 1. It is safe to unwrap `fr.scope` because we
+                    // should only ever wind up comparing against
+                    // `ReScope` in the context of a method or fn
+                    // body, where `fr.scope` should be `Some`.
+                    tcx.region_maps().is_subscope_of(sub_scope, fr.scope.unwrap() /*1*/) ||
+                        self.is_static(fr)
+                }
 
                 (&ty::ReFree(sub_fr), &ty::ReFree(super_fr)) =>
                     self.sub_free_region(sub_fr, super_fr),
@@ -166,9 +171,7 @@ impl FreeRegionMap {
 
 #[cfg(test)]
 fn free_region(index: u32) -> FreeRegion {
-    use middle::region::DUMMY_CODE_EXTENT;
-    FreeRegion { scope: DUMMY_CODE_EXTENT,
-                 bound_region: ty::BoundRegion::BrAnon(index) }
+    FreeRegion { scope: None, bound_region: ty::BoundRegion::BrAnon(index) }
 }
 
 #[test]

src/librustc/middle/liveness.rs

@@ -1441,7 +1441,7 @@ impl<'a, 'tcx> Liveness<'a, 'tcx> {
         // and must outlive the *call-site* of the function.
         let fn_ret =
             self.ir.tcx.liberate_late_bound_regions(
-                self.ir.tcx.region_maps().call_site_extent(id, body.value.id),
+                Some(self.ir.tcx.region_maps().call_site_extent(id, body.value.id)),
                 &fn_ret);
 
         if !fn_ret.is_never() && self.live_on_entry(entry_ln, self.s.no_ret_var).is_some() {

src/librustc/middle/mem_categorization.rs

@@ -796,7 +796,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
             // The environment of a closure is guaranteed to
             // outlive any bindings introduced in the body of the
             // closure itself.
-            scope: self.tcx().region_maps().item_extent(fn_body_id),
+            scope: Some(self.tcx().region_maps().item_extent(fn_body_id)),
             bound_region: ty::BrEnv
         }));