ast_enum_of_structs! {
/// Things that can appear directly inside of a module or scope.
///
- /// *This type is available only if Syn is built with the `"full"` feature.*
- ///
/// # Syntax tree enum
///
/// This type is a [syntax tree enum].
///
/// [syntax tree enum]: Expr#syntax-tree-enums
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
- #[cfg_attr(not(syn_no_non_exhaustive), non_exhaustive)]
+ #[non_exhaustive]
pub enum Item {
/// A constant item: `const MAX: u16 = 65535`.
Const(ItemConst),
/// A macro invocation, which includes `macro_rules!` definitions.
Macro(ItemMacro),
- /// A 2.0-style declarative macro introduced by the `macro` keyword.
- Macro2(ItemMacro2),
-
/// A module or module declaration: `mod m` or `mod m { ... }`.
Mod(ItemMod),
/// Tokens forming an item not interpreted by Syn.
Verbatim(TokenStream),
- // Not public API.
- //
// For testing exhaustiveness in downstream code, use the following idiom:
//
// match item {
// a variant. You will be notified by a test failure when a variant is
// added, so that you can add code to handle it, but your library will
// continue to compile and work for downstream users in the interim.
- #[cfg(syn_no_non_exhaustive)]
- #[doc(hidden)]
- __NonExhaustive,
}
}
ast_struct! {
/// A constant item: `const MAX: u16 = 65535`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemConst {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub const_token: Token![const],
pub ident: Ident,
+ pub generics: Generics,
pub colon_token: Token![:],
pub ty: Box<Type>,
pub eq_token: Token![=],
ast_struct! {
/// An enum definition: `enum Foo<A, B> { A(A), B(B) }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemEnum {
pub attrs: Vec<Attribute>,
ast_struct! {
/// An `extern crate` item: `extern crate serde`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemExternCrate {
pub attrs: Vec<Attribute>,
}
ast_struct! {
- /// A free-standing function: `fn process(n: usize) -> Result<()> { ...
- /// }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
+ /// A free-standing function: `fn process(n: usize) -> Result<()> { ... }`.
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemFn {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A block of foreign items: `extern "C" { ... }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemForeignMod {
pub attrs: Vec<Attribute>,
+ pub unsafety: Option<Token![unsafe]>,
pub abi: Abi,
pub brace_token: token::Brace,
pub items: Vec<ForeignItem>,
ast_struct! {
/// An impl block providing trait or associated items: `impl<A> Trait
/// for Data<A> { ... }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemImpl {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A macro invocation, which includes `macro_rules!` definitions.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemMacro {
pub attrs: Vec<Attribute>,
}
}
-ast_struct! {
- /// A 2.0-style declarative macro introduced by the `macro` keyword.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
- #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
- pub struct ItemMacro2 {
- pub attrs: Vec<Attribute>,
- pub vis: Visibility,
- pub macro_token: Token![macro],
- pub ident: Ident,
- pub rules: TokenStream,
- }
-}
-
ast_struct! {
/// A module or module declaration: `mod m` or `mod m { ... }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemMod {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
+ pub unsafety: Option<Token![unsafe]>,
pub mod_token: Token![mod],
pub ident: Ident,
pub content: Option<(token::Brace, Vec<Item>)>,
ast_struct! {
/// A static item: `static BIKE: Shed = Shed(42)`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemStatic {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub static_token: Token![static],
- pub mutability: Option<Token![mut]>,
+ pub mutability: StaticMutability,
pub ident: Ident,
pub colon_token: Token![:],
pub ty: Box<Type>,
ast_struct! {
/// A struct definition: `struct Foo<A> { x: A }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemStruct {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A trait definition: `pub trait Iterator { ... }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemTrait {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub unsafety: Option<Token![unsafe]>,
pub auto_token: Option<Token![auto]>,
+ pub restriction: Option<ImplRestriction>,
pub trait_token: Token![trait],
pub ident: Ident,
pub generics: Generics,
ast_struct! {
/// A trait alias: `pub trait SharableIterator = Iterator + Sync`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemTraitAlias {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A type alias: `type Result<T> = std::result::Result<T, MyError>`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemType {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A union definition: `union Foo<A, B> { x: A, y: B }`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemUnion {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A use declaration: `use std::collections::HashMap`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ItemUse {
pub attrs: Vec<Attribute>,
#[cfg(feature = "parsing")]
pub(crate) fn replace_attrs(&mut self, new: Vec<Attribute>) -> Vec<Attribute> {
match self {
- Item::ExternCrate(ItemExternCrate { attrs, .. })
- | Item::Use(ItemUse { attrs, .. })
- | Item::Static(ItemStatic { attrs, .. })
- | Item::Const(ItemConst { attrs, .. })
+ Item::Const(ItemConst { attrs, .. })
+ | Item::Enum(ItemEnum { attrs, .. })
+ | Item::ExternCrate(ItemExternCrate { attrs, .. })
| Item::Fn(ItemFn { attrs, .. })
- | Item::Mod(ItemMod { attrs, .. })
| Item::ForeignMod(ItemForeignMod { attrs, .. })
- | Item::Type(ItemType { attrs, .. })
+ | Item::Impl(ItemImpl { attrs, .. })
+ | Item::Macro(ItemMacro { attrs, .. })
+ | Item::Mod(ItemMod { attrs, .. })
+ | Item::Static(ItemStatic { attrs, .. })
| Item::Struct(ItemStruct { attrs, .. })
- | Item::Enum(ItemEnum { attrs, .. })
- | Item::Union(ItemUnion { attrs, .. })
| Item::Trait(ItemTrait { attrs, .. })
| Item::TraitAlias(ItemTraitAlias { attrs, .. })
- | Item::Impl(ItemImpl { attrs, .. })
- | Item::Macro(ItemMacro { attrs, .. })
- | Item::Macro2(ItemMacro2 { attrs, .. }) => mem::replace(attrs, new),
+ | Item::Type(ItemType { attrs, .. })
+ | Item::Union(ItemUnion { attrs, .. })
+ | Item::Use(ItemUse { attrs, .. }) => mem::replace(attrs, new),
Item::Verbatim(_) => Vec::new(),
-
- #[cfg(syn_no_non_exhaustive)]
- _ => unreachable!(),
}
}
}
ast_enum_of_structs! {
/// A suffix of an import tree in a `use` item: `Type as Renamed` or `*`.
///
- /// *This type is available only if Syn is built with the `"full"` feature.*
- ///
/// # Syntax tree enum
///
/// This type is a [syntax tree enum].
ast_struct! {
/// A path prefix of imports in a `use` item: `std::...`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct UsePath {
pub ident: Ident,
ast_struct! {
/// An identifier imported by a `use` item: `HashMap`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct UseName {
pub ident: Ident,
ast_struct! {
/// An renamed identifier imported by a `use` item: `HashMap as Map`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct UseRename {
pub ident: Ident,
ast_struct! {
/// A glob import in a `use` item: `*`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct UseGlob {
pub star_token: Token![*],
ast_struct! {
/// A braced group of imports in a `use` item: `{A, B, C}`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct UseGroup {
pub brace_token: token::Brace,
ast_enum_of_structs! {
/// An item within an `extern` block.
///
- /// *This type is available only if Syn is built with the `"full"` feature.*
- ///
/// # Syntax tree enum
///
/// This type is a [syntax tree enum].
///
/// [syntax tree enum]: Expr#syntax-tree-enums
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
- #[cfg_attr(not(syn_no_non_exhaustive), non_exhaustive)]
+ #[non_exhaustive]
pub enum ForeignItem {
/// A foreign function in an `extern` block.
Fn(ForeignItemFn),
/// Tokens in an `extern` block not interpreted by Syn.
Verbatim(TokenStream),
- // Not public API.
- //
// For testing exhaustiveness in downstream code, use the following idiom:
//
// match item {
// a variant. You will be notified by a test failure when a variant is
// added, so that you can add code to handle it, but your library will
// continue to compile and work for downstream users in the interim.
- #[cfg(syn_no_non_exhaustive)]
- #[doc(hidden)]
- __NonExhaustive,
}
}
ast_struct! {
/// A foreign function in an `extern` block.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ForeignItemFn {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A foreign static item in an `extern` block: `static ext: u8`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ForeignItemStatic {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub static_token: Token![static],
- pub mutability: Option<Token![mut]>,
+ pub mutability: StaticMutability,
pub ident: Ident,
pub colon_token: Token![:],
pub ty: Box<Type>,
ast_struct! {
/// A foreign type in an `extern` block: `type void`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ForeignItemType {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub type_token: Token![type],
pub ident: Ident,
+ pub generics: Generics,
pub semi_token: Token![;],
}
}
ast_struct! {
/// A macro invocation within an extern block.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ForeignItemMacro {
pub attrs: Vec<Attribute>,
ast_enum_of_structs! {
/// An item declaration within the definition of a trait.
///
- /// *This type is available only if Syn is built with the `"full"` feature.*
- ///
/// # Syntax tree enum
///
/// This type is a [syntax tree enum].
///
/// [syntax tree enum]: Expr#syntax-tree-enums
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
- #[cfg_attr(not(syn_no_non_exhaustive), non_exhaustive)]
+ #[non_exhaustive]
pub enum TraitItem {
/// An associated constant within the definition of a trait.
Const(TraitItemConst),
- /// A trait method within the definition of a trait.
- Method(TraitItemMethod),
+ /// An associated function within the definition of a trait.
+ Fn(TraitItemFn),
/// An associated type within the definition of a trait.
Type(TraitItemType),
/// Tokens within the definition of a trait not interpreted by Syn.
Verbatim(TokenStream),
- // Not public API.
- //
// For testing exhaustiveness in downstream code, use the following idiom:
//
// match item {
// TraitItem::Const(item) => {...}
- // TraitItem::Method(item) => {...}
+ // TraitItem::Fn(item) => {...}
// ...
// TraitItem::Verbatim(item) => {...}
//
// a variant. You will be notified by a test failure when a variant is
// added, so that you can add code to handle it, but your library will
// continue to compile and work for downstream users in the interim.
- #[cfg(syn_no_non_exhaustive)]
- #[doc(hidden)]
- __NonExhaustive,
}
}
ast_struct! {
/// An associated constant within the definition of a trait.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct TraitItemConst {
pub attrs: Vec<Attribute>,
pub const_token: Token![const],
pub ident: Ident,
+ pub generics: Generics,
pub colon_token: Token![:],
pub ty: Type,
pub default: Option<(Token![=], Expr)>,
}
ast_struct! {
- /// A trait method within the definition of a trait.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
+ /// An associated function within the definition of a trait.
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
- pub struct TraitItemMethod {
+ pub struct TraitItemFn {
pub attrs: Vec<Attribute>,
pub sig: Signature,
pub default: Option<Block>,
ast_struct! {
/// An associated type within the definition of a trait.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct TraitItemType {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A macro invocation within the definition of a trait.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct TraitItemMacro {
pub attrs: Vec<Attribute>,
ast_enum_of_structs! {
/// An item within an impl block.
///
- /// *This type is available only if Syn is built with the `"full"` feature.*
- ///
/// # Syntax tree enum
///
/// This type is a [syntax tree enum].
///
/// [syntax tree enum]: Expr#syntax-tree-enums
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
- #[cfg_attr(not(syn_no_non_exhaustive), non_exhaustive)]
+ #[non_exhaustive]
pub enum ImplItem {
/// An associated constant within an impl block.
Const(ImplItemConst),
- /// A method within an impl block.
- Method(ImplItemMethod),
+ /// An associated function within an impl block.
+ Fn(ImplItemFn),
/// An associated type within an impl block.
Type(ImplItemType),
/// Tokens within an impl block not interpreted by Syn.
Verbatim(TokenStream),
- // Not public API.
- //
// For testing exhaustiveness in downstream code, use the following idiom:
//
// match item {
// ImplItem::Const(item) => {...}
- // ImplItem::Method(item) => {...}
+ // ImplItem::Fn(item) => {...}
// ...
// ImplItem::Verbatim(item) => {...}
//
// a variant. You will be notified by a test failure when a variant is
// added, so that you can add code to handle it, but your library will
// continue to compile and work for downstream users in the interim.
- #[cfg(syn_no_non_exhaustive)]
- #[doc(hidden)]
- __NonExhaustive,
}
}
ast_struct! {
/// An associated constant within an impl block.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ImplItemConst {
pub attrs: Vec<Attribute>,
pub defaultness: Option<Token![default]>,
pub const_token: Token![const],
pub ident: Ident,
+ pub generics: Generics,
pub colon_token: Token![:],
pub ty: Type,
pub eq_token: Token![=],
}
ast_struct! {
- /// A method within an impl block.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
+ /// An associated function within an impl block.
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
- pub struct ImplItemMethod {
+ pub struct ImplItemFn {
pub attrs: Vec<Attribute>,
pub vis: Visibility,
pub defaultness: Option<Token![default]>,
ast_struct! {
/// An associated type within an impl block.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ImplItemType {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A macro invocation within an impl block.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct ImplItemMacro {
pub attrs: Vec<Attribute>,
ast_struct! {
/// A function signature in a trait or implementation: `unsafe fn
/// initialize(&self)`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct Signature {
pub constness: Option<Token![const]>,
impl Signature {
/// A method's `self` receiver, such as `&self` or `self: Box<Self>`.
- pub fn receiver(&self) -> Option<&FnArg> {
+ pub fn receiver(&self) -> Option<&Receiver> {
let arg = self.inputs.first()?;
match arg {
- FnArg::Receiver(_) => Some(arg),
- FnArg::Typed(PatType { pat, .. }) => {
- if let Pat::Ident(PatIdent { ident, .. }) = &**pat {
- if ident == "self" {
- return Some(arg);
- }
- }
- None
- }
+ FnArg::Receiver(receiver) => Some(receiver),
+ FnArg::Typed(_) => None,
}
}
}
ast_enum_of_structs! {
/// An argument in a function signature: the `n: usize` in `fn f(n: usize)`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub enum FnArg {
- /// The `self` argument of an associated method, whether taken by value
- /// or by reference.
- ///
- /// Note that `self` receivers with a specified type, such as `self:
- /// Box<Self>`, are parsed as a `FnArg::Typed`.
+ /// The `self` argument of an associated method.
Receiver(Receiver),
/// A function argument accepted by pattern and type.
}
ast_struct! {
- /// The `self` argument of an associated method, whether taken by value
- /// or by reference.
+ /// The `self` argument of an associated method.
///
- /// Note that `self` receivers with a specified type, such as `self:
- /// Box<Self>`, are parsed as a `FnArg::Typed`.
- ///
- /// *This type is available only if Syn is built with the `"full"` feature.*
+ /// If `colon_token` is present, the receiver is written with an explicit
+ /// type such as `self: Box<Self>`. If `colon_token` is absent, the receiver
+ /// is written in shorthand such as `self` or `&self` or `&mut self`. In the
+ /// shorthand case, the type in `ty` is reconstructed as one of `Self`,
+ /// `&Self`, or `&mut Self`.
#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
pub struct Receiver {
pub attrs: Vec<Attribute>,
pub reference: Option<(Token![&], Option<Lifetime>)>,
pub mutability: Option<Token![mut]>,
pub self_token: Token![self],
+ pub colon_token: Option<Token![:]>,
+ pub ty: Box<Type>,
}
}
}
}
+ast_struct! {
+ /// The variadic argument of a foreign function.
+ ///
+ /// ```rust
+ /// # struct c_char;
+ /// # struct c_int;
+ /// #
+ /// extern "C" {
+ /// fn printf(format: *const c_char, ...) -> c_int;
+ /// // ^^^
+ /// }
+ /// ```
+ #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
+ pub struct Variadic {
+ pub attrs: Vec<Attribute>,
+ pub pat: Option<(Box<Pat>, Token![:])>,
+ pub dots: Token![...],
+ pub comma: Option<Token![,]>,
+ }
+}
+
+ast_enum! {
+ /// The mutability of an `Item::Static` or `ForeignItem::Static`.
+ #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
+ #[non_exhaustive]
+ pub enum StaticMutability {
+ Mut(Token![mut]),
+ None,
+ }
+}
+
+ast_enum! {
+ /// Unused, but reserved for RFC 3323 restrictions.
+ #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
+ #[non_exhaustive]
+ pub enum ImplRestriction {}
+
+
+ // TODO: https://rust-lang.github.io/rfcs/3323-restrictions.html
+ //
+ // pub struct ImplRestriction {
+ // pub impl_token: Token![impl],
+ // pub paren_token: token::Paren,
+ // pub in_token: Option<Token![in]>,
+ // pub path: Box<Path>,
+ // }
+}
+
#[cfg(feature = "parsing")]
-pub mod parsing {
+pub(crate) mod parsing {
use super::*;
use crate::ext::IdentExt;
use crate::parse::discouraged::Speculative;
use crate::parse::{Parse, ParseBuffer, ParseStream, Result};
use crate::token::Brace;
- use proc_macro2::{Delimiter, Group, Punct, Spacing, TokenTree};
- use std::iter::{self, FromIterator};
-
- crate::custom_keyword!(macro_rules);
+ use proc_macro2::{Punct, Spacing, TokenTree};
+ use std::iter::FromIterator;
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
impl Parse for Item {
Err(lookahead.error())
}
} else if lookahead.peek(Token![use]) {
- input.parse().map(Item::Use)
+ let allow_crate_root_in_path = true;
+ match parse_item_use(input, allow_crate_root_in_path)? {
+ Some(item_use) => Ok(Item::Use(item_use)),
+ None => Ok(Item::Verbatim(verbatim::between(begin, input))),
+ }
} else if lookahead.peek(Token![static]) {
let vis = input.parse()?;
let static_token = input.parse()?;
vis,
const_token,
ident,
+ generics: Generics::default(),
colon_token,
ty,
eq_token: input.parse()?,
Ok(Item::Verbatim(verbatim::between(begin, input)))
}
} else if lookahead.peek(Token![extern]) {
- input.parse::<Visibility>()?;
- input.parse::<Token![unsafe]>()?;
- input.parse::<ItemForeignMod>()?;
- Ok(Item::Verbatim(verbatim::between(begin, input)))
+ input.parse().map(Item::ForeignMod)
} else if lookahead.peek(Token![mod]) {
- input.parse::<Visibility>()?;
- input.parse::<Token![unsafe]>()?;
- input.parse::<ItemMod>()?;
- Ok(Item::Verbatim(verbatim::between(begin, input)))
+ input.parse().map(Item::Mod)
} else {
Err(lookahead.error())
}
Ok(Item::Verbatim(verbatim::between(begin, input)))
}
} else if lookahead.peek(Token![macro]) {
- input.parse().map(Item::Macro2)
+ input.advance_to(&ahead);
+ parse_macro2(begin, vis, input)
} else if vis.is_inherited()
&& (lookahead.peek(Ident)
|| lookahead.peek(Token![self])
|| lookahead.peek(Token![::]))
{
input.parse().map(Item::Macro)
- } else if ahead.peek(macro_rules) {
- input.advance_to(&ahead);
- input.parse::<ItemMacro>()?;
- Ok(Item::Verbatim(verbatim::between(begin, input)))
} else {
Err(lookahead.error())
}?;
// type Ty<T> where T: 'static = T;
BeforeEq,
// type Ty<T> = T where T: 'static;
- #[allow(dead_code)]
AfterEq,
// TODO: goes away once the migration period on rust-lang/rust#89122 is over
Both,
WhereClauseLocation::BeforeEq | WhereClauseLocation::Both => {
generics.where_clause = input.parse()?;
}
- _ => {}
+ WhereClauseLocation::AfterEq => {}
}
let ty = if let Some(eq_token) = input.parse()? {
let attrs = input.call(Attribute::parse_outer)?;
let path = input.call(Path::parse_mod_style)?;
let bang_token: Token![!] = input.parse()?;
- let ident: Option<Ident> = input.parse()?;
+ let ident: Option<Ident> = if input.peek(Token![try]) {
+ input.call(Ident::parse_any).map(Some)
+ } else {
+ input.parse()
+ }?;
let (delimiter, tokens) = input.call(mac::parse_delimiter)?;
let semi_token: Option<Token![;]> = if !delimiter.is_brace() {
Some(input.parse()?)
}
}
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for ItemMacro2 {
- fn parse(input: ParseStream) -> Result<Self> {
- let attrs = input.call(Attribute::parse_outer)?;
- let vis: Visibility = input.parse()?;
- let macro_token: Token![macro] = input.parse()?;
- let ident: Ident = input.parse()?;
- let mut rules = TokenStream::new();
-
- let mut lookahead = input.lookahead1();
- if lookahead.peek(token::Paren) {
- let paren_content;
- let paren_token = parenthesized!(paren_content in input);
- let args: TokenStream = paren_content.parse()?;
- let mut args = Group::new(Delimiter::Parenthesis, args);
- args.set_span(paren_token.span);
- rules.extend(iter::once(TokenTree::Group(args)));
- lookahead = input.lookahead1();
- }
+ fn parse_macro2(begin: ParseBuffer, _vis: Visibility, input: ParseStream) -> Result<Item> {
+ input.parse::<Token![macro]>()?;
+ input.parse::<Ident>()?;
- if lookahead.peek(token::Brace) {
- let brace_content;
- let brace_token = braced!(brace_content in input);
- let body: TokenStream = brace_content.parse()?;
- let mut body = Group::new(Delimiter::Brace, body);
- body.set_span(brace_token.span);
- rules.extend(iter::once(TokenTree::Group(body)));
- } else {
- return Err(lookahead.error());
- }
+ let mut lookahead = input.lookahead1();
+ if lookahead.peek(token::Paren) {
+ let paren_content;
+ parenthesized!(paren_content in input);
+ paren_content.parse::<TokenStream>()?;
+ lookahead = input.lookahead1();
+ }
- Ok(ItemMacro2 {
- attrs,
- vis,
- macro_token,
- ident,
- rules,
- })
+ if lookahead.peek(token::Brace) {
+ let brace_content;
+ braced!(brace_content in input);
+ brace_content.parse::<TokenStream>()?;
+ } else {
+ return Err(lookahead.error());
}
+
+ Ok(Item::Verbatim(verbatim::between(begin, input)))
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
impl Parse for ItemUse {
fn parse(input: ParseStream) -> Result<Self> {
- Ok(ItemUse {
- attrs: input.call(Attribute::parse_outer)?,
- vis: input.parse()?,
- use_token: input.parse()?,
- leading_colon: input.parse()?,
- tree: input.parse()?,
- semi_token: input.parse()?,
- })
+ let allow_crate_root_in_path = false;
+ parse_item_use(input, allow_crate_root_in_path).map(Option::unwrap)
}
}
+ fn parse_item_use(
+ input: ParseStream,
+ allow_crate_root_in_path: bool,
+ ) -> Result<Option<ItemUse>> {
+ let attrs = input.call(Attribute::parse_outer)?;
+ let vis: Visibility = input.parse()?;
+ let use_token: Token![use] = input.parse()?;
+ let leading_colon: Option<Token![::]> = input.parse()?;
+ let tree = parse_use_tree(input, allow_crate_root_in_path && leading_colon.is_none())?;
+ let semi_token: Token![;] = input.parse()?;
+
+ let tree = match tree {
+ Some(tree) => tree,
+ None => return Ok(None),
+ };
+
+ Ok(Some(ItemUse {
+ attrs,
+ vis,
+ use_token,
+ leading_colon,
+ tree,
+ semi_token,
+ }))
+ }
+
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
impl Parse for UseTree {
fn parse(input: ParseStream) -> Result<UseTree> {
- let lookahead = input.lookahead1();
- if lookahead.peek(Ident)
- || lookahead.peek(Token![self])
- || lookahead.peek(Token![super])
- || lookahead.peek(Token![crate])
- {
- let ident = input.call(Ident::parse_any)?;
- if input.peek(Token![::]) {
- Ok(UseTree::Path(UsePath {
- ident,
- colon2_token: input.parse()?,
- tree: Box::new(input.parse()?),
- }))
- } else if input.peek(Token![as]) {
- Ok(UseTree::Rename(UseRename {
- ident,
- as_token: input.parse()?,
- rename: {
- if input.peek(Ident) {
- input.parse()?
- } else if input.peek(Token![_]) {
- Ident::from(input.parse::<Token![_]>()?)
- } else {
- return Err(input.error("expected identifier or underscore"));
- }
- },
- }))
- } else {
- Ok(UseTree::Name(UseName { ident }))
+ let allow_crate_root_in_path = false;
+ parse_use_tree(input, allow_crate_root_in_path).map(Option::unwrap)
+ }
+ }
+
+ fn parse_use_tree(
+ input: ParseStream,
+ allow_crate_root_in_path: bool,
+ ) -> Result<Option<UseTree>> {
+ let lookahead = input.lookahead1();
+ if lookahead.peek(Ident)
+ || lookahead.peek(Token![self])
+ || lookahead.peek(Token![super])
+ || lookahead.peek(Token![crate])
+ || lookahead.peek(Token![try])
+ {
+ let ident = input.call(Ident::parse_any)?;
+ if input.peek(Token![::]) {
+ Ok(Some(UseTree::Path(UsePath {
+ ident,
+ colon2_token: input.parse()?,
+ tree: Box::new(input.parse()?),
+ })))
+ } else if input.peek(Token![as]) {
+ Ok(Some(UseTree::Rename(UseRename {
+ ident,
+ as_token: input.parse()?,
+ rename: {
+ if input.peek(Ident) {
+ input.parse()?
+ } else if input.peek(Token![_]) {
+ Ident::from(input.parse::<Token![_]>()?)
+ } else {
+ return Err(input.error("expected identifier or underscore"));
+ }
+ },
+ })))
+ } else {
+ Ok(Some(UseTree::Name(UseName { ident })))
+ }
+ } else if lookahead.peek(Token![*]) {
+ Ok(Some(UseTree::Glob(UseGlob {
+ star_token: input.parse()?,
+ })))
+ } else if lookahead.peek(token::Brace) {
+ let content;
+ let brace_token = braced!(content in input);
+ let mut items = Punctuated::new();
+ let mut has_crate_root_in_path = false;
+ loop {
+ if content.is_empty() {
+ break;
}
- } else if lookahead.peek(Token![*]) {
- Ok(UseTree::Glob(UseGlob {
- star_token: input.parse()?,
- }))
- } else if lookahead.peek(token::Brace) {
- let content;
- Ok(UseTree::Group(UseGroup {
- brace_token: braced!(content in input),
- items: content.parse_terminated(UseTree::parse)?,
- }))
+ has_crate_root_in_path |=
+ allow_crate_root_in_path && content.parse::<Option<Token![::]>>()?.is_some();
+ let tree: UseTree = content.parse()?;
+ items.push_value(tree);
+ if content.is_empty() {
+ break;
+ }
+ let comma: Token![,] = content.parse()?;
+ items.push_punct(comma);
+ }
+ if has_crate_root_in_path {
+ Ok(None)
} else {
- Err(lookahead.error())
+ Ok(Some(UseTree::Group(UseGroup { brace_token, items })))
}
+ } else {
+ Err(lookahead.error())
}
}
return Err(lookahead.error());
}
},
+ generics: Generics::default(),
colon_token: input.parse()?,
ty: input.parse()?,
eq_token: input.parse()?,
}
}
- fn pop_variadic(args: &mut Punctuated<FnArg, Token![,]>) -> Option<Variadic> {
- let trailing_punct = args.trailing_punct();
-
- let last = match args.last_mut()? {
- FnArg::Typed(last) => last,
- _ => return None,
- };
-
- let ty = match last.ty.as_ref() {
- Type::Verbatim(ty) => ty,
- _ => return None,
- };
-
- let mut variadic = Variadic {
- attrs: Vec::new(),
- dots: parse2(ty.clone()).ok()?,
- };
-
- if let Pat::Verbatim(pat) = last.pat.as_ref() {
- if pat.to_string() == "..." && !trailing_punct {
- variadic.attrs = mem::replace(&mut last.attrs, Vec::new());
- args.pop();
- }
- }
-
- Some(variadic)
- }
-
- fn variadic_to_tokens(dots: &Token![...]) -> TokenStream {
- TokenStream::from_iter(vec![
- TokenTree::Punct({
- let mut dot = Punct::new('.', Spacing::Joint);
- dot.set_span(dots.spans[0]);
- dot
- }),
- TokenTree::Punct({
- let mut dot = Punct::new('.', Spacing::Joint);
- dot.set_span(dots.spans[1]);
- dot
- }),
- TokenTree::Punct({
- let mut dot = Punct::new('.', Spacing::Alone);
- dot.set_span(dots.spans[2]);
- dot
- }),
- ])
- }
-
fn peek_signature(input: ParseStream) -> bool {
let fork = input.fork();
fork.parse::<Option<Token![const]>>().is_ok()
let content;
let paren_token = parenthesized!(content in input);
- let mut inputs = parse_fn_args(&content)?;
- let variadic = pop_variadic(&mut inputs);
+ let (inputs, variadic) = parse_fn_args(&content)?;
let output: ReturnType = input.parse()?;
generics.where_clause = input.parse()?;
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
impl Parse for FnArg {
fn parse(input: ParseStream) -> Result<Self> {
+ let allow_variadic = false;
let attrs = input.call(Attribute::parse_outer)?;
-
- let ahead = input.fork();
- if let Ok(mut receiver) = ahead.parse::<Receiver>() {
- if !ahead.peek(Token![:]) {
- input.advance_to(&ahead);
- receiver.attrs = attrs;
- return Ok(FnArg::Receiver(receiver));
- }
+ match parse_fn_arg_or_variadic(input, attrs, allow_variadic)? {
+ FnArgOrVariadic::FnArg(arg) => Ok(arg),
+ FnArgOrVariadic::Variadic(_) => unreachable!(),
}
+ }
+ }
+
+ enum FnArgOrVariadic {
+ FnArg(FnArg),
+ Variadic(Variadic),
+ }
+
+ fn parse_fn_arg_or_variadic(
+ input: ParseStream,
+ attrs: Vec<Attribute>,
+ allow_variadic: bool,
+ ) -> Result<FnArgOrVariadic> {
+ let ahead = input.fork();
+ if let Ok(mut receiver) = ahead.parse::<Receiver>() {
+ input.advance_to(&ahead);
+ receiver.attrs = attrs;
+ return Ok(FnArgOrVariadic::FnArg(FnArg::Receiver(receiver)));
+ }
+
+ // Hack to parse pre-2018 syntax in
+ // test/ui/rfc-2565-param-attrs/param-attrs-pretty.rs
+ // because the rest of the test case is valuable.
+ if input.peek(Ident) && input.peek2(Token![<]) {
+ let span = input.fork().parse::<Ident>()?.span();
+ return Ok(FnArgOrVariadic::FnArg(FnArg::Typed(PatType {
+ attrs,
+ pat: Box::new(Pat::Wild(PatWild {
+ attrs: Vec::new(),
+ underscore_token: Token,
+ })),
+ colon_token: Token,
+ ty: input.parse()?,
+ })));
+ }
+
+ let pat = Box::new(Pat::parse_single(input)?);
+ let colon_token: Token![:] = input.parse()?;
- let mut typed = input.call(fn_arg_typed)?;
- typed.attrs = attrs;
- Ok(FnArg::Typed(typed))
+ if allow_variadic {
+ if let Some(dots) = input.parse::<Option<Token![...]>>()? {
+ return Ok(FnArgOrVariadic::Variadic(Variadic {
+ attrs,
+ pat: Some((pat, colon_token)),
+ dots,
+ comma: None,
+ }));
+ }
}
+
+ Ok(FnArgOrVariadic::FnArg(FnArg::Typed(PatType {
+ attrs,
+ pat,
+ colon_token,
+ ty: input.parse()?,
+ })))
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
impl Parse for Receiver {
fn parse(input: ParseStream) -> Result<Self> {
+ let reference = if input.peek(Token![&]) {
+ let ampersand: Token![&] = input.parse()?;
+ let lifetime: Option<Lifetime> = input.parse()?;
+ Some((ampersand, lifetime))
+ } else {
+ None
+ };
+ let mutability: Option<Token![mut]> = input.parse()?;
+ let self_token: Token![self] = input.parse()?;
+ let colon_token: Option<Token![:]> = if reference.is_some() {
+ None
+ } else {
+ input.parse()?
+ };
+ let ty: Type = if colon_token.is_some() {
+ input.parse()?
+ } else {
+ let mut ty = Type::Path(TypePath {
+ qself: None,
+ path: Path::from(Ident::new("Self", self_token.span)),
+ });
+ if let Some((ampersand, lifetime)) = reference.as_ref() {
+ ty = Type::Reference(TypeReference {
+ and_token: Token,
+ lifetime: lifetime.clone(),
+ mutability: mutability.as_ref().map(|m| Token),
+ elem: Box::new(ty),
+ });
+ }
+ ty
+ };
Ok(Receiver {
attrs: Vec::new(),
- reference: {
- if input.peek(Token![&]) {
- Some((input.parse()?, input.parse()?))
- } else {
- None
- }
- },
- mutability: input.parse()?,
- self_token: input.parse()?,
+ reference,
+ mutability,
+ self_token,
+ colon_token,
+ ty: Box::new(ty),
})
}
}
- fn parse_fn_args(input: ParseStream) -> Result<Punctuated<FnArg, Token![,]>> {
+ fn parse_fn_args(
+ input: ParseStream,
+ ) -> Result<(Punctuated<FnArg, Token![,]>, Option<Variadic>)> {
let mut args = Punctuated::new();
+ let mut variadic = None;
let mut has_receiver = false;
while !input.is_empty() {
let attrs = input.call(Attribute::parse_outer)?;
- let arg = if let Some(dots) = input.parse::<Option<Token![...]>>()? {
- FnArg::Typed(PatType {
+ if let Some(dots) = input.parse::<Option<Token![...]>>()? {
+ variadic = Some(Variadic {
attrs,
- pat: Box::new(Pat::Verbatim(variadic_to_tokens(&dots))),
- colon_token: Token,
- ty: Box::new(Type::Verbatim(variadic_to_tokens(&dots))),
- })
- } else {
- let mut arg: FnArg = input.parse()?;
- match &mut arg {
- FnArg::Receiver(receiver) if has_receiver => {
- return Err(Error::new(
- receiver.self_token.span,
- "unexpected second method receiver",
- ));
- }
- FnArg::Receiver(receiver) if !args.is_empty() => {
- return Err(Error::new(
- receiver.self_token.span,
- "unexpected method receiver",
- ));
- }
- FnArg::Receiver(receiver) => {
- has_receiver = true;
- receiver.attrs = attrs;
- }
- FnArg::Typed(arg) => arg.attrs = attrs,
+ pat: None,
+ dots,
+ comma: if input.is_empty() {
+ None
+ } else {
+ Some(input.parse()?)
+ },
+ });
+ break;
+ }
+
+ let allow_variadic = true;
+ let arg = match parse_fn_arg_or_variadic(input, attrs, allow_variadic)? {
+ FnArgOrVariadic::FnArg(arg) => arg,
+ FnArgOrVariadic::Variadic(arg) => {
+ variadic = Some(Variadic {
+ comma: if input.is_empty() {
+ None
+ } else {
+ Some(input.parse()?)
+ },
+ ..arg
+ });
+ break;
}
- arg
};
+
+ match &arg {
+ FnArg::Receiver(receiver) if has_receiver => {
+ return Err(Error::new(
+ receiver.self_token.span,
+ "unexpected second method receiver",
+ ));
+ }
+ FnArg::Receiver(receiver) if !args.is_empty() => {
+ return Err(Error::new(
+ receiver.self_token.span,
+ "unexpected method receiver",
+ ));
+ }
+ FnArg::Receiver(_) => has_receiver = true,
+ FnArg::Typed(_) => {}
+ }
args.push_value(arg);
if input.is_empty() {
args.push_punct(comma);
}
- Ok(args)
- }
-
- fn fn_arg_typed(input: ParseStream) -> Result<PatType> {
- // Hack to parse pre-2018 syntax in
- // test/ui/rfc-2565-param-attrs/param-attrs-pretty.rs
- // because the rest of the test case is valuable.
- if input.peek(Ident) && input.peek2(Token![<]) {
- let span = input.fork().parse::<Ident>()?.span();
- return Ok(PatType {
- attrs: Vec::new(),
- pat: Box::new(Pat::Wild(PatWild {
- attrs: Vec::new(),
- underscore_token: Token,
- })),
- colon_token: Token,
- ty: input.parse()?,
- });
- }
-
- Ok(PatType {
- attrs: Vec::new(),
- pat: Box::new(pat::parsing::multi_pat(input)?),
- colon_token: input.parse()?,
- ty: Box::new(match input.parse::<Option<Token![...]>>()? {
- Some(dot3) => Type::Verbatim(variadic_to_tokens(&dot3)),
- None => input.parse()?,
- }),
- })
+ Ok((args, variadic))
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
fn parse(input: ParseStream) -> Result<Self> {
let mut attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
+ let unsafety: Option<Token![unsafe]> = input.parse()?;
let mod_token: Token![mod] = input.parse()?;
- let ident: Ident = input.parse()?;
+ let ident: Ident = if input.peek(Token![try]) {
+ input.call(Ident::parse_any)
+ } else {
+ input.parse()
+ }?;
let lookahead = input.lookahead1();
if lookahead.peek(Token![;]) {
Ok(ItemMod {
attrs,
vis,
+ unsafety,
mod_token,
ident,
content: None,
Ok(ItemMod {
attrs,
vis,
+ unsafety,
mod_token,
ident,
content: Some((brace_token, items)),
impl Parse for ItemForeignMod {
fn parse(input: ParseStream) -> Result<Self> {
let mut attrs = input.call(Attribute::parse_outer)?;
+ let unsafety: Option<Token![unsafe]> = input.parse()?;
let abi: Abi = input.parse()?;
let content;
Ok(ItemForeignMod {
attrs,
+ unsafety,
abi,
brace_token,
items,
ForeignItem::Type(item) => &mut item.attrs,
ForeignItem::Macro(item) => &mut item.attrs,
ForeignItem::Verbatim(_) => return Ok(item),
-
- #[cfg(syn_no_non_exhaustive)]
- _ => unreachable!(),
};
attrs.append(item_attrs);
*item_attrs = attrs;
vis: input.parse()?,
type_token: input.parse()?,
ident: input.parse()?,
+ generics: {
+ let mut generics: Generics = input.parse()?;
+ generics.where_clause = input.parse()?;
+ generics
+ },
semi_token: input.parse()?,
})
}
bounds: _,
ty,
semi_token,
- } = FlexibleItemType::parse(input, WhereClauseLocation::BeforeEq)?;
+ } = FlexibleItemType::parse(input, WhereClauseLocation::Both)?;
- if defaultness.is_some()
- || generics.lt_token.is_some()
- || generics.where_clause.is_some()
- || colon_token.is_some()
- || ty.is_some()
- {
+ if defaultness.is_some() || colon_token.is_some() || ty.is_some() {
Ok(ForeignItem::Verbatim(verbatim::between(begin, input)))
} else {
Ok(ForeignItem::Type(ForeignItemType {
vis,
type_token,
ident,
+ generics,
semi_token,
}))
}
vis,
unsafety,
auto_token,
+ restriction: None,
trait_token,
ident,
generics,
let lookahead = ahead.lookahead1();
let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) {
- input.parse().map(TraitItem::Method)
+ input.parse().map(TraitItem::Fn)
} else if lookahead.peek(Token![const]) {
ahead.parse::<Token![const]>()?;
let lookahead = ahead.lookahead1();
|| lookahead.peek(Token![extern])
|| lookahead.peek(Token![fn])
{
- input.parse().map(TraitItem::Method)
+ input.parse().map(TraitItem::Fn)
} else {
Err(lookahead.error())
}
let item_attrs = match &mut item {
TraitItem::Const(item) => &mut item.attrs,
- TraitItem::Method(item) => &mut item.attrs,
+ TraitItem::Fn(item) => &mut item.attrs,
TraitItem::Type(item) => &mut item.attrs,
TraitItem::Macro(item) => &mut item.attrs,
TraitItem::Verbatim(_) => unreachable!(),
-
- #[cfg(syn_no_non_exhaustive)]
- _ => unreachable!(),
};
attrs.append(item_attrs);
*item_attrs = attrs;
return Err(lookahead.error());
}
},
+ generics: Generics::default(),
colon_token: input.parse()?,
ty: input.parse()?,
default: {
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for TraitItemMethod {
+ impl Parse for TraitItemFn {
fn parse(input: ParseStream) -> Result<Self> {
let mut attrs = input.call(Attribute::parse_outer)?;
let sig: Signature = input.parse()?;
return Err(lookahead.error());
};
- Ok(TraitItemMethod {
+ Ok(TraitItemFn {
attrs,
sig,
default: brace_token.map(|brace_token| Block { brace_token, stmts }),
bounds,
ty,
semi_token,
- } = FlexibleItemType::parse(input, WhereClauseLocation::Both)?;
+ } = FlexibleItemType::parse(input, WhereClauseLocation::AfterEq)?;
if defaultness.is_some() || vis.is_some() {
Ok(TraitItem::Verbatim(verbatim::between(begin, input)))
};
let mut item = if lookahead.peek(Token![fn]) || peek_signature(&ahead) {
- input.parse().map(ImplItem::Method)
+ input.parse().map(ImplItem::Fn)
} else if lookahead.peek(Token![const]) {
let const_token: Token![const] = ahead.parse()?;
let lookahead = ahead.lookahead1();
defaultness,
const_token,
ident,
+ generics: Generics::default(),
colon_token,
ty,
eq_token,
{
let item_attrs = match &mut item {
ImplItem::Const(item) => &mut item.attrs,
- ImplItem::Method(item) => &mut item.attrs,
+ ImplItem::Fn(item) => &mut item.attrs,
ImplItem::Type(item) => &mut item.attrs,
ImplItem::Macro(item) => &mut item.attrs,
ImplItem::Verbatim(_) => return Ok(item),
-
- #[cfg(syn_no_non_exhaustive)]
- _ => unreachable!(),
};
attrs.append(item_attrs);
*item_attrs = attrs;
return Err(lookahead.error());
}
},
+ generics: Generics::default(),
colon_token: input.parse()?,
ty: input.parse()?,
eq_token: input.parse()?,
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for ImplItemMethod {
+ impl Parse for ImplItemFn {
fn parse(input: ParseStream) -> Result<Self> {
let mut attrs = input.call(Attribute::parse_outer)?;
let vis: Visibility = input.parse()?;
let sig: Signature = input.parse()?;
let block = if let Some(semi) = input.parse::<Option<Token![;]>>()? {
- // Accept methods without a body in an impl block because
+ // Accept functions without a body in an impl block because
// rustc's *parser* does not reject them (the compilation error
// is emitted later than parsing) and it can be useful for macro
// DSLs.
punct.set_span(semi.span);
let tokens = TokenStream::from_iter(vec![TokenTree::Punct(punct)]);
Block {
- brace_token: Brace { span: semi.span },
+ brace_token: Brace(semi.span),
stmts: vec![Stmt::Item(Item::Verbatim(tokens))],
}
} else {
}
};
- Ok(ImplItemMethod {
+ Ok(ImplItemFn {
attrs,
vis,
defaultness,
bounds: _,
ty,
semi_token,
- } = FlexibleItemType::parse(input, WhereClauseLocation::Both)?;
+ } = FlexibleItemType::parse(input, WhereClauseLocation::AfterEq)?;
if colon_token.is_some() || ty.is_none() {
Ok(ImplItem::Verbatim(verbatim::between(begin, input)))
impl Visibility {
fn is_inherited(&self) -> bool {
- match *self {
+ match self {
Visibility::Inherited => true,
_ => false,
}
}
impl MacroDelimiter {
- fn is_brace(&self) -> bool {
- match *self {
+ pub(crate) fn is_brace(&self) -> bool {
+ match self {
MacroDelimiter::Brace(_) => true,
MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => false,
}
}
}
+
+ #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
+ impl Parse for StaticMutability {
+ fn parse(input: ParseStream) -> Result<Self> {
+ let mut_token: Option<Token![mut]> = input.parse()?;
+ Ok(mut_token.map_or(StaticMutability::None, StaticMutability::Mut))
+ }
+ }
}
#[cfg(feature = "printing")]
fn to_tokens(&self, tokens: &mut TokenStream) {
tokens.append_all(self.attrs.outer());
self.vis.to_tokens(tokens);
+ self.unsafety.to_tokens(tokens);
self.mod_token.to_tokens(tokens);
self.ident.to_tokens(tokens);
if let Some((brace, items)) = &self.content {
impl ToTokens for ItemForeignMod {
fn to_tokens(&self, tokens: &mut TokenStream) {
tokens.append_all(self.attrs.outer());
+ self.unsafety.to_tokens(tokens);
self.abi.to_tokens(tokens);
self.brace_token.surround(tokens, |tokens| {
tokens.append_all(self.attrs.inner());
}
}
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for ItemMacro2 {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- tokens.append_all(self.attrs.outer());
- self.vis.to_tokens(tokens);
- self.macro_token.to_tokens(tokens);
- self.ident.to_tokens(tokens);
- self.rules.to_tokens(tokens);
- }
- }
-
#[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
impl ToTokens for UsePath {
fn to_tokens(&self, tokens: &mut TokenStream) {
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for TraitItemMethod {
+ impl ToTokens for TraitItemFn {
fn to_tokens(&self, tokens: &mut TokenStream) {
tokens.append_all(self.attrs.outer());
self.sig.to_tokens(tokens);
}
#[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for ImplItemMethod {
+ impl ToTokens for ImplItemFn {
fn to_tokens(&self, tokens: &mut TokenStream) {
tokens.append_all(self.attrs.outer());
self.vis.to_tokens(tokens);
self.vis.to_tokens(tokens);
self.type_token.to_tokens(tokens);
self.ident.to_tokens(tokens);
+ self.generics.to_tokens(tokens);
+ self.generics.where_clause.to_tokens(tokens);
self.semi_token.to_tokens(tokens);
}
}
}
}
- fn maybe_variadic_to_tokens(arg: &FnArg, tokens: &mut TokenStream) -> bool {
- let arg = match arg {
- FnArg::Typed(arg) => arg,
- FnArg::Receiver(receiver) => {
- receiver.to_tokens(tokens);
- return false;
- }
- };
-
- match arg.ty.as_ref() {
- Type::Verbatim(ty) if ty.to_string() == "..." => {
- match arg.pat.as_ref() {
- Pat::Verbatim(pat) if pat.to_string() == "..." => {
- tokens.append_all(arg.attrs.outer());
- pat.to_tokens(tokens);
- }
- _ => arg.to_tokens(tokens),
- }
- true
- }
- _ => {
- arg.to_tokens(tokens);
- false
- }
- }
- }
-
#[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
impl ToTokens for Signature {
fn to_tokens(&self, tokens: &mut TokenStream) {
self.ident.to_tokens(tokens);
self.generics.to_tokens(tokens);
self.paren_token.surround(tokens, |tokens| {
- let mut last_is_variadic = false;
- for pair in self.inputs.pairs() {
- last_is_variadic = maybe_variadic_to_tokens(pair.value(), tokens);
- pair.punct().to_tokens(tokens);
- }
- if self.variadic.is_some() && !last_is_variadic {
+ self.inputs.to_tokens(tokens);
+ if let Some(variadic) = &self.variadic {
if !self.inputs.empty_or_trailing() {
<Token![,]>::default().to_tokens(tokens);
}
- self.variadic.to_tokens(tokens);
+ variadic.to_tokens(tokens);
}
});
self.output.to_tokens(tokens);
}
self.mutability.to_tokens(tokens);
self.self_token.to_tokens(tokens);
+ if let Some(colon_token) = &self.colon_token {
+ colon_token.to_tokens(tokens);
+ self.ty.to_tokens(tokens);
+ } else {
+ let consistent = match (&self.reference, &self.mutability, &*self.ty) {
+ (Some(_), mutability, Type::Reference(ty)) => {
+ mutability.is_some() == ty.mutability.is_some()
+ && match &*ty.elem {
+ Type::Path(ty) => ty.qself.is_none() && ty.path.is_ident("Self"),
+ _ => false,
+ }
+ }
+ (None, _, Type::Path(ty)) => ty.qself.is_none() && ty.path.is_ident("Self"),
+ _ => false,
+ };
+ if !consistent {
+ <Token![:]>::default().to_tokens(tokens);
+ self.ty.to_tokens(tokens);
+ }
+ }
+ }
+ }
+
+ #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
+ impl ToTokens for Variadic {
+ fn to_tokens(&self, tokens: &mut TokenStream) {
+ tokens.append_all(self.attrs.outer());
+ if let Some((pat, colon)) = &self.pat {
+ pat.to_tokens(tokens);
+ colon.to_tokens(tokens);
+ }
+ self.dots.to_tokens(tokens);
+ self.comma.to_tokens(tokens);
+ }
+ }
+
+ #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
+ impl ToTokens for StaticMutability {
+ fn to_tokens(&self, tokens: &mut TokenStream) {
+ match self {
+ StaticMutability::None => {}
+ StaticMutability::Mut(mut_token) => mut_token.to_tokens(tokens),
+ }
}
}
}
projects / rustc.git / blobdiff