rustc: rename mir::VisibilityScope to mir::SourceScope.

Author: eddyb

src/librustc/ich/impls_mir.rs

@@ -127,7 +127,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for mir::Field {
 }
 
 impl<'a> HashStable<StableHashingContext<'a>>
-for mir::VisibilityScope {
+for mir::SourceScope {
     #[inline]
     fn hash_stable<W: StableHasherResult>(&self,
                                           hcx: &mut StableHashingContext<'a>,
@@ -363,8 +363,8 @@ for mir::ProjectionElem<'gcx, V, T>
     }
 }
 
-impl_stable_hash_for!(struct mir::VisibilityScopeData { span, parent_scope });
-impl_stable_hash_for!(struct mir::VisibilityScopeInfo {
+impl_stable_hash_for!(struct mir::SourceScopeData { span, parent_scope });
+impl_stable_hash_for!(struct mir::SourceScopeInfo {
     lint_root, safety
 });
 

src/librustc/mir/mod.rs

@@ -78,13 +78,13 @@ pub struct Mir<'tcx> {
     /// that indexes into this vector.
     basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
 
-    /// List of visibility (lexical) scopes; these are referenced by statements
-    /// and used (eventually) for debuginfo. Indexed by a `VisibilityScope`.
-    pub visibility_scopes: IndexVec<VisibilityScope, VisibilityScopeData>,
+    /// List of source scopes; these are referenced by statements
+    /// and used for debuginfo. Indexed by a `SourceScope`.
+    pub source_scopes: IndexVec<SourceScope, SourceScopeData>,
 
-    /// Crate-local information for each visibility scope, that can't (and
+    /// Crate-local information for each source scope, that can't (and
     /// needn't) be tracked across crates.
-    pub visibility_scope_info: ClearCrossCrate<IndexVec<VisibilityScope, VisibilityScopeInfo>>,
+    pub source_scope_info: ClearCrossCrate<IndexVec<SourceScope, SourceScopeInfo>>,
 
     /// Rvalues promoted from this function, such as borrows of constants.
     /// Each of them is the Mir of a constant with the fn's type parameters
@@ -137,9 +137,9 @@ pub const START_BLOCK: BasicBlock = BasicBlock(0);
 
 impl<'tcx> Mir<'tcx> {
     pub fn new(basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
-               visibility_scopes: IndexVec<VisibilityScope, VisibilityScopeData>,
-               visibility_scope_info: ClearCrossCrate<IndexVec<VisibilityScope,
-                                                               VisibilityScopeInfo>>,
+               source_scopes: IndexVec<SourceScope, SourceScopeData>,
+               source_scope_info: ClearCrossCrate<IndexVec<SourceScope,
+                                                               SourceScopeInfo>>,
                promoted: IndexVec<Promoted, Mir<'tcx>>,
                yield_ty: Option<Ty<'tcx>>,
                local_decls: IndexVec<Local, LocalDecl<'tcx>>,
@@ -153,8 +153,8 @@ impl<'tcx> Mir<'tcx> {
 
         Mir {
             basic_blocks,
-            visibility_scopes,
-            visibility_scope_info,
+            source_scopes,
+            source_scope_info,
             promoted,
             yield_ty,
             generator_drop: None,
@@ -309,7 +309,7 @@ impl<'tcx> Mir<'tcx> {
 }
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
-pub struct VisibilityScopeInfo {
+pub struct SourceScopeInfo {
     /// A NodeId with lint levels equivalent to this scope's lint levels.
     pub lint_root: ast::NodeId,
     /// The unsafe block that contains this node.
@@ -329,8 +329,8 @@ pub enum Safety {
 
 impl_stable_hash_for!(struct Mir<'tcx> {
     basic_blocks,
-    visibility_scopes,
-    visibility_scope_info,
+    source_scopes,
+    source_scope_info,
     promoted,
     yield_ty,
     generator_drop,
@@ -376,8 +376,9 @@ pub struct SourceInfo {
     /// Source span for the AST pertaining to this MIR entity.
     pub span: Span,
 
-    /// The lexical visibility scope, i.e. which bindings can be seen.
-    pub scope: VisibilityScope
+    /// The source scope, keeping track of which bindings can be
+    /// seen by debuginfo, active lint levels, `unsafe {...}`, etc.
+    pub scope: SourceScope
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -512,16 +513,17 @@ pub struct LocalDecl<'tcx> {
     /// to generate better debuginfo.
     pub name: Option<Name>,
 
-    /// Source info of the local.
+    /// Source info of the local. The `SourceScope` is the *visibility* one,
+    /// not the the *syntactic* one (see `syntactic_scope` for more details).
     pub source_info: SourceInfo,
 
-    /// The *syntactic* visibility scope the local is defined
+    /// The *syntactic* (i.e. not visibility) source scope the local is defined
     /// in. If the local was defined in a let-statement, this
     /// is *within* the let-statement, rather than outside
     /// of it.
     ///
-    /// This is needed because visibility scope of locals within a let-statement
-    /// is weird.
+    /// This is needed because the visibility source scope of locals within
+    /// a let-statement is weird.
     ///
     /// The reason is that we want the local to be *within* the let-statement
     /// for lint purposes, but we want the local to be *after* the let-statement
@@ -594,7 +596,7 @@ pub struct LocalDecl<'tcx> {
     ///  │ │← x.source_info.scope
     ///  │ │← `drop(x)` // this accesses `x: u32`
     /// ```
-    pub syntactic_scope: VisibilityScope,
+    pub syntactic_scope: SourceScope,
 }
 
 impl<'tcx> LocalDecl<'tcx> {
@@ -607,9 +609,9 @@ impl<'tcx> LocalDecl<'tcx> {
             name: None,
             source_info: SourceInfo {
                 span,
-                scope: ARGUMENT_VISIBILITY_SCOPE
+                scope: OUTERMOST_SOURCE_SCOPE
             },
-            syntactic_scope: ARGUMENT_VISIBILITY_SCOPE,
+            syntactic_scope: OUTERMOST_SOURCE_SCOPE,
             internal: false,
             is_user_variable: false
         }
@@ -624,9 +626,9 @@ impl<'tcx> LocalDecl<'tcx> {
             name: None,
             source_info: SourceInfo {
                 span,
-                scope: ARGUMENT_VISIBILITY_SCOPE
+                scope: OUTERMOST_SOURCE_SCOPE
             },
-            syntactic_scope: ARGUMENT_VISIBILITY_SCOPE,
+            syntactic_scope: OUTERMOST_SOURCE_SCOPE,
             internal: true,
             is_user_variable: false
         }
@@ -642,9 +644,9 @@ impl<'tcx> LocalDecl<'tcx> {
             ty: return_ty,
             source_info: SourceInfo {
                 span,
-                scope: ARGUMENT_VISIBILITY_SCOPE
+                scope: OUTERMOST_SOURCE_SCOPE
             },
-            syntactic_scope: ARGUMENT_VISIBILITY_SCOPE,
+            syntactic_scope: OUTERMOST_SOURCE_SCOPE,
             internal: false,
             name: None,     // FIXME maybe we do want some name here?
             is_user_variable: false
@@ -1047,7 +1049,7 @@ impl<'tcx> BasicBlockData<'tcx> {
         self.statements.resize(gap.end, Statement {
             source_info: SourceInfo {
                 span: DUMMY_SP,
-                scope: ARGUMENT_VISIBILITY_SCOPE
+                scope: OUTERMOST_SOURCE_SCOPE
             },
             kind: StatementKind::Nop
         });
@@ -1501,16 +1503,16 @@ impl<'tcx> Debug for Place<'tcx> {
 ///////////////////////////////////////////////////////////////////////////
 // Scopes
 
-newtype_index!(VisibilityScope
+newtype_index!(SourceScope
     {
         DEBUG_FORMAT = "scope[{}]",
-        const ARGUMENT_VISIBILITY_SCOPE = 0,
+        const OUTERMOST_SOURCE_SCOPE = 0,
     });
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
-pub struct VisibilityScopeData {
+pub struct SourceScopeData {
     pub span: Span,
-    pub parent_scope: Option<VisibilityScope>,
+    pub parent_scope: Option<SourceScope>,
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -2153,16 +2155,16 @@ CloneTypeFoldableAndLiftImpls! {
     SourceInfo,
     UpvarDecl,
     ValidationOp,
-    VisibilityScopeData,
-    VisibilityScope,
-    VisibilityScopeInfo,
+    SourceScopeData,
+    SourceScope,
+    SourceScopeInfo,
 }
 
 BraceStructTypeFoldableImpl! {
     impl<'tcx> TypeFoldable<'tcx> for Mir<'tcx> {
         basic_blocks,
-        visibility_scopes,
-        visibility_scope_info,
+        source_scopes,
+        source_scope_info,
         promoted,
         yield_ty,
         generator_drop,

src/librustc/mir/visit.rs

@@ -92,9 +92,9 @@ macro_rules! make_mir_visitor {
                 self.super_basic_block_data(block, data);
             }
 
-            fn visit_visibility_scope_data(&mut self,
-                                           scope_data: & $($mutability)* VisibilityScopeData) {
-                self.super_visibility_scope_data(scope_data);
+            fn visit_source_scope_data(&mut self,
+                                           scope_data: & $($mutability)* SourceScopeData) {
+                self.super_source_scope_data(scope_data);
             }
 
             fn visit_statement(&mut self,
@@ -261,9 +261,9 @@ macro_rules! make_mir_visitor {
                             _location: Location) {
             }
 
-            fn visit_visibility_scope(&mut self,
-                                      scope: & $($mutability)* VisibilityScope) {
-                self.super_visibility_scope(scope);
+            fn visit_source_scope(&mut self,
+                                      scope: & $($mutability)* SourceScope) {
+                self.super_source_scope(scope);
             }
 
             // The `super_xxx` methods comprise the default behavior and are
@@ -274,7 +274,7 @@ macro_rules! make_mir_visitor {
                 if let Some(yield_ty) = &$($mutability)* mir.yield_ty {
                     self.visit_ty(yield_ty, TyContext::YieldTy(SourceInfo {
                         span: mir.span,
-                        scope: ARGUMENT_VISIBILITY_SCOPE,
+                        scope: OUTERMOST_SOURCE_SCOPE,
                     }));
                 }
 
@@ -289,13 +289,13 @@ macro_rules! make_mir_visitor {
                     self.visit_basic_block_data(bb, data);
                 }
 
-                for scope in &$($mutability)* mir.visibility_scopes {
-                    self.visit_visibility_scope_data(scope);
+                for scope in &$($mutability)* mir.source_scopes {
+                    self.visit_source_scope_data(scope);
                 }
 
                 self.visit_ty(&$($mutability)* mir.return_ty(), TyContext::ReturnTy(SourceInfo {
                     span: mir.span,
-                    scope: ARGUMENT_VISIBILITY_SCOPE,
+                    scope: OUTERMOST_SOURCE_SCOPE,
                 }));
 
                 for local in mir.local_decls.indices() {
@@ -327,16 +327,16 @@ macro_rules! make_mir_visitor {
                 }
             }
 
-            fn super_visibility_scope_data(&mut self,
-                                           scope_data: & $($mutability)* VisibilityScopeData) {
-                let VisibilityScopeData {
+            fn super_source_scope_data(&mut self,
+                                           scope_data: & $($mutability)* SourceScopeData) {
+                let SourceScopeData {
                     ref $($mutability)* span,
                     ref $($mutability)* parent_scope,
                 } = *scope_data;
 
                 self.visit_span(span);
                 if let Some(ref $($mutability)* parent_scope) = *parent_scope {
-                    self.visit_visibility_scope(parent_scope);
+                    self.visit_source_scope(parent_scope);
                 }
             }
 
@@ -725,11 +725,11 @@ macro_rules! make_mir_visitor {
                     source_info: *source_info,
                 });
                 self.visit_source_info(source_info);
-                self.visit_visibility_scope(syntactic_scope);
+                self.visit_source_scope(syntactic_scope);
             }
 
-            fn super_visibility_scope(&mut self,
-                                      _scope: & $($mutability)* VisibilityScope) {
+            fn super_source_scope(&mut self,
+                                      _scope: & $($mutability)* SourceScope) {
             }
 
             fn super_branch(&mut self,
@@ -775,7 +775,7 @@ macro_rules! make_mir_visitor {
                 } = *source_info;
 
                 self.visit_span(span);
-                self.visit_visibility_scope(scope);
+                self.visit_source_scope(scope);
             }
 
             fn super_ty(&mut self, _ty: & $($mutability)* Ty<'tcx>) {

src/librustc_codegen_llvm/debuginfo/create_scope_map.rs

@@ -15,7 +15,7 @@ use super::utils::{DIB, span_start};
 use llvm;
 use llvm::debuginfo::DIScope;
 use common::CodegenCx;
-use rustc::mir::{Mir, VisibilityScope};
+use rustc::mir::{Mir, SourceScope};
 
 use libc::c_uint;
 use std::ptr;
@@ -45,13 +45,13 @@ impl MirDebugScope {
 /// Produce DIScope DIEs for each MIR Scope which has variables defined in it.
 /// If debuginfo is disabled, the returned vector is empty.
 pub fn create_mir_scopes(cx: &CodegenCx, mir: &Mir, debug_context: &FunctionDebugContext)
-    -> IndexVec<VisibilityScope, MirDebugScope> {
+    -> IndexVec<SourceScope, MirDebugScope> {
     let null_scope = MirDebugScope {
         scope_metadata: ptr::null_mut(),
         file_start_pos: BytePos(0),
         file_end_pos: BytePos(0)
     };
-    let mut scopes = IndexVec::from_elem(null_scope, &mir.visibility_scopes);
+    let mut scopes = IndexVec::from_elem(null_scope, &mir.source_scopes);
 
     let debug_context = match *debug_context {
         FunctionDebugContext::RegularContext(ref data) => data,
@@ -62,15 +62,15 @@ pub fn create_mir_scopes(cx: &CodegenCx, mir: &Mir, debug_context: &FunctionDebu
     };
 
     // Find all the scopes with variables defined in them.
-    let mut has_variables = BitVector::new(mir.visibility_scopes.len());
+    let mut has_variables = BitVector::new(mir.source_scopes.len());
     for var in mir.vars_iter() {
         let decl = &mir.local_decls[var];
         has_variables.insert(decl.source_info.scope.index());
     }
 
     // Instantiate all scopes.
-    for idx in 0..mir.visibility_scopes.len() {
-        let scope = VisibilityScope::new(idx);
+    for idx in 0..mir.source_scopes.len() {
+        let scope = SourceScope::new(idx);
         make_mir_scope(cx, &mir, &has_variables, debug_context, scope, &mut scopes);
     }
 
@@ -81,13 +81,13 @@ fn make_mir_scope(cx: &CodegenCx,
                   mir: &Mir,
                   has_variables: &BitVector,
                   debug_context: &FunctionDebugContextData,
-                  scope: VisibilityScope,
-                  scopes: &mut IndexVec<VisibilityScope, MirDebugScope>) {
+                  scope: SourceScope,
+                  scopes: &mut IndexVec<SourceScope, MirDebugScope>) {
     if scopes[scope].is_valid() {
         return;
     }
 
-    let scope_data = &mir.visibility_scopes[scope];
+    let scope_data = &mir.source_scopes[scope];
     let parent_scope = if let Some(parent) = scope_data.parent_scope {
         make_mir_scope(cx, mir, has_variables, debug_context, parent, scopes);
         scopes[parent]