Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

HirId-ification, continued #51321

Merged
merged 2 commits into from
Jul 2, 2018
Merged

HirId-ification, continued #51321

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
735d1bd
use HirId in middle::mem_categorization::cmt_, and consequences of that
zackmdavis Jun 3, 2018
f23d90a
add FIXMEs pleading for post-@ edit of commentary on mem_categorization
zackmdavis Jun 2, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
10 changes: 5 additions & 5 deletions src/librustc/middle/expr_use_visitor.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -319,7 +319,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
let fn_body_scope_r =
self.tcx().mk_region(ty::ReScope(region::Scope::Node(body.value.hir_id.local_id)));
let arg_cmt = Rc::new(self.mc.cat_rvalue(
arg.id,
arg.hir_id,
arg.pat.span,
fn_body_scope_r, // Args live only as long as the fn body.
arg_ty));
Expand Down Expand Up @@ -860,7 +860,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
// Each match binding is effectively an assignment to the
// binding being produced.
let def = Def::Local(canonical_id);
if let Ok(ref binding_cmt) = mc.cat_def(pat.id, pat.span, pat_ty, def) {
if let Ok(ref binding_cmt) = mc.cat_def(pat.hir_id, pat.span, pat_ty, def) {
delegate.mutate(pat.id, pat.span, binding_cmt, MutateMode::Init);
}

Expand Down Expand Up @@ -923,7 +923,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
closure_expr_id: closure_def_id.to_local(),
};
let upvar_capture = self.mc.tables.upvar_capture(upvar_id);
let cmt_var = return_if_err!(self.cat_captured_var(closure_expr.id,
let cmt_var = return_if_err!(self.cat_captured_var(closure_expr.hir_id,
fn_decl_span,
freevar));
match upvar_capture {
Expand All @@ -948,15 +948,15 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
}

fn cat_captured_var(&mut self,
closure_id: ast::NodeId,
closure_hir_id: hir::HirId,
closure_span: Span,
upvar: &hir::Freevar)
-> mc::McResult<mc::cmt_<'tcx>> {
// Create the cmt for the variable being borrowed, from the
// caller's perspective
let var_hir_id = self.tcx().hir.node_to_hir_id(upvar.var_id());
let var_ty = self.mc.node_ty(var_hir_id)?;
self.mc.cat_def(closure_id, closure_span, var_ty, upvar.def)
self.mc.cat_def(closure_hir_id, closure_span, var_ty, upvar.def)
}
}

Expand Down
109 changes: 57 additions & 52 deletions src/librustc/middle/mem_categorization.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -179,17 +179,21 @@ pub enum Note {
// and how it is located, as well as the mutability of the memory in
// which the value is stored.
//
// *WARNING* The field `cmt.ty` is NOT necessarily the same as the
// result of `node_id_to_type(cmt.id)`. This is because the `id` is
// always the `id` of the node producing the type; in an expression
// like `*x`, the type of this deref node is the deref'd type (`T`),
// but in a pattern like `@x`, the `@x` pattern is again a
// dereference, but its type is the type *before* the dereference
// (`@T`). So use `cmt.ty` to find the type of the value in a consistent
// fashion. For more details, see the method `cat_pattern`
// *WARNING* The field `cmt.type` is NOT necessarily the same as the
// result of `node_id_to_type(cmt.id)`.
//
// (FIXME: rewrite the following comment given that `@x` managed
// pointers have been obsolete for quite some time.)
//
// This is because the `id` is always the `id` of the node producing the
// type; in an expression like `*x`, the type of this deref node is the
// deref'd type (`T`), but in a pattern like `@x`, the `@x` pattern is
// again a dereference, but its type is the type *before* the
// dereference (`@T`). So use `cmt.ty` to find the type of the value in
// a consistent fashion. For more details, see the method `cat_pattern`
#[derive(Clone, Debug, PartialEq)]
pub struct cmt_<'tcx> {
pub id: ast::NodeId, // id of expr/pat producing this value
pub hir_id: hir::HirId, // HIR id of expr/pat producing this value
pub span: Span, // span of same expr/pat
pub cat: Categorization<'tcx>, // categorization of expr
pub mutbl: MutabilityCategory, // mutability of expr as place
Expand Down Expand Up @@ -271,18 +275,18 @@ impl<'tcx> cmt_<'tcx> {
}
}

pub trait ast_node {
fn id(&self) -> ast::NodeId;
pub trait HirNode {
fn hir_id(&self) -> hir::HirId;
fn span(&self) -> Span;
}

impl ast_node for hir::Expr {
fn id(&self) -> ast::NodeId { self.id }
impl HirNode for hir::Expr {
fn hir_id(&self) -> hir::HirId { self.hir_id }
fn span(&self) -> Span { self.span }
}

impl ast_node for hir::Pat {
fn id(&self) -> ast::NodeId { self.id }
impl HirNode for hir::Pat {
fn hir_id(&self) -> hir::HirId { self.hir_id }
fn span(&self) -> Span { self.span }
}

Expand Down Expand Up @@ -610,7 +614,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
ty: target,
mutbl: deref.mutbl,
});
self.cat_rvalue_node(expr.id, expr.span, ref_ty)
self.cat_rvalue_node(expr.hir_id, expr.span, ref_ty)
} else {
previous()?
});
Expand All @@ -625,7 +629,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
adjustment::Adjust::Borrow(_) |
adjustment::Adjust::Unsize => {
// Result is an rvalue.
Ok(self.cat_rvalue_node(expr.id, expr.span, target))
Ok(self.cat_rvalue_node(expr.hir_id, expr.span, target))
}
}
}
Expand Down Expand Up @@ -669,8 +673,8 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}

hir::ExprPath(ref qpath) => {
let def = self.tables.qpath_def(qpath, expr.hir_id);
self.cat_def(expr.id, expr.span, expr_ty, def)
let def = self.tables.qpath_def(qpath, expr.hir_id);
self.cat_def(expr.hir_id, expr.span, expr_ty, def)
}

hir::ExprType(ref e, _) => {
Expand All @@ -688,35 +692,35 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
hir::ExprLit(..) | hir::ExprBreak(..) |
hir::ExprContinue(..) | hir::ExprStruct(..) | hir::ExprRepeat(..) |
hir::ExprInlineAsm(..) | hir::ExprBox(..) => {
Ok(self.cat_rvalue_node(expr.id(), expr.span(), expr_ty))
Ok(self.cat_rvalue_node(expr.hir_id, expr.span, expr_ty))
}
}
}

pub fn cat_def(&self,
id: ast::NodeId,
hir_id: hir::HirId,
span: Span,
expr_ty: Ty<'tcx>,
def: Def)
-> McResult<cmt_<'tcx>> {
debug!("cat_def: id={} expr={:?} def={:?}",
id, expr_ty, def);
debug!("cat_def: id={:?} expr={:?} def={:?}",
hir_id, expr_ty, def);

match def {
Def::StructCtor(..) | Def::VariantCtor(..) | Def::Const(..) |
Def::AssociatedConst(..) | Def::Fn(..) | Def::Method(..) => {
Ok(self.cat_rvalue_node(id, span, expr_ty))
Ok(self.cat_rvalue_node(hir_id, span, expr_ty))
}

Def::Static(def_id, mutbl) => {
// `#[thread_local]` statics may not outlive the current function.
for attr in &self.tcx.get_attrs(def_id)[..] {
if attr.check_name("thread_local") {
return Ok(self.cat_rvalue_node(id, span, expr_ty));
return Ok(self.cat_rvalue_node(hir_id, span, expr_ty));
}
}
Ok(cmt_ {
id:id,
hir_id,
span:span,
cat:Categorization::StaticItem,
mutbl: if mutbl { McDeclared } else { McImmutable},
Expand All @@ -726,12 +730,12 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}

Def::Upvar(var_id, _, fn_node_id) => {
self.cat_upvar(id, span, var_id, fn_node_id)
self.cat_upvar(hir_id, span, var_id, fn_node_id)
}

Def::Local(vid) => {
Ok(cmt_ {
id,
hir_id,
span,
cat: Categorization::Local(vid),
mutbl: MutabilityCategory::from_local(self.tcx, self.tables, vid),
Expand All @@ -747,7 +751,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// Categorize an upvar, complete with invisible derefs of closure
// environment and upvar reference as appropriate.
fn cat_upvar(&self,
id: ast::NodeId,
hir_id: hir::HirId,
span: Span,
var_id: ast::NodeId,
fn_node_id: ast::NodeId)
Expand Down Expand Up @@ -814,7 +818,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// from the environment (perhaps we should eventually desugar
// this field further, but it will do for now).
let cmt_result = cmt_ {
id,
hir_id,
span,
cat: Categorization::Upvar(Upvar {id: upvar_id, kind: kind}),
mutbl: var_mutbl,
Expand All @@ -830,10 +834,10 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
cmt_result
}
ty::ClosureKind::FnMut => {
self.env_deref(id, span, upvar_id, var_mutbl, ty::MutBorrow, cmt_result)
self.env_deref(hir_id, span, upvar_id, var_mutbl, ty::MutBorrow, cmt_result)
}
ty::ClosureKind::Fn => {
self.env_deref(id, span, upvar_id, var_mutbl, ty::ImmBorrow, cmt_result)
self.env_deref(hir_id, span, upvar_id, var_mutbl, ty::ImmBorrow, cmt_result)
}
};

Expand All @@ -848,7 +852,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
ty::UpvarCapture::ByRef(upvar_borrow) => {
let ptr = BorrowedPtr(upvar_borrow.kind, upvar_borrow.region);
cmt_ {
id,
hir_id,
span,
cat: Categorization::Deref(Rc::new(cmt_result), ptr),
mutbl: MutabilityCategory::from_borrow_kind(upvar_borrow.kind),
Expand All @@ -864,7 +868,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}

fn env_deref(&self,
id: ast::NodeId,
hir_id: hir::HirId,
span: Span,
upvar_id: ty::UpvarId,
upvar_mutbl: MutabilityCategory,
Expand Down Expand Up @@ -908,7 +912,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}

let ret = cmt_ {
id,
hir_id,
span,
cat: Categorization::Deref(Rc::new(cmt_result), env_ptr),
mutbl: deref_mutbl,
Expand All @@ -932,17 +936,16 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
}

pub fn cat_rvalue_node(&self,
id: ast::NodeId,
hir_id: hir::HirId,
span: Span,
expr_ty: Ty<'tcx>)
-> cmt_<'tcx> {
debug!(
"cat_rvalue_node(id={:?}, span={:?}, expr_ty={:?})",
id,
hir_id,
span,
expr_ty,
);
let hir_id = self.tcx.hir.node_to_hir_id(id);
let promotable = self.rvalue_promotable_map.as_ref().map(|m| m.contains(&hir_id.local_id))
.unwrap_or(false);

Expand Down Expand Up @@ -970,18 +973,18 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
} else {
self.temporary_scope(hir_id.local_id)
};
let ret = self.cat_rvalue(id, span, re, expr_ty);
let ret = self.cat_rvalue(hir_id, span, re, expr_ty);
debug!("cat_rvalue_node ret {:?}", ret);
ret
}

pub fn cat_rvalue(&self,
cmt_id: ast::NodeId,
cmt_hir_id: hir::HirId,
span: Span,
temp_scope: ty::Region<'tcx>,
expr_ty: Ty<'tcx>) -> cmt_<'tcx> {
let ret = cmt_ {
id:cmt_id,
hir_id: cmt_hir_id,
span:span,
cat:Categorization::Rvalue(temp_scope),
mutbl:McDeclared,
Expand All @@ -992,15 +995,15 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
ret
}

pub fn cat_field<N:ast_node>(&self,
pub fn cat_field<N: HirNode>(&self,
node: &N,
base_cmt: cmt<'tcx>,
f_index: usize,
f_ident: ast::Ident,
f_ty: Ty<'tcx>)
-> cmt_<'tcx> {
let ret = cmt_ {
id: node.id(),
hir_id: node.hir_id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: Categorization::Interior(base_cmt,
Expand Down Expand Up @@ -1042,13 +1045,13 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
mutbl,
});

let base_cmt = Rc::new(self.cat_rvalue_node(expr.id, expr.span, ref_ty));
let base_cmt = Rc::new(self.cat_rvalue_node(expr.hir_id, expr.span, ref_ty));
self.cat_deref(expr, base_cmt, note)
}

pub fn cat_deref(
&self,
node: &impl ast_node,
node: &impl HirNode,
base_cmt: cmt<'tcx>,
note: Note,
) -> McResult<cmt_<'tcx>> {
Expand All @@ -1074,7 +1077,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
ref ty => bug!("unexpected type in cat_deref: {:?}", ty)
};
let ret = cmt_ {
id: node.id(),
hir_id: node.hir_id(),
span: node.span(),
// For unique ptrs, we inherit mutability from the owning reference.
mutbl: MutabilityCategory::from_pointer_kind(base_cmt.mutbl, ptr),
Expand All @@ -1086,7 +1089,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
Ok(ret)
}

fn cat_index<N:ast_node>(&self,
fn cat_index<N: HirNode>(&self,
elt: &N,
base_cmt: cmt<'tcx>,
element_ty: Ty<'tcx>,
Expand All @@ -1106,7 +1109,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
//! presuming that `base_cmt` is not of fixed-length type.
//!
//! # Parameters
//! - `elt`: the AST node being indexed
//! - `elt`: the HIR node being indexed
//! - `base_cmt`: the cmt of `elt`

let interior_elem = InteriorElement(context);
Expand All @@ -1115,14 +1118,14 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
return Ok(ret);
}

pub fn cat_imm_interior<N:ast_node>(&self,
pub fn cat_imm_interior<N:HirNode>(&self,
node: &N,
base_cmt: cmt<'tcx>,
interior_ty: Ty<'tcx>,
interior: InteriorKind)
-> cmt_<'tcx> {
let ret = cmt_ {
id: node.id(),
hir_id: node.hir_id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: Categorization::Interior(base_cmt, interior),
Expand All @@ -1133,7 +1136,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
ret
}

pub fn cat_downcast_if_needed<N:ast_node>(&self,
pub fn cat_downcast_if_needed<N:HirNode>(&self,
node: &N,
base_cmt: cmt<'tcx>,
variant_did: DefId)
Expand All @@ -1143,7 +1146,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
if self.tcx.adt_def(base_did).variants.len() != 1 {
let base_ty = base_cmt.ty;
let ret = Rc::new(cmt_ {
id: node.id(),
hir_id: node.hir_id(),
span: node.span(),
mutbl: base_cmt.mutbl.inherit(),
cat: Categorization::Downcast(base_cmt, variant_did),
Expand Down Expand Up @@ -1193,6 +1196,8 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// value, and I consider them to produce the value that was
// matched. So if you have something like:
//
// (FIXME: `@@3` is not legal code anymore!)
//
// let x = @@3;
// match x {
// @@y { ... }
Expand Down
Loading