mutability,
ty,
name,
- source_info,
syntactic_source_info,
+ visibility_source_info,
internal,
is_user_variable
});
/// to generate better debuginfo.
pub name: Option<Name>,
- /// Source info of the local. The `SourceScope` is the *visibility* one,
- /// not the the *syntactic* one (see `syntactic_source_info` for more details).
- pub source_info: SourceInfo,
-
/// 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
/// To allow both uses to work, we need to have more than a single scope
/// for a local. We have the `syntactic_source_info.scope` represent the
/// "syntactic" lint scope (with a variable being under its let
- /// block) while the `source_info.scope` represents the "local variable"
+ /// block) while the `visibility_source_info.scope` represents the "local variable"
/// scope (where the "rest" of a block is under all prior let-statements).
///
/// The end result looks like this:
/// │ │
/// │ │ │{ let y: u32 }
/// │ │ │
- /// │ │ │← y.source_info.scope
+ /// │ │ │← y.visibility_source_info.scope
/// │ │ │← `y + 2`
/// │
/// │ │{ let x: u32 }
- /// │ │← x.source_info.scope
+ /// │ │← x.visibility_source_info.scope
/// │ │← `drop(x)` // this accesses `x: u32`
/// ```
pub syntactic_source_info: SourceInfo,
+
+ /// Source info of the local. The `SourceScope` is the *visibility* one,
+ /// not the the *syntactic* one (see `syntactic_source_info` for more details).
+ pub visibility_source_info: SourceInfo,
}
impl<'tcx> LocalDecl<'tcx> {
mutability: Mutability::Mut,
ty,
name: None,
- source_info: SourceInfo {
+ syntactic_source_info: SourceInfo {
span,
scope: OUTERMOST_SOURCE_SCOPE
},
- syntactic_source_info: SourceInfo {
+ visibility_source_info: SourceInfo {
span,
scope: OUTERMOST_SOURCE_SCOPE
},
mutability: Mutability::Mut,
ty,
name: None,
- source_info: SourceInfo {
+ syntactic_source_info: SourceInfo {
span,
scope: OUTERMOST_SOURCE_SCOPE
},
- syntactic_source_info: SourceInfo {
+ visibility_source_info: SourceInfo {
span,
scope: OUTERMOST_SOURCE_SCOPE
},
LocalDecl {
mutability: Mutability::Mut,
ty: return_ty,
- source_info: SourceInfo {
+ syntactic_source_info: SourceInfo {
span,
scope: OUTERMOST_SOURCE_SCOPE
},
- syntactic_source_info: SourceInfo {
+ visibility_source_info: SourceInfo {
span,
scope: OUTERMOST_SOURCE_SCOPE
},
internal,
ty,
name,
- source_info,
syntactic_source_info,
+ visibility_source_info,
}
}
mutability: _,
ref $($mutability)* ty,
name: _,
- ref $($mutability)* source_info,
- internal: _,
ref $($mutability)* syntactic_source_info,
+ ref $($mutability)* visibility_source_info,
+ internal: _,
is_user_variable: _,
} = *local_decl;
self.visit_ty(ty, TyContext::LocalDecl {
local,
- source_info: *source_info,
+ source_info: *visibility_source_info,
});
self.visit_source_info(syntactic_source_info);
- self.visit_source_info(source_info);
+ self.visit_source_info(visibility_source_info);
}
fn super_source_scope(&mut self,
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());
+ has_variables.insert(decl.visibility_source_info.scope.index());
}
// Instantiate all scopes.
if let Some(name) = decl.name {
// User variable
- let debug_scope = fx.scopes[decl.source_info.scope];
+ let debug_scope = fx.scopes[decl.visibility_source_info.scope];
let dbg = debug_scope.is_valid() && bx.sess().opts.debuginfo == FullDebugInfo;
if !memory_locals.contains(local.index()) && !dbg {
debug!("alloc: {:?} ({}) -> place", local, name);
let place = PlaceRef::alloca(&bx, layout, &name.as_str());
if dbg {
- let (scope, span) = fx.debug_loc(decl.source_info);
+ let (scope, span) = fx.debug_loc(decl.visibility_source_info);
declare_local(&bx, &fx.debug_context, name, layout.ty, scope,
VariableAccess::DirectVariable { alloca: place.llval },
VariableKind::LocalVariable, span);
let borrow_span = self.mir.source_info(borrow.reserve_location).span;
let proper_span = match *root_place {
- Place::Local(local) => self.mir.local_decls[local].source_info.span,
+ Place::Local(local) => self.mir.local_decls[local].visibility_source_info.span,
_ => drop_span,
};
None => continue,
}
- let source_info = local_decl.source_info;
+ let source_info = local_decl.visibility_source_info;
let mut_span = tcx.sess.codemap().span_until_non_whitespace(source_info.span);
tcx.struct_span_lint_node(
}
None => {
err.span_label(
- mir.local_decls[local].source_info.span,
+ mir.local_decls[local].visibility_source_info.span,
"borrow may end up in a temporary, created here",
);
LocalKind::Var | LocalKind::Temp => {}
}
- let span = local_decl.source_info.span;
+ let span = local_decl.visibility_source_info.span;
let ty = local_decl.ty;
// Erase the regions from `ty` to get a global type. The
mutability: Mutability::Mut,
ty: ptr_ty,
name: None,
- source_info,
syntactic_source_info: source_info,
+ visibility_source_info: source_info,
internal: true,
is_user_variable: false
});
block.unit()
}
- /// Declares the bindings of the given pattern and returns the source scope
+ /// Declares the bindings of the given pattern and returns the visibility scope
/// for the bindings in this patterns, if such a scope had to be created.
/// NOTE: Declaring the bindings should always be done in their drop scope.
pub fn declare_bindings(&mut self,
- mut var_scope: Option<SourceScope>,
+ mut visibility_scope: Option<SourceScope>,
scope_span: Span,
lint_level: LintLevel,
pattern: &Pattern<'tcx>,
has_guard: ArmHasGuard)
-> Option<SourceScope> {
- assert!(!(var_scope.is_some() && lint_level.is_explicit()),
- "can't have both a var and a lint scope at the same time");
+ assert!(!(visibility_scope.is_some() && lint_level.is_explicit()),
+ "can't have both a visibility and a lint scope at the same time");
let mut syntactic_scope = self.source_scope;
self.visit_bindings(pattern, &mut |this, mutability, name, var, span, ty| {
- if var_scope.is_none() {
- var_scope = Some(this.new_source_scope(scope_span,
+ if visibility_scope.is_none() {
+ visibility_scope = Some(this.new_source_scope(scope_span,
LintLevel::Inherited,
None));
// If we have lints, create a new source scope
this.new_source_scope(scope_span, lint_level, None);
}
}
- let source_info = SourceInfo {
- span,
- scope: var_scope.unwrap()
- };
let syntactic_source_info = SourceInfo {
span,
scope: syntactic_scope,
};
- this.declare_binding(source_info, syntactic_source_info, mutability, name, var,
+ let visibility_source_info = SourceInfo {
+ span,
+ scope: visibility_scope.unwrap()
+ };
+ this.declare_binding(syntactic_source_info, visibility_source_info, mutability, name, var,
ty, has_guard);
});
- var_scope
+ visibility_scope
}
pub fn storage_live_binding(&mut self,
/// `&T`. The second local is a binding for occurrences of `var`
/// in the arm body, which will have type `T`.
fn declare_binding(&mut self,
- source_info: SourceInfo,
syntactic_source_info: SourceInfo,
+ visibility_source_info: SourceInfo,
mutability: Mutability,
name: Name,
var_id: NodeId,
var_ty: Ty<'tcx>,
has_guard: ArmHasGuard)
{
- debug!("declare_binding(var_id={:?}, name={:?}, var_ty={:?}, source_info={:?}, \
+ debug!("declare_binding(var_id={:?}, name={:?}, var_ty={:?}, visibility_source_info={:?}, \
syntactic_source_info={:?})",
- var_id, name, var_ty, source_info, syntactic_source_info);
+ var_id, name, var_ty, visibility_source_info, syntactic_source_info);
let tcx = self.hir.tcx();
let local = LocalDecl::<'tcx> {
mutability,
ty: var_ty.clone(),
name: Some(name),
- source_info,
syntactic_source_info,
+ visibility_source_info,
internal: false,
is_user_variable: true,
};
mutability,
ty: tcx.mk_imm_ref(tcx.types.re_empty, var_ty),
name: Some(name),
- source_info,
syntactic_source_info,
+ visibility_source_info,
internal: false,
is_user_variable: true,
});
self.local_decls.push(LocalDecl {
mutability: Mutability::Mut,
ty,
- source_info,
syntactic_source_info: source_info,
+ visibility_source_info: source_info,
name,
internal: false,
is_user_variable: false,
fn gather_args(&mut self) {
for arg in self.mir.args_iter() {
let path = self.data.rev_lookup.locals[arg];
- let span = self.mir.local_decls[arg].source_info.span;
+ let span = self.mir.local_decls[arg].visibility_source_info.span;
let init = self.data.inits.push(Init {
path, span, kind: InitKind::Deep
let source_info = SourceInfo { scope: OUTERMOST_SOURCE_SCOPE, span };
LocalDecl {
mutability, ty, name: None,
- source_info,
syntactic_source_info: source_info,
+ visibility_source_info: source_info,
internal: false,
is_user_variable: false
}
// Internal locals are used in the `move_val_init` desugaring.
// We want to check unsafety against the source info of the
// desugaring, rather than the source info of the RHS.
- self.source_info = self.mir.local_decls[local].source_info;
+ self.source_info = self.mir.local_decls[local].visibility_source_info;
}
}
let base_ty = base.ty(self.mir, self.tcx).to_ty(self.tcx);
mutability: Mutability::Mut,
ty: ret_ty,
name: None,
- source_info,
syntactic_source_info: source_info,
+ visibility_source_info: source_info,
internal: false,
is_user_variable: false,
};
mutability: Mutability::Mut,
ty: tcx.mk_nil(),
name: None,
- source_info,
syntactic_source_info: source_info,
+ visibility_source_info: source_info,
internal: false,
is_user_variable: false,
};
mutbl: hir::Mutability::MutMutable,
}),
name: None,
- source_info,
syntactic_source_info: source_info,
+ visibility_source_info: source_info,
internal: false,
is_user_variable: false,
};
for loc in callee_mir.vars_and_temps_iter() {
let mut local = callee_mir.local_decls[loc].clone();
- local.source_info.scope = scope_map[local.source_info.scope];
- local.source_info.span = callsite.location.span;
local.syntactic_source_info.scope =
scope_map[local.syntactic_source_info.scope];
local.syntactic_source_info.span = callsite.location.span;
+ local.visibility_source_info.scope =
+ scope_map[local.visibility_source_info.scope];
+ local.visibility_source_info.span = callsite.location.span;
let idx = caller_mir.local_decls.push(local);
local_map.push(idx);
let no_stmts = self.source[loc.block].statements.len();
let new_temp = self.promoted.local_decls.push(
LocalDecl::new_temp(self.source.local_decls[temp].ty,
- self.source.local_decls[temp].source_info.span));
+ self.source.local_decls[temp].visibility_source_info.span));
debug!("promote({:?} @ {:?}/{:?}, {:?})",
temp, loc, no_stmts, self.keep_original);
// This is because `*r` requires `r` to be a local,
// otherwise we would use the `promoted` directly.
let mut promoted_ref = LocalDecl::new_temp(ref_ty, span);
- promoted_ref.source_info = statement.source_info;
promoted_ref.syntactic_source_info = statement.source_info;
+ promoted_ref.visibility_source_info = statement.source_info;
let promoted_ref = local_decls.push(promoted_ref);
assert_eq!(self.temps.push(TempState::Unpromotable), promoted_ref);
self.extra_statements.push((loc, Statement {
// conservatively, that drop elaboration will do.
let needs_drop = if let Place::Local(local) = *place {
if self.local_qualif[local].map_or(true, |q| q.intersects(Qualif::NEEDS_DROP)) {
- Some(self.mir.local_decls[local].source_info.span)
+ Some(self.mir.local_decls[local].visibility_source_info.span)
} else {
None
}
let mut err = feature_err(
&self.tcx.sess.parse_sess,
"const_let",
- decl.source_info.span,
+ decl.visibility_source_info.span,
GateIssue::Language,
"arguments of constant functions can only be immutable by-value bindings"
);
// User variable types (including the user's name in a comment).
for local in mir.vars_iter() {
let var = &mir.local_decls[local];
- let (name, source_info) = if var.source_info.scope == child {
- (var.name.unwrap(), var.source_info)
+ let (name, source_info) = if var.visibility_source_info.scope == child {
+ (var.name.unwrap(), var.visibility_source_info)
} else {
// Not a variable or not declared in this scope.
continue;