Skip to content

Visit and fold macro invocations in the same order #36555

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

Merged
merged 2 commits into from
Sep 18, 2016
Merged

Visit and fold macro invocations in the same order #36555

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
2cee9ec
Ensure that macro invocations are folded and visited the same order.
jseyfried Sep 17, 2016
c7e4ae0
Add regression test.
jseyfried Sep 17, 2016
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
84 changes: 31 additions & 53 deletions src/libsyntax/fold.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -478,8 +478,8 @@ pub fn noop_fold_parenthesized_parameter_data<T: Folder>(data: ParenthesizedPara
pub fn noop_fold_local<T: Folder>(l: P<Local>, fld: &mut T) -> P<Local> {
l.map(|Local {id, pat, ty, init, span, attrs}| Local {
id: fld.new_id(id),
ty: ty.map(|t| fld.fold_ty(t)),
pat: fld.fold_pat(pat),
ty: ty.map(|t| fld.fold_ty(t)),
init: init.map(|e| fld.fold_expr(e)),
span: fld.new_span(span),
attrs: fold_attrs(attrs.into(), fld).into(),
Expand Down Expand Up @@ -860,65 +860,46 @@ pub fn noop_fold_item_kind<T: Folder>(i: ItemKind, folder: &mut T) -> ItemKind {
ItemKind::Const(folder.fold_ty(t), folder.fold_expr(e))
}
ItemKind::Fn(decl, unsafety, constness, abi, generics, body) => {
ItemKind::Fn(
folder.fold_fn_decl(decl),
unsafety,
constness,
abi,
folder.fold_generics(generics),
folder.fold_block(body)
)
let generics = folder.fold_generics(generics);
let decl = folder.fold_fn_decl(decl);
let body = folder.fold_block(body);
ItemKind::Fn(decl, unsafety, constness, abi, generics, body)
}
ItemKind::Mod(m) => ItemKind::Mod(folder.fold_mod(m)),
ItemKind::ForeignMod(nm) => ItemKind::ForeignMod(folder.fold_foreign_mod(nm)),
ItemKind::Ty(t, generics) => {
ItemKind::Ty(folder.fold_ty(t), folder.fold_generics(generics))
}
ItemKind::Enum(enum_definition, generics) => {
ItemKind::Enum(
ast::EnumDef {
variants: enum_definition.variants.move_map(|x| folder.fold_variant(x)),
},
folder.fold_generics(generics))
let generics = folder.fold_generics(generics);
let variants = enum_definition.variants.move_map(|x| folder.fold_variant(x));
ItemKind::Enum(ast::EnumDef { variants: variants }, generics)
}
ItemKind::Struct(struct_def, generics) => {
let struct_def = folder.fold_variant_data(struct_def);
ItemKind::Struct(struct_def, folder.fold_generics(generics))
let generics = folder.fold_generics(generics);
ItemKind::Struct(folder.fold_variant_data(struct_def), generics)
}
ItemKind::Union(struct_def, generics) => {
let struct_def = folder.fold_variant_data(struct_def);
ItemKind::Union(struct_def, folder.fold_generics(generics))
let generics = folder.fold_generics(generics);
ItemKind::Union(folder.fold_variant_data(struct_def), generics)
}
ItemKind::DefaultImpl(unsafety, ref trait_ref) => {
ItemKind::DefaultImpl(unsafety, folder.fold_trait_ref((*trait_ref).clone()))
}
ItemKind::Impl(unsafety, polarity, generics, ifce, ty, impl_items) => {
let new_impl_items = impl_items.move_flat_map(|item| {
folder.fold_impl_item(item)
});
let ifce = match ifce {
None => None,
Some(ref trait_ref) => {
Some(folder.fold_trait_ref((*trait_ref).clone()))
}
};
ItemKind::Impl(unsafety,
polarity,
folder.fold_generics(generics),
ifce,
folder.fold_ty(ty),
new_impl_items)
}
ItemKind::Trait(unsafety, generics, bounds, items) => {
let bounds = folder.fold_bounds(bounds);
let items = items.move_flat_map(|item| {
folder.fold_trait_item(item)
});
ItemKind::Trait(unsafety,
folder.fold_generics(generics),
bounds,
items)
}
ItemKind::Impl(unsafety, polarity, generics, ifce, ty, impl_items) => ItemKind::Impl(
unsafety,
polarity,
folder.fold_generics(generics),
ifce.map(|trait_ref| folder.fold_trait_ref(trait_ref.clone())),
folder.fold_ty(ty),
impl_items.move_flat_map(|item| folder.fold_impl_item(item)),
),
ItemKind::Trait(unsafety, generics, bounds, items) => ItemKind::Trait(
unsafety,
folder.fold_generics(generics),
folder.fold_bounds(bounds),
items.move_flat_map(|item| folder.fold_trait_item(item)),
),
ItemKind::Mac(m) => ItemKind::Mac(folder.fold_mac(m)),
}
}
Expand Down Expand Up @@ -954,9 +935,9 @@ pub fn noop_fold_impl_item<T: Folder>(i: ImplItem, folder: &mut T)
-> SmallVector<ImplItem> {
SmallVector::one(ImplItem {
id: folder.new_id(i.id),
vis: folder.fold_vis(i.vis),
ident: folder.fold_ident(i.ident),
attrs: fold_attrs(i.attrs, folder),
vis: folder.fold_vis(i.vis),
defaultness: i.defaultness,
node: match i.node {
ast::ImplItemKind::Const(ty, expr) => {
Expand Down Expand Up @@ -1031,22 +1012,20 @@ pub fn noop_fold_item<T: Folder>(i: P<Item>, folder: &mut T) -> SmallVector<P<It
// fold one item into exactly one item
pub fn noop_fold_item_simple<T: Folder>(Item {id, ident, attrs, node, vis, span}: Item,
folder: &mut T) -> Item {
let id = folder.new_id(id);
let node = folder.fold_item_kind(node);

Item {
id: id,
id: folder.new_id(id),
vis: folder.fold_vis(vis),
ident: folder.fold_ident(ident),
attrs: fold_attrs(attrs, folder),
node: node,
vis: folder.fold_vis(vis),
node: folder.fold_item_kind(node),
span: folder.new_span(span)
}
}

pub fn noop_fold_foreign_item<T: Folder>(ni: ForeignItem, folder: &mut T) -> ForeignItem {
ForeignItem {
id: folder.new_id(ni.id),
vis: folder.fold_vis(ni.vis),
ident: folder.fold_ident(ni.ident),
attrs: fold_attrs(ni.attrs, folder),
node: match ni.node {
Expand All @@ -1057,7 +1036,6 @@ pub fn noop_fold_foreign_item<T: Folder>(ni: ForeignItem, folder: &mut T) -> For
ForeignItemKind::Static(folder.fold_ty(t), m)
}
},
vis: folder.fold_vis(ni.vis),
span: folder.new_span(ni.span)
}
}
Expand Down
10 changes: 5 additions & 5 deletions src/libsyntax/visit.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -532,8 +532,8 @@ pub fn walk_fn_kind<V: Visitor>(visitor: &mut V, function_kind: FnKind) {
pub fn walk_fn<V>(visitor: &mut V, kind: FnKind, declaration: &FnDecl, body: &Block, _span: Span)
where V: Visitor,
{
walk_fn_decl(visitor, declaration);
walk_fn_kind(visitor, kind);
walk_fn_decl(visitor, declaration);
visitor.visit_block(body)
}

Expand Down Expand Up @@ -652,13 +652,13 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
walk_list!(visitor, visit_expr, subexpressions);
}
ExprKind::Call(ref callee_expression, ref arguments) => {
visitor.visit_expr(callee_expression);
walk_list!(visitor, visit_expr, arguments);
visitor.visit_expr(callee_expression)
}
ExprKind::MethodCall(ref ident, ref types, ref arguments) => {
visitor.visit_ident(ident.span, ident.node);
walk_list!(visitor, visit_expr, arguments);
walk_list!(visitor, visit_ty, types);
walk_list!(visitor, visit_expr, arguments);
}
ExprKind::Binary(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(left_expression);
Expand Down Expand Up @@ -717,12 +717,12 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expression: &Expr) {
}
ExprKind::Block(ref block) => visitor.visit_block(block),
ExprKind::Assign(ref left_hand_expression, ref right_hand_expression) => {
visitor.visit_expr(left_hand_expression);
visitor.visit_expr(right_hand_expression);
visitor.visit_expr(left_hand_expression)
}
ExprKind::AssignOp(_, ref left_expression, ref right_expression) => {
visitor.visit_expr(left_expression);
visitor.visit_expr(right_expression);
visitor.visit_expr(left_expression)
}
ExprKind::Field(ref subexpression, ref ident) => {
visitor.visit_expr(subexpression);
Expand Down
19 changes: 19 additions & 0 deletions src/test/run-pass/type-macros-simple.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,3 +15,22 @@ macro_rules! Tuple {
fn main() {
let x: Tuple!(i32, i32) = (1, 2);
}

fn issue_36540() {
let i32 = 0;
macro_rules! m { () => { i32 } }
struct S<T = m!()>(m!(), T) where T: Trait<m!()>;

let x: m!() = m!();
std::cell::Cell::<m!()>::new(m!());
impl<T = m!()> std::ops::Index<m!()> for Trait<(m!(), T)>
where T: Trait<m!()>
{
type Output = m!();
fn index(&self, i: m!()) -> &m!() {
unimplemented!()
}
}
}

trait Trait<T> {}