use rustc_ast::ptr::P;
use rustc_ast::token::{self, Nonterminal};
-use rustc_ast::tokenstream::{CanSynthesizeMissingTokens, LazyTokenStream, TokenStream};
+use rustc_ast::tokenstream::{CanSynthesizeMissingTokens, TokenStream};
use rustc_ast::visit::{AssocCtxt, Visitor};
use rustc_ast::{self as ast, AstLike, Attribute, Item, NodeId, PatKind};
use rustc_attr::{self as attr, Deprecation, Stability};
Variant(ast::Variant),
}
-impl AstLike for Annotatable {
- fn attrs(&self) -> &[Attribute] {
+impl Annotatable {
+ pub fn span(&self) -> Span {
match *self {
- Annotatable::Item(ref item) => &item.attrs,
- Annotatable::TraitItem(ref trait_item) => &trait_item.attrs,
- Annotatable::ImplItem(ref impl_item) => &impl_item.attrs,
- Annotatable::ForeignItem(ref foreign_item) => &foreign_item.attrs,
- Annotatable::Stmt(ref stmt) => stmt.attrs(),
- Annotatable::Expr(ref expr) => &expr.attrs,
- Annotatable::Arm(ref arm) => &arm.attrs,
- Annotatable::ExprField(ref field) => &field.attrs,
- Annotatable::PatField(ref fp) => &fp.attrs,
- Annotatable::GenericParam(ref gp) => &gp.attrs,
- Annotatable::Param(ref p) => &p.attrs,
- Annotatable::FieldDef(ref sf) => &sf.attrs,
- Annotatable::Variant(ref v) => &v.attrs(),
+ Annotatable::Item(ref item) => item.span,
+ Annotatable::TraitItem(ref trait_item) => trait_item.span,
+ Annotatable::ImplItem(ref impl_item) => impl_item.span,
+ Annotatable::ForeignItem(ref foreign_item) => foreign_item.span,
+ Annotatable::Stmt(ref stmt) => stmt.span,
+ Annotatable::Expr(ref expr) => expr.span,
+ Annotatable::Arm(ref arm) => arm.span,
+ Annotatable::ExprField(ref field) => field.span,
+ Annotatable::PatField(ref fp) => fp.pat.span,
+ Annotatable::GenericParam(ref gp) => gp.ident.span,
+ Annotatable::Param(ref p) => p.span,
+ Annotatable::FieldDef(ref sf) => sf.span,
+ Annotatable::Variant(ref v) => v.span,
}
}
- fn visit_attrs(&mut self, f: impl FnOnce(&mut Vec<Attribute>)) {
+ pub fn visit_attrs(&mut self, f: impl FnOnce(&mut Vec<Attribute>)) {
match self {
Annotatable::Item(item) => item.visit_attrs(f),
Annotatable::TraitItem(trait_item) => trait_item.visit_attrs(f),
}
}
- fn tokens_mut(&mut self) -> Option<&mut Option<LazyTokenStream>> {
- match self {
- Annotatable::Item(item) => item.tokens_mut(),
- Annotatable::TraitItem(trait_item) => trait_item.tokens_mut(),
- Annotatable::ImplItem(impl_item) => impl_item.tokens_mut(),
- Annotatable::ForeignItem(foreign_item) => foreign_item.tokens_mut(),
- Annotatable::Stmt(stmt) => stmt.tokens_mut(),
- Annotatable::Expr(expr) => expr.tokens_mut(),
- Annotatable::Arm(arm) => arm.tokens_mut(),
- Annotatable::ExprField(field) => field.tokens_mut(),
- Annotatable::PatField(fp) => fp.tokens_mut(),
- Annotatable::GenericParam(gp) => gp.tokens_mut(),
- Annotatable::Param(p) => p.tokens_mut(),
- Annotatable::FieldDef(sf) => sf.tokens_mut(),
- Annotatable::Variant(v) => v.tokens_mut(),
- }
- }
-}
-
-impl Annotatable {
- pub fn span(&self) -> Span {
- match *self {
- Annotatable::Item(ref item) => item.span,
- Annotatable::TraitItem(ref trait_item) => trait_item.span,
- Annotatable::ImplItem(ref impl_item) => impl_item.span,
- Annotatable::ForeignItem(ref foreign_item) => foreign_item.span,
- Annotatable::Stmt(ref stmt) => stmt.span,
- Annotatable::Expr(ref expr) => expr.span,
- Annotatable::Arm(ref arm) => arm.span,
- Annotatable::ExprField(ref field) => field.span,
- Annotatable::PatField(ref fp) => fp.pat.span,
- Annotatable::GenericParam(ref gp) => gp.ident.span,
- Annotatable::Param(ref p) => p.span,
- Annotatable::FieldDef(ref sf) => sf.span,
- Annotatable::Variant(ref v) => v.span,
- }
- }
-
pub fn visit_with<'a, V: Visitor<'a>>(&'a self, visitor: &mut V) {
match self {
Annotatable::Item(item) => visitor.visit_item(item),
}
}
- crate fn into_nonterminal(self) -> Nonterminal {
+ pub fn into_nonterminal(self) -> Nonterminal {
match self {
Annotatable::Item(item) => token::NtItem(item),
Annotatable::TraitItem(item) | Annotatable::ImplItem(item) => {
}
crate fn into_tokens(self, sess: &ParseSess) -> TokenStream {
- // Tokens of an attribute target may be invalidated by some outer `#[derive]` performing
- // "full configuration" (attributes following derives on the same item should be the most
- // common case), that's why synthesizing tokens is allowed.
- nt_to_tokenstream(&self.into_nonterminal(), sess, CanSynthesizeMissingTokens::Yes)
+ nt_to_tokenstream(&self.into_nonterminal(), sess, CanSynthesizeMissingTokens::No)
}
pub fn expect_item(self) -> P<ast::Item> {