Update region_scope_tree

Author: Zoxc

src/librustc/hir/mod.rs

@@ -135,6 +135,8 @@ mod item_local_id_inner {
     }
 }
 
+impl_defer_dellocs_for_no_drop_type!([] ItemLocalId);
+
 pub use self::item_local_id_inner::ItemLocalId;
 
 /// The `HirId` corresponding to CRATE_NODE_ID and CRATE_DEF_INDEX
@@ -1269,6 +1271,8 @@ pub struct BodyId {
     pub node_id: NodeId,
 }
 
+impl_defer_dellocs_for_no_drop_type!([] BodyId);
+
 /// The body of a function, closure, or constant value. In the case of
 /// a function, the body contains not only the function body itself
 /// (which is an expression), but also the argument patterns, since

src/librustc/middle/region.rs

@@ -22,7 +22,6 @@ use ty;
 
 use std::mem;
 use std::fmt;
-use rustc_data_structures::sync::Lrc;
 use syntax::source_map;
 use syntax::ast;
 use syntax_pos::{Span, DUMMY_SP};
@@ -34,6 +33,7 @@ use hir::Node;
 use hir::def_id::DefId;
 use hir::intravisit::{self, Visitor, NestedVisitorMap};
 use hir::{Block, Arm, Pat, PatKind, Stmt, Expr, Local};
+use rustc_data_structures::defer_deallocs::{DeferDeallocs, DeferredDeallocs};
 use rustc_data_structures::indexed_vec::Idx;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
                                            StableHasherResult};
@@ -106,6 +106,8 @@ pub struct Scope {
     pub data: ScopeData,
 }
 
+impl_defer_dellocs_for_no_drop_type!([] Scope);
+
 impl fmt::Debug for Scope {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self.data {
@@ -349,6 +351,18 @@ pub struct ScopeTree {
     body_expr_count: FxHashMap<hir::BodyId, usize>,
 }
 
+unsafe impl DeferDeallocs for ScopeTree {
+    fn defer(&self, deferred: &mut DeferredDeallocs) {
+        self.parent_map.defer(deferred);
+        self.var_map.defer(deferred);
+        self.destruction_scopes.defer(deferred);
+        self.rvalue_scopes.defer(deferred);
+        self.closure_tree.defer(deferred);
+        self.yield_in_scope.defer(deferred);
+        self.body_expr_count.defer(deferred);
+    }
+}
+
 #[derive(Debug, Copy, Clone)]
 pub struct Context {
     /// the root of the current region tree. This is typically the id
@@ -1329,7 +1343,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RegionResolutionVisitor<'a, 'tcx> {
 }
 
 fn region_scope_tree<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
-    -> Lrc<ScopeTree>
+    -> &'tcx ScopeTree
 {
     let closure_base_def_id = tcx.closure_base_def_id(def_id);
     if closure_base_def_id != def_id {
@@ -1371,7 +1385,7 @@ fn region_scope_tree<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId)
         ScopeTree::default()
     };
 
-    Lrc::new(scope_tree)
+    tcx.promote(scope_tree)
 }
 
 pub fn provide(providers: &mut Providers<'_>) {

src/librustc/ty/query/mod.rs

@@ -330,7 +330,7 @@ define_queries! { <'tcx>
 
         /// Per-body `region::ScopeTree`. The `DefId` should be the owner-def-id for the body;
         /// in the case of closures, this will be redirected to the enclosing function.
-        [] fn region_scope_tree: RegionScopeTree(DefId) -> Lrc<region::ScopeTree>,
+        [] fn region_scope_tree: RegionScopeTree(DefId) -> &'tcx region::ScopeTree,
 
         [] fn mir_shims: mir_shim_dep_node(ty::InstanceDef<'tcx>) -> &'tcx mir::Mir<'tcx>,
 

src/librustc_borrowck/borrowck/mod.rs

@@ -253,7 +253,7 @@ pub struct BorrowckCtxt<'a, 'tcx: 'a> {
     // Some in `borrowck_fn` and cleared later
     tables: &'a ty::TypeckTables<'tcx>,
 
-    region_scope_tree: Lrc<region::ScopeTree>,
+    region_scope_tree: &'tcx region::ScopeTree,
 
     owner_def_id: DefId,
 

src/librustc_data_structures/defer_deallocs.rs

@@ -75,9 +75,30 @@ unsafe impl<T: DeferDeallocs> DeferDeallocs for Vec<T> {
     }
 }
 
+impl_defer_dellocs_for_no_drop_type!([] usize);
+impl_defer_dellocs_for_no_drop_type!([] u32);
 impl_defer_dellocs_for_no_drop_type!([] u64);
 impl_defer_dellocs_for_no_drop_type!([<T>] BuildHasherDefault<T>);
 
+unsafe impl<T: DeferDeallocs> DeferDeallocs for Option<T> {
+    #[inline]
+    fn defer(&self, deferred: &mut DeferredDeallocs) {
+        self.as_ref().map(|v| v.defer(deferred));
+    }
+}
+
+unsafe impl<
+    T1: DeferDeallocs,
+    T2: DeferDeallocs,
+> DeferDeallocs
+for (T1, T2) {
+    #[inline]
+    fn defer(&self, deferred: &mut DeferredDeallocs) {
+        self.0.defer(deferred);
+        self.1.defer(deferred);
+    }
+}
+
 unsafe impl<
     K: DeferDeallocs + Eq + Hash,
     V: DeferDeallocs,

src/librustc_mir/borrow_check/error_reporting.rs

@@ -25,7 +25,6 @@ use rustc::ty::{self, DefIdTree};
 use rustc::util::ppaux::with_highlight_region_for_bound_region;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::indexed_vec::Idx;
-use rustc_data_structures::sync::Lrc;
 use rustc_errors::{Applicability, DiagnosticBuilder};
 use syntax_pos::Span;
 
@@ -668,7 +667,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
         &mut self,
         context: Context,
         name: &str,
-        scope_tree: &Lrc<ScopeTree>,
+        scope_tree: &'tcx ScopeTree,
         borrow: &BorrowData<'tcx>,
         drop_span: Span,
         borrow_spans: UseSpans,
@@ -851,7 +850,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
     fn report_temporary_value_does_not_live_long_enough(
         &mut self,
         context: Context,
-        scope_tree: &Lrc<ScopeTree>,
+        scope_tree: &'tcx ScopeTree,
         borrow: &BorrowData<'tcx>,
         drop_span: Span,
         borrow_spans: UseSpans,

src/librustc_mir/hair/cx/mod.rs

@@ -30,7 +30,6 @@ use syntax::ast;
 use syntax::attr;
 use syntax::symbol::Symbol;
 use rustc::hir;
-use rustc_data_structures::sync::Lrc;
 use hair::constant::{lit_to_const, LitToConstError};
 
 #[derive(Clone)]
@@ -44,7 +43,7 @@ pub struct Cx<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
     /// Identity `Substs` for use with const-evaluation.
     pub identity_substs: &'gcx Substs<'gcx>,
 
-    pub region_scope_tree: Lrc<region::ScopeTree>,
+    pub region_scope_tree: &'gcx region::ScopeTree,
     pub tables: &'a ty::TypeckTables<'gcx>,
 
     /// This is `Constness::Const` if we are compiling a `static`,

src/librustc_typeck/check/generator_interior.rs

@@ -18,15 +18,14 @@ use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
 use rustc::hir::{self, Pat, PatKind, Expr};
 use rustc::middle::region;
 use rustc::ty::{self, Ty};
-use rustc_data_structures::sync::Lrc;
 use syntax_pos::Span;
 use super::FnCtxt;
 use util::nodemap::FxHashMap;
 
 struct InteriorVisitor<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
     fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
     types: FxHashMap<Ty<'tcx>, usize>,
-    region_scope_tree: Lrc<region::ScopeTree>,
+    region_scope_tree: &'gcx region::ScopeTree,
     expr_count: usize,
 }
 

src/librustc_typeck/check/regionck.rs

@@ -96,7 +96,6 @@ use rustc::ty::{self, Ty};
 
 use rustc::hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc::hir::{self, PatKind};
-use rustc_data_structures::sync::Lrc;
 use std::mem;
 use std::ops::Deref;
 use std::rc::Rc;
@@ -206,7 +205,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
 pub struct RegionCtxt<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
     pub fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
 
-    pub region_scope_tree: Lrc<region::ScopeTree>,
+    pub region_scope_tree: &'gcx region::ScopeTree,
 
     outlives_environment: OutlivesEnvironment<'tcx>,
 

src/libsyntax_pos/lib.rs

@@ -39,6 +39,7 @@ use rustc_data_structures::stable_hasher::StableHasher;
 use rustc_data_structures::sync::{Lrc, Lock};
 
 extern crate arena;
+#[macro_use]
 extern crate rustc_data_structures;
 
 #[macro_use]