use crate::ext::base::*;
use crate::ext::proc_macro::{collect_derives, MarkAttrs};
use crate::ext::hygiene::{ExpnId, SyntaxContext, ExpnData, ExpnKind};
-use crate::ext::tt::macro_rules::annotate_err_with_kind;
+use crate::ext::mbe::macro_rules::annotate_err_with_kind;
use crate::ext::placeholders::{placeholder, PlaceholderExpander};
use crate::feature_gate::{self, Features, GateIssue, is_builtin_attr, emit_feature_err};
use crate::mut_visit::*;
}
}
- impl<'a> MacResult for crate::ext::tt::macro_rules::ParserAnyMacro<'a> {
- $(fn $make_ast(self: Box<crate::ext::tt::macro_rules::ParserAnyMacro<'a>>)
+ impl<'a> MacResult for crate::ext::mbe::macro_rules::ParserAnyMacro<'a> {
+ $(fn $make_ast(self: Box<crate::ext::mbe::macro_rules::ParserAnyMacro<'a>>)
-> Option<$AstTy> {
Some(self.make(AstFragmentKind::$Kind).$make_ast())
})*
let attr = attr::find_by_name(item.attrs(), sym::derive)
.expect("`derive` attribute should exist");
let span = attr.span;
- let mut err = self.cx.mut_span_err(span,
+ let mut err = self.cx.struct_span_err(span,
"`derive` may only be applied to structs, enums and unions");
if let ast::AttrStyle::Inner = attr.style {
let trait_list = derives.iter()
fn visit_expr(&mut self, expr: &mut P<ast::Expr>) {
self.cfg.configure_expr(expr);
visit_clobber(expr.deref_mut(), |mut expr| {
- self.cfg.configure_expr_kind(&mut expr.node);
+ self.cfg.configure_expr_kind(&mut expr.kind);
// ignore derives so they remain unused
let (attr, after_derive) = self.classify_nonitem(&mut expr);
.into_inner()
}
- if let ast::ExprKind::Mac(mac) = expr.node {
+ if let ast::ExprKind::Mac(mac) = expr.kind {
self.check_attributes(&expr.attrs);
self.collect_bang(mac, expr.span, AstFragmentKind::Expr)
.make_expr()
fn filter_map_expr(&mut self, expr: P<ast::Expr>) -> Option<P<ast::Expr>> {
let expr = configure!(self, expr);
expr.filter_map(|mut expr| {
- self.cfg.configure_expr_kind(&mut expr.node);
+ self.cfg.configure_expr_kind(&mut expr.kind);
// Ignore derives so they remain unused.
let (attr, after_derive) = self.classify_nonitem(&mut expr);
.map(|expr| expr.into_inner())
}
- if let ast::ExprKind::Mac(mac) = expr.node {
+ if let ast::ExprKind::Mac(mac) = expr.kind {
self.check_attributes(&expr.attrs);
self.collect_bang(mac, expr.span, AstFragmentKind::OptExpr)
.make_opt_expr()
fn visit_pat(&mut self, pat: &mut P<ast::Pat>) {
self.cfg.configure_pat(pat);
- match pat.node {
+ match pat.kind {
PatKind::Mac(_) => {}
_ => return noop_visit_pat(pat, self),
}
visit_clobber(pat, |mut pat| {
- match mem::replace(&mut pat.node, PatKind::Wild) {
+ match mem::replace(&mut pat.kind, PatKind::Wild) {
PatKind::Mac(mac) =>
self.collect_bang(mac, pat.span, AstFragmentKind::Pat).make_pat(),
_ => unreachable!(),
AstFragmentKind::TraitItems, after_derive).make_trait_items()
}
- match item.node {
+ match item.kind {
ast::TraitItemKind::Macro(mac) => {
let ast::TraitItem { attrs, span, .. } = item;
self.check_attributes(&attrs);
AstFragmentKind::ImplItems, after_derive).make_impl_items();
}
- match item.node {
+ match item.kind {
ast::ImplItemKind::Macro(mac) => {
let ast::ImplItem { attrs, span, .. } = item;
self.check_attributes(&attrs);
}
fn visit_ty(&mut self, ty: &mut P<ast::Ty>) {
- match ty.node {
+ match ty.kind {
ast::TyKind::Mac(_) => {}
_ => return noop_visit_ty(ty, self),
};
visit_clobber(ty, |mut ty| {
- match mem::replace(&mut ty.node, ast::TyKind::Err) {
+ match mem::replace(&mut ty.kind, ast::TyKind::Err) {
ast::TyKind::Mac(mac) =>
self.collect_bang(mac, ty.span, AstFragmentKind::Ty).make_ty(),
_ => unreachable!(),
// Check if the user erroneously used `doc(include(...))` syntax.
let literal = it.meta_item_list().and_then(|list| {
if list.len() == 1 {
- list[0].literal().map(|literal| &literal.node)
+ list[0].literal().map(|literal| &literal.kind)
} else {
None
}