use hir;
+use std::collections::BTreeMap;
use std::collections::HashMap;
-
use syntax::ast::*;
+use syntax::attr::{ThinAttributes, ThinAttributesExt};
+use syntax::ext::mtwt;
use syntax::ptr::P;
use syntax::codemap::{respan, Spanned, Span};
use syntax::owned_slice::OwnedSlice;
-use syntax::parse::token::{self, str_to_ident};
+use syntax::parse::token;
use syntax::std_inject;
+use syntax::visit::{self, Visitor};
use std::cell::{Cell, RefCell};
// incrementing.
cached_id: Cell<u32>,
// Keep track of gensym'ed idents.
- gensym_cache: RefCell<HashMap<(NodeId, &'static str), Ident>>,
+ gensym_cache: RefCell<HashMap<(NodeId, &'static str), hir::Ident>>,
// A copy of cached_id, but is also set to an id while it is being cached.
gensym_key: Cell<u32>,
}
fn next_id(&self) -> NodeId {
let cached = self.cached_id.get();
if cached == 0 {
- return self.id_assigner.next_node_id()
+ return self.id_assigner.next_node_id();
}
self.cached_id.set(cached + 1);
cached
}
- fn str_to_ident(&self, s: &'static str) -> Ident {
+ fn str_to_ident(&self, s: &'static str) -> hir::Ident {
let cached_id = self.gensym_key.get();
if cached_id == 0 {
- return token::gensym_ident(s);
+ return hir::Ident::from_name(token::gensym(s));
}
let cached = self.gensym_cache.borrow().contains_key(&(cached_id, s));
if cached {
self.gensym_cache.borrow()[&(cached_id, s)]
} else {
- let result = token::gensym_ident(s);
+ let result = hir::Ident::from_name(token::gensym(s));
self.gensym_cache.borrow_mut().insert((cached_id, s), result);
result
}
}
}
-pub fn lower_view_path(_lctx: &LoweringContext, view_path: &ViewPath) -> P<hir::ViewPath> {
+pub fn lower_ident(_lctx: &LoweringContext, ident: Ident) -> hir::Ident {
+ hir::Ident {
+ name: mtwt::resolve(ident),
+ unhygienic_name: ident.name,
+ }
+}
+
+pub fn lower_view_path(lctx: &LoweringContext, view_path: &ViewPath) -> P<hir::ViewPath> {
P(Spanned {
node: match view_path.node {
ViewPathSimple(ident, ref path) => {
- hir::ViewPathSimple(ident.name, lower_path(_lctx, path))
+ hir::ViewPathSimple(ident.name, lower_path(lctx, path))
}
ViewPathGlob(ref path) => {
- hir::ViewPathGlob(lower_path(_lctx, path))
+ hir::ViewPathGlob(lower_path(lctx, path))
}
ViewPathList(ref path, ref path_list_idents) => {
- hir::ViewPathList(lower_path(_lctx, path),
+ hir::ViewPathList(lower_path(lctx, path),
path_list_idents.iter()
.map(|path_list_ident| {
Spanned {
})
}
-pub fn lower_arm(_lctx: &LoweringContext, arm: &Arm) -> hir::Arm {
+pub fn lower_arm(lctx: &LoweringContext, arm: &Arm) -> hir::Arm {
hir::Arm {
attrs: arm.attrs.clone(),
- pats: arm.pats.iter().map(|x| lower_pat(_lctx, x)).collect(),
- guard: arm.guard.as_ref().map(|ref x| lower_expr(_lctx, x)),
- body: lower_expr(_lctx, &arm.body),
+ pats: arm.pats.iter().map(|x| lower_pat(lctx, x)).collect(),
+ guard: arm.guard.as_ref().map(|ref x| lower_expr(lctx, x)),
+ body: lower_expr(lctx, &arm.body),
}
}
-pub fn lower_decl(_lctx: &LoweringContext, d: &Decl) -> P<hir::Decl> {
+pub fn lower_decl(lctx: &LoweringContext, d: &Decl) -> P<hir::Decl> {
match d.node {
DeclLocal(ref l) => P(Spanned {
- node: hir::DeclLocal(lower_local(_lctx, l)),
+ node: hir::DeclLocal(lower_local(lctx, l)),
span: d.span,
}),
DeclItem(ref it) => P(Spanned {
- node: hir::DeclItem(lower_item(_lctx, it)),
+ node: hir::DeclItem(lower_item_id(lctx, it)),
span: d.span,
}),
}
}
-pub fn lower_ty_binding(_lctx: &LoweringContext, b: &TypeBinding) -> P<hir::TypeBinding> {
- P(hir::TypeBinding {
+pub fn lower_ty_binding(lctx: &LoweringContext, b: &TypeBinding) -> hir::TypeBinding {
+ hir::TypeBinding {
id: b.id,
name: b.ident.name,
- ty: lower_ty(_lctx, &b.ty),
+ ty: lower_ty(lctx, &b.ty),
span: b.span,
- })
+ }
}
-pub fn lower_ty(_lctx: &LoweringContext, t: &Ty) -> P<hir::Ty> {
+pub fn lower_ty(lctx: &LoweringContext, t: &Ty) -> P<hir::Ty> {
P(hir::Ty {
id: t.id,
node: match t.node {
TyInfer => hir::TyInfer,
- TyVec(ref ty) => hir::TyVec(lower_ty(_lctx, ty)),
- TyPtr(ref mt) => hir::TyPtr(lower_mt(_lctx, mt)),
+ TyVec(ref ty) => hir::TyVec(lower_ty(lctx, ty)),
+ TyPtr(ref mt) => hir::TyPtr(lower_mt(lctx, mt)),
TyRptr(ref region, ref mt) => {
- hir::TyRptr(lower_opt_lifetime(_lctx, region),
- lower_mt(_lctx, mt))
+ hir::TyRptr(lower_opt_lifetime(lctx, region), lower_mt(lctx, mt))
}
TyBareFn(ref f) => {
hir::TyBareFn(P(hir::BareFnTy {
- lifetimes: lower_lifetime_defs(_lctx, &f.lifetimes),
- unsafety: lower_unsafety(_lctx, f.unsafety),
+ lifetimes: lower_lifetime_defs(lctx, &f.lifetimes),
+ unsafety: lower_unsafety(lctx, f.unsafety),
abi: f.abi,
- decl: lower_fn_decl(_lctx, &f.decl),
+ decl: lower_fn_decl(lctx, &f.decl),
}))
}
- TyTup(ref tys) => hir::TyTup(tys.iter().map(|ty| lower_ty(_lctx, ty)).collect()),
- TyParen(ref ty) => hir::TyParen(lower_ty(_lctx, ty)),
+ TyTup(ref tys) => hir::TyTup(tys.iter().map(|ty| lower_ty(lctx, ty)).collect()),
+ TyParen(ref ty) => {
+ return lower_ty(lctx, ty);
+ }
TyPath(ref qself, ref path) => {
let qself = qself.as_ref().map(|&QSelf { ref ty, position }| {
hir::QSelf {
- ty: lower_ty(_lctx, ty),
+ ty: lower_ty(lctx, ty),
position: position,
}
});
- hir::TyPath(qself, lower_path(_lctx, path))
+ hir::TyPath(qself, lower_path(lctx, path))
}
TyObjectSum(ref ty, ref bounds) => {
- hir::TyObjectSum(lower_ty(_lctx, ty), lower_bounds(_lctx, bounds))
+ hir::TyObjectSum(lower_ty(lctx, ty), lower_bounds(lctx, bounds))
}
TyFixedLengthVec(ref ty, ref e) => {
- hir::TyFixedLengthVec(lower_ty(_lctx, ty), lower_expr(_lctx, e))
+ hir::TyFixedLengthVec(lower_ty(lctx, ty), lower_expr(lctx, e))
}
TyTypeof(ref expr) => {
- hir::TyTypeof(lower_expr(_lctx, expr))
+ hir::TyTypeof(lower_expr(lctx, expr))
}
TyPolyTraitRef(ref bounds) => {
- hir::TyPolyTraitRef(bounds.iter().map(|b| lower_ty_param_bound(_lctx, b)).collect())
+ hir::TyPolyTraitRef(bounds.iter().map(|b| lower_ty_param_bound(lctx, b)).collect())
}
TyMac(_) => panic!("TyMac should have been expanded by now."),
},
})
}
-pub fn lower_foreign_mod(_lctx: &LoweringContext, fm: &ForeignMod) -> hir::ForeignMod {
+pub fn lower_foreign_mod(lctx: &LoweringContext, fm: &ForeignMod) -> hir::ForeignMod {
hir::ForeignMod {
abi: fm.abi,
- items: fm.items.iter().map(|x| lower_foreign_item(_lctx, x)).collect(),
+ items: fm.items.iter().map(|x| lower_foreign_item(lctx, x)).collect(),
}
}
-pub fn lower_variant(_lctx: &LoweringContext, v: &Variant) -> P<hir::Variant> {
- P(Spanned {
+pub fn lower_variant(lctx: &LoweringContext, v: &Variant) -> hir::Variant {
+ Spanned {
node: hir::Variant_ {
name: v.node.name.name,
attrs: v.node.attrs.clone(),
- data: lower_variant_data(_lctx, &v.node.data),
- disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(_lctx, e)),
+ data: lower_variant_data(lctx, &v.node.data),
+ disr_expr: v.node.disr_expr.as_ref().map(|e| lower_expr(lctx, e)),
},
span: v.span,
- })
+ }
}
-pub fn lower_path(_lctx: &LoweringContext, p: &Path) -> hir::Path {
+// Path segments are usually unhygienic, hygienic path segments can occur only in
+// identifier-like paths originating from `ExprPath`.
+// Make life simpler for rustc_resolve by renaming only such segments.
+pub fn lower_path_full(lctx: &LoweringContext, p: &Path, maybe_hygienic: bool) -> hir::Path {
+ let maybe_hygienic = maybe_hygienic && !p.global && p.segments.len() == 1;
hir::Path {
global: p.global,
segments: p.segments
.iter()
.map(|&PathSegment { identifier, ref parameters }| {
hir::PathSegment {
- identifier: identifier,
- parameters: lower_path_parameters(_lctx, parameters),
+ identifier: if maybe_hygienic {
+ lower_ident(lctx, identifier)
+ } else {
+ hir::Ident::from_name(identifier.name)
+ },
+ parameters: lower_path_parameters(lctx, parameters),
}
})
.collect(),
}
}
-pub fn lower_path_parameters(_lctx: &LoweringContext,
+pub fn lower_path(lctx: &LoweringContext, p: &Path) -> hir::Path {
+ lower_path_full(lctx, p, false)
+}
+
+pub fn lower_path_parameters(lctx: &LoweringContext,
path_parameters: &PathParameters)
-> hir::PathParameters {
match *path_parameters {
AngleBracketedParameters(ref data) =>
- hir::AngleBracketedParameters(lower_angle_bracketed_parameter_data(_lctx, data)),
+ hir::AngleBracketedParameters(lower_angle_bracketed_parameter_data(lctx, data)),
ParenthesizedParameters(ref data) =>
- hir::ParenthesizedParameters(lower_parenthesized_parameter_data(_lctx, data)),
+ hir::ParenthesizedParameters(lower_parenthesized_parameter_data(lctx, data)),
}
}
-pub fn lower_angle_bracketed_parameter_data(_lctx: &LoweringContext,
+pub fn lower_angle_bracketed_parameter_data(lctx: &LoweringContext,
data: &AngleBracketedParameterData)
-> hir::AngleBracketedParameterData {
let &AngleBracketedParameterData { ref lifetimes, ref types, ref bindings } = data;
hir::AngleBracketedParameterData {
- lifetimes: lower_lifetimes(_lctx, lifetimes),
- types: types.iter().map(|ty| lower_ty(_lctx, ty)).collect(),
- bindings: bindings.iter().map(|b| lower_ty_binding(_lctx, b)).collect(),
+ lifetimes: lower_lifetimes(lctx, lifetimes),
+ types: types.iter().map(|ty| lower_ty(lctx, ty)).collect(),
+ bindings: bindings.iter().map(|b| lower_ty_binding(lctx, b)).collect(),
}
}
-pub fn lower_parenthesized_parameter_data(_lctx: &LoweringContext,
+pub fn lower_parenthesized_parameter_data(lctx: &LoweringContext,
data: &ParenthesizedParameterData)
-> hir::ParenthesizedParameterData {
let &ParenthesizedParameterData { ref inputs, ref output, span } = data;
hir::ParenthesizedParameterData {
- inputs: inputs.iter().map(|ty| lower_ty(_lctx, ty)).collect(),
- output: output.as_ref().map(|ty| lower_ty(_lctx, ty)),
+ inputs: inputs.iter().map(|ty| lower_ty(lctx, ty)).collect(),
+ output: output.as_ref().map(|ty| lower_ty(lctx, ty)),
span: span,
}
}
-pub fn lower_local(_lctx: &LoweringContext, l: &Local) -> P<hir::Local> {
+pub fn lower_local(lctx: &LoweringContext, l: &Local) -> P<hir::Local> {
P(hir::Local {
id: l.id,
- ty: l.ty.as_ref().map(|t| lower_ty(_lctx, t)),
- pat: lower_pat(_lctx, &l.pat),
- init: l.init.as_ref().map(|e| lower_expr(_lctx, e)),
+ ty: l.ty.as_ref().map(|t| lower_ty(lctx, t)),
+ pat: lower_pat(lctx, &l.pat),
+ init: l.init.as_ref().map(|e| lower_expr(lctx, e)),
span: l.span,
+ attrs: l.attrs.clone(),
})
}
-pub fn lower_explicit_self_underscore(_lctx: &LoweringContext,
+pub fn lower_explicit_self_underscore(lctx: &LoweringContext,
es: &ExplicitSelf_)
-> hir::ExplicitSelf_ {
match *es {
SelfStatic => hir::SelfStatic,
SelfValue(v) => hir::SelfValue(v.name),
SelfRegion(ref lifetime, m, ident) => {
- hir::SelfRegion(lower_opt_lifetime(_lctx, lifetime),
- lower_mutability(_lctx, m),
+ hir::SelfRegion(lower_opt_lifetime(lctx, lifetime),
+ lower_mutability(lctx, m),
ident.name)
}
SelfExplicit(ref typ, ident) => {
- hir::SelfExplicit(lower_ty(_lctx, typ), ident.name)
+ hir::SelfExplicit(lower_ty(lctx, typ), ident.name)
}
}
}
}
}
-pub fn lower_explicit_self(_lctx: &LoweringContext, s: &ExplicitSelf) -> hir::ExplicitSelf {
+pub fn lower_explicit_self(lctx: &LoweringContext, s: &ExplicitSelf) -> hir::ExplicitSelf {
Spanned {
- node: lower_explicit_self_underscore(_lctx, &s.node),
+ node: lower_explicit_self_underscore(lctx, &s.node),
span: s.span,
}
}
-pub fn lower_arg(_lctx: &LoweringContext, arg: &Arg) -> hir::Arg {
+pub fn lower_arg(lctx: &LoweringContext, arg: &Arg) -> hir::Arg {
hir::Arg {
id: arg.id,
- pat: lower_pat(_lctx, &arg.pat),
- ty: lower_ty(_lctx, &arg.ty),
+ pat: lower_pat(lctx, &arg.pat),
+ ty: lower_ty(lctx, &arg.ty),
}
}
-pub fn lower_fn_decl(_lctx: &LoweringContext, decl: &FnDecl) -> P<hir::FnDecl> {
+pub fn lower_fn_decl(lctx: &LoweringContext, decl: &FnDecl) -> P<hir::FnDecl> {
P(hir::FnDecl {
- inputs: decl.inputs.iter().map(|x| lower_arg(_lctx, x)).collect(),
+ inputs: decl.inputs.iter().map(|x| lower_arg(lctx, x)).collect(),
output: match decl.output {
- Return(ref ty) => hir::Return(lower_ty(_lctx, ty)),
+ Return(ref ty) => hir::Return(lower_ty(lctx, ty)),
DefaultReturn(span) => hir::DefaultReturn(span),
NoReturn(span) => hir::NoReturn(span),
},
})
}
-pub fn lower_ty_param_bound(_lctx: &LoweringContext, tpb: &TyParamBound) -> hir::TyParamBound {
+pub fn lower_ty_param_bound(lctx: &LoweringContext, tpb: &TyParamBound) -> hir::TyParamBound {
match *tpb {
TraitTyParamBound(ref ty, modifier) => {
- hir::TraitTyParamBound(lower_poly_trait_ref(_lctx, ty),
- lower_trait_bound_modifier(_lctx, modifier))
+ hir::TraitTyParamBound(lower_poly_trait_ref(lctx, ty),
+ lower_trait_bound_modifier(lctx, modifier))
}
RegionTyParamBound(ref lifetime) => {
- hir::RegionTyParamBound(lower_lifetime(_lctx, lifetime))
+ hir::RegionTyParamBound(lower_lifetime(lctx, lifetime))
}
}
}
-pub fn lower_ty_param(_lctx: &LoweringContext, tp: &TyParam) -> hir::TyParam {
+pub fn lower_ty_param(lctx: &LoweringContext, tp: &TyParam) -> hir::TyParam {
hir::TyParam {
id: tp.id,
name: tp.ident.name,
- bounds: lower_bounds(_lctx, &tp.bounds),
- default: tp.default.as_ref().map(|x| lower_ty(_lctx, x)),
+ bounds: lower_bounds(lctx, &tp.bounds),
+ default: tp.default.as_ref().map(|x| lower_ty(lctx, x)),
span: tp.span,
}
}
-pub fn lower_ty_params(_lctx: &LoweringContext,
+pub fn lower_ty_params(lctx: &LoweringContext,
tps: &OwnedSlice<TyParam>)
-> OwnedSlice<hir::TyParam> {
- tps.iter().map(|tp| lower_ty_param(_lctx, tp)).collect()
+ tps.iter().map(|tp| lower_ty_param(lctx, tp)).collect()
}
pub fn lower_lifetime(_lctx: &LoweringContext, l: &Lifetime) -> hir::Lifetime {
}
}
-pub fn lower_lifetime_def(_lctx: &LoweringContext, l: &LifetimeDef) -> hir::LifetimeDef {
+pub fn lower_lifetime_def(lctx: &LoweringContext, l: &LifetimeDef) -> hir::LifetimeDef {
hir::LifetimeDef {
- lifetime: lower_lifetime(_lctx, &l.lifetime),
- bounds: lower_lifetimes(_lctx, &l.bounds),
+ lifetime: lower_lifetime(lctx, &l.lifetime),
+ bounds: lower_lifetimes(lctx, &l.bounds),
}
}
-pub fn lower_lifetimes(_lctx: &LoweringContext, lts: &Vec<Lifetime>) -> Vec<hir::Lifetime> {
- lts.iter().map(|l| lower_lifetime(_lctx, l)).collect()
+pub fn lower_lifetimes(lctx: &LoweringContext, lts: &Vec<Lifetime>) -> Vec<hir::Lifetime> {
+ lts.iter().map(|l| lower_lifetime(lctx, l)).collect()
}
-pub fn lower_lifetime_defs(_lctx: &LoweringContext,
+pub fn lower_lifetime_defs(lctx: &LoweringContext,
lts: &Vec<LifetimeDef>)
-> Vec<hir::LifetimeDef> {
- lts.iter().map(|l| lower_lifetime_def(_lctx, l)).collect()
+ lts.iter().map(|l| lower_lifetime_def(lctx, l)).collect()
}
-pub fn lower_opt_lifetime(_lctx: &LoweringContext,
+pub fn lower_opt_lifetime(lctx: &LoweringContext,
o_lt: &Option<Lifetime>)
-> Option<hir::Lifetime> {
- o_lt.as_ref().map(|lt| lower_lifetime(_lctx, lt))
+ o_lt.as_ref().map(|lt| lower_lifetime(lctx, lt))
}
-pub fn lower_generics(_lctx: &LoweringContext, g: &Generics) -> hir::Generics {
+pub fn lower_generics(lctx: &LoweringContext, g: &Generics) -> hir::Generics {
hir::Generics {
- ty_params: lower_ty_params(_lctx, &g.ty_params),
- lifetimes: lower_lifetime_defs(_lctx, &g.lifetimes),
- where_clause: lower_where_clause(_lctx, &g.where_clause),
+ ty_params: lower_ty_params(lctx, &g.ty_params),
+ lifetimes: lower_lifetime_defs(lctx, &g.lifetimes),
+ where_clause: lower_where_clause(lctx, &g.where_clause),
}
}
-pub fn lower_where_clause(_lctx: &LoweringContext, wc: &WhereClause) -> hir::WhereClause {
+pub fn lower_where_clause(lctx: &LoweringContext, wc: &WhereClause) -> hir::WhereClause {
hir::WhereClause {
id: wc.id,
predicates: wc.predicates
.iter()
- .map(|predicate| lower_where_predicate(_lctx, predicate))
+ .map(|predicate| lower_where_predicate(lctx, predicate))
.collect(),
}
}
-pub fn lower_where_predicate(_lctx: &LoweringContext,
+pub fn lower_where_predicate(lctx: &LoweringContext,
pred: &WherePredicate)
-> hir::WherePredicate {
match *pred {
ref bounds,
span}) => {
hir::WherePredicate::BoundPredicate(hir::WhereBoundPredicate {
- bound_lifetimes: lower_lifetime_defs(_lctx, bound_lifetimes),
- bounded_ty: lower_ty(_lctx, bounded_ty),
- bounds: bounds.iter().map(|x| lower_ty_param_bound(_lctx, x)).collect(),
+ bound_lifetimes: lower_lifetime_defs(lctx, bound_lifetimes),
+ bounded_ty: lower_ty(lctx, bounded_ty),
+ bounds: bounds.iter().map(|x| lower_ty_param_bound(lctx, x)).collect(),
span: span,
})
}
span}) => {
hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
span: span,
- lifetime: lower_lifetime(_lctx, lifetime),
- bounds: bounds.iter().map(|bound| lower_lifetime(_lctx, bound)).collect(),
+ lifetime: lower_lifetime(lctx, lifetime),
+ bounds: bounds.iter().map(|bound| lower_lifetime(lctx, bound)).collect(),
})
}
WherePredicate::EqPredicate(WhereEqPredicate{ id,
span}) => {
hir::WherePredicate::EqPredicate(hir::WhereEqPredicate {
id: id,
- path: lower_path(_lctx, path),
- ty: lower_ty(_lctx, ty),
+ path: lower_path(lctx, path),
+ ty: lower_ty(lctx, ty),
span: span,
})
}
}
}
-pub fn lower_variant_data(_lctx: &LoweringContext, vdata: &VariantData) -> hir::VariantData {
+pub fn lower_variant_data(lctx: &LoweringContext, vdata: &VariantData) -> hir::VariantData {
match *vdata {
VariantData::Struct(ref fields, id) => {
hir::VariantData::Struct(fields.iter()
- .map(|f| lower_struct_field(_lctx, f)).collect(), id)
+ .map(|f| lower_struct_field(lctx, f))
+ .collect(),
+ id)
}
VariantData::Tuple(ref fields, id) => {
hir::VariantData::Tuple(fields.iter()
- .map(|f| lower_struct_field(_lctx, f)).collect(), id)
+ .map(|f| lower_struct_field(lctx, f))
+ .collect(),
+ id)
}
- VariantData::Unit(id) => hir::VariantData::Unit(id)
+ VariantData::Unit(id) => hir::VariantData::Unit(id),
}
}
-pub fn lower_trait_ref(_lctx: &LoweringContext, p: &TraitRef) -> hir::TraitRef {
+pub fn lower_trait_ref(lctx: &LoweringContext, p: &TraitRef) -> hir::TraitRef {
hir::TraitRef {
- path: lower_path(_lctx, &p.path),
+ path: lower_path(lctx, &p.path),
ref_id: p.ref_id,
}
}
-pub fn lower_poly_trait_ref(_lctx: &LoweringContext, p: &PolyTraitRef) -> hir::PolyTraitRef {
+pub fn lower_poly_trait_ref(lctx: &LoweringContext, p: &PolyTraitRef) -> hir::PolyTraitRef {
hir::PolyTraitRef {
- bound_lifetimes: lower_lifetime_defs(_lctx, &p.bound_lifetimes),
- trait_ref: lower_trait_ref(_lctx, &p.trait_ref),
+ bound_lifetimes: lower_lifetime_defs(lctx, &p.bound_lifetimes),
+ trait_ref: lower_trait_ref(lctx, &p.trait_ref),
span: p.span,
}
}
-pub fn lower_struct_field(_lctx: &LoweringContext, f: &StructField) -> hir::StructField {
+pub fn lower_struct_field(lctx: &LoweringContext, f: &StructField) -> hir::StructField {
Spanned {
node: hir::StructField_ {
id: f.node.id,
- kind: lower_struct_field_kind(_lctx, &f.node.kind),
- ty: lower_ty(_lctx, &f.node.ty),
+ kind: lower_struct_field_kind(lctx, &f.node.kind),
+ ty: lower_ty(lctx, &f.node.ty),
attrs: f.node.attrs.clone(),
},
span: f.span,
}
}
-pub fn lower_field(_lctx: &LoweringContext, f: &Field) -> hir::Field {
+pub fn lower_field(lctx: &LoweringContext, f: &Field) -> hir::Field {
hir::Field {
name: respan(f.ident.span, f.ident.node.name),
- expr: lower_expr(_lctx, &f.expr),
+ expr: lower_expr(lctx, &f.expr),
span: f.span,
}
}
-pub fn lower_mt(_lctx: &LoweringContext, mt: &MutTy) -> hir::MutTy {
+pub fn lower_mt(lctx: &LoweringContext, mt: &MutTy) -> hir::MutTy {
hir::MutTy {
- ty: lower_ty(_lctx, &mt.ty),
- mutbl: lower_mutability(_lctx, mt.mutbl),
+ ty: lower_ty(lctx, &mt.ty),
+ mutbl: lower_mutability(lctx, mt.mutbl),
}
}
-pub fn lower_opt_bounds(_lctx: &LoweringContext,
+pub fn lower_opt_bounds(lctx: &LoweringContext,
b: &Option<OwnedSlice<TyParamBound>>)
-> Option<OwnedSlice<hir::TyParamBound>> {
- b.as_ref().map(|ref bounds| lower_bounds(_lctx, bounds))
+ b.as_ref().map(|ref bounds| lower_bounds(lctx, bounds))
}
-fn lower_bounds(_lctx: &LoweringContext, bounds: &TyParamBounds) -> hir::TyParamBounds {
- bounds.iter().map(|bound| lower_ty_param_bound(_lctx, bound)).collect()
+fn lower_bounds(lctx: &LoweringContext, bounds: &TyParamBounds) -> hir::TyParamBounds {
+ bounds.iter().map(|bound| lower_ty_param_bound(lctx, bound)).collect()
}
-pub fn lower_block(_lctx: &LoweringContext, b: &Block) -> P<hir::Block> {
+pub fn lower_block(lctx: &LoweringContext, b: &Block) -> P<hir::Block> {
P(hir::Block {
id: b.id,
- stmts: b.stmts.iter().map(|s| lower_stmt(_lctx, s)).collect(),
- expr: b.expr.as_ref().map(|ref x| lower_expr(_lctx, x)),
- rules: lower_block_check_mode(_lctx, &b.rules),
+ stmts: b.stmts.iter().map(|s| lower_stmt(lctx, s)).collect(),
+ expr: b.expr.as_ref().map(|ref x| lower_expr(lctx, x)),
+ rules: lower_block_check_mode(lctx, &b.rules),
span: b.span,
})
}
-pub fn lower_item_underscore(_lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
+pub fn lower_item_underscore(lctx: &LoweringContext, i: &Item_) -> hir::Item_ {
match *i {
ItemExternCrate(string) => hir::ItemExternCrate(string),
ItemUse(ref view_path) => {
- hir::ItemUse(lower_view_path(_lctx, view_path))
+ hir::ItemUse(lower_view_path(lctx, view_path))
}
ItemStatic(ref t, m, ref e) => {
- hir::ItemStatic(lower_ty(_lctx, t),
- lower_mutability(_lctx, m),
- lower_expr(_lctx, e))
+ hir::ItemStatic(lower_ty(lctx, t),
+ lower_mutability(lctx, m),
+ lower_expr(lctx, e))
}
ItemConst(ref t, ref e) => {
- hir::ItemConst(lower_ty(_lctx, t), lower_expr(_lctx, e))
+ hir::ItemConst(lower_ty(lctx, t), lower_expr(lctx, e))
}
ItemFn(ref decl, unsafety, constness, abi, ref generics, ref body) => {
- hir::ItemFn(lower_fn_decl(_lctx, decl),
- lower_unsafety(_lctx, unsafety),
- lower_constness(_lctx, constness),
+ hir::ItemFn(lower_fn_decl(lctx, decl),
+ lower_unsafety(lctx, unsafety),
+ lower_constness(lctx, constness),
abi,
- lower_generics(_lctx, generics),
- lower_block(_lctx, body))
+ lower_generics(lctx, generics),
+ lower_block(lctx, body))
}
- ItemMod(ref m) => hir::ItemMod(lower_mod(_lctx, m)),
- ItemForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(_lctx, nm)),
+ ItemMod(ref m) => hir::ItemMod(lower_mod(lctx, m)),
+ ItemForeignMod(ref nm) => hir::ItemForeignMod(lower_foreign_mod(lctx, nm)),
ItemTy(ref t, ref generics) => {
- hir::ItemTy(lower_ty(_lctx, t), lower_generics(_lctx, generics))
+ hir::ItemTy(lower_ty(lctx, t), lower_generics(lctx, generics))
}
ItemEnum(ref enum_definition, ref generics) => {
hir::ItemEnum(hir::EnumDef {
variants: enum_definition.variants
.iter()
- .map(|x| lower_variant(_lctx, x))
+ .map(|x| lower_variant(lctx, x))
.collect(),
},
- lower_generics(_lctx, generics))
+ lower_generics(lctx, generics))
}
ItemStruct(ref struct_def, ref generics) => {
- let struct_def = lower_variant_data(_lctx, struct_def);
- hir::ItemStruct(struct_def, lower_generics(_lctx, generics))
+ let struct_def = lower_variant_data(lctx, struct_def);
+ hir::ItemStruct(struct_def, lower_generics(lctx, generics))
}
ItemDefaultImpl(unsafety, ref trait_ref) => {
- hir::ItemDefaultImpl(lower_unsafety(_lctx, unsafety),
- lower_trait_ref(_lctx, trait_ref))
+ hir::ItemDefaultImpl(lower_unsafety(lctx, unsafety),
+ lower_trait_ref(lctx, trait_ref))
}
ItemImpl(unsafety, polarity, ref generics, ref ifce, ref ty, ref impl_items) => {
let new_impl_items = impl_items.iter()
- .map(|item| lower_impl_item(_lctx, item))
+ .map(|item| lower_impl_item(lctx, item))
.collect();
- let ifce = ifce.as_ref().map(|trait_ref| lower_trait_ref(_lctx, trait_ref));
- hir::ItemImpl(lower_unsafety(_lctx, unsafety),
- lower_impl_polarity(_lctx, polarity),
- lower_generics(_lctx, generics),
+ let ifce = ifce.as_ref().map(|trait_ref| lower_trait_ref(lctx, trait_ref));
+ hir::ItemImpl(lower_unsafety(lctx, unsafety),
+ lower_impl_polarity(lctx, polarity),
+ lower_generics(lctx, generics),
ifce,
- lower_ty(_lctx, ty),
+ lower_ty(lctx, ty),
new_impl_items)
}
ItemTrait(unsafety, ref generics, ref bounds, ref items) => {
- let bounds = lower_bounds(_lctx, bounds);
- let items = items.iter().map(|item| lower_trait_item(_lctx, item)).collect();
- hir::ItemTrait(lower_unsafety(_lctx, unsafety),
- lower_generics(_lctx, generics),
+ let bounds = lower_bounds(lctx, bounds);
+ let items = items.iter().map(|item| lower_trait_item(lctx, item)).collect();
+ hir::ItemTrait(lower_unsafety(lctx, unsafety),
+ lower_generics(lctx, generics),
bounds,
items)
}
}
}
-pub fn lower_trait_item(_lctx: &LoweringContext, i: &TraitItem) -> P<hir::TraitItem> {
- P(hir::TraitItem {
+pub fn lower_trait_item(lctx: &LoweringContext, i: &TraitItem) -> hir::TraitItem {
+ hir::TraitItem {
id: i.id,
name: i.ident.name,
attrs: i.attrs.clone(),
node: match i.node {
ConstTraitItem(ref ty, ref default) => {
- hir::ConstTraitItem(lower_ty(_lctx, ty),
- default.as_ref().map(|x| lower_expr(_lctx, x)))
+ hir::ConstTraitItem(lower_ty(lctx, ty),
+ default.as_ref().map(|x| lower_expr(lctx, x)))
}
MethodTraitItem(ref sig, ref body) => {
- hir::MethodTraitItem(lower_method_sig(_lctx, sig),
- body.as_ref().map(|x| lower_block(_lctx, x)))
+ hir::MethodTraitItem(lower_method_sig(lctx, sig),
+ body.as_ref().map(|x| lower_block(lctx, x)))
}
TypeTraitItem(ref bounds, ref default) => {
- hir::TypeTraitItem(lower_bounds(_lctx, bounds),
- default.as_ref().map(|x| lower_ty(_lctx, x)))
+ hir::TypeTraitItem(lower_bounds(lctx, bounds),
+ default.as_ref().map(|x| lower_ty(lctx, x)))
}
},
span: i.span,
- })
+ }
}
-pub fn lower_impl_item(_lctx: &LoweringContext, i: &ImplItem) -> P<hir::ImplItem> {
- P(hir::ImplItem {
+pub fn lower_impl_item(lctx: &LoweringContext, i: &ImplItem) -> hir::ImplItem {
+ hir::ImplItem {
id: i.id,
name: i.ident.name,
attrs: i.attrs.clone(),
- vis: lower_visibility(_lctx, i.vis),
+ vis: lower_visibility(lctx, i.vis),
node: match i.node {
- ConstImplItem(ref ty, ref expr) => {
- hir::ConstImplItem(lower_ty(_lctx, ty), lower_expr(_lctx, expr))
+ ImplItemKind::Const(ref ty, ref expr) => {
+ hir::ImplItemKind::Const(lower_ty(lctx, ty), lower_expr(lctx, expr))
}
- MethodImplItem(ref sig, ref body) => {
- hir::MethodImplItem(lower_method_sig(_lctx, sig),
- lower_block(_lctx, body))
+ ImplItemKind::Method(ref sig, ref body) => {
+ hir::ImplItemKind::Method(lower_method_sig(lctx, sig), lower_block(lctx, body))
}
- TypeImplItem(ref ty) => hir::TypeImplItem(lower_ty(_lctx, ty)),
- MacImplItem(..) => panic!("Shouldn't exist any more"),
+ ImplItemKind::Type(ref ty) => hir::ImplItemKind::Type(lower_ty(lctx, ty)),
+ ImplItemKind::Macro(..) => panic!("Shouldn't exist any more"),
},
span: i.span,
- })
+ }
}
-pub fn lower_mod(_lctx: &LoweringContext, m: &Mod) -> hir::Mod {
+pub fn lower_mod(lctx: &LoweringContext, m: &Mod) -> hir::Mod {
hir::Mod {
inner: m.inner,
- items: m.items.iter().map(|x| lower_item(_lctx, x)).collect(),
+ item_ids: m.items.iter().map(|x| lower_item_id(lctx, x)).collect(),
+ }
+}
+
+struct ItemLowerer<'lcx, 'interner: 'lcx> {
+ items: BTreeMap<NodeId, hir::Item>,
+ lctx: &'lcx LoweringContext<'interner>,
+}
+
+impl<'lcx, 'interner> Visitor<'lcx> for ItemLowerer<'lcx, 'interner> {
+ fn visit_item(&mut self, item: &'lcx Item) {
+ self.items.insert(item.id, lower_item(self.lctx, item));
+ visit::walk_item(self, item);
}
}
-pub fn lower_crate(_lctx: &LoweringContext, c: &Crate) -> hir::Crate {
+pub fn lower_crate(lctx: &LoweringContext, c: &Crate) -> hir::Crate {
+ let items = {
+ let mut item_lowerer = ItemLowerer { items: BTreeMap::new(), lctx: lctx };
+ visit::walk_crate(&mut item_lowerer, c);
+ item_lowerer.items
+ };
+
hir::Crate {
- module: lower_mod(_lctx, &c.module),
+ module: lower_mod(lctx, &c.module),
attrs: c.attrs.clone(),
config: c.config.clone(),
span: c.span,
- exported_macros: c.exported_macros.iter().map(|m| lower_macro_def(_lctx, m)).collect(),
+ exported_macros: c.exported_macros.iter().map(|m| lower_macro_def(lctx, m)).collect(),
+ items: items,
}
}
}
}
-// fold one item into possibly many items
-pub fn lower_item(_lctx: &LoweringContext, i: &Item) -> P<hir::Item> {
- P(lower_item_simple(_lctx, i))
+pub fn lower_item_id(_lctx: &LoweringContext, i: &Item) -> hir::ItemId {
+ hir::ItemId { id: i.id }
}
-// fold one item into exactly one item
-pub fn lower_item_simple(_lctx: &LoweringContext, i: &Item) -> hir::Item {
- let node = lower_item_underscore(_lctx, &i.node);
+pub fn lower_item(lctx: &LoweringContext, i: &Item) -> hir::Item {
+ let node = lower_item_underscore(lctx, &i.node);
hir::Item {
id: i.id,
name: i.ident.name,
attrs: i.attrs.clone(),
node: node,
- vis: lower_visibility(_lctx, i.vis),
+ vis: lower_visibility(lctx, i.vis),
span: i.span,
}
}
-pub fn lower_foreign_item(_lctx: &LoweringContext, i: &ForeignItem) -> P<hir::ForeignItem> {
- P(hir::ForeignItem {
+pub fn lower_foreign_item(lctx: &LoweringContext, i: &ForeignItem) -> hir::ForeignItem {
+ hir::ForeignItem {
id: i.id,
name: i.ident.name,
attrs: i.attrs.clone(),
node: match i.node {
ForeignItemFn(ref fdec, ref generics) => {
- hir::ForeignItemFn(lower_fn_decl(_lctx, fdec),
- lower_generics(_lctx, generics))
+ hir::ForeignItemFn(lower_fn_decl(lctx, fdec), lower_generics(lctx, generics))
}
ForeignItemStatic(ref t, m) => {
- hir::ForeignItemStatic(lower_ty(_lctx, t), m)
+ hir::ForeignItemStatic(lower_ty(lctx, t), m)
}
},
- vis: lower_visibility(_lctx, i.vis),
+ vis: lower_visibility(lctx, i.vis),
span: i.span,
- })
+ }
}
-pub fn lower_method_sig(_lctx: &LoweringContext, sig: &MethodSig) -> hir::MethodSig {
+pub fn lower_method_sig(lctx: &LoweringContext, sig: &MethodSig) -> hir::MethodSig {
hir::MethodSig {
- generics: lower_generics(_lctx, &sig.generics),
+ generics: lower_generics(lctx, &sig.generics),
abi: sig.abi,
- explicit_self: lower_explicit_self(_lctx, &sig.explicit_self),
- unsafety: lower_unsafety(_lctx, sig.unsafety),
- constness: lower_constness(_lctx, sig.constness),
- decl: lower_fn_decl(_lctx, &sig.decl),
+ explicit_self: lower_explicit_self(lctx, &sig.explicit_self),
+ unsafety: lower_unsafety(lctx, sig.unsafety),
+ constness: lower_constness(lctx, sig.constness),
+ decl: lower_fn_decl(lctx, &sig.decl),
}
}
}
}
-pub fn lower_pat(_lctx: &LoweringContext, p: &Pat) -> P<hir::Pat> {
+pub fn lower_pat(lctx: &LoweringContext, p: &Pat) -> P<hir::Pat> {
P(hir::Pat {
id: p.id,
node: match p.node {
- PatWild(k) => hir::PatWild(lower_pat_wild_kind(_lctx, k)),
+ PatWild => hir::PatWild,
PatIdent(ref binding_mode, pth1, ref sub) => {
- hir::PatIdent(lower_binding_mode(_lctx, binding_mode),
- pth1,
- sub.as_ref().map(|x| lower_pat(_lctx, x)))
+ hir::PatIdent(lower_binding_mode(lctx, binding_mode),
+ respan(pth1.span, lower_ident(lctx, pth1.node)),
+ sub.as_ref().map(|x| lower_pat(lctx, x)))
}
- PatLit(ref e) => hir::PatLit(lower_expr(_lctx, e)),
+ PatLit(ref e) => hir::PatLit(lower_expr(lctx, e)),
PatEnum(ref pth, ref pats) => {
- hir::PatEnum(lower_path(_lctx, pth),
+ hir::PatEnum(lower_path(lctx, pth),
pats.as_ref()
- .map(|pats| pats.iter().map(|x| lower_pat(_lctx, x)).collect()))
+ .map(|pats| pats.iter().map(|x| lower_pat(lctx, x)).collect()))
}
PatQPath(ref qself, ref pth) => {
let qself = hir::QSelf {
- ty: lower_ty(_lctx, &qself.ty),
+ ty: lower_ty(lctx, &qself.ty),
position: qself.position,
};
- hir::PatQPath(qself, lower_path(_lctx, pth))
+ hir::PatQPath(qself, lower_path(lctx, pth))
}
PatStruct(ref pth, ref fields, etc) => {
- let pth = lower_path(_lctx, pth);
+ let pth = lower_path(lctx, pth);
let fs = fields.iter()
.map(|f| {
Spanned {
span: f.span,
node: hir::FieldPat {
name: f.node.ident.name,
- pat: lower_pat(_lctx, &f.node.pat),
+ pat: lower_pat(lctx, &f.node.pat),
is_shorthand: f.node.is_shorthand,
},
}
.collect();
hir::PatStruct(pth, fs, etc)
}
- PatTup(ref elts) => hir::PatTup(elts.iter().map(|x| lower_pat(_lctx, x)).collect()),
- PatBox(ref inner) => hir::PatBox(lower_pat(_lctx, inner)),
- PatRegion(ref inner, mutbl) => hir::PatRegion(lower_pat(_lctx, inner),
- lower_mutability(_lctx, mutbl)),
+ PatTup(ref elts) => hir::PatTup(elts.iter().map(|x| lower_pat(lctx, x)).collect()),
+ PatBox(ref inner) => hir::PatBox(lower_pat(lctx, inner)),
+ PatRegion(ref inner, mutbl) => {
+ hir::PatRegion(lower_pat(lctx, inner), lower_mutability(lctx, mutbl))
+ }
PatRange(ref e1, ref e2) => {
- hir::PatRange(lower_expr(_lctx, e1), lower_expr(_lctx, e2))
+ hir::PatRange(lower_expr(lctx, e1), lower_expr(lctx, e2))
}
PatVec(ref before, ref slice, ref after) => {
- hir::PatVec(before.iter().map(|x| lower_pat(_lctx, x)).collect(),
- slice.as_ref().map(|x| lower_pat(_lctx, x)),
- after.iter().map(|x| lower_pat(_lctx, x)).collect())
+ hir::PatVec(before.iter().map(|x| lower_pat(lctx, x)).collect(),
+ slice.as_ref().map(|x| lower_pat(lctx, x)),
+ after.iter().map(|x| lower_pat(lctx, x)).collect())
}
PatMac(_) => panic!("Shouldn't exist here"),
},
})
}
-// RAII utility for setting and unsetting the cached id.
-struct CachedIdSetter<'a> {
- reset: bool,
- lctx: &'a LoweringContext<'a>,
-}
-
-impl<'a> CachedIdSetter<'a> {
- fn new(lctx: &'a LoweringContext, expr_id: NodeId) -> CachedIdSetter<'a> {
- // Only reset the id if it was previously 0, i.e., was not cached.
- // If it was cached, we are in a nested node, but our id count will
- // still count towards the parent's count.
- let reset_cached_id = lctx.cached_id.get() == 0;
+// Utility fn for setting and unsetting the cached id.
+fn cache_ids<'a, OP, R>(lctx: &LoweringContext, expr_id: NodeId, op: OP) -> R
+ where OP: FnOnce(&LoweringContext) -> R
+{
+ // Only reset the id if it was previously 0, i.e., was not cached.
+ // If it was cached, we are in a nested node, but our id count will
+ // still count towards the parent's count.
+ let reset_cached_id = lctx.cached_id.get() == 0;
+ {
let id_cache: &mut HashMap<_, _> = &mut lctx.id_cache.borrow_mut();
if id_cache.contains_key(&expr_id) {
id_cache.insert(expr_id, next_id);
lctx.gensym_key.set(next_id);
}
-
- CachedIdSetter {
- reset: reset_cached_id,
- lctx: lctx,
- }
}
-}
-impl<'a> Drop for CachedIdSetter<'a> {
- fn drop(&mut self) {
- if self.reset {
- self.lctx.cached_id.set(0);
- self.lctx.gensym_key.set(0);
- }
+ let result = op(lctx);
+
+ if reset_cached_id {
+ lctx.cached_id.set(0);
+ lctx.gensym_key.set(0);
}
+
+ result
}
pub fn lower_expr(lctx: &LoweringContext, e: &Expr) -> P<hir::Expr> {
// std::intrinsics::move_val_init(raw_place, pop_unsafe!( EXPR ));
// InPlace::finalize(place)
// })
- let _old_cached = CachedIdSetter::new(lctx, e.id);
+ return cache_ids(lctx, e.id, |lctx| {
+ let placer_expr = lower_expr(lctx, placer);
+ let value_expr = lower_expr(lctx, value_expr);
+
+ let placer_ident = lctx.str_to_ident("placer");
+ let place_ident = lctx.str_to_ident("place");
+ let p_ptr_ident = lctx.str_to_ident("p_ptr");
+
+ let make_place = ["ops", "Placer", "make_place"];
+ let place_pointer = ["ops", "Place", "pointer"];
+ let move_val_init = ["intrinsics", "move_val_init"];
+ let inplace_finalize = ["ops", "InPlace", "finalize"];
+
+ let make_call = |lctx: &LoweringContext, p, args| {
+ let path = core_path(lctx, e.span, p);
+ let path = expr_path(lctx, path, None);
+ expr_call(lctx, e.span, path, args, None)
+ };
- let placer_expr = lower_expr(lctx, placer);
- let value_expr = lower_expr(lctx, value_expr);
+ let mk_stmt_let = |lctx: &LoweringContext, bind, expr| {
+ stmt_let(lctx, e.span, false, bind, expr, None)
+ };
- let placer_ident = lctx.str_to_ident("placer");
- let agent_ident = lctx.str_to_ident("place");
- let p_ptr_ident = lctx.str_to_ident("p_ptr");
+ let mk_stmt_let_mut = |lctx: &LoweringContext, bind, expr| {
+ stmt_let(lctx, e.span, true, bind, expr, None)
+ };
- let make_place = ["ops", "Placer", "make_place"];
- let place_pointer = ["ops", "Place", "pointer"];
- let move_val_init = ["intrinsics", "move_val_init"];
- let inplace_finalize = ["ops", "InPlace", "finalize"];
+ // let placer = <placer_expr> ;
+ let s1 = {
+ let placer_expr = signal_block_expr(lctx,
+ vec![],
+ placer_expr,
+ e.span,
+ hir::PopUnstableBlock,
+ None);
+ mk_stmt_let(lctx, placer_ident, placer_expr)
+ };
- let make_call = |lctx, p, args| {
- let path = core_path(lctx, e.span, p);
- let path = expr_path(lctx, path);
- expr_call(lctx, e.span, path, args)
- };
+ // let mut place = Placer::make_place(placer);
+ let s2 = {
+ let placer = expr_ident(lctx, e.span, placer_ident, None);
+ let call = make_call(lctx, &make_place, vec![placer]);
+ mk_stmt_let_mut(lctx, place_ident, call)
+ };
- let mk_stmt_let = |lctx, bind, expr| stmt_let(lctx, e.span, false, bind, expr);
- let mk_stmt_let_mut = |lctx, bind, expr| stmt_let(lctx, e.span, true, bind, expr);
-
- // let placer = <placer_expr> ;
- let s1 = mk_stmt_let(lctx,
- placer_ident,
- signal_block_expr(lctx,
- vec![],
- placer_expr,
- e.span,
- hir::PopUnstableBlock));
-
- // let mut place = Placer::make_place(placer);
- let s2 = {
- let call = make_call(lctx,
- &make_place,
- vec![expr_ident(lctx, e.span, placer_ident)]);
- mk_stmt_let_mut(lctx, agent_ident, call)
- };
+ // let p_ptr = Place::pointer(&mut place);
+ let s3 = {
+ let agent = expr_ident(lctx, e.span, place_ident, None);
+ let args = vec![expr_mut_addr_of(lctx, e.span, agent, None)];
+ let call = make_call(lctx, &place_pointer, args);
+ mk_stmt_let(lctx, p_ptr_ident, call)
+ };
- // let p_ptr = Place::pointer(&mut place);
- let s3 = {
- let args = vec![expr_mut_addr_of(lctx,
- e.span,
- expr_ident(lctx, e.span, agent_ident))];
- let call = make_call(lctx, &place_pointer, args);
- mk_stmt_let(lctx, p_ptr_ident, call)
- };
+ // pop_unsafe!(EXPR));
+ let pop_unsafe_expr = {
+ let value_expr = signal_block_expr(lctx,
+ vec![],
+ value_expr,
+ e.span,
+ hir::PopUnstableBlock,
+ None);
+ signal_block_expr(lctx,
+ vec![],
+ value_expr,
+ e.span,
+ hir::PopUnsafeBlock(hir::CompilerGenerated), None)
+ };
- // pop_unsafe!(EXPR));
- let pop_unsafe_expr =
- signal_block_expr(lctx,
- vec![],
- signal_block_expr(lctx,
- vec![],
- value_expr,
- e.span,
- hir::PopUnstableBlock),
- e.span,
- hir::PopUnsafeBlock(hir::CompilerGenerated));
+ // push_unsafe!({
+ // std::intrinsics::move_val_init(raw_place, pop_unsafe!( EXPR ));
+ // InPlace::finalize(place)
+ // })
+ let expr = {
+ let ptr = expr_ident(lctx, e.span, p_ptr_ident, None);
+ let call_move_val_init =
+ hir::StmtSemi(
+ make_call(lctx, &move_val_init, vec![ptr, pop_unsafe_expr]),
+ lctx.next_id());
+ let call_move_val_init = respan(e.span, call_move_val_init);
+
+ let place = expr_ident(lctx, e.span, place_ident, None);
+ let call = make_call(lctx, &inplace_finalize, vec![place]);
+ signal_block_expr(lctx,
+ vec![call_move_val_init],
+ call,
+ e.span,
+ hir::PushUnsafeBlock(hir::CompilerGenerated), None)
+ };
- // push_unsafe!({
- // std::intrinsics::move_val_init(raw_place, pop_unsafe!( EXPR ));
- // InPlace::finalize(place)
- // })
- let expr = {
- let call_move_val_init = hir::StmtSemi(make_call(lctx,
- &move_val_init,
- vec![expr_ident(lctx, e.span, p_ptr_ident),
- pop_unsafe_expr]),
- lctx.next_id());
- let call_move_val_init = respan(e.span, call_move_val_init);
-
- let call = make_call(lctx,
- &inplace_finalize,
- vec![expr_ident(lctx, e.span, agent_ident)]);
signal_block_expr(lctx,
- vec![P(call_move_val_init)],
- call,
+ vec![s1, s2, s3],
+ expr,
e.span,
- hir::PushUnsafeBlock(hir::CompilerGenerated))
- };
-
- return signal_block_expr(lctx,
- vec![s1, s2, s3],
- expr,
- e.span,
- hir::PushUnstableBlock);
+ hir::PushUnstableBlock,
+ e.attrs.clone())
+ });
}
ExprVec(ref exprs) => {
hir::ExprVec(exprs.iter().map(|x| lower_expr(lctx, x)).collect())
}
ExprRepeat(ref expr, ref count) => {
- hir::ExprRepeat(lower_expr(lctx, expr), lower_expr(lctx, count))
+ let expr = lower_expr(lctx, expr);
+ let count = lower_expr(lctx, count);
+ hir::ExprRepeat(expr, count)
}
ExprTup(ref elts) => {
hir::ExprTup(elts.iter().map(|x| lower_expr(lctx, x)).collect())
}
ExprCall(ref f, ref args) => {
- hir::ExprCall(lower_expr(lctx, f),
- args.iter().map(|x| lower_expr(lctx, x)).collect())
+ let f = lower_expr(lctx, f);
+ hir::ExprCall(f, args.iter().map(|x| lower_expr(lctx, x)).collect())
}
ExprMethodCall(i, ref tps, ref args) => {
- hir::ExprMethodCall(respan(i.span, i.node.name),
- tps.iter().map(|x| lower_ty(lctx, x)).collect(),
- args.iter().map(|x| lower_expr(lctx, x)).collect())
+ let tps = tps.iter().map(|x| lower_ty(lctx, x)).collect();
+ let args = args.iter().map(|x| lower_expr(lctx, x)).collect();
+ hir::ExprMethodCall(respan(i.span, i.node.name), tps, args)
}
ExprBinary(binop, ref lhs, ref rhs) => {
- hir::ExprBinary(lower_binop(lctx, binop),
- lower_expr(lctx, lhs),
- lower_expr(lctx, rhs))
+ let binop = lower_binop(lctx, binop);
+ let lhs = lower_expr(lctx, lhs);
+ let rhs = lower_expr(lctx, rhs);
+ hir::ExprBinary(binop, lhs, rhs)
}
ExprUnary(op, ref ohs) => {
- hir::ExprUnary(lower_unop(lctx, op), lower_expr(lctx, ohs))
+ let op = lower_unop(lctx, op);
+ let ohs = lower_expr(lctx, ohs);
+ hir::ExprUnary(op, ohs)
}
ExprLit(ref l) => hir::ExprLit(P((**l).clone())),
ExprCast(ref expr, ref ty) => {
- hir::ExprCast(lower_expr(lctx, expr), lower_ty(lctx, ty))
+ let expr = lower_expr(lctx, expr);
+ hir::ExprCast(expr, lower_ty(lctx, ty))
}
ExprAddrOf(m, ref ohs) => {
- hir::ExprAddrOf(lower_mutability(lctx, m), lower_expr(lctx, ohs))
+ let m = lower_mutability(lctx, m);
+ let ohs = lower_expr(lctx, ohs);
+ hir::ExprAddrOf(m, ohs)
}
// More complicated than you might expect because the else branch
// might be `if let`.
let else_opt = else_opt.as_ref().map(|els| {
match els.node {
ExprIfLet(..) => {
- let _old_cached = CachedIdSetter::new(lctx, e.id);
- // wrap the if-let expr in a block
- let span = els.span;
- let blk = P(hir::Block {
- stmts: vec![],
- expr: Some(lower_expr(lctx, els)),
- id: lctx.next_id(),
- rules: hir::DefaultBlock,
- span: span,
- });
- expr_block(lctx, blk)
+ cache_ids(lctx, e.id, |lctx| {
+ // wrap the if-let expr in a block
+ let span = els.span;
+ let els = lower_expr(lctx, els);
+ let id = lctx.next_id();
+ let blk = P(hir::Block {
+ stmts: vec![],
+ expr: Some(els),
+ id: id,
+ rules: hir::DefaultBlock,
+ span: span,
+ });
+ expr_block(lctx, blk, None)
+ })
}
_ => lower_expr(lctx, els),
}
});
- hir::ExprIf(lower_expr(lctx, cond),
- lower_block(lctx, blk),
- else_opt)
+ hir::ExprIf(lower_expr(lctx, cond), lower_block(lctx, blk), else_opt)
}
ExprWhile(ref cond, ref body, opt_ident) => {
- hir::ExprWhile(lower_expr(lctx, cond),
- lower_block(lctx, body),
- opt_ident)
+ hir::ExprWhile(lower_expr(lctx, cond), lower_block(lctx, body),
+ opt_ident.map(|ident| lower_ident(lctx, ident)))
}
ExprLoop(ref body, opt_ident) => {
- hir::ExprLoop(lower_block(lctx, body), opt_ident)
+ hir::ExprLoop(lower_block(lctx, body),
+ opt_ident.map(|ident| lower_ident(lctx, ident)))
}
ExprMatch(ref expr, ref arms) => {
hir::ExprMatch(lower_expr(lctx, expr),
lower_expr(lctx, er))
}
ExprField(ref el, ident) => {
- hir::ExprField(lower_expr(lctx, el),
- respan(ident.span, ident.node.name))
+ hir::ExprField(lower_expr(lctx, el), respan(ident.span, ident.node.name))
}
ExprTupField(ref el, ident) => {
hir::ExprTupField(lower_expr(lctx, el), ident)
e2.as_ref().map(|x| lower_expr(lctx, x)))
}
ExprPath(ref qself, ref path) => {
- let qself = qself.as_ref().map(|&QSelf { ref ty, position }| {
+ let hir_qself = qself.as_ref().map(|&QSelf { ref ty, position }| {
hir::QSelf {
ty: lower_ty(lctx, ty),
position: position,
}
});
- hir::ExprPath(qself, lower_path(lctx, path))
+ hir::ExprPath(hir_qself, lower_path_full(lctx, path, qself.is_none()))
}
- ExprBreak(opt_ident) => hir::ExprBreak(opt_ident),
- ExprAgain(opt_ident) => hir::ExprAgain(opt_ident),
+ ExprBreak(opt_ident) => hir::ExprBreak(opt_ident.map(|sp_ident| {
+ respan(sp_ident.span, lower_ident(lctx, sp_ident.node))
+ })),
+ ExprAgain(opt_ident) => hir::ExprAgain(opt_ident.map(|sp_ident| {
+ respan(sp_ident.span, lower_ident(lctx, sp_ident.node))
+ })),
ExprRet(ref e) => hir::ExprRet(e.as_ref().map(|x| lower_expr(lctx, x))),
ExprInlineAsm(InlineAsm {
ref inputs,
maybe_expr.as_ref().map(|x| lower_expr(lctx, x)))
}
ExprParen(ref ex) => {
- return lower_expr(lctx, ex);
+ // merge attributes into the inner expression.
+ return lower_expr(lctx, ex).map(|mut ex| {
+ ex.attrs.update(|attrs| {
+ attrs.prepend(e.attrs.clone())
+ });
+ ex
+ });
}
// Desugar ExprIfLet
// _ => [<else_opt> | ()]
// }
- let _old_cached = CachedIdSetter::new(lctx, e.id);
-
- // `<pat> => <body>`
- let pat_arm = {
- let body_expr = expr_block(lctx, lower_block(lctx, body));
- arm(vec![lower_pat(lctx, pat)], body_expr)
- };
+ return cache_ids(lctx, e.id, |lctx| {
+ // `<pat> => <body>`
+ let pat_arm = {
+ let body = lower_block(lctx, body);
+ let body_expr = expr_block(lctx, body, None);
+ arm(vec![lower_pat(lctx, pat)], body_expr)
+ };
- // `[_ if <else_opt_if_cond> => <else_opt_if_body>,]`
- let mut else_opt = else_opt.as_ref().map(|e| lower_expr(lctx, e));
- let else_if_arms = {
- let mut arms = vec![];
- loop {
- let else_opt_continue = else_opt.and_then(|els| {
- els.and_then(|els| {
- match els.node {
- // else if
- hir::ExprIf(cond, then, else_opt) => {
- let pat_under = pat_wild(lctx, e.span);
- arms.push(hir::Arm {
- attrs: vec![],
- pats: vec![pat_under],
- guard: Some(cond),
- body: expr_block(lctx, then),
- });
- else_opt.map(|else_opt| (else_opt, true))
+ // `[_ if <else_opt_if_cond> => <else_opt_if_body>,]`
+ let mut else_opt = else_opt.as_ref().map(|e| lower_expr(lctx, e));
+ let else_if_arms = {
+ let mut arms = vec![];
+ loop {
+ let else_opt_continue = else_opt.and_then(|els| {
+ els.and_then(|els| {
+ match els.node {
+ // else if
+ hir::ExprIf(cond, then, else_opt) => {
+ let pat_under = pat_wild(lctx, e.span);
+ arms.push(hir::Arm {
+ attrs: vec![],
+ pats: vec![pat_under],
+ guard: Some(cond),
+ body: expr_block(lctx, then, None),
+ });
+ else_opt.map(|else_opt| (else_opt, true))
+ }
+ _ => Some((P(els), false)),
}
- _ => Some((P(els), false)),
+ })
+ });
+ match else_opt_continue {
+ Some((e, true)) => {
+ else_opt = Some(e);
+ }
+ Some((e, false)) => {
+ else_opt = Some(e);
+ break;
+ }
+ None => {
+ else_opt = None;
+ break;
}
- })
- });
- match else_opt_continue {
- Some((e, true)) => {
- else_opt = Some(e);
- }
- Some((e, false)) => {
- else_opt = Some(e);
- break;
- }
- None => {
- else_opt = None;
- break;
}
}
- }
- arms
- };
+ arms
+ };
- let contains_else_clause = else_opt.is_some();
+ let contains_else_clause = else_opt.is_some();
- // `_ => [<else_opt> | ()]`
- let else_arm = {
- let pat_under = pat_wild(lctx, e.span);
- let else_expr = else_opt.unwrap_or_else(|| expr_tuple(lctx, e.span, vec![]));
- arm(vec![pat_under], else_expr)
- };
+ // `_ => [<else_opt> | ()]`
+ let else_arm = {
+ let pat_under = pat_wild(lctx, e.span);
+ let else_expr =
+ else_opt.unwrap_or_else(
+ || expr_tuple(lctx, e.span, vec![], None));
+ arm(vec![pat_under], else_expr)
+ };
- let mut arms = Vec::with_capacity(else_if_arms.len() + 2);
- arms.push(pat_arm);
- arms.extend(else_if_arms);
- arms.push(else_arm);
+ let mut arms = Vec::with_capacity(else_if_arms.len() + 2);
+ arms.push(pat_arm);
+ arms.extend(else_if_arms);
+ arms.push(else_arm);
- let match_expr = expr(lctx,
- e.span,
- hir::ExprMatch(lower_expr(lctx, sub_expr),
- arms,
- hir::MatchSource::IfLetDesugar {
- contains_else_clause: contains_else_clause,
- }));
- return match_expr;
+ let sub_expr = lower_expr(lctx, sub_expr);
+ // add attributes to the outer returned expr node
+ expr(lctx,
+ e.span,
+ hir::ExprMatch(sub_expr,
+ arms,
+ hir::MatchSource::IfLetDesugar {
+ contains_else_clause: contains_else_clause,
+ }),
+ e.attrs.clone())
+ });
}
// Desugar ExprWhileLet
// }
// }
- let _old_cached = CachedIdSetter::new(lctx, e.id);
-
- // `<pat> => <body>`
- let pat_arm = {
- let body_expr = expr_block(lctx, lower_block(lctx, body));
- arm(vec![lower_pat(lctx, pat)], body_expr)
- };
-
- // `_ => break`
- let break_arm = {
- let pat_under = pat_wild(lctx, e.span);
- let break_expr = expr_break(lctx, e.span);
- arm(vec![pat_under], break_expr)
- };
+ return cache_ids(lctx, e.id, |lctx| {
+ // `<pat> => <body>`
+ let pat_arm = {
+ let body = lower_block(lctx, body);
+ let body_expr = expr_block(lctx, body, None);
+ arm(vec![lower_pat(lctx, pat)], body_expr)
+ };
- // `match <sub_expr> { ... }`
- let arms = vec![pat_arm, break_arm];
- let match_expr = expr(lctx,
- e.span,
- hir::ExprMatch(lower_expr(lctx, sub_expr),
- arms,
- hir::MatchSource::WhileLetDesugar));
+ // `_ => break`
+ let break_arm = {
+ let pat_under = pat_wild(lctx, e.span);
+ let break_expr = expr_break(lctx, e.span, None);
+ arm(vec![pat_under], break_expr)
+ };
- // `[opt_ident]: loop { ... }`
- let loop_block = block_expr(lctx, match_expr);
- return expr(lctx, e.span, hir::ExprLoop(loop_block, opt_ident));
+ // `match <sub_expr> { ... }`
+ let arms = vec![pat_arm, break_arm];
+ let sub_expr = lower_expr(lctx, sub_expr);
+ let match_expr = expr(lctx,
+ e.span,
+ hir::ExprMatch(sub_expr,
+ arms,
+ hir::MatchSource::WhileLetDesugar),
+ None);
+
+ // `[opt_ident]: loop { ... }`
+ let loop_block = block_expr(lctx, match_expr);
+ let loop_expr = hir::ExprLoop(loop_block,
+ opt_ident.map(|ident| lower_ident(lctx, ident)));
+ // add attributes to the outer returned expr node
+ expr(lctx, e.span, loop_expr, e.attrs.clone())
+ });
}
// Desugar ExprForLoop
// result
// }
- let _old_cached = CachedIdSetter::new(lctx, e.id);
-
- // expand <head>
- let head = lower_expr(lctx, head);
-
- let iter = lctx.str_to_ident("iter");
-
- // `::std::option::Option::Some(<pat>) => <body>`
- let pat_arm = {
- let body_block = lower_block(lctx, body);
- let body_span = body_block.span;
- let body_expr = P(hir::Expr {
- id: lctx.next_id(),
- node: hir::ExprBlock(body_block),
- span: body_span,
- });
- let pat = lower_pat(lctx, pat);
- let some_pat = pat_some(lctx, e.span, pat);
-
- arm(vec![some_pat], body_expr)
- };
+ return cache_ids(lctx, e.id, |lctx| {
+ // expand <head>
+ let head = lower_expr(lctx, head);
+
+ let iter = lctx.str_to_ident("iter");
+
+ // `::std::option::Option::Some(<pat>) => <body>`
+ let pat_arm = {
+ let body_block = lower_block(lctx, body);
+ let body_span = body_block.span;
+ let body_expr = P(hir::Expr {
+ id: lctx.next_id(),
+ node: hir::ExprBlock(body_block),
+ span: body_span,
+ attrs: None,
+ });
+ let pat = lower_pat(lctx, pat);
+ let some_pat = pat_some(lctx, e.span, pat);
- // `::std::option::Option::None => break`
- let break_arm = {
- let break_expr = expr_break(lctx, e.span);
+ arm(vec![some_pat], body_expr)
+ };
- arm(vec![pat_none(lctx, e.span)], break_expr)
- };
+ // `::std::option::Option::None => break`
+ let break_arm = {
+ let break_expr = expr_break(lctx, e.span, None);
- // `match ::std::iter::Iterator::next(&mut iter) { ... }`
- let match_expr = {
- let next_path = {
- let strs = std_path(lctx, &["iter", "Iterator", "next"]);
+ arm(vec![pat_none(lctx, e.span)], break_expr)
+ };
- path_global(e.span, strs)
+ // `match ::std::iter::Iterator::next(&mut iter) { ... }`
+ let match_expr = {
+ let next_path = {
+ let strs = std_path(lctx, &["iter", "Iterator", "next"]);
+
+ path_global(e.span, strs)
+ };
+ let iter = expr_ident(lctx, e.span, iter, None);
+ let ref_mut_iter = expr_mut_addr_of(lctx, e.span, iter, None);
+ let next_path = expr_path(lctx, next_path, None);
+ let next_expr = expr_call(lctx,
+ e.span,
+ next_path,
+ vec![ref_mut_iter],
+ None);
+ let arms = vec![pat_arm, break_arm];
+
+ expr(lctx,
+ e.span,
+ hir::ExprMatch(next_expr, arms, hir::MatchSource::ForLoopDesugar),
+ None)
};
- let ref_mut_iter = expr_mut_addr_of(lctx,
- e.span,
- expr_ident(lctx, e.span, iter));
- let next_expr = expr_call(lctx,
- e.span,
- expr_path(lctx, next_path),
- vec![ref_mut_iter]);
- let arms = vec![pat_arm, break_arm];
- expr(lctx,
- e.span,
- hir::ExprMatch(next_expr, arms, hir::MatchSource::ForLoopDesugar))
- };
+ // `[opt_ident]: loop { ... }`
+ let loop_block = block_expr(lctx, match_expr);
+ let loop_expr = hir::ExprLoop(loop_block,
+ opt_ident.map(|ident| lower_ident(lctx, ident)));
+ let loop_expr = expr(lctx, e.span, loop_expr, None);
+
+ // `mut iter => { ... }`
+ let iter_arm = {
+ let iter_pat = pat_ident_binding_mode(lctx,
+ e.span,
+ iter,
+ hir::BindByValue(hir::MutMutable));
+ arm(vec![iter_pat], loop_expr)
+ };
- // `[opt_ident]: loop { ... }`
- let loop_block = block_expr(lctx, match_expr);
- let loop_expr = expr(lctx, e.span, hir::ExprLoop(loop_block, opt_ident));
-
- // `mut iter => { ... }`
- let iter_arm = {
- let iter_pat = pat_ident_binding_mode(lctx,
- e.span,
- iter,
- hir::BindByValue(hir::MutMutable));
- arm(vec![iter_pat], loop_expr)
- };
+ // `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
+ let into_iter_expr = {
+ let into_iter_path = {
+ let strs = std_path(lctx, &["iter", "IntoIterator", "into_iter"]);
- // `match ::std::iter::IntoIterator::into_iter(<head>) { ... }`
- let into_iter_expr = {
- let into_iter_path = {
- let strs = std_path(lctx, &["iter", "IntoIterator", "into_iter"]);
+ path_global(e.span, strs)
+ };
- path_global(e.span, strs)
+ let into_iter = expr_path(lctx, into_iter_path, None);
+ expr_call(lctx, e.span, into_iter, vec![head], None)
};
- expr_call(lctx,
- e.span,
- expr_path(lctx, into_iter_path),
- vec![head])
- };
-
- let match_expr = expr_match(lctx,
- e.span,
- into_iter_expr,
- vec![iter_arm],
- hir::MatchSource::ForLoopDesugar);
-
- // `{ let result = ...; result }`
- let result_ident = lctx.str_to_ident("result");
- return expr_block(lctx,
- block_all(lctx,
- e.span,
- vec![stmt_let(lctx,
- e.span,
- false,
- result_ident,
- match_expr)],
- Some(expr_ident(lctx, e.span, result_ident))))
+ let match_expr = expr_match(lctx,
+ e.span,
+ into_iter_expr,
+ vec![iter_arm],
+ hir::MatchSource::ForLoopDesugar,
+ None);
+
+ // `{ let result = ...; result }`
+ let result_ident = lctx.str_to_ident("result");
+ let let_stmt = stmt_let(lctx, e.span, false, result_ident, match_expr, None);
+ let result = expr_ident(lctx, e.span, result_ident, None);
+ let block = block_all(lctx, e.span, vec![let_stmt], Some(result));
+ // add the attributes to the outer returned expr node
+ expr_block(lctx, block, e.attrs.clone())
+ });
}
ExprMac(_) => panic!("Shouldn't exist here"),
},
span: e.span,
+ attrs: e.attrs.clone(),
})
}
-pub fn lower_stmt(_lctx: &LoweringContext, s: &Stmt) -> P<hir::Stmt> {
+pub fn lower_stmt(lctx: &LoweringContext, s: &Stmt) -> hir::Stmt {
match s.node {
StmtDecl(ref d, id) => {
- P(Spanned {
- node: hir::StmtDecl(lower_decl(_lctx, d), id),
+ Spanned {
+ node: hir::StmtDecl(lower_decl(lctx, d), id),
span: s.span,
- })
+ }
}
StmtExpr(ref e, id) => {
- P(Spanned {
- node: hir::StmtExpr(lower_expr(_lctx, e), id),
+ Spanned {
+ node: hir::StmtExpr(lower_expr(lctx, e), id),
span: s.span,
- })
+ }
}
StmtSemi(ref e, id) => {
- P(Spanned {
- node: hir::StmtSemi(lower_expr(_lctx, e), id),
+ Spanned {
+ node: hir::StmtSemi(lower_expr(lctx, e), id),
span: s.span,
- })
+ }
}
StmtMac(..) => panic!("Shouldn't exist here"),
}
}
}
-pub fn lower_block_check_mode(_lctx: &LoweringContext, b: &BlockCheckMode) -> hir::BlockCheckMode {
+pub fn lower_block_check_mode(lctx: &LoweringContext, b: &BlockCheckMode) -> hir::BlockCheckMode {
match *b {
DefaultBlock => hir::DefaultBlock,
- UnsafeBlock(u) => hir::UnsafeBlock(lower_unsafe_source(_lctx, u)),
+ UnsafeBlock(u) => hir::UnsafeBlock(lower_unsafe_source(lctx, u)),
}
}
-pub fn lower_pat_wild_kind(_lctx: &LoweringContext, p: PatWildKind) -> hir::PatWildKind {
- match p {
- PatWildSingle => hir::PatWildSingle,
- PatWildMulti => hir::PatWildMulti,
- }
-}
-
-pub fn lower_binding_mode(_lctx: &LoweringContext, b: &BindingMode) -> hir::BindingMode {
+pub fn lower_binding_mode(lctx: &LoweringContext, b: &BindingMode) -> hir::BindingMode {
match *b {
- BindByRef(m) => hir::BindByRef(lower_mutability(_lctx, m)),
- BindByValue(m) => hir::BindByValue(lower_mutability(_lctx, m)),
+ BindByRef(m) => hir::BindByRef(lower_mutability(lctx, m)),
+ BindByValue(m) => hir::BindByValue(lower_mutability(lctx, m)),
}
}
-pub fn lower_struct_field_kind(_lctx: &LoweringContext,
+pub fn lower_struct_field_kind(lctx: &LoweringContext,
s: &StructFieldKind)
-> hir::StructFieldKind {
match *s {
- NamedField(ident, vis) => hir::NamedField(ident.name, lower_visibility(_lctx, vis)),
- UnnamedField(vis) => hir::UnnamedField(lower_visibility(_lctx, vis)),
+ NamedField(ident, vis) => hir::NamedField(ident.name, lower_visibility(lctx, vis)),
+ UnnamedField(vis) => hir::UnnamedField(lower_visibility(lctx, vis)),
}
}
fn arm(pats: Vec<P<hir::Pat>>, expr: P<hir::Expr>) -> hir::Arm {
hir::Arm {
- attrs: vec!(),
+ attrs: vec![],
pats: pats,
guard: None,
body: expr,
}
}
-fn expr_break(lctx: &LoweringContext, span: Span) -> P<hir::Expr> {
- expr(lctx, span, hir::ExprBreak(None))
+fn expr_break(lctx: &LoweringContext, span: Span,
+ attrs: ThinAttributes) -> P<hir::Expr> {
+ expr(lctx, span, hir::ExprBreak(None), attrs)
}
fn expr_call(lctx: &LoweringContext,
span: Span,
e: P<hir::Expr>,
- args: Vec<P<hir::Expr>>)
+ args: Vec<P<hir::Expr>>,
+ attrs: ThinAttributes)
-> P<hir::Expr> {
- expr(lctx, span, hir::ExprCall(e, args))
+ expr(lctx, span, hir::ExprCall(e, args), attrs)
}
-fn expr_ident(lctx: &LoweringContext, span: Span, id: Ident) -> P<hir::Expr> {
- expr_path(lctx, path_ident(span, id))
+fn expr_ident(lctx: &LoweringContext, span: Span, id: hir::Ident,
+ attrs: ThinAttributes) -> P<hir::Expr> {
+ expr_path(lctx, path_ident(span, id), attrs)
}
-fn expr_mut_addr_of(lctx: &LoweringContext, span: Span, e: P<hir::Expr>) -> P<hir::Expr> {
- expr(lctx, span, hir::ExprAddrOf(hir::MutMutable, e))
+fn expr_mut_addr_of(lctx: &LoweringContext, span: Span, e: P<hir::Expr>,
+ attrs: ThinAttributes) -> P<hir::Expr> {
+ expr(lctx, span, hir::ExprAddrOf(hir::MutMutable, e), attrs)
}
-fn expr_path(lctx: &LoweringContext, path: hir::Path) -> P<hir::Expr> {
- expr(lctx, path.span, hir::ExprPath(None, path))
+fn expr_path(lctx: &LoweringContext, path: hir::Path,
+ attrs: ThinAttributes) -> P<hir::Expr> {
+ expr(lctx, path.span, hir::ExprPath(None, path), attrs)
}
fn expr_match(lctx: &LoweringContext,
span: Span,
arg: P<hir::Expr>,
arms: Vec<hir::Arm>,
- source: hir::MatchSource)
+ source: hir::MatchSource,
+ attrs: ThinAttributes)
-> P<hir::Expr> {
- expr(lctx,
- span,
- hir::ExprMatch(arg, arms, source))
+ expr(lctx, span, hir::ExprMatch(arg, arms, source), attrs)
}
-fn expr_block(lctx: &LoweringContext, b: P<hir::Block>) -> P<hir::Expr> {
- expr(lctx, b.span, hir::ExprBlock(b))
+fn expr_block(lctx: &LoweringContext, b: P<hir::Block>,
+ attrs: ThinAttributes) -> P<hir::Expr> {
+ expr(lctx, b.span, hir::ExprBlock(b), attrs)
}
-fn expr_tuple(lctx: &LoweringContext, sp: Span, exprs: Vec<P<hir::Expr>>) -> P<hir::Expr> {
- expr(lctx, sp, hir::ExprTup(exprs))
+fn expr_tuple(lctx: &LoweringContext, sp: Span, exprs: Vec<P<hir::Expr>>,
+ attrs: ThinAttributes) -> P<hir::Expr> {
+ expr(lctx, sp, hir::ExprTup(exprs), attrs)
}
-fn expr(lctx: &LoweringContext, span: Span, node: hir::Expr_) -> P<hir::Expr> {
+fn expr(lctx: &LoweringContext, span: Span, node: hir::Expr_,
+ attrs: ThinAttributes) -> P<hir::Expr> {
P(hir::Expr {
id: lctx.next_id(),
node: node,
span: span,
+ attrs: attrs,
})
}
fn stmt_let(lctx: &LoweringContext,
sp: Span,
mutbl: bool,
- ident: Ident,
- ex: P<hir::Expr>)
- -> P<hir::Stmt> {
+ ident: hir::Ident,
+ ex: P<hir::Expr>,
+ attrs: ThinAttributes)
+ -> hir::Stmt {
let pat = if mutbl {
pat_ident_binding_mode(lctx, sp, ident, hir::BindByValue(hir::MutMutable))
} else {
init: Some(ex),
id: lctx.next_id(),
span: sp,
+ attrs: attrs,
});
let decl = respan(sp, hir::DeclLocal(local));
- P(respan(sp, hir::StmtDecl(P(decl), lctx.next_id())))
+ respan(sp, hir::StmtDecl(P(decl), lctx.next_id()))
}
fn block_expr(lctx: &LoweringContext, expr: P<hir::Expr>) -> P<hir::Block> {
fn block_all(lctx: &LoweringContext,
span: Span,
- stmts: Vec<P<hir::Stmt>>,
+ stmts: Vec<hir::Stmt>,
expr: Option<P<hir::Expr>>)
-> P<hir::Block> {
P(hir::Block {
fn pat_some(lctx: &LoweringContext, span: Span, pat: P<hir::Pat>) -> P<hir::Pat> {
let some = std_path(lctx, &["option", "Option", "Some"]);
let path = path_global(span, some);
- pat_enum(lctx, span, path, vec!(pat))
+ pat_enum(lctx, span, path, vec![pat])
}
fn pat_none(lctx: &LoweringContext, span: Span) -> P<hir::Pat> {
pat(lctx, span, pt)
}
-fn pat_ident(lctx: &LoweringContext, span: Span, ident: Ident) -> P<hir::Pat> {
+fn pat_ident(lctx: &LoweringContext, span: Span, ident: hir::Ident) -> P<hir::Pat> {
pat_ident_binding_mode(lctx, span, ident, hir::BindByValue(hir::MutImmutable))
}
fn pat_ident_binding_mode(lctx: &LoweringContext,
span: Span,
- ident: Ident,
+ ident: hir::Ident,
bm: hir::BindingMode)
-> P<hir::Pat> {
let pat_ident = hir::PatIdent(bm,
}
fn pat_wild(lctx: &LoweringContext, span: Span) -> P<hir::Pat> {
- pat(lctx, span, hir::PatWild(hir::PatWildSingle))
+ pat(lctx, span, hir::PatWild)
}
fn pat(lctx: &LoweringContext, span: Span, pat: hir::Pat_) -> P<hir::Pat> {
})
}
-fn path_ident(span: Span, id: Ident) -> hir::Path {
- path(span, vec!(id))
+fn path_ident(span: Span, id: hir::Ident) -> hir::Path {
+ path(span, vec![id])
}
-fn path(span: Span, strs: Vec<Ident>) -> hir::Path {
+fn path(span: Span, strs: Vec<hir::Ident>) -> hir::Path {
path_all(span, false, strs, Vec::new(), Vec::new(), Vec::new())
}
-fn path_global(span: Span, strs: Vec<Ident>) -> hir::Path {
+fn path_global(span: Span, strs: Vec<hir::Ident>) -> hir::Path {
path_all(span, true, strs, Vec::new(), Vec::new(), Vec::new())
}
fn path_all(sp: Span,
global: bool,
- mut idents: Vec<Ident>,
+ mut idents: Vec<hir::Ident>,
lifetimes: Vec<hir::Lifetime>,
types: Vec<P<hir::Ty>>,
- bindings: Vec<P<hir::TypeBinding>>)
+ bindings: Vec<hir::TypeBinding>)
-> hir::Path {
let last_identifier = idents.pop().unwrap();
let mut segments: Vec<hir::PathSegment> = idents.into_iter()
}
}
-fn std_path(lctx: &LoweringContext, components: &[&str]) -> Vec<Ident> {
+fn std_path(lctx: &LoweringContext, components: &[&str]) -> Vec<hir::Ident> {
let mut v = Vec::new();
if let Some(s) = lctx.crate_root {
- v.push(str_to_ident(s));
+ v.push(hir::Ident::from_name(token::intern(s)));
}
- v.extend(components.iter().map(|s| str_to_ident(s)));
- return v
+ v.extend(components.iter().map(|s| hir::Ident::from_name(token::intern(s))));
+ return v;
}
// Given suffix ["b","c","d"], returns path `::std::b::c::d` when
}
fn signal_block_expr(lctx: &LoweringContext,
- stmts: Vec<P<hir::Stmt>>,
+ stmts: Vec<hir::Stmt>,
expr: P<hir::Expr>,
span: Span,
- rule: hir::BlockCheckMode)
+ rule: hir::BlockCheckMode,
+ attrs: ThinAttributes)
-> P<hir::Expr> {
+ let id = lctx.next_id();
expr_block(lctx,
P(hir::Block {
rules: rule,
span: span,
- id: lctx.next_id(),
+ id: id,
stmts: stmts,
expr: Some(expr),
- }))
+ }),
+ attrs)
}
impl MockAssigner {
fn new() -> MockAssigner {
- MockAssigner {
- next_id: Cell::new(0),
- }
+ MockAssigner { next_id: Cell::new(0) }
}
}
expn_id: codemap::NO_EXPANSION,
}
}
- fn cfg(&self) -> ast::CrateConfig { Vec::new() }
+ fn cfg(&self) -> ast::CrateConfig {
+ Vec::new()
+ }
fn ident_of(&self, st: &str) -> ast::Ident {
parse::token::str_to_ident(st)
}
fn name_of(&self, st: &str) -> ast::Name {
parse::token::intern(st)
}
- fn parse_sess(&self) -> &parse::ParseSess { self }
+ fn parse_sess(&self) -> &parse::ParseSess {
+ self
+ }
}
impl NodeIdAssigner for MockAssigner {
let cx = parse::ParseSess::new();
let mut assigner = MockAssigner::new();
- let ast_if_let = quote_expr!(&cx, if let Some(foo) = baz { bar(foo); });
+ let ast_if_let = quote_expr!(&cx,
+ if let Some(foo) = baz {
+ bar(foo);
+ });
let ast_if_let = assigner.fold_expr(ast_if_let);
- let ast_while_let = quote_expr!(&cx, while let Some(foo) = baz { bar(foo); });
+ let ast_while_let = quote_expr!(&cx,
+ while let Some(foo) = baz {
+ bar(foo);
+ });
let ast_while_let = assigner.fold_expr(ast_while_let);
- let ast_for = quote_expr!(&cx, for i in 0..10 { foo(i); });
+ let ast_for = quote_expr!(&cx,
+ for i in 0..10 {
+ foo(i);
+ });
let ast_for = assigner.fold_expr(ast_for);
let ast_in = quote_expr!(&cx, in HEAP { foo() });
let ast_in = assigner.fold_expr(ast_in);
projects / rustc.git / blobdiff