From 64fb709f99bdfb7d9a182eeaa068c7f209ce421b Mon Sep 17 00:00:00 2001 From: Vadim Petrochenkov Date: Sun, 20 Sep 2015 14:00:18 +0300 Subject: [PATCH] Use Names in hir::{Field, ExprMethodCall, ExprField} --- src/librustc/middle/const_eval.rs | 6 ++-- src/librustc/middle/dead.rs | 4 +-- src/librustc/middle/expr_use_visitor.rs | 2 +- src/librustc/middle/mem_categorization.rs | 2 +- src/librustc/middle/pat_util.rs | 4 +-- src/librustc/middle/stability.rs | 4 +-- src/librustc_back/svh.rs | 2 +- src/librustc_front/fold.rs | 14 ++++---- src/librustc_front/hir.rs | 27 ++++----------- src/librustc_front/lowering.rs | 11 +++--- src/librustc_front/print/pprust.rs | 16 ++++----- src/librustc_mir/tcx/expr.rs | 4 +-- src/librustc_mir/tcx/to_ref.rs | 3 +- src/librustc_privacy/lib.rs | 8 ++--- src/librustc_resolve/lib.rs | 8 ++--- src/librustc_trans/trans/_match.rs | 2 +- src/librustc_trans/trans/consts.rs | 4 +-- src/librustc_trans/trans/expr.rs | 8 ++--- src/librustc_typeck/check/mod.rs | 41 +++++++++++------------ 19 files changed, 79 insertions(+), 91 deletions(-) diff --git a/src/librustc/middle/const_eval.rs b/src/librustc/middle/const_eval.rs index ae9f0108610..9e7ef0187c2 100644 --- a/src/librustc/middle/const_eval.rs +++ b/src/librustc/middle/const_eval.rs @@ -314,7 +314,7 @@ pub fn const_expr_to_pat(tcx: &ty::ctxt, expr: &Expr, span: Span) -> P let field_pats = fields.iter().map(|field| codemap::Spanned { span: codemap::DUMMY_SP, node: hir::FieldPat { - ident: field.ident.node, + ident: ast::Ident::new(field.name.node), pat: const_expr_to_pat(tcx, &*field.expr, span), is_shorthand: false, }, @@ -1040,8 +1040,8 @@ pub fn eval_const_expr_partial<'tcx>(tcx: &ty::ctxt<'tcx>, if let hir::ExprStruct(_, ref fields, _) = tcx.map.expect_expr(struct_id).node { // Check that the given field exists and evaluate it // if the idents are compared run-pass/issue-19244 fails - if let Some(f) = fields.iter().find(|f| f.ident.node.name - == field_name.node.name) { + if let Some(f) = fields.iter().find(|f| f.name.node + == field_name.node) { return eval_const_expr_partial(tcx, &*f.expr, base_hint) } else { signal!(e, MissingStructField); diff --git a/src/librustc/middle/dead.rs b/src/librustc/middle/dead.rs index 3a7ba822980..b234a6166a4 100644 --- a/src/librustc/middle/dead.rs +++ b/src/librustc/middle/dead.rs @@ -227,8 +227,8 @@ impl<'a, 'tcx, 'v> Visitor<'v> for MarkSymbolVisitor<'a, 'tcx> { hir::ExprMethodCall(..) => { self.lookup_and_handle_method(expr.id); } - hir::ExprField(ref lhs, ref ident) => { - self.handle_field_access(&**lhs, ident.node.name); + hir::ExprField(ref lhs, ref name) => { + self.handle_field_access(&**lhs, name.node); } hir::ExprTupField(ref lhs, idx) => { self.handle_tup_field_access(&**lhs, idx.node); diff --git a/src/librustc/middle/expr_use_visitor.rs b/src/librustc/middle/expr_use_visitor.rs index 29708494048..a8eb109398a 100644 --- a/src/librustc/middle/expr_use_visitor.rs +++ b/src/librustc/middle/expr_use_visitor.rs @@ -710,7 +710,7 @@ impl<'d,'t,'a,'tcx> ExprUseVisitor<'d,'t,'a,'tcx> { -> bool { fields.iter().any( - |f| f.ident.node.name == field.name) + |f| f.name.node == field.name) } } diff --git a/src/librustc/middle/mem_categorization.rs b/src/librustc/middle/mem_categorization.rs index 2078ee2c57b..f3629c66416 100644 --- a/src/librustc/middle/mem_categorization.rs +++ b/src/librustc/middle/mem_categorization.rs @@ -474,7 +474,7 @@ impl<'t, 'a,'tcx> MemCategorizationContext<'t, 'a, 'tcx> { expr.id, expr, base_cmt); - Ok(self.cat_field(expr, base_cmt, f_name.node.name, expr_ty)) + Ok(self.cat_field(expr, base_cmt, f_name.node, expr_ty)) } hir::ExprTupField(ref base, idx) => { diff --git a/src/librustc/middle/pat_util.rs b/src/librustc/middle/pat_util.rs index 3c483f70a4e..6f55ddfdfd2 100644 --- a/src/librustc/middle/pat_util.rs +++ b/src/librustc/middle/pat_util.rs @@ -16,7 +16,7 @@ use util::nodemap::FnvHashMap; use syntax::ast; use rustc_front::hir; use rustc_front::util::walk_pat; -use syntax::codemap::{Span, DUMMY_SP}; +use syntax::codemap::{Span, Spanned, DUMMY_SP}; pub type PatIdMap = FnvHashMap; @@ -109,7 +109,7 @@ pub fn pat_is_binding_or_wild(dm: &DefMap, pat: &hir::Pat) -> bool { /// Call `it` on every "binding" in a pattern, e.g., on `a` in /// `match foo() { Some(a) => (), None => () }` pub fn pat_bindings(dm: &DefMap, pat: &hir::Pat, mut it: I) where - I: FnMut(hir::BindingMode, ast::NodeId, Span, &hir::SpannedIdent), + I: FnMut(hir::BindingMode, ast::NodeId, Span, &Spanned), { walk_pat(pat, |p| { match p.node { diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index be199212750..6ff6e8e3d0f 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -418,7 +418,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &hir::Expr, hir::ExprField(ref base_e, ref field) => { span = field.span; match tcx.expr_ty_adjusted(base_e).sty { - ty::TyStruct(def, _) => def.struct_variant().field_named(field.node.name).did, + ty::TyStruct(def, _) => def.struct_variant().field_named(field.node).did, _ => tcx.sess.span_bug(e.span, "stability::check_expr: named field access on non-struct") } @@ -441,7 +441,7 @@ pub fn check_expr(tcx: &ty::ctxt, e: &hir::Expr, // in the construction expression. for field in expr_fields { let did = def.struct_variant() - .field_named(field.ident.node.name) + .field_named(field.name.node) .did; maybe_do_stability_check(tcx, did, field.span, cb); } diff --git a/src/librustc_back/svh.rs b/src/librustc_back/svh.rs index 93c7c928b3c..7004e72f8f5 100644 --- a/src/librustc_back/svh.rs +++ b/src/librustc_back/svh.rs @@ -270,7 +270,7 @@ mod svh_visitor { ExprBlock(..) => SawExprBlock, ExprAssign(..) => SawExprAssign, ExprAssignOp(op, _, _) => SawExprAssignOp(op.node), - ExprField(_, id) => SawExprField(id.node.name.as_str()), + ExprField(_, name) => SawExprField(name.node.as_str()), ExprTupField(_, id) => SawExprTupField(id.node), ExprIndex(..) => SawExprIndex, ExprRange(..) => SawExprRange, diff --git a/src/librustc_front/fold.rs b/src/librustc_front/fold.rs index f0b4e5328b5..e0e4539872e 100644 --- a/src/librustc_front/fold.rs +++ b/src/librustc_front/fold.rs @@ -721,9 +721,9 @@ pub fn noop_fold_struct_field(f: StructField, fld: &mut T) -> StructF } } -pub fn noop_fold_field(Field {ident, expr, span}: Field, folder: &mut T) -> Field { +pub fn noop_fold_field(Field {name, expr, span}: Field, folder: &mut T) -> Field { Field { - ident: respan(ident.span, fold_ident(folder, ident.node)), + name: respan(folder.new_span(name.span), folder.fold_name(name.node)), expr: folder.fold_expr(expr), span: folder.new_span(span) } @@ -1050,9 +1050,9 @@ pub fn noop_fold_expr(Expr {id, node, span}: Expr, folder: &mut T) -> ExprCall(folder.fold_expr(f), args.move_map(|x| folder.fold_expr(x))) } - ExprMethodCall(i, tps, args) => { + ExprMethodCall(name, tps, args) => { ExprMethodCall( - respan(folder.new_span(i.span), fold_ident(folder, i.node)), + respan(folder.new_span(name.span), folder.fold_name(name.node)), tps.move_map(|x| folder.fold_ty(x)), args.move_map(|x| folder.fold_expr(x))) } @@ -1102,10 +1102,10 @@ pub fn noop_fold_expr(Expr {id, node, span}: Expr, folder: &mut T) -> folder.fold_expr(el), folder.fold_expr(er)) } - ExprField(el, ident) => { + ExprField(el, name) => { ExprField(folder.fold_expr(el), - respan(folder.new_span(ident.span), - fold_ident(folder, ident.node))) + respan(folder.new_span(name.span), + folder.fold_name(name.node))) } ExprTupField(el, ident) => { ExprTupField(folder.fold_expr(el), diff --git a/src/librustc_front/hir.rs b/src/librustc_front/hir.rs index 7997ac7ea10..5585833a39f 100644 --- a/src/librustc_front/hir.rs +++ b/src/librustc_front/hir.rs @@ -52,10 +52,6 @@ use util; use std::fmt; use serialize::{Encodable, Encoder, Decoder}; - -/// Function name (not all functions have names) -pub type FnIdent = Option; - #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Copy)] pub struct Lifetime { pub id: NodeId, @@ -416,7 +412,7 @@ pub enum Pat_ { /// which it is. The resolver determines this, and /// records this pattern's NodeId in an auxiliary /// set (of "PatIdents that refer to nullary enums") - PatIdent(BindingMode, SpannedIdent, Option>), + PatIdent(BindingMode, Spanned, Option>), /// "None" means a * pattern where we don't bind the fields to names. PatEnum(Path, Option>>), @@ -564,13 +560,11 @@ pub struct Arm { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct Field { - pub ident: SpannedIdent, + pub name: Spanned, pub expr: P, pub span: Span, } -pub type SpannedIdent = Spanned; - #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum BlockCheckMode { DefaultBlock, @@ -612,7 +606,7 @@ pub enum Expr_ { ExprCall(P, Vec>), /// A method call (`x.foo::(a, b, c, d)`) /// - /// The `SpannedIdent` is the identifier for the method name. + /// The `Spanned` is the identifier for the method name. /// The vector of `Ty`s are the ascripted type parameters for the method /// (within the angle brackets). /// @@ -622,7 +616,7 @@ pub enum Expr_ { /// /// Thus, `x.foo::(a, b, c, d)` is represented as /// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])`. - ExprMethodCall(SpannedIdent, Vec>, Vec>), + ExprMethodCall(Spanned, Vec>, Vec>), /// A tuple (`(a, b, c ,d)`) ExprTup(Vec>), /// A binary operation (For example: `a + b`, `a * b`) @@ -662,7 +656,7 @@ pub enum Expr_ { /// For example, `a += 1`. ExprAssignOp(BinOp, P, P), /// Access of a named struct field (`obj.foo`) - ExprField(P, SpannedIdent), + ExprField(P, Spanned), /// Access of an unnamed field of a struct or tuple-struct /// /// For example, `foo.0`. @@ -682,9 +676,9 @@ pub enum Expr_ { /// A referencing operation (`&a` or `&mut a`) ExprAddrOf(Mutability, P), /// A `break`, with an optional label to break - ExprBreak(Option), + ExprBreak(Option>), /// A `continue`, with an optional label - ExprAgain(Option), + ExprAgain(Option>), /// A `return`, with an optional value to be returned ExprRet(Option>), @@ -744,13 +738,6 @@ pub struct MutTy { pub mutbl: Mutability, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -pub struct TypeField { - pub ident: Ident, - pub mt: MutTy, - pub span: Span, -} - /// Represents a method's signature in a trait declaration, /// or in an implementation. #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] diff --git a/src/librustc_front/lowering.rs b/src/librustc_front/lowering.rs index 92a77131bda..2ce80e95302 100644 --- a/src/librustc_front/lowering.rs +++ b/src/librustc_front/lowering.rs @@ -14,7 +14,7 @@ use hir; use syntax::ast::*; use syntax::ptr::P; -use syntax::codemap::Spanned; +use syntax::codemap::{respan, Spanned}; use syntax::owned_slice::OwnedSlice; @@ -370,7 +370,10 @@ pub fn lower_struct_field(f: &StructField) -> hir::StructField { } pub fn lower_field(f: &Field) -> hir::Field { - hir::Field { ident: f.ident, expr: lower_expr(&f.expr), span: f.span } + hir::Field { + name: respan(f.ident.span, f.ident.node.name), + expr: lower_expr(&f.expr), span: f.span + } } pub fn lower_mt(mt: &MutTy) -> hir::MutTy { @@ -704,7 +707,7 @@ pub fn lower_expr(e: &Expr) -> P { } ExprMethodCall(i, ref tps, ref args) => { hir::ExprMethodCall( - i, + respan(i.span, i.node.name), tps.iter().map(|x| lower_ty(x)).collect(), args.iter().map(|x| lower_expr(x)).collect()) } @@ -755,7 +758,7 @@ pub fn lower_expr(e: &Expr) -> P { lower_expr(er)) } ExprField(ref el, ident) => { - hir::ExprField(lower_expr(el), ident) + hir::ExprField(lower_expr(el), respan(ident.span, ident.node.name)) } ExprTupField(ref el, ident) => { hir::ExprTupField(lower_expr(el), ident) diff --git a/src/librustc_front/print/pprust.rs b/src/librustc_front/print/pprust.rs index ba944bfd988..ba4c61c83a0 100644 --- a/src/librustc_front/print/pprust.rs +++ b/src/librustc_front/print/pprust.rs @@ -13,7 +13,7 @@ pub use self::AnnNode::*; use syntax::abi; use syntax::ast; use syntax::owned_slice::OwnedSlice; -use syntax::codemap::{self, CodeMap, BytePos}; +use syntax::codemap::{self, CodeMap, BytePos, Spanned}; use syntax::diagnostic; use syntax::parse::token::{self, BinOpToken}; use syntax::parse::lexer::comments; @@ -1223,7 +1223,7 @@ impl<'a> State<'a> { &fields[..], |s, field| { try!(s.ibox(indent_unit)); - try!(s.print_ident(field.ident.node)); + try!(s.print_name(field.name.node)); try!(s.word_space(":")); try!(s.print_expr(&*field.expr)); s.end() @@ -1265,13 +1265,13 @@ impl<'a> State<'a> { } fn print_expr_method_call(&mut self, - ident: hir::SpannedIdent, + name: Spanned, tys: &[P], args: &[P]) -> io::Result<()> { let base_args = &args[1..]; try!(self.print_expr(&*args[0])); try!(word(&mut self.s, ".")); - try!(self.print_ident(ident.node)); + try!(self.print_name(name.node)); if !tys.is_empty() { try!(word(&mut self.s, "::<")); try!(self.commasep(Inconsistent, tys, @@ -1329,8 +1329,8 @@ impl<'a> State<'a> { hir::ExprCall(ref func, ref args) => { try!(self.print_expr_call(&**func, &args[..])); } - hir::ExprMethodCall(ident, ref tys, ref args) => { - try!(self.print_expr_method_call(ident, &tys[..], &args[..])); + hir::ExprMethodCall(name, ref tys, ref args) => { + try!(self.print_expr_method_call(name, &tys[..], &args[..])); } hir::ExprBinary(op, ref lhs, ref rhs) => { try!(self.print_expr_binary(op, &**lhs, &**rhs)); @@ -1435,10 +1435,10 @@ impl<'a> State<'a> { try!(self.word_space("=")); try!(self.print_expr(&**rhs)); } - hir::ExprField(ref expr, id) => { + hir::ExprField(ref expr, name) => { try!(self.print_expr(&**expr)); try!(word(&mut self.s, ".")); - try!(self.print_ident(id.node)); + try!(self.print_name(name.node)); } hir::ExprTupField(ref expr, id) => { try!(self.print_expr(&**expr)); diff --git a/src/librustc_mir/tcx/expr.rs b/src/librustc_mir/tcx/expr.rs index 7e68993b130..78f23fcd71c 100644 --- a/src/librustc_mir/tcx/expr.rs +++ b/src/librustc_mir/tcx/expr.rs @@ -288,9 +288,9 @@ impl<'a,'tcx:'a> Mirror> for &'tcx hir::Expr { hir::ExprLoop(ref body, _) => ExprKind::Loop { condition: None, body: block::to_expr_ref(cx, body) }, - hir::ExprField(ref source, ident) => + hir::ExprField(ref source, name) => ExprKind::Field { lhs: source.to_ref(), - name: Field::Named(ident.node.name) }, + name: Field::Named(name.node) }, hir::ExprTupField(ref source, ident) => ExprKind::Field { lhs: source.to_ref(), name: Field::Indexed(ident.node) }, diff --git a/src/librustc_mir/tcx/to_ref.rs b/src/librustc_mir/tcx/to_ref.rs index 6d5e4c2e3fd..3c8a5534e1a 100644 --- a/src/librustc_mir/tcx/to_ref.rs +++ b/src/librustc_mir/tcx/to_ref.rs @@ -86,9 +86,8 @@ impl<'a,'tcx:'a> ToRef> for &'tcx hir::Field { fn to_ref(self) -> FieldExprRef> { FieldExprRef { - name: Field::Named(self.ident.node.name), + name: Field::Named(self.name.node), expr: self.expr.to_ref() } } } - diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index b16d6baa73f..d077ee451fb 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -866,12 +866,12 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { fn visit_expr(&mut self, expr: &hir::Expr) { match expr.node { - hir::ExprField(ref base, ident) => { + hir::ExprField(ref base, name) => { if let ty::TyStruct(def, _) = self.tcx.expr_ty_adjusted(&**base).sty { self.check_field(expr.span, def, def.struct_variant(), - NamedField(ident.node.name)); + NamedField(name.node)); } } hir::ExprTupField(ref base, idx) => { @@ -882,11 +882,11 @@ impl<'a, 'tcx, 'v> Visitor<'v> for PrivacyVisitor<'a, 'tcx> { UnnamedField(idx.node)); } } - hir::ExprMethodCall(ident, _, _) => { + hir::ExprMethodCall(name, _, _) => { let method_call = ty::MethodCall::expr(expr.id); let method = self.tcx.tables.borrow().method_map[&method_call]; debug!("(privacy checking) checking impl method"); - self.check_method(expr.span, method.def_id, ident.node.name); + self.check_method(expr.span, method.def_id, name.node); } hir::ExprStruct(..) => { let adt = self.tcx.expr_ty(expr).ty_adt_def().unwrap(); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index ce56c1548fa..04e90be5363 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -3817,19 +3817,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> { fn record_candidate_traits_for_expr_if_necessary(&mut self, expr: &Expr) { match expr.node { - ExprField(_, ident) => { + ExprField(_, name) => { // FIXME(#6890): Even though you can't treat a method like a // field, we need to add any trait methods we find that match // the field name so that we can do some nice error reporting // later on in typeck. - let traits = self.get_traits_containing_item(ident.node.name); + let traits = self.get_traits_containing_item(name.node); self.trait_map.insert(expr.id, traits); } - ExprMethodCall(ident, _, _) => { + ExprMethodCall(name, _, _) => { debug!("(recording candidate traits for expr) recording \ traits for {}", expr.id); - let traits = self.get_traits_containing_item(ident.node.name); + let traits = self.get_traits_containing_item(name.node); self.trait_map.insert(expr.id, traits); } _ => { diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index aaa10aacd03..cccc610601c 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -1436,7 +1436,7 @@ fn is_discr_reassigned(bcx: Block, discr: &hir::Expr, body: &hir::Expr) -> bool Some(def::DefLocal(vid)) | Some(def::DefUpvar(vid, _, _)) => vid, _ => return false }; - (vid, Some(mc::NamedField(field.node.name))) + (vid, Some(mc::NamedField(field.node))) }, hir::ExprTupField(ref base, field) => { let vid = match bcx.tcx().def_map.borrow().get(&base.id).map(|d| d.full_def()) { diff --git a/src/librustc_trans/trans/consts.rs b/src/librustc_trans/trans/consts.rs index 1d0c5137ece..ccf602126eb 100644 --- a/src/librustc_trans/trans/consts.rs +++ b/src/librustc_trans/trans/consts.rs @@ -574,7 +574,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let (bv, bt) = const_expr(cx, &**base, param_substs, fn_args); let brepr = adt::represent_type(cx, bt); let vinfo = VariantInfo::from_ty(cx.tcx(), bt, None); - let ix = vinfo.field_index(field.node.name); + let ix = vinfo.field_index(field.node); adt::const_get_field(cx, &*brepr, bv, vinfo.discr, ix) }, hir::ExprTupField(ref base, idx) => { @@ -742,7 +742,7 @@ fn const_expr_unadjusted<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>, let VariantInfo { discr, fields } = VariantInfo::of_node(cx.tcx(), ety, e.id); let cs = fields.iter().enumerate().map(|(ix, &Field(f_name, _))| { - match (fs.iter().find(|f| f_name == f.ident.node.name), base_val) { + match (fs.iter().find(|f| f_name == f.name.node), base_val) { (Some(ref f), _) => const_expr(cx, &*f.expr, param_substs, fn_args).0, (_, Some((bv, _))) => adt::const_get_field(cx, &*repr, bv, discr, ix), (_, None) => cx.sess().span_bug(e.span, "missing struct field"), diff --git a/src/librustc_trans/trans/expr.rs b/src/librustc_trans/trans/expr.rs index b4252d4b8b0..f2dcf84d419 100644 --- a/src/librustc_trans/trans/expr.rs +++ b/src/librustc_trans/trans/expr.rs @@ -664,8 +664,8 @@ fn trans_datum_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, hir::ExprPath(..) => { trans_def(bcx, expr, bcx.def(expr.id)) } - hir::ExprField(ref base, ident) => { - trans_rec_field(bcx, &**base, ident.node.name) + hir::ExprField(ref base, name) => { + trans_rec_field(bcx, &**base, name.node) } hir::ExprTupField(ref base, idx) => { trans_rec_tup_field(bcx, &**base, idx.node) @@ -1114,7 +1114,7 @@ fn trans_rvalue_dps_unadjusted<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, // trans. Shudder. fn make_field(field_name: &str, expr: P) -> hir::Field { hir::Field { - ident: codemap::dummy_spanned(token::str_to_ident(field_name)), + name: codemap::dummy_spanned(token::str_to_ident(field_name).name), expr: expr, span: codemap::DUMMY_SP, } @@ -1408,7 +1408,7 @@ fn trans_struct<'blk, 'tcx>(bcx: Block<'blk, 'tcx>, let mut need_base = vec![true; vinfo.fields.len()]; let numbered_fields = fields.iter().map(|field| { - let pos = vinfo.field_index(field.ident.node.name); + let pos = vinfo.field_index(field.name.node); need_base[pos] = false; (pos, &*field.expr) }).collect::>(); diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs index 8cb556473ad..ff7acbf741c 100644 --- a/src/librustc_typeck/check/mod.rs +++ b/src/librustc_typeck/check/mod.rs @@ -119,7 +119,7 @@ use syntax::abi; use syntax::ast; use syntax::attr; use syntax::attr::AttrMetaMethods; -use syntax::codemap::{self, Span}; +use syntax::codemap::{self, Span, Spanned}; use syntax::owned_slice::OwnedSlice; use syntax::parse::token::{self, InternedString}; use syntax::ptr::P; @@ -2820,7 +2820,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // Checks a method call. fn check_method_call<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, expr: &'tcx hir::Expr, - method_name: hir::SpannedIdent, + method_name: Spanned, args: &'tcx [P], tps: &[P], expected: Expectation<'tcx>, @@ -2836,7 +2836,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let tps = tps.iter().map(|ast_ty| fcx.to_ty(&**ast_ty)).collect::>(); let fn_ty = match method::lookup(fcx, method_name.span, - method_name.node.name, + method_name.node, expr_t, tps, expr, @@ -2849,7 +2849,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, } Err(error) => { method::report_error(fcx, method_name.span, expr_t, - method_name.node.name, Some(rcvr), error); + method_name.node, Some(rcvr), error); fcx.write_error(expr.id); fcx.tcx().types.err } @@ -2916,7 +2916,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, expr: &'tcx hir::Expr, lvalue_pref: LvaluePreference, base: &'tcx hir::Expr, - field: &hir::SpannedIdent) { + field: &Spanned) { let tcx = fcx.ccx.tcx; check_expr_with_lvalue_pref(fcx, base, lvalue_pref); let expr_t = structurally_resolved_type(fcx, expr.span, @@ -2933,7 +2933,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, ty::TyStruct(base_def, substs) => { debug!("struct named {:?}", base_t); base_def.struct_variant() - .find_field_named(field.node.name) + .find_field_named(field.node) .map(|f| fcx.field_ty(expr.span, f, substs)) } _ => None @@ -2948,7 +2948,7 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, None => {} } - if method::exists(fcx, field.span, field.node.name, expr_t, expr.id) { + if method::exists(fcx, field.span, field.node, expr_t, expr.id) { fcx.type_error_message( field.span, |actual| { @@ -2981,10 +2981,10 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, // displays hints about the closest matches in field names fn suggest_field_names<'tcx>(variant: ty::VariantDef<'tcx>, - field: &hir::SpannedIdent, + field: &Spanned, tcx: &ty::ctxt<'tcx>, skip : Vec) { - let name = field.node.name.as_str(); + let name = field.node.as_str(); // only find fits with at least one matching letter let mut best_dist = name.len(); let mut best = None; @@ -3082,22 +3082,21 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, field: &hir::Field, skip_fields: &[hir::Field]) { fcx.type_error_message( - field.ident.span, + field.name.span, |actual| if let ty::TyEnum(..) = ty.sty { format!("struct variant `{}::{}` has no field named `{}`", - actual, variant.name.as_str(), field.ident.node) + actual, variant.name.as_str(), field.name.node) } else { format!("structure `{}` has no field named `{}`", - actual, field.ident.node) + actual, field.name.node) }, ty, None); // prevent all specified fields from being suggested - let skip_fields = skip_fields.iter().map(|ref x| x.ident.node.name.as_str()); - suggest_field_names(variant, &field.ident, fcx.tcx(), skip_fields.collect()); + let skip_fields = skip_fields.iter().map(|ref x| x.name.node.as_str()); + suggest_field_names(variant, &field.name, fcx.tcx(), skip_fields.collect()); } - fn check_expr_struct_fields<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>, adt_ty: Ty<'tcx>, span: Span, @@ -3121,15 +3120,15 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, for field in ast_fields { let expected_field_type; - if let Some(v_field) = remaining_fields.remove(&field.ident.node.name) { + if let Some(v_field) = remaining_fields.remove(&field.name.node) { expected_field_type = fcx.field_ty(field.span, v_field, substs); } else { error_happened = true; expected_field_type = tcx.types.err; - if let Some(_) = variant.find_field_named(field.ident.node.name) { - span_err!(fcx.tcx().sess, field.ident.span, E0062, + if let Some(_) = variant.find_field_named(field.name.node) { + span_err!(fcx.tcx().sess, field.name.span, E0062, "field `{}` specified more than once", - field.ident.node); + field.name.node); } else { report_unknown_field(fcx, adt_ty, variant, field, ast_fields); } @@ -3506,8 +3505,8 @@ fn check_expr_with_unifier<'a, 'tcx, F>(fcx: &FnCtxt<'a, 'tcx>, let ret_ty = fcx.expr_ty(expr); fcx.register_wf_obligation(ret_ty, expr.span, traits::MiscObligation); } - hir::ExprMethodCall(ident, ref tps, ref args) => { - check_method_call(fcx, expr, ident, &args[..], &tps[..], expected, lvalue_pref); + hir::ExprMethodCall(name, ref tps, ref args) => { + check_method_call(fcx, expr, name, &args[..], &tps[..], expected, lvalue_pref); let arg_tys = args.iter().map(|a| fcx.expr_ty(&**a)); let args_err = arg_tys.fold(false, |rest_err, a| rest_err || a.references_error()); if args_err {