fld: &mut T)
-> AngleBracketedParameterData
{
- let AngleBracketedParameterData { lifetimes, types, bindings } = data;
+ let AngleBracketedParameterData { lifetimes, types, bindings, span } = data;
AngleBracketedParameterData { lifetimes: fld.fold_lifetimes(lifetimes),
types: types.move_map(|ty| fld.fold_ty(ty)),
- bindings: bindings.move_map(|b| fld.fold_ty_binding(b)) }
+ bindings: bindings.move_map(|b| fld.fold_ty_binding(b)),
+ span: fld.new_span(span) }
}
pub fn noop_fold_parenthesized_parameter_data<T: Folder>(data: ParenthesizedParameterData,
}
pub fn noop_fold_where_clause<T: Folder>(
- WhereClause {id, predicates}: WhereClause,
+ WhereClause {id, predicates, span}: WhereClause,
fld: &mut T)
-> WhereClause {
WhereClause {
id: fld.new_id(id),
predicates: predicates.move_map(|predicate| {
fld.fold_where_predicate(predicate)
- })
+ }),
+ span: span,
}
}
TraitItemKind::Macro(folder.fold_mac(mac))
}
},
- span: folder.new_span(i.span)
+ span: folder.new_span(i.span),
+ tokens: i.tokens,
})
}
ast::ImplItemKind::Type(ty) => ast::ImplItemKind::Type(folder.fold_ty(ty)),
ast::ImplItemKind::Macro(mac) => ast::ImplItemKind::Macro(folder.fold_mac(mac))
},
- span: folder.new_span(i.span)
+ span: folder.new_span(i.span),
+ tokens: i.tokens,
})
}
vis: ast::Visibility::Public,
span: span,
node: ast::ItemKind::Mod(module),
+ tokens: None,
})).into_iter();
let (module, attrs, span) = match items.next() {
}
// fold one item into exactly one item
-pub fn noop_fold_item_simple<T: Folder>(Item {id, ident, attrs, node, vis, span}: Item,
+pub fn noop_fold_item_simple<T: Folder>(Item {id, ident, attrs, node, vis, span, tokens}: Item,
folder: &mut T) -> Item {
Item {
id: folder.new_id(id),
ident: folder.fold_ident(ident),
attrs: fold_attrs(attrs, folder),
node: folder.fold_item_kind(node),
- span: folder.new_span(span)
+ span: folder.new_span(span),
+
+ // FIXME: if this is replaced with a call to `folder.fold_tts` it causes
+ // an ICE during resolve... odd!
+ tokens: tokens,
}
}
ExprKind::Call(folder.fold_expr(f),
folder.fold_exprs(args))
}
- ExprKind::MethodCall(i, tps, args) => {
+ ExprKind::MethodCall(seg, args) => {
ExprKind::MethodCall(
- respan(folder.new_span(i.span), folder.fold_ident(i.node)),
- tps.move_map(|x| folder.fold_ty(x)),
+ PathSegment {
+ identifier: folder.fold_ident(seg.identifier),
+ span: folder.new_span(seg.span),
+ parameters: seg.parameters.map(|ps| {
+ ps.map(|ps| folder.fold_path_parameters(ps))
+ }),
+ },
folder.fold_exprs(args))
}
ExprKind::Binary(binop, lhs, rhs) => {