| use super::*; |
| use delimited::Delimited; |
| |
| ast_struct! { |
| /// An expression. |
| pub struct Expr { |
| /// Type of the expression. |
| pub node: ExprKind, |
| |
| /// Attributes tagged on the expression. |
| pub attrs: Vec<Attribute>, |
| } |
| } |
| |
| impl From<ExprKind> for Expr { |
| fn from(node: ExprKind) -> Expr { |
| Expr { |
| node: node, |
| attrs: Vec::new(), |
| } |
| } |
| } |
| |
| ast_enum_of_structs! { |
| pub enum ExprKind { |
| /// A `box x` expression. |
| pub Box(ExprBox #full { |
| pub expr: Box<Expr>, |
| pub box_token: Token![box], |
| }), |
| |
| /// E.g. 'place <- val' or `in place { val }`. |
| pub InPlace(ExprInPlace #full { |
| pub place: Box<Expr>, |
| pub kind: InPlaceKind, |
| pub value: Box<Expr>, |
| }), |
| |
| /// An array, e.g. `[a, b, c, d]`. |
| pub Array(ExprArray #full { |
| pub exprs: Delimited<Expr, Token![,]>, |
| pub bracket_token: tokens::Bracket, |
| }), |
| |
| /// A function call. |
| pub Call(ExprCall { |
| pub func: Box<Expr>, |
| pub args: Delimited<Expr, Token![,]>, |
| pub paren_token: tokens::Paren, |
| }), |
| |
| /// A method call (`x.foo::<Bar, Baz>(a, b, c, d)`) |
| /// |
| /// The `Ident` is the identifier for the method name. |
| /// The vector of `Type`s are the ascripted type parameters for the method |
| /// (within the angle brackets). |
| /// |
| /// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as |
| /// `ExprKind::MethodCall(foo, [Bar, Baz], [x, a, b, c, d])`. |
| pub MethodCall(ExprMethodCall #full { |
| pub expr: Box<Expr>, |
| pub method: Ident, |
| pub typarams: Delimited<Type, Token![,]>, |
| pub args: Delimited<Expr, Token![,]>, |
| pub paren_token: tokens::Paren, |
| pub dot_token: Token![.], |
| pub lt_token: Option<Token![<]>, |
| pub colon2_token: Option<Token![::]>, |
| pub gt_token: Option<Token![>]>, |
| }), |
| |
| /// A tuple, e.g. `(a, b, c, d)`. |
| pub Tup(ExprTup #full { |
| pub args: Delimited<Expr, Token![,]>, |
| pub paren_token: tokens::Paren, |
| pub lone_comma: Option<Token![,]>, |
| }), |
| |
| /// A binary operation, e.g. `a + b`, `a * b`. |
| pub Binary(ExprBinary { |
| pub op: BinOp, |
| pub left: Box<Expr>, |
| pub right: Box<Expr>, |
| }), |
| |
| /// A unary operation, e.g. `!x`, `*x`. |
| pub Unary(ExprUnary { |
| pub op: UnOp, |
| pub expr: Box<Expr>, |
| }), |
| |
| /// A literal, e.g. `1`, `"foo"`. |
| pub Lit(Lit), |
| |
| /// A cast, e.g. `foo as f64`. |
| pub Cast(ExprCast { |
| pub expr: Box<Expr>, |
| pub as_token: Token![as], |
| pub ty: Box<Type>, |
| }), |
| |
| /// A type ascription, e.g. `foo: f64`. |
| pub Type(ExprType { |
| pub expr: Box<Expr>, |
| pub colon_token: Token![:], |
| pub ty: Box<Type>, |
| }), |
| |
| /// An `if` block, with an optional else block |
| /// |
| /// E.g., `if expr { block } else { expr }` |
| pub If(ExprIf #full { |
| pub cond: Box<Expr>, |
| pub if_true: Block, |
| pub if_false: Option<Box<Expr>>, |
| pub if_token: Token![if], |
| pub else_token: Option<Token![else]>, |
| }), |
| |
| /// An `if let` expression with an optional else block |
| /// |
| /// E.g., `if let pat = expr { block } else { expr }` |
| /// |
| /// This is desugared to a `match` expression. |
| pub IfLet(ExprIfLet #full { |
| pub pat: Box<Pat>, |
| pub expr: Box<Expr>, |
| pub if_true: Block, |
| pub if_false: Option<Box<Expr>>, |
| pub if_token: Token![if], |
| pub let_token: Token![let], |
| pub eq_token: Token![=], |
| pub else_token: Option<Token![else]>, |
| }), |
| |
| /// A while loop, with an optional label |
| /// |
| /// E.g., `'label: while expr { block }` |
| pub While(ExprWhile #full { |
| pub cond: Box<Expr>, |
| pub body: Block, |
| pub label: Option<Lifetime>, |
| pub colon_token: Option<Token![:]>, |
| pub while_token: Token![while], |
| }), |
| |
| /// A while-let loop, with an optional label. |
| /// |
| /// E.g., `'label: while let pat = expr { block }` |
| /// |
| /// This is desugared to a combination of `loop` and `match` expressions. |
| pub WhileLet(ExprWhileLet #full { |
| pub pat: Box<Pat>, |
| pub expr: Box<Expr>, |
| pub body: Block, |
| pub label: Option<Lifetime>, |
| pub colon_token: Option<Token![:]>, |
| pub while_token: Token![while], |
| pub let_token: Token![let], |
| pub eq_token: Token![=], |
| }), |
| |
| /// A for loop, with an optional label. |
| /// |
| /// E.g., `'label: for pat in expr { block }` |
| /// |
| /// This is desugared to a combination of `loop` and `match` expressions. |
| pub ForLoop(ExprForLoop #full { |
| pub pat: Box<Pat>, |
| pub expr: Box<Expr>, |
| pub body: Block, |
| pub label: Option<Lifetime>, |
| pub for_token: Token![for], |
| pub colon_token: Option<Token![:]>, |
| pub in_token: Token![in], |
| }), |
| |
| /// Conditionless loop with an optional label. |
| /// |
| /// E.g. `'label: loop { block }` |
| pub Loop(ExprLoop #full { |
| pub body: Block, |
| pub label: Option<Lifetime>, |
| pub loop_token: Token![loop], |
| pub colon_token: Option<Token![:]>, |
| }), |
| |
| /// A `match` block. |
| pub Match(ExprMatch #full { |
| pub match_token: Token![match], |
| pub brace_token: tokens::Brace, |
| pub expr: Box<Expr>, |
| pub arms: Vec<Arm>, |
| }), |
| |
| /// A closure (for example, `move |a, b, c| a + b + c`) |
| pub Closure(ExprClosure #full { |
| pub capture: CaptureBy, |
| pub decl: Box<FnDecl>, |
| pub body: Box<Expr>, |
| pub or1_token: Token![|], |
| pub or2_token: Token![|], |
| }), |
| |
| /// An unsafe block (`unsafe { ... }`) |
| pub Unsafe(ExprUnsafe #full { |
| pub unsafe_token: Token![unsafe], |
| pub block: Block, |
| }), |
| |
| /// A block (`{ ... }`) |
| pub Block(ExprBlock #full { |
| pub block: Block, |
| }), |
| |
| /// An assignment (`a = foo()`) |
| pub Assign(ExprAssign #full { |
| pub left: Box<Expr>, |
| pub right: Box<Expr>, |
| pub eq_token: Token![=], |
| }), |
| |
| /// An assignment with an operator |
| /// |
| /// For example, `a += 1`. |
| pub AssignOp(ExprAssignOp #full { |
| pub op: BinOp, |
| pub left: Box<Expr>, |
| pub right: Box<Expr>, |
| }), |
| |
| /// Access of a named struct field (`obj.foo`) |
| pub Field(ExprField #full { |
| pub expr: Box<Expr>, |
| pub field: Ident, |
| pub dot_token: Token![.], |
| }), |
| |
| /// Access of an unnamed field of a struct or tuple-struct |
| /// |
| /// For example, `foo.0`. |
| pub TupField(ExprTupField #full { |
| pub expr: Box<Expr>, |
| pub field: Lit, |
| pub dot_token: Token![.], |
| }), |
| |
| /// An indexing operation (`foo[2]`) |
| pub Index(ExprIndex { |
| pub expr: Box<Expr>, |
| pub index: Box<Expr>, |
| pub bracket_token: tokens::Bracket, |
| }), |
| |
| /// A range (`1..2`, `1..`, `..2`, `1...2`, `1...`, `...2`) |
| pub Range(ExprRange #full { |
| pub from: Option<Box<Expr>>, |
| pub to: Option<Box<Expr>>, |
| pub limits: RangeLimits, |
| }), |
| |
| /// Variable reference, possibly containing `::` and/or type |
| /// parameters, e.g. foo::bar::<baz>. |
| /// |
| /// Optionally "qualified", |
| /// E.g. `<Vec<T> as SomeTrait>::SomeType`. |
| pub Path(ExprPath { |
| pub qself: Option<QSelf>, |
| pub path: Path, |
| }), |
| |
| /// A referencing operation (`&a` or `&mut a`) |
| pub AddrOf(ExprAddrOf #full { |
| pub and_token: Token![&], |
| pub mutbl: Mutability, |
| pub expr: Box<Expr>, |
| }), |
| |
| /// A `break`, with an optional label to break, and an optional expression |
| pub Break(ExprBreak #full { |
| pub label: Option<Lifetime>, |
| pub expr: Option<Box<Expr>>, |
| pub break_token: Token![break], |
| }), |
| |
| /// A `continue`, with an optional label |
| pub Continue(ExprContinue #full { |
| pub label: Option<Lifetime>, |
| pub continue_token: Token![continue], |
| }), |
| |
| /// A `return`, with an optional value to be returned |
| pub Ret(ExprRet #full { |
| pub expr: Option<Box<Expr>>, |
| pub return_token: Token![return], |
| }), |
| |
| /// A macro invocation; pre-expansion |
| pub Macro(Macro), |
| |
| /// A struct literal expression. |
| /// |
| /// For example, `Foo {x: 1, y: 2}`, or |
| /// `Foo {x: 1, .. base}`, where `base` is the `Option<Expr>`. |
| pub Struct(ExprStruct #full { |
| pub path: Path, |
| pub fields: Delimited<FieldValue, Token![,]>, |
| pub rest: Option<Box<Expr>>, |
| pub dot2_token: Option<Token![..]>, |
| pub brace_token: tokens::Brace, |
| }), |
| |
| /// An array literal constructed from one repeated element. |
| /// |
| /// For example, `[1; 5]`. The first expression is the element |
| /// to be repeated; the second is the number of times to repeat it. |
| pub Repeat(ExprRepeat #full { |
| pub bracket_token: tokens::Bracket, |
| pub semi_token: Token![;], |
| pub expr: Box<Expr>, |
| pub amt: Box<Expr>, |
| }), |
| |
| /// No-op: used solely so we can pretty-print faithfully |
| pub Paren(ExprParen { |
| pub expr: Box<Expr>, |
| pub paren_token: tokens::Paren, |
| }), |
| |
| /// No-op: used solely so we can pretty-print faithfully |
| /// |
| /// A `group` represents a `None`-delimited span in the input |
| /// `TokenStream` which affects the precidence of the resulting |
| /// expression. They are used for macro hygiene. |
| pub Group(ExprGroup { |
| pub expr: Box<Expr>, |
| pub group_token: tokens::Group, |
| }), |
| |
| /// `expr?` |
| pub Try(ExprTry #full { |
| pub expr: Box<Expr>, |
| pub question_token: Token![?], |
| }), |
| |
| /// A catch expression. |
| /// |
| /// E.g. `do catch { block }` |
| pub Catch(ExprCatch #full { |
| pub do_token: Token![do], |
| pub catch_token: Token![catch], |
| pub block: Block, |
| }), |
| |
| /// A yield expression. |
| /// |
| /// E.g. `yield expr` |
| pub Yield(ExprYield #full { |
| pub yield_token: Token![yield], |
| pub expr: Option<Box<Expr>>, |
| }), |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_struct! { |
| /// A field-value pair in a struct literal. |
| pub struct FieldValue { |
| /// Name of the field. |
| pub ident: Ident, |
| |
| /// Value of the field. |
| pub expr: Expr, |
| |
| /// Whether this is a shorthand field, e.g. `Struct { x }` |
| /// instead of `Struct { x: x }`. |
| pub is_shorthand: bool, |
| |
| /// Attributes tagged on the field. |
| pub attrs: Vec<Attribute>, |
| |
| pub colon_token: Option<Token![:]>, |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_struct! { |
| /// A Block (`{ .. }`). |
| /// |
| /// E.g. `{ .. }` as in `fn foo() { .. }` |
| pub struct Block { |
| pub brace_token: tokens::Brace, |
| /// Statements in a block |
| pub stmts: Vec<Stmt>, |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_enum! { |
| /// A statement, usually ending in a semicolon. |
| pub enum Stmt { |
| /// A local (let) binding. |
| Local(Box<Local>), |
| |
| /// An item definition. |
| Item(Box<Item>), |
| |
| /// Expr without trailing semicolon. |
| Expr(Box<Expr>), |
| |
| /// Expression with trailing semicolon; |
| Semi(Box<Expr>, Token![;]), |
| |
| /// Macro invocation. |
| Macro(Box<(Macro, MacStmtStyle, Vec<Attribute>)>), |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_enum! { |
| /// How a macro was invoked. |
| #[cfg_attr(feature = "clone-impls", derive(Copy))] |
| pub enum MacStmtStyle { |
| /// The macro statement had a trailing semicolon, e.g. `foo! { ... };` |
| /// `foo!(...);`, `foo![...];` |
| Semicolon(Token![;]), |
| |
| /// The macro statement had braces; e.g. foo! { ... } |
| Braces, |
| |
| /// The macro statement had parentheses or brackets and no semicolon; e.g. |
| /// `foo!(...)`. All of these will end up being converted into macro |
| /// expressions. |
| NoBraces, |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_struct! { |
| /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;` |
| pub struct Local { |
| pub let_token: Token![let], |
| pub colon_token: Option<Token![:]>, |
| pub eq_token: Option<Token![=]>, |
| pub semi_token: Token![;], |
| |
| pub pat: Box<Pat>, |
| pub ty: Option<Box<Type>>, |
| |
| /// Initializer expression to set the value, if any |
| pub init: Option<Box<Expr>>, |
| pub attrs: Vec<Attribute>, |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_enum_of_structs! { |
| // Clippy false positive |
| // https://github.com/Manishearth/rust-clippy/issues/1241 |
| #[cfg_attr(feature = "cargo-clippy", allow(enum_variant_names))] |
| pub enum Pat { |
| /// Represents a wildcard pattern (`_`) |
| pub Wild(PatWild { |
| pub underscore_token: Token![_], |
| }), |
| |
| /// A `Pat::Ident` may either be a new bound variable (`ref mut binding @ OPT_SUBPATTERN`), |
| /// or a unit struct/variant pattern, or a const pattern (in the last two cases the third |
| /// field must be `None`). Disambiguation cannot be done with parser alone, so it happens |
| /// during name resolution. |
| pub Ident(PatIdent { |
| pub mode: BindingMode, |
| pub ident: Ident, |
| pub subpat: Option<Box<Pat>>, |
| pub at_token: Option<Token![@]>, |
| }), |
| |
| /// A struct or struct variant pattern, e.g. `Variant {x, y, ..}`. |
| /// The `bool` is `true` in the presence of a `..`. |
| pub Struct(PatStruct { |
| pub path: Path, |
| pub fields: Delimited<FieldPat, Token![,]>, |
| pub brace_token: tokens::Brace, |
| pub dot2_token: Option<Token![..]>, |
| }), |
| |
| /// A tuple struct/variant pattern `Variant(x, y, .., z)`. |
| /// If the `..` pattern fragment is present, then `Option<usize>` denotes its position. |
| /// 0 <= position <= subpats.len() |
| pub TupleStruct(PatTupleStruct { |
| pub path: Path, |
| pub pat: PatTuple, |
| }), |
| |
| /// A possibly qualified path pattern. |
| /// Unquailfied path patterns `A::B::C` can legally refer to variants, structs, constants |
| /// or associated constants. Quailfied path patterns `<A>::B::C`/`<A as Trait>::B::C` can |
| /// only legally refer to associated constants. |
| pub Path(PatPath { |
| pub qself: Option<QSelf>, |
| pub path: Path, |
| }), |
| |
| /// A tuple pattern `(a, b)`. |
| /// If the `..` pattern fragment is present, then `Option<usize>` denotes its position. |
| /// 0 <= position <= subpats.len() |
| pub Tuple(PatTuple { |
| pub pats: Delimited<Pat, Token![,]>, |
| pub dots_pos: Option<usize>, |
| pub paren_token: tokens::Paren, |
| pub dot2_token: Option<Token![..]>, |
| pub comma_token: Option<Token![,]>, |
| }), |
| /// A `box` pattern |
| pub Box(PatBox { |
| pub pat: Box<Pat>, |
| pub box_token: Token![box], |
| }), |
| /// A reference pattern, e.g. `&mut (a, b)` |
| pub Ref(PatRef { |
| pub pat: Box<Pat>, |
| pub mutbl: Mutability, |
| pub and_token: Token![&], |
| }), |
| /// A literal |
| pub Lit(PatLit { |
| pub expr: Box<Expr>, |
| }), |
| /// A range pattern, e.g. `1...2` |
| pub Range(PatRange { |
| pub lo: Box<Expr>, |
| pub hi: Box<Expr>, |
| pub limits: RangeLimits, |
| }), |
| /// `[a, b, i.., y, z]` is represented as: |
| pub Slice(PatSlice { |
| pub front: Delimited<Pat, Token![,]>, |
| pub middle: Option<Box<Pat>>, |
| pub back: Delimited<Pat, Token![,]>, |
| pub dot2_token: Option<Token![..]>, |
| pub comma_token: Option<Token![,]>, |
| pub bracket_token: tokens::Bracket, |
| }), |
| /// A macro pattern; pre-expansion |
| pub Macro(Macro), |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_struct! { |
| /// An arm of a 'match'. |
| /// |
| /// E.g. `0...10 => { println!("match!") }` as in |
| /// |
| /// ```rust,ignore |
| /// match n { |
| /// 0...10 => { println!("match!") }, |
| /// // .. |
| /// } |
| /// ``` |
| pub struct Arm { |
| pub attrs: Vec<Attribute>, |
| pub pats: Delimited<Pat, Token![|]>, |
| pub if_token: Option<Token![if]>, |
| pub guard: Option<Box<Expr>>, |
| pub rocket_token: Token![=>], |
| pub body: Box<Expr>, |
| pub comma: Option<Token![,]>, |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_enum! { |
| /// A capture clause |
| #[cfg_attr(feature = "clone-impls", derive(Copy))] |
| pub enum CaptureBy { |
| Value(Token![move]), |
| Ref, |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_enum! { |
| /// Limit types of a range (inclusive or exclusive) |
| #[cfg_attr(feature = "clone-impls", derive(Copy))] |
| pub enum RangeLimits { |
| /// Inclusive at the beginning, exclusive at the end |
| HalfOpen(Token![..]), |
| /// Inclusive at the beginning and end |
| Closed(Token![...]), |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_struct! { |
| /// A single field in a struct pattern |
| /// |
| /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` |
| /// are treated the same as `x: x, y: ref y, z: ref mut z`, |
| /// except `is_shorthand` is true |
| pub struct FieldPat { |
| /// The identifier for the field |
| pub ident: Ident, |
| /// The pattern the field is destructured to |
| pub pat: Box<Pat>, |
| pub is_shorthand: bool, |
| pub colon_token: Option<Token![:]>, |
| pub attrs: Vec<Attribute>, |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_enum! { |
| #[cfg_attr(feature = "clone-impls", derive(Copy))] |
| pub enum BindingMode { |
| ByRef(Token![ref], Mutability), |
| ByValue(Mutability), |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| ast_enum! { |
| #[cfg_attr(feature = "clone-impls", derive(Copy))] |
| pub enum InPlaceKind { |
| Arrow(Token![<-]), |
| In(Token![in]), |
| } |
| } |
| |
| #[cfg(any(feature = "parsing", feature = "printing"))] |
| #[cfg(feature = "full")] |
| fn arm_expr_requires_comma(expr: &Expr) -> bool { |
| // see https://github.com/rust-lang/rust/blob/eb8f2586e |
| // /src/libsyntax/parse/classify.rs#L17-L37 |
| match expr.node { |
| ExprKind::Unsafe(..) | |
| ExprKind::Block(..) | |
| ExprKind::If(..) | |
| ExprKind::IfLet(..) | |
| ExprKind::Match(..) | |
| ExprKind::While(..) | |
| ExprKind::WhileLet(..) | |
| ExprKind::Loop(..) | |
| ExprKind::ForLoop(..) | |
| ExprKind::Catch(..) => false, |
| _ => true, |
| } |
| } |
| |
| #[cfg(feature = "parsing")] |
| pub mod parsing { |
| use super::*; |
| use ty::parsing::qpath; |
| |
| #[cfg(feature = "full")] |
| use proc_macro2::{TokenStream, TokenNode, Delimiter, Term}; |
| use synom::{PResult, Cursor, Synom}; |
| #[cfg(feature = "full")] |
| use synom::parse_error; |
| |
| /// When we're parsing expressions which occur before blocks, like in |
| /// an if statement's condition, we cannot parse a struct literal. |
| /// |
| /// Struct literals are ambiguous in certain positions |
| /// https://github.com/rust-lang/rfcs/pull/92 |
| macro_rules! ambiguous_expr { |
| ($i:expr, $allow_struct:ident) => { |
| ambiguous_expr($i, $allow_struct, true) |
| }; |
| } |
| |
| /// When we are parsing an optional suffix expression, we cannot allow |
| /// blocks if structs are not allowed. |
| /// |
| /// Example: |
| /// ```ignore |
| /// if break { } { } |
| /// // is ambiguous between: |
| /// if (break { }) { } |
| /// // - or - |
| /// if (break) { } { } |
| /// ``` |
| #[cfg(feature = "full")] |
| macro_rules! opt_ambiguous_expr { |
| ($i:expr, $allow_struct:ident) => { |
| option!($i, call!(ambiguous_expr, $allow_struct, $allow_struct)) |
| }; |
| } |
| |
| impl Synom for Expr { |
| named!(parse -> Self, ambiguous_expr!(true)); |
| |
| fn description() -> Option<&'static str> { |
| Some("expression") |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| named!(expr_no_struct -> Expr, ambiguous_expr!(false)); |
| |
| /// Parse an arbitrary expression. |
| #[cfg(feature = "full")] |
| fn ambiguous_expr(i: Cursor, |
| allow_struct: bool, |
| allow_block: bool) |
| -> PResult<Expr> { |
| map!( |
| i, |
| call!(assign_expr, allow_struct, allow_block), |
| ExprKind::into |
| ) |
| } |
| |
| #[cfg(not(feature = "full"))] |
| fn ambiguous_expr(i: Cursor, |
| allow_struct: bool, |
| allow_block: bool) |
| -> PResult<Expr> { |
| map!( |
| i, |
| // NOTE: We intentionally skip assign_expr, placement_expr, and |
| // range_expr, as they are not parsed in non-full mode. |
| call!(or_expr, allow_struct, allow_block), |
| ExprKind::into |
| ) |
| } |
| |
| /// Parse a left-associative binary operator. |
| macro_rules! binop { |
| ( |
| $name: ident, |
| $next: ident, |
| $submac: ident!( $($args:tt)* ) |
| ) => { |
| named!($name(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!( |
| mut e: call!($next, allow_struct, allow_block) >> |
| many0!(do_parse!( |
| op: $submac!($($args)*) >> |
| rhs: call!($next, allow_struct, true) >> |
| ({ |
| e = ExprBinary { |
| left: Box::new(e.into()), |
| op: op, |
| right: Box::new(rhs.into()), |
| }.into(); |
| }) |
| )) >> |
| (e) |
| )); |
| } |
| } |
| |
| /// ```ignore |
| /// <placement> = <placement> .. |
| /// <placement> += <placement> .. |
| /// <placement> -= <placement> .. |
| /// <placement> *= <placement> .. |
| /// <placement> /= <placement> .. |
| /// <placement> %= <placement> .. |
| /// <placement> ^= <placement> .. |
| /// <placement> &= <placement> .. |
| /// <placement> |= <placement> .. |
| /// <placement> <<= <placement> .. |
| /// <placement> >>= <placement> .. |
| /// ``` |
| /// |
| /// NOTE: This operator is right-associative. |
| #[cfg(feature = "full")] |
| named!(assign_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!( |
| mut e: call!(placement_expr, allow_struct, allow_block) >> |
| alt!( |
| do_parse!( |
| eq: punct!(=) >> |
| // Recurse into self to parse right-associative operator. |
| rhs: call!(assign_expr, allow_struct, true) >> |
| ({ |
| e = ExprAssign { |
| left: Box::new(e.into()), |
| eq_token: eq, |
| right: Box::new(rhs.into()), |
| }.into(); |
| }) |
| ) |
| | |
| do_parse!( |
| op: call!(BinOp::parse_assign_op) >> |
| // Recurse into self to parse right-associative operator. |
| rhs: call!(assign_expr, allow_struct, true) >> |
| ({ |
| e = ExprAssignOp { |
| left: Box::new(e.into()), |
| op: op, |
| right: Box::new(rhs.into()), |
| }.into(); |
| }) |
| ) |
| | |
| epsilon!() |
| ) >> |
| (e) |
| )); |
| |
| /// ```ignore |
| /// <range> <- <range> .. |
| /// ``` |
| /// |
| /// NOTE: The `in place { expr }` version of this syntax is parsed in |
| /// `atom_expr`, not here. |
| /// |
| /// NOTE: This operator is right-associative. |
| #[cfg(feature = "full")] |
| named!(placement_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!( |
| mut e: call!(range_expr, allow_struct, allow_block) >> |
| alt!( |
| do_parse!( |
| arrow: punct!(<-) >> |
| // Recurse into self to parse right-associative operator. |
| rhs: call!(placement_expr, allow_struct, true) >> |
| ({ |
| e = ExprInPlace { |
| // op: BinOp::Place(larrow), |
| place: Box::new(e.into()), |
| kind: InPlaceKind::Arrow(arrow), |
| value: Box::new(rhs.into()), |
| }.into(); |
| }) |
| ) |
| | |
| epsilon!() |
| ) >> |
| (e) |
| )); |
| |
| /// ```ignore |
| /// <or> ... <or> .. |
| /// <or> .. <or> .. |
| /// <or> .. |
| /// ``` |
| /// |
| /// NOTE: This is currently parsed oddly - I'm not sure of what the exact |
| /// rules are for parsing these expressions are, but this is not correct. |
| /// For example, `a .. b .. c` is not a legal expression. It should not |
| /// be parsed as either `(a .. b) .. c` or `a .. (b .. c)` apparently. |
| /// |
| /// NOTE: The form of ranges which don't include a preceding expression are |
| /// parsed by `atom_expr`, rather than by this function. |
| #[cfg(feature = "full")] |
| named!(range_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!( |
| mut e: call!(or_expr, allow_struct, allow_block) >> |
| many0!(do_parse!( |
| limits: syn!(RangeLimits) >> |
| // We don't want to allow blocks here if we don't allow structs. See |
| // the reasoning for `opt_ambiguous_expr!` above. |
| hi: option!(call!(or_expr, allow_struct, allow_struct)) >> |
| ({ |
| e = ExprRange { |
| from: Some(Box::new(e.into())), |
| limits: limits, |
| to: hi.map(|e| Box::new(e.into())), |
| }.into(); |
| }) |
| )) >> |
| (e) |
| )); |
| |
| /// ```ignore |
| /// <and> || <and> ... |
| /// ``` |
| binop!(or_expr, and_expr, map!(punct!(||), BinOp::Or)); |
| |
| /// ```ignore |
| /// <compare> && <compare> ... |
| /// ``` |
| binop!(and_expr, compare_expr, map!(punct!(&&), BinOp::And)); |
| |
| /// ```ignore |
| /// <bitor> == <bitor> ... |
| /// <bitor> != <bitor> ... |
| /// <bitor> >= <bitor> ... |
| /// <bitor> <= <bitor> ... |
| /// <bitor> > <bitor> ... |
| /// <bitor> < <bitor> ... |
| /// ``` |
| /// |
| /// NOTE: This operator appears to be parsed as left-associative, but errors |
| /// if it is used in a non-associative manner. |
| binop!(compare_expr, bitor_expr, alt!( |
| punct!(==) => { BinOp::Eq } |
| | |
| punct!(!=) => { BinOp::Ne } |
| | |
| // must be above Lt |
| punct!(<=) => { BinOp::Le } |
| | |
| // must be above Gt |
| punct!(>=) => { BinOp::Ge } |
| | |
| do_parse!( |
| // Make sure that we don't eat the < part of a <- operator |
| not!(punct!(<-)) >> |
| t: punct!(<) >> |
| (BinOp::Lt(t)) |
| ) |
| | |
| punct!(>) => { BinOp::Gt } |
| )); |
| |
| /// ```ignore |
| /// <bitxor> | <bitxor> ... |
| /// ``` |
| binop!(bitor_expr, bitxor_expr, do_parse!( |
| not!(punct!(||)) >> |
| not!(punct!(|=)) >> |
| t: punct!(|) >> |
| (BinOp::BitOr(t)) |
| )); |
| |
| /// ```ignore |
| /// <bitand> ^ <bitand> ... |
| /// ``` |
| binop!(bitxor_expr, bitand_expr, do_parse!( |
| // NOTE: Make sure we aren't looking at ^=. |
| not!(punct!(^=)) >> |
| t: punct!(^) >> |
| (BinOp::BitXor(t)) |
| )); |
| |
| /// ```ignore |
| /// <shift> & <shift> ... |
| /// ``` |
| binop!(bitand_expr, shift_expr, do_parse!( |
| // NOTE: Make sure we aren't looking at && or &=. |
| not!(punct!(&&)) >> |
| not!(punct!(&=)) >> |
| t: punct!(&) >> |
| (BinOp::BitAnd(t)) |
| )); |
| |
| /// ```ignore |
| /// <arith> << <arith> ... |
| /// <arith> >> <arith> ... |
| /// ``` |
| binop!(shift_expr, arith_expr, alt!( |
| punct!(<<) => { BinOp::Shl } |
| | |
| punct!(>>) => { BinOp::Shr } |
| )); |
| |
| /// ```ignore |
| /// <term> + <term> ... |
| /// <term> - <term> ... |
| /// ``` |
| binop!(arith_expr, term_expr, alt!( |
| punct!(+) => { BinOp::Add } |
| | |
| punct!(-) => { BinOp::Sub } |
| )); |
| |
| /// ```ignore |
| /// <cast> * <cast> ... |
| /// <cast> / <cast> ... |
| /// <cast> % <cast> ... |
| /// ``` |
| binop!(term_expr, cast_expr, alt!( |
| punct!(*) => { BinOp::Mul } |
| | |
| punct!(/) => { BinOp::Div } |
| | |
| punct!(%) => { BinOp::Rem } |
| )); |
| |
| /// ```ignore |
| /// <unary> as <ty> |
| /// <unary> : <ty> |
| /// ``` |
| named!(cast_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!( |
| mut e: call!(unary_expr, allow_struct, allow_block) >> |
| many0!(alt!( |
| do_parse!( |
| as_: keyword!(as) >> |
| // We can't accept `A + B` in cast expressions, as it's |
| // ambiguous with the + expression. |
| ty: call!(Type::without_plus) >> |
| ({ |
| e = ExprCast { |
| expr: Box::new(e.into()), |
| as_token: as_, |
| ty: Box::new(ty), |
| }.into(); |
| }) |
| ) |
| | |
| do_parse!( |
| colon: punct!(:) >> |
| // We can't accept `A + B` in cast expressions, as it's |
| // ambiguous with the + expression. |
| ty: call!(Type::without_plus) >> |
| ({ |
| e = ExprType { |
| expr: Box::new(e.into()), |
| colon_token: colon, |
| ty: Box::new(ty), |
| }.into(); |
| }) |
| ) |
| )) >> |
| (e) |
| )); |
| |
| /// ``` |
| /// <UnOp> <trailer> |
| /// & <trailer> |
| /// &mut <trailer> |
| /// box <trailer> |
| /// ``` |
| #[cfg(feature = "full")] |
| named!(unary_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!( |
| do_parse!( |
| op: syn!(UnOp) >> |
| expr: call!(unary_expr, allow_struct, true) >> |
| (ExprUnary { |
| op: op, |
| expr: Box::new(expr.into()), |
| }.into()) |
| ) |
| | |
| do_parse!( |
| and: punct!(&) >> |
| mutability: syn!(Mutability) >> |
| expr: call!(unary_expr, allow_struct, true) >> |
| (ExprAddrOf { |
| and_token: and, |
| mutbl: mutability, |
| expr: Box::new(expr.into()), |
| }.into()) |
| ) |
| | |
| do_parse!( |
| box_: keyword!(box) >> |
| expr: call!(unary_expr, allow_struct, true) >> |
| (ExprBox { |
| box_token: box_, |
| expr: Box::new(expr.into()), |
| }.into()) |
| ) |
| | |
| call!(trailer_expr, allow_struct, allow_block) |
| )); |
| |
| // XXX: This duplication is ugly |
| #[cfg(not(feature = "full"))] |
| named!(unary_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!( |
| do_parse!( |
| op: syn!(UnOp) >> |
| expr: call!(unary_expr, allow_struct, true) >> |
| (ExprUnary { |
| op: op, |
| expr: Box::new(expr.into()), |
| }.into()) |
| ) |
| | |
| call!(trailer_expr, allow_struct, allow_block) |
| )); |
| |
| /// ```ignore |
| /// <atom> (..<args>) ... |
| /// <atom> . <ident> (..<args>) ... |
| /// <atom> . <ident> ... |
| /// <atom> . <lit> ... |
| /// <atom> [ <expr> ] ... |
| /// <atom> ? ... |
| /// ``` |
| #[cfg(feature = "full")] |
| named!(trailer_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!( |
| mut e: call!(atom_expr, allow_struct, allow_block) >> |
| many0!(alt!( |
| tap!(args: and_call => { |
| let (args, paren) = args; |
| e = ExprCall { |
| func: Box::new(e.into()), |
| args: args, |
| paren_token: paren, |
| }.into(); |
| }) |
| | |
| tap!(more: and_method_call => { |
| let mut call = more; |
| call.expr = Box::new(e.into()); |
| e = call.into(); |
| }) |
| | |
| tap!(field: and_field => { |
| let (field, token) = field; |
| e = ExprField { |
| expr: Box::new(e.into()), |
| field: field, |
| dot_token: token, |
| }.into(); |
| }) |
| | |
| tap!(field: and_tup_field => { |
| let (field, token) = field; |
| e = ExprTupField { |
| expr: Box::new(e.into()), |
| field: field, |
| dot_token: token, |
| }.into(); |
| }) |
| | |
| tap!(i: and_index => { |
| let (i, token) = i; |
| e = ExprIndex { |
| expr: Box::new(e.into()), |
| bracket_token: token, |
| index: Box::new(i), |
| }.into(); |
| }) |
| | |
| tap!(question: punct!(?) => { |
| e = ExprTry { |
| expr: Box::new(e.into()), |
| question_token: question, |
| }.into(); |
| }) |
| )) >> |
| (e) |
| )); |
| |
| // XXX: Duplication == ugly |
| #[cfg(not(feature = "full"))] |
| named!(trailer_expr(allow_struct: bool, allow_block: bool) -> ExprKind, do_parse!( |
| mut e: call!(atom_expr, allow_struct, allow_block) >> |
| many0!(alt!( |
| tap!(args: and_call => { |
| let (args, paren) = args; |
| e = ExprCall { |
| func: Box::new(e.into()), |
| args: args, |
| paren_token: paren, |
| }.into(); |
| }) |
| | |
| tap!(i: and_index => { |
| let (i, token) = i; |
| e = ExprIndex { |
| expr: Box::new(e.into()), |
| bracket_token: token, |
| index: Box::new(i), |
| }.into(); |
| }) |
| )) >> |
| (e) |
| )); |
| |
| /// Parse all atomic expressions which don't have to worry about precidence |
| /// interactions, as they are fully contained. |
| #[cfg(feature = "full")] |
| named!(atom_expr(allow_struct: bool, allow_block: bool) -> ExprKind, alt!( |
| syn!(ExprGroup) => { ExprKind::Group } // must be placed first |
| | |
| syn!(Lit) => { ExprKind::Lit } // must be before expr_struct |
| | |
| // must be before expr_path |
| cond_reduce!(allow_struct, map!(syn!(ExprStruct), ExprKind::Struct)) |
| | |
| syn!(ExprParen) => { ExprKind::Paren } // must be before expr_tup |
| | |
| syn!(Macro) => { ExprKind::Macro } // must be before expr_path |
| | |
| call!(expr_break, allow_struct) // must be before expr_path |
| | |
| syn!(ExprContinue) => { ExprKind::Continue } // must be before expr_path |
| | |
| call!(expr_ret, allow_struct) // must be before expr_path |
| | |
| // NOTE: The `in place { expr }` form. `place <- expr` is parsed above. |
| syn!(ExprInPlace) => { ExprKind::InPlace } |
| | |
| syn!(ExprArray) => { ExprKind::Array } |
| | |
| syn!(ExprTup) => { ExprKind::Tup } |
| | |
| syn!(ExprIf) => { ExprKind::If } |
| | |
| syn!(ExprIfLet) => { ExprKind::IfLet } |
| | |
| syn!(ExprWhile) => { ExprKind::While } |
| | |
| syn!(ExprWhileLet) => { ExprKind::WhileLet } |
| | |
| syn!(ExprForLoop) => { ExprKind::ForLoop } |
| | |
| syn!(ExprLoop) => { ExprKind::Loop } |
| | |
| syn!(ExprMatch) => { ExprKind::Match } |
| | |
| syn!(ExprCatch) => { ExprKind::Catch } |
| | |
| syn!(ExprYield) => { ExprKind::Yield } |
| | |
| syn!(ExprUnsafe) => { ExprKind::Unsafe } |
| | |
| call!(expr_closure, allow_struct) |
| | |
| cond_reduce!(allow_block, map!(syn!(ExprBlock), ExprKind::Block)) |
| | |
| // NOTE: This is the prefix-form of range |
| call!(expr_range, allow_struct) |
| | |
| syn!(ExprPath) => { ExprKind::Path } |
| | |
| syn!(ExprRepeat) => { ExprKind::Repeat } |
| )); |
| |
| #[cfg(not(feature = "full"))] |
| named!(atom_expr(_allow_struct: bool, _allow_block: bool) -> ExprKind, alt!( |
| syn!(ExprGroup) => { ExprKind::Group } // must be placed first |
| | |
| syn!(Lit) => { ExprKind::Lit } // must be before expr_struct |
| | |
| syn!(ExprParen) => { ExprKind::Paren } // must be before expr_tup |
| | |
| syn!(Macro) => { ExprKind::Macro } // must be before expr_path |
| | |
| syn!(ExprPath) => { ExprKind::Path } |
| )); |
| |
| |
| #[cfg(feature = "full")] |
| named!(expr_nosemi -> Expr, map!(alt!( |
| syn!(ExprIf) => { ExprKind::If } |
| | |
| syn!(ExprIfLet) => { ExprKind::IfLet } |
| | |
| syn!(ExprWhile) => { ExprKind::While } |
| | |
| syn!(ExprWhileLet) => { ExprKind::WhileLet } |
| | |
| syn!(ExprForLoop) => { ExprKind::ForLoop } |
| | |
| syn!(ExprLoop) => { ExprKind::Loop } |
| | |
| syn!(ExprMatch) => { ExprKind::Match } |
| | |
| syn!(ExprCatch) => { ExprKind::Catch } |
| | |
| syn!(ExprYield) => { ExprKind::Yield } |
| | |
| syn!(ExprUnsafe) => { ExprKind::Unsafe } |
| | |
| syn!(ExprBlock) => { ExprKind::Block } |
| ), Expr::from)); |
| |
| impl Synom for ExprGroup { |
| named!(parse -> Self, do_parse!( |
| e: grouped!(syn!(Expr)) >> |
| (ExprGroup { |
| expr: Box::new(e.0), |
| group_token: e.1, |
| }.into()) |
| )); |
| } |
| |
| impl Synom for ExprParen { |
| named!(parse -> Self, do_parse!( |
| e: parens!(syn!(Expr)) >> |
| (ExprParen { |
| expr: Box::new(e.0), |
| paren_token: e.1, |
| }.into()) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprInPlace { |
| named!(parse -> Self, do_parse!( |
| in_: keyword!(in) >> |
| place: expr_no_struct >> |
| value: braces!(call!(Block::parse_within)) >> |
| (ExprInPlace { |
| place: Box::new(place), |
| kind: InPlaceKind::In(in_), |
| value: Box::new(Expr { |
| node: ExprBlock { |
| block: Block { |
| stmts: value.0, |
| brace_token: value.1, |
| }, |
| }.into(), |
| attrs: Vec::new(), |
| }), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprArray { |
| named!(parse -> Self, do_parse!( |
| elems: brackets!(call!(Delimited::parse_terminated)) >> |
| (ExprArray { |
| exprs: elems.0, |
| bracket_token: elems.1, |
| }) |
| )); |
| } |
| |
| named!(and_call -> (Delimited<Expr, Token![,]>, tokens::Paren), |
| parens!(call!(Delimited::parse_terminated))); |
| |
| #[cfg(feature = "full")] |
| named!(and_method_call -> ExprMethodCall, do_parse!( |
| dot: punct!(.) >> |
| method: syn!(Ident) >> |
| typarams: option!(do_parse!( |
| colon2: punct!(::) >> |
| lt: punct!(<) >> |
| tys: call!(Delimited::parse_terminated) >> |
| gt: punct!(>) >> |
| (colon2, lt, tys, gt) |
| )) >> |
| args: parens!(call!(Delimited::parse_terminated)) >> |
| ({ |
| let (colon2, lt, tys, gt) = match typarams { |
| Some((a, b, c, d)) => (Some(a), Some(b), Some(c), Some(d)), |
| None => (None, None, None, None), |
| }; |
| ExprMethodCall { |
| // this expr will get overwritten after being returned |
| expr: Box::new(ExprKind::Lit(Lit { |
| span: Span::default(), |
| value: LitKind::Bool(false), |
| }).into()), |
| |
| method: method, |
| args: args.0, |
| paren_token: args.1, |
| dot_token: dot, |
| lt_token: lt, |
| gt_token: gt, |
| colon2_token: colon2, |
| typarams: tys.unwrap_or_default(), |
| } |
| }) |
| )); |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprTup { |
| named!(parse -> Self, do_parse!( |
| elems: parens!(call!(Delimited::parse_terminated)) >> |
| (ExprTup { |
| args: elems.0, |
| paren_token: elems.1, |
| lone_comma: None, // TODO: parse this |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprIfLet { |
| named!(parse -> Self, do_parse!( |
| if_: keyword!(if) >> |
| let_: keyword!(let) >> |
| pat: syn!(Pat) >> |
| eq: punct!(=) >> |
| cond: expr_no_struct >> |
| then_block: braces!(call!(Block::parse_within)) >> |
| else_block: option!(else_block) >> |
| (ExprIfLet { |
| pat: Box::new(pat), |
| let_token: let_, |
| eq_token: eq, |
| expr: Box::new(cond), |
| if_true: Block { |
| stmts: then_block.0, |
| brace_token: then_block.1, |
| }, |
| if_token: if_, |
| else_token: else_block.as_ref().map(|p| Token.0)), |
| if_false: else_block.map(|p| Box::new(p.1.into())), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprIf { |
| named!(parse -> Self, do_parse!( |
| if_: keyword!(if) >> |
| cond: expr_no_struct >> |
| then_block: braces!(call!(Block::parse_within)) >> |
| else_block: option!(else_block) >> |
| (ExprIf { |
| cond: Box::new(cond), |
| if_true: Block { |
| stmts: then_block.0, |
| brace_token: then_block.1, |
| }, |
| if_token: if_, |
| else_token: else_block.as_ref().map(|p| Token.0)), |
| if_false: else_block.map(|p| Box::new(p.1.into())), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(else_block -> (Token![else], ExprKind), do_parse!( |
| else_: keyword!(else) >> |
| expr: alt!( |
| syn!(ExprIf) => { ExprKind::If } |
| | |
| syn!(ExprIfLet) => { ExprKind::IfLet } |
| | |
| do_parse!( |
| else_block: braces!(call!(Block::parse_within)) >> |
| (ExprKind::Block(ExprBlock { |
| block: Block { |
| stmts: else_block.0, |
| brace_token: else_block.1, |
| }, |
| })) |
| ) |
| ) >> |
| (else_, expr) |
| )); |
| |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprForLoop { |
| named!(parse -> Self, do_parse!( |
| lbl: option!(tuple!(syn!(Lifetime), punct!(:))) >> |
| for_: keyword!(for) >> |
| pat: syn!(Pat) >> |
| in_: keyword!(in) >> |
| expr: expr_no_struct >> |
| loop_block: syn!(Block) >> |
| (ExprForLoop { |
| for_token: for_, |
| in_token: in_, |
| pat: Box::new(pat), |
| expr: Box::new(expr), |
| body: loop_block, |
| colon_token: lbl.as_ref().map(|p| Token.0)), |
| label: lbl.map(|p| p.0), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprLoop { |
| named!(parse -> Self, do_parse!( |
| lbl: option!(tuple!(syn!(Lifetime), punct!(:))) >> |
| loop_: keyword!(loop) >> |
| loop_block: syn!(Block) >> |
| (ExprLoop { |
| loop_token: loop_, |
| body: loop_block, |
| colon_token: lbl.as_ref().map(|p| Token.0)), |
| label: lbl.map(|p| p.0), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprMatch { |
| named!(parse -> Self, do_parse!( |
| match_: keyword!(match) >> |
| obj: expr_no_struct >> |
| res: braces!(many0!(syn!(Arm))) >> |
| ({ |
| let (arms, brace) = res; |
| ExprMatch { |
| expr: Box::new(obj), |
| match_token: match_, |
| brace_token: brace, |
| arms: arms, |
| } |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprCatch { |
| named!(parse -> Self, do_parse!( |
| do_: keyword!(do) >> |
| catch_: keyword!(catch) >> |
| catch_block: syn!(Block) >> |
| (ExprCatch { |
| block: catch_block, |
| do_token: do_, |
| catch_token: catch_, |
| }.into()) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprYield { |
| named!(parse -> Self, do_parse!( |
| yield_: keyword!(yield) >> |
| expr: option!(syn!(Expr)) >> |
| (ExprYield { |
| yield_token: yield_, |
| expr: expr.map(Box::new), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for Arm { |
| named!(parse -> Self, do_parse!( |
| attrs: many0!(call!(Attribute::parse_outer)) >> |
| pats: call!(Delimited::parse_separated_nonempty) >> |
| guard: option!(tuple!(keyword!(if), syn!(Expr))) >> |
| rocket: punct!(=>) >> |
| body: do_parse!( |
| expr: alt!(expr_nosemi | syn!(Expr)) >> |
| comma1: cond!(arm_expr_requires_comma(&expr), alt!( |
| map!(input_end!(), |_| None) |
| | |
| map!(punct!(,), Some) |
| )) >> |
| comma2: cond!(!arm_expr_requires_comma(&expr), option!(punct!(,))) >> |
| (expr, comma1.and_then(|x| x).or(comma2.and_then(|x| x))) |
| ) >> |
| (Arm { |
| rocket_token: rocket, |
| if_token: guard.as_ref().map(|p| Token.0)), |
| attrs: attrs, |
| pats: pats, |
| guard: guard.map(|p| Box::new(p.1)), |
| body: Box::new(body.0), |
| comma: body.1, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(expr_closure(allow_struct: bool) -> ExprKind, do_parse!( |
| capture: syn!(CaptureBy) >> |
| or1: punct!(|) >> |
| inputs: call!(Delimited::parse_terminated_with, fn_arg) >> |
| or2: punct!(|) >> |
| ret_and_body: alt!( |
| do_parse!( |
| arrow: punct!(->) >> |
| ty: syn!(Type) >> |
| body: syn!(Block) >> |
| (ReturnType::Type(ty, arrow), |
| ExprKind::Block(ExprBlock { |
| block: body, |
| }).into()) |
| ) |
| | |
| map!(ambiguous_expr!(allow_struct), |e| (ReturnType::Default, e)) |
| ) >> |
| (ExprClosure { |
| capture: capture, |
| or1_token: or1, |
| or2_token: or2, |
| decl: Box::new(FnDecl { |
| inputs: inputs, |
| output: ret_and_body.0, |
| variadic: false, |
| dot_tokens: None, |
| fn_token: <Token![fn]>::default(), |
| generics: Generics::default(), |
| paren_token: tokens::Paren::default(), |
| }), |
| body: Box::new(ret_and_body.1), |
| }.into()) |
| )); |
| |
| #[cfg(feature = "full")] |
| named!(fn_arg -> FnArg, do_parse!( |
| pat: syn!(Pat) >> |
| ty: option!(tuple!(punct!(:), syn!(Type))) >> |
| ({ |
| let (colon, ty) = ty.unwrap_or_else(|| { |
| (<Token![:]>::default(), TypeInfer { |
| underscore_token: <Token![_]>::default(), |
| }.into()) |
| }); |
| ArgCaptured { |
| pat: pat, |
| colon_token: colon, |
| ty: ty, |
| }.into() |
| }) |
| )); |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprWhile { |
| named!(parse -> Self, do_parse!( |
| lbl: option!(tuple!(syn!(Lifetime), punct!(:))) >> |
| while_: keyword!(while) >> |
| cond: expr_no_struct >> |
| while_block: syn!(Block) >> |
| (ExprWhile { |
| while_token: while_, |
| colon_token: lbl.as_ref().map(|p| Token.0)), |
| cond: Box::new(cond), |
| body: while_block, |
| label: lbl.map(|p| p.0), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprWhileLet { |
| named!(parse -> Self, do_parse!( |
| lbl: option!(tuple!(syn!(Lifetime), punct!(:))) >> |
| while_: keyword!(while) >> |
| let_: keyword!(let) >> |
| pat: syn!(Pat) >> |
| eq: punct!(=) >> |
| value: expr_no_struct >> |
| while_block: syn!(Block) >> |
| (ExprWhileLet { |
| eq_token: eq, |
| let_token: let_, |
| while_token: while_, |
| colon_token: lbl.as_ref().map(|p| Token.0)), |
| pat: Box::new(pat), |
| expr: Box::new(value), |
| body: while_block, |
| label: lbl.map(|p| p.0), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprContinue { |
| named!(parse -> Self, do_parse!( |
| cont: keyword!(continue) >> |
| lbl: option!(syn!(Lifetime)) >> |
| (ExprContinue { |
| continue_token: cont, |
| label: lbl, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(expr_break(allow_struct: bool) -> ExprKind, do_parse!( |
| break_: keyword!(break) >> |
| lbl: option!(syn!(Lifetime)) >> |
| // We can't allow blocks after a `break` expression when we wouldn't |
| // allow structs, as this expression is ambiguous. |
| val: opt_ambiguous_expr!(allow_struct) >> |
| (ExprBreak { |
| label: lbl, |
| expr: val.map(Box::new), |
| break_token: break_, |
| }.into()) |
| )); |
| |
| #[cfg(feature = "full")] |
| named!(expr_ret(allow_struct: bool) -> ExprKind, do_parse!( |
| return_: keyword!(return) >> |
| // NOTE: return is greedy and eats blocks after it even when in a |
| // position where structs are not allowed, such as in if statement |
| // conditions. For example: |
| // |
| // if return { println!("A") } { } // Prints "A" |
| ret_value: option!(ambiguous_expr!(allow_struct)) >> |
| (ExprRet { |
| expr: ret_value.map(Box::new), |
| return_token: return_, |
| }.into()) |
| )); |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprStruct { |
| named!(parse -> Self, do_parse!( |
| path: syn!(Path) >> |
| data: braces!(do_parse!( |
| fields: call!(Delimited::parse_terminated) >> |
| base: option!( |
| cond!(fields.is_empty() || fields.trailing_delim(), |
| do_parse!( |
| dots: punct!(..) >> |
| base: syn!(Expr) >> |
| (dots, base) |
| ) |
| ) |
| ) >> |
| (fields, base) |
| )) >> |
| ({ |
| let ((fields, base), brace) = data; |
| let (dots, rest) = match base.and_then(|b| b) { |
| Some((dots, base)) => (Some(dots), Some(base)), |
| None => (None, None), |
| }; |
| ExprStruct { |
| brace_token: brace, |
| path: path, |
| fields: fields, |
| dot2_token: dots, |
| rest: rest.map(Box::new), |
| } |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for FieldValue { |
| named!(parse -> Self, alt!( |
| do_parse!( |
| ident: field_ident >> |
| colon: punct!(:) >> |
| value: syn!(Expr) >> |
| (FieldValue { |
| ident: ident, |
| expr: value, |
| is_shorthand: false, |
| attrs: Vec::new(), |
| colon_token: Some(colon), |
| }) |
| ) |
| | |
| map!(syn!(Ident), |name| FieldValue { |
| ident: name.clone(), |
| expr: ExprKind::Path(ExprPath { qself: None, path: name.into() }).into(), |
| is_shorthand: true, |
| attrs: Vec::new(), |
| colon_token: None, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprRepeat { |
| named!(parse -> Self, do_parse!( |
| data: brackets!(do_parse!( |
| value: syn!(Expr) >> |
| semi: punct!(;) >> |
| times: syn!(Expr) >> |
| (value, semi, times) |
| )) >> |
| (ExprRepeat { |
| expr: Box::new((data.0).0), |
| amt: Box::new((data.0).2), |
| bracket_token: data.1, |
| semi_token: (data.0).1, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprUnsafe { |
| named!(parse -> Self, do_parse!( |
| unsafe_: keyword!(unsafe) >> |
| b: syn!(Block) >> |
| (ExprUnsafe { |
| unsafe_token: unsafe_, |
| block: b, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for ExprBlock { |
| named!(parse -> Self, do_parse!( |
| b: syn!(Block) >> |
| (ExprBlock { |
| block: b, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(expr_range(allow_struct: bool) -> ExprKind, do_parse!( |
| limits: syn!(RangeLimits) >> |
| hi: opt_ambiguous_expr!(allow_struct) >> |
| (ExprRange { from: None, to: hi.map(Box::new), limits: limits }.into()) |
| )); |
| |
| #[cfg(feature = "full")] |
| impl Synom for RangeLimits { |
| named!(parse -> Self, alt!( |
| // Must come before Dot2 |
| punct!(...) => { RangeLimits::Closed } |
| | |
| punct!(..) => { RangeLimits::HalfOpen } |
| )); |
| } |
| |
| impl Synom for ExprPath { |
| named!(parse -> Self, do_parse!( |
| pair: qpath >> |
| (ExprPath { |
| qself: pair.0, |
| path: pair.1, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(and_field -> (Ident, Token![.]), |
| map!(tuple!(punct!(.), syn!(Ident)), |(a, b)| (b, a))); |
| |
| #[cfg(feature = "full")] |
| named!(and_tup_field -> (Lit, Token![.]), |
| map!(tuple!(punct!(.), syn!(Lit)), |(a, b)| (b, a))); |
| |
| named!(and_index -> (Expr, tokens::Bracket), brackets!(syn!(Expr))); |
| |
| #[cfg(feature = "full")] |
| impl Synom for Block { |
| named!(parse -> Self, do_parse!( |
| stmts: braces!(call!(Block::parse_within)) >> |
| (Block { |
| stmts: stmts.0, |
| brace_token: stmts.1, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Block { |
| named!(pub parse_within -> Vec<Stmt>, do_parse!( |
| many0!(punct!(;)) >> |
| mut standalone: many0!(terminated!(syn!(Stmt), many0!(punct!(;)))) >> |
| last: option!(do_parse!( |
| attrs: many0!(call!(Attribute::parse_outer)) >> |
| mut e: syn!(Expr) >> |
| ({ |
| e.attrs = attrs; |
| Stmt::Expr(Box::new(e)) |
| }) |
| )) >> |
| (match last { |
| None => standalone, |
| Some(last) => { |
| standalone.push(last); |
| standalone |
| } |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for Stmt { |
| named!(parse -> Self, alt!( |
| stmt_mac |
| | |
| stmt_local |
| | |
| stmt_item |
| | |
| stmt_blockexpr |
| | |
| stmt_expr |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(stmt_mac -> Stmt, do_parse!( |
| attrs: many0!(call!(Attribute::parse_outer)) >> |
| what: syn!(Path) >> |
| bang: punct!(!) >> |
| // Only parse braces here; paren and bracket will get parsed as |
| // expression statements |
| data: braces!(syn!(TokenStream)) >> |
| semi: option!(punct!(;)) >> |
| (Stmt::Macro(Box::new(( |
| Macro { |
| path: what, |
| bang_token: bang, |
| tokens: vec![TokenTree(proc_macro2::TokenTree { |
| span: ((data.1).0).0, |
| kind: TokenNode::Group(Delimiter::Brace, data.0), |
| })], |
| }, |
| match semi { |
| Some(semi) => MacStmtStyle::Semicolon(semi), |
| None => MacStmtStyle::Braces, |
| }, |
| attrs, |
| )))) |
| )); |
| |
| #[cfg(feature = "full")] |
| named!(stmt_local -> Stmt, do_parse!( |
| attrs: many0!(call!(Attribute::parse_outer)) >> |
| let_: keyword!(let) >> |
| pat: syn!(Pat) >> |
| ty: option!(tuple!(punct!(:), syn!(Type))) >> |
| init: option!(tuple!(punct!(=), syn!(Expr))) >> |
| semi: punct!(;) >> |
| (Stmt::Local(Box::new(Local { |
| let_token: let_, |
| semi_token: semi, |
| colon_token: ty.as_ref().map(|p| Token.0)), |
| eq_token: init.as_ref().map(|p| Token.0)), |
| pat: Box::new(pat), |
| ty: ty.map(|p| Box::new(p.1)), |
| init: init.map(|p| Box::new(p.1)), |
| attrs: attrs, |
| }))) |
| )); |
| |
| #[cfg(feature = "full")] |
| named!(stmt_item -> Stmt, map!(syn!(Item), |i| Stmt::Item(Box::new(i)))); |
| |
| #[cfg(feature = "full")] |
| named!(stmt_blockexpr -> Stmt, do_parse!( |
| attrs: many0!(call!(Attribute::parse_outer)) >> |
| mut e: expr_nosemi >> |
| // If the next token is a `.` or a `?` it is special-cased to parse as |
| // an expression instead of a blockexpression. |
| not!(punct!(.)) >> |
| not!(punct!(?)) >> |
| semi: option!(punct!(;)) >> |
| ({ |
| e.attrs = attrs; |
| if let Some(semi) = semi { |
| Stmt::Semi(Box::new(e), semi) |
| } else { |
| Stmt::Expr(Box::new(e)) |
| } |
| }) |
| )); |
| |
| #[cfg(feature = "full")] |
| named!(stmt_expr -> Stmt, do_parse!( |
| attrs: many0!(call!(Attribute::parse_outer)) >> |
| mut e: syn!(Expr) >> |
| semi: punct!(;) >> |
| ({ |
| e.attrs = attrs; |
| Stmt::Semi(Box::new(e), semi) |
| }) |
| )); |
| |
| #[cfg(feature = "full")] |
| impl Synom for Pat { |
| named!(parse -> Self, alt!( |
| syn!(PatWild) => { Pat::Wild } // must be before pat_ident |
| | |
| syn!(PatBox) => { Pat::Box } // must be before pat_ident |
| | |
| syn!(PatRange) => { Pat::Range } // must be before pat_lit |
| | |
| syn!(PatTupleStruct) => { Pat::TupleStruct } // must be before pat_ident |
| | |
| syn!(PatStruct) => { Pat::Struct } // must be before pat_ident |
| | |
| syn!(Macro) => { Pat::Macro } // must be before pat_ident |
| | |
| syn!(PatLit) => { Pat::Lit } // must be before pat_ident |
| | |
| syn!(PatIdent) => { Pat::Ident } // must be before pat_path |
| | |
| syn!(PatPath) => { Pat::Path } |
| | |
| syn!(PatTuple) => { Pat::Tuple } |
| | |
| syn!(PatRef) => { Pat::Ref } |
| | |
| syn!(PatSlice) => { Pat::Slice } |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatWild { |
| named!(parse -> Self, map!( |
| punct!(_), |
| |u| PatWild { underscore_token: u } |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatBox { |
| named!(parse -> Self, do_parse!( |
| boxed: keyword!(box) >> |
| pat: syn!(Pat) >> |
| (PatBox { |
| pat: Box::new(pat), |
| box_token: boxed, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatIdent { |
| named!(parse -> Self, do_parse!( |
| mode: option!(keyword!(ref)) >> |
| mutability: syn!(Mutability) >> |
| name: alt!( |
| syn!(Ident) |
| | |
| keyword!(self) => { Into::into } |
| ) >> |
| not!(punct!(<)) >> |
| not!(punct!(::)) >> |
| subpat: option!(tuple!(punct!(@), syn!(Pat))) >> |
| (PatIdent { |
| mode: match mode { |
| Some(mode) => BindingMode::ByRef(mode, mutability), |
| None => BindingMode::ByValue(mutability), |
| }, |
| ident: name, |
| at_token: subpat.as_ref().map(|p| Token.0)), |
| subpat: subpat.map(|p| Box::new(p.1)), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatTupleStruct { |
| named!(parse -> Self, do_parse!( |
| path: syn!(Path) >> |
| tuple: syn!(PatTuple) >> |
| (PatTupleStruct { |
| path: path, |
| pat: tuple, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatStruct { |
| named!(parse -> Self, do_parse!( |
| path: syn!(Path) >> |
| data: braces!(do_parse!( |
| fields: call!(Delimited::parse_terminated) >> |
| base: option!( |
| cond!(fields.is_empty() || fields.trailing_delim(), |
| punct!(..)) |
| ) >> |
| (fields, base) |
| )) >> |
| (PatStruct { |
| path: path, |
| fields: (data.0).0, |
| brace_token: data.1, |
| dot2_token: (data.0).1.and_then(|m| m), |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for FieldPat { |
| named!(parse -> Self, alt!( |
| do_parse!( |
| ident: field_ident >> |
| colon: punct!(:) >> |
| pat: syn!(Pat) >> |
| (FieldPat { |
| ident: ident, |
| pat: Box::new(pat), |
| is_shorthand: false, |
| attrs: Vec::new(), |
| colon_token: Some(colon), |
| }) |
| ) |
| | |
| do_parse!( |
| boxed: option!(keyword!(box)) >> |
| mode: option!(keyword!(ref)) >> |
| mutability: syn!(Mutability) >> |
| ident: syn!(Ident) >> |
| ({ |
| let mut pat: Pat = PatIdent { |
| mode: if let Some(mode) = mode { |
| BindingMode::ByRef(mode, mutability) |
| } else { |
| BindingMode::ByValue(mutability) |
| }, |
| ident: ident.clone(), |
| subpat: None, |
| at_token: None, |
| }.into(); |
| if let Some(boxed) = boxed { |
| pat = PatBox { |
| pat: Box::new(pat), |
| box_token: boxed, |
| }.into(); |
| } |
| FieldPat { |
| ident: ident, |
| pat: Box::new(pat), |
| is_shorthand: true, |
| attrs: Vec::new(), |
| colon_token: None, |
| } |
| }) |
| ) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(field_ident -> Ident, alt!( |
| syn!(Ident) |
| | |
| do_parse!( |
| lit: syn!(Lit) >> |
| ({ |
| let s = lit.to_string(); |
| if s.parse::<usize>().is_ok() { |
| Ident::new(Term::intern(&s), lit.span) |
| } else { |
| return parse_error(); |
| } |
| }) |
| ) |
| )); |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatPath { |
| named!(parse -> Self, map!( |
| syn!(ExprPath), |
| |p| PatPath { qself: p.qself, path: p.path } |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatTuple { |
| named!(parse -> Self, do_parse!( |
| data: parens!(do_parse!( |
| elems: call!(Delimited::parse_terminated) >> |
| dotdot: map!(cond!( |
| elems.is_empty() || elems.trailing_delim(), |
| option!(do_parse!( |
| dots: punct!(..) >> |
| trailing: option!(punct!(,)) >> |
| (dots, trailing) |
| )) |
| ), |x| x.and_then(|x| x)) >> |
| rest: cond!(match dotdot { |
| Some((_, Some(_))) => true, |
| _ => false, |
| }, |
| call!(Delimited::parse_terminated)) >> |
| (elems, dotdot, rest) |
| )) >> |
| ({ |
| let ((mut elems, dotdot, rest), parens) = data; |
| let (dotdot, trailing) = match dotdot { |
| Some((a, b)) => (Some(a), Some(b)), |
| None => (None, None), |
| }; |
| PatTuple { |
| paren_token: parens, |
| dots_pos: dotdot.as_ref().map(|_| elems.len()), |
| dot2_token: dotdot, |
| comma_token: trailing.and_then(|b| b), |
| pats: { |
| if let Some(rest) = rest { |
| for elem in rest { |
| elems.push(elem); |
| } |
| } |
| elems |
| }, |
| } |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatRef { |
| named!(parse -> Self, do_parse!( |
| and: punct!(&) >> |
| mutability: syn!(Mutability) >> |
| pat: syn!(Pat) >> |
| (PatRef { |
| pat: Box::new(pat), |
| mutbl: mutability, |
| and_token: and, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatLit { |
| named!(parse -> Self, do_parse!( |
| lit: pat_lit_expr >> |
| (if let ExprKind::Path(_) = lit.node { |
| return parse_error(); // these need to be parsed by pat_path |
| } else { |
| PatLit { |
| expr: Box::new(lit), |
| } |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatRange { |
| named!(parse -> Self, do_parse!( |
| lo: pat_lit_expr >> |
| limits: syn!(RangeLimits) >> |
| hi: pat_lit_expr >> |
| (PatRange { |
| lo: Box::new(lo), |
| hi: Box::new(hi), |
| limits: limits, |
| }) |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| named!(pat_lit_expr -> Expr, do_parse!( |
| neg: option!(punct!(-)) >> |
| v: alt!( |
| syn!(Lit) => { ExprKind::Lit } |
| | |
| syn!(ExprPath) => { ExprKind::Path } |
| ) >> |
| (if neg.is_some() { |
| ExprKind::Unary(ExprUnary { |
| op: UnOp::Neg(<Token![-]>::default()), |
| expr: Box::new(v.into()) |
| }).into() |
| } else { |
| v.into() |
| }) |
| )); |
| |
| #[cfg(feature = "full")] |
| impl Synom for PatSlice { |
| named!(parse -> Self, map!( |
| brackets!(do_parse!( |
| before: call!(Delimited::parse_terminated) >> |
| middle: option!(do_parse!( |
| dots: punct!(..) >> |
| trailing: option!(punct!(,)) >> |
| (dots, trailing) |
| )) >> |
| after: cond!( |
| match middle { |
| Some((_, ref trailing)) => trailing.is_some(), |
| _ => false, |
| }, |
| call!(Delimited::parse_terminated) |
| ) >> |
| (before, middle, after) |
| )), |
| |((before, middle, after), brackets)| { |
| let mut before: Delimited<Pat, Token![,]> = before; |
| let after: Option<Delimited<Pat, Token![,]>> = after; |
| let middle: Option<(Token![..], Option<Token![,]>)> = middle; |
| PatSlice { |
| dot2_token: middle.as_ref().map(|m| Token.0)), |
| comma_token: middle.as_ref().and_then(|m| { |
| m.1.as_ref().map(|m| Token) |
| }), |
| bracket_token: brackets, |
| middle: middle.and_then(|_| { |
| if !before.is_empty() && !before.trailing_delim() { |
| Some(Box::new(before.pop().unwrap().into_item())) |
| } else { |
| None |
| } |
| }), |
| front: before, |
| back: after.unwrap_or_default(), |
| } |
| } |
| )); |
| } |
| |
| #[cfg(feature = "full")] |
| impl Synom for CaptureBy { |
| named!(parse -> Self, alt!( |
| keyword!(move) => { CaptureBy::Value } |
| | |
| epsilon!() => { |_| CaptureBy::Ref } |
| )); |
| } |
| } |
| |
| #[cfg(feature = "printing")] |
| mod printing { |
| use super::*; |
| #[cfg(feature = "full")] |
| use attr::FilterAttrs; |
| use quote::{Tokens, ToTokens}; |
| |
| /// If the given expression is a bare `ExprStruct`, wraps it in parenthesis |
| /// before appending it to `Tokens`. |
| #[cfg(feature = "full")] |
| fn wrap_bare_struct(tokens: &mut Tokens, e: &Expr) { |
| if let ExprKind::Struct(_) = e.node { |
| tokens::Paren::default().surround(tokens, |tokens| { |
| e.to_tokens(tokens); |
| }); |
| } else { |
| e.to_tokens(tokens); |
| } |
| } |
| |
| impl ToTokens for Expr { |
| #[cfg(feature = "full")] |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| tokens.append_all(self.attrs.outer()); |
| self.node.to_tokens(tokens) |
| } |
| |
| #[cfg(not(feature = "full"))] |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.node.to_tokens(tokens) |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprBox { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.box_token.to_tokens(tokens); |
| self.expr.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprInPlace { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| match self.kind { |
| InPlaceKind::Arrow(ref arrow) => { |
| self.place.to_tokens(tokens); |
| arrow.to_tokens(tokens); |
| self.value.to_tokens(tokens); |
| } |
| InPlaceKind::In(ref _in) => { |
| _in.to_tokens(tokens); |
| self.place.to_tokens(tokens); |
| // NOTE: The second operand must be in a block, add one if |
| // it is not present. |
| if let ExprKind::Block(_) = self.value.node { |
| self.value.to_tokens(tokens); |
| } else { |
| tokens::Brace::default().surround(tokens, |tokens| { |
| self.value.to_tokens(tokens); |
| }) |
| } |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprArray { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.bracket_token.surround(tokens, |tokens| { |
| self.exprs.to_tokens(tokens); |
| }) |
| } |
| } |
| |
| impl ToTokens for ExprCall { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.func.to_tokens(tokens); |
| self.paren_token.surround(tokens, |tokens| { |
| self.args.to_tokens(tokens); |
| }) |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprMethodCall { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| self.dot_token.to_tokens(tokens); |
| self.method.to_tokens(tokens); |
| if !self.typarams.is_empty() { |
| TokensOrDefault(&self.colon2_token).to_tokens(tokens); |
| TokensOrDefault(&self.lt_token).to_tokens(tokens); |
| self.typarams.to_tokens(tokens); |
| TokensOrDefault(&self.gt_token).to_tokens(tokens); |
| } |
| self.paren_token.surround(tokens, |tokens| { |
| self.args.to_tokens(tokens); |
| }); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprTup { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.paren_token.surround(tokens, |tokens| { |
| self.args.to_tokens(tokens); |
| // If we only have one argument, we need a trailing comma to |
| // distinguish ExprTup from ExprParen. |
| if self.args.len() == 1 && !self.args.trailing_delim() { |
| <Token![,]>::default().to_tokens(tokens); |
| } |
| // XXX: Not sure how to handle this, but we never parse it yet. |
| // Is this for an expression like (0,)? Can't we use the |
| // trailing delimiter on Delimited for that? (,) isn't a valid |
| // expression as far as I know. |
| self.lone_comma.to_tokens(tokens); |
| }) |
| } |
| } |
| |
| impl ToTokens for ExprBinary { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.left.to_tokens(tokens); |
| self.op.to_tokens(tokens); |
| self.right.to_tokens(tokens); |
| } |
| } |
| |
| impl ToTokens for ExprUnary { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.op.to_tokens(tokens); |
| self.expr.to_tokens(tokens); |
| } |
| } |
| |
| impl ToTokens for ExprCast { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| self.as_token.to_tokens(tokens); |
| self.ty.to_tokens(tokens); |
| } |
| } |
| |
| impl ToTokens for ExprType { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| self.colon_token.to_tokens(tokens); |
| self.ty.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| fn maybe_wrap_else(tokens: &mut Tokens, |
| else_token: &Option<Token![else]>, |
| if_false: &Option<Box<Expr>>) |
| { |
| if let Some(ref if_false) = *if_false { |
| TokensOrDefault(&else_token).to_tokens(tokens); |
| |
| // If we are not one of the valid expressions to exist in an else |
| // clause, wrap ourselves in a block. |
| match if_false.node { |
| ExprKind::If(_) | |
| ExprKind::IfLet(_) | |
| ExprKind::Block(_) => { |
| if_false.to_tokens(tokens); |
| } |
| _ => { |
| tokens::Brace::default().surround(tokens, |tokens| { |
| if_false.to_tokens(tokens); |
| }); |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprIf { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.if_token.to_tokens(tokens); |
| wrap_bare_struct(tokens, &self.cond); |
| self.if_true.to_tokens(tokens); |
| maybe_wrap_else(tokens, &self.else_token, &self.if_false); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprIfLet { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.if_token.to_tokens(tokens); |
| self.let_token.to_tokens(tokens); |
| self.pat.to_tokens(tokens); |
| self.eq_token.to_tokens(tokens); |
| wrap_bare_struct(tokens, &self.expr); |
| self.if_true.to_tokens(tokens); |
| maybe_wrap_else(tokens, &self.else_token, &self.if_false); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprWhile { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| if self.label.is_some() { |
| self.label.to_tokens(tokens); |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| } |
| self.while_token.to_tokens(tokens); |
| wrap_bare_struct(tokens, &self.cond); |
| self.body.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprWhileLet { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| if self.label.is_some() { |
| self.label.to_tokens(tokens); |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| } |
| self.while_token.to_tokens(tokens); |
| self.let_token.to_tokens(tokens); |
| self.pat.to_tokens(tokens); |
| self.eq_token.to_tokens(tokens); |
| wrap_bare_struct(tokens, &self.expr); |
| self.body.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprForLoop { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| if self.label.is_some() { |
| self.label.to_tokens(tokens); |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| } |
| self.for_token.to_tokens(tokens); |
| self.pat.to_tokens(tokens); |
| self.in_token.to_tokens(tokens); |
| wrap_bare_struct(tokens, &self.expr); |
| self.body.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprLoop { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| if self.label.is_some() { |
| self.label.to_tokens(tokens); |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| } |
| self.loop_token.to_tokens(tokens); |
| self.body.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprMatch { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.match_token.to_tokens(tokens); |
| wrap_bare_struct(tokens, &self.expr); |
| self.brace_token.surround(tokens, |tokens| { |
| for (i, arm) in self.arms.iter().enumerate() { |
| arm.to_tokens(tokens); |
| // Ensure that we have a comma after a non-block arm, except |
| // for the last one. |
| let is_last = i == self.arms.len() - 1; |
| if !is_last && arm_expr_requires_comma(&arm.body) && arm.comma.is_none() { |
| <Token![,]>::default().to_tokens(tokens); |
| } |
| } |
| }); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprCatch { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.do_token.to_tokens(tokens); |
| self.catch_token.to_tokens(tokens); |
| self.block.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprYield { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.yield_token.to_tokens(tokens); |
| self.expr.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprClosure { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.capture.to_tokens(tokens); |
| self.or1_token.to_tokens(tokens); |
| for item in self.decl.inputs.iter() { |
| match **item.item() { |
| FnArg::Captured(ArgCaptured { ref pat, ty: Type::Infer(_), .. }) => { |
| pat.to_tokens(tokens); |
| } |
| _ => item.item().to_tokens(tokens), |
| } |
| item.delimiter().to_tokens(tokens); |
| } |
| self.or2_token.to_tokens(tokens); |
| self.decl.output.to_tokens(tokens); |
| self.body.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprUnsafe { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.unsafe_token.to_tokens(tokens); |
| self.block.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprBlock { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.block.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprAssign { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.left.to_tokens(tokens); |
| self.eq_token.to_tokens(tokens); |
| self.right.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprAssignOp { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.left.to_tokens(tokens); |
| self.op.to_tokens(tokens); |
| self.right.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprField { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| self.dot_token.to_tokens(tokens); |
| // XXX: I don't think we can do anything if someone shoves a |
| // nonsense Lit in here. |
| self.field.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprTupField { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| self.dot_token.to_tokens(tokens); |
| self.field.to_tokens(tokens); |
| } |
| } |
| |
| impl ToTokens for ExprIndex { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| self.bracket_token.surround(tokens, |tokens| { |
| self.index.to_tokens(tokens); |
| }); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprRange { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.from.to_tokens(tokens); |
| self.limits.to_tokens(tokens); |
| self.to.to_tokens(tokens); |
| } |
| } |
| |
| impl ToTokens for ExprPath { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| ::PathTokens(&self.qself, &self.path).to_tokens(tokens) |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprAddrOf { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.and_token.to_tokens(tokens); |
| self.mutbl.to_tokens(tokens); |
| self.expr.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprBreak { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.break_token.to_tokens(tokens); |
| self.label.to_tokens(tokens); |
| self.expr.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprContinue { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.continue_token.to_tokens(tokens); |
| self.label.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprRet { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.return_token.to_tokens(tokens); |
| self.expr.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprStruct { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.path.to_tokens(tokens); |
| self.brace_token.surround(tokens, |tokens| { |
| self.fields.to_tokens(tokens); |
| if self.rest.is_some() { |
| TokensOrDefault(&self.dot2_token).to_tokens(tokens); |
| self.rest.to_tokens(tokens); |
| } |
| }) |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprRepeat { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.bracket_token.surround(tokens, |tokens| { |
| self.expr.to_tokens(tokens); |
| self.semi_token.to_tokens(tokens); |
| self.amt.to_tokens(tokens); |
| }) |
| } |
| } |
| |
| impl ToTokens for ExprGroup { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.group_token.surround(tokens, |tokens| { |
| self.expr.to_tokens(tokens); |
| }); |
| } |
| } |
| |
| impl ToTokens for ExprParen { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.paren_token.surround(tokens, |tokens| { |
| self.expr.to_tokens(tokens); |
| }); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for ExprTry { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| self.question_token.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for FieldValue { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.ident.to_tokens(tokens); |
| // XXX: Override self.is_shorthand if expr is not an IdentExpr with |
| // the ident self.ident? |
| if !self.is_shorthand { |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| self.expr.to_tokens(tokens); |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for Arm { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| tokens.append_all(&self.attrs); |
| self.pats.to_tokens(tokens); |
| if self.guard.is_some() { |
| TokensOrDefault(&self.if_token).to_tokens(tokens); |
| self.guard.to_tokens(tokens); |
| } |
| self.rocket_token.to_tokens(tokens); |
| self.body.to_tokens(tokens); |
| self.comma.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatWild { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.underscore_token.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatIdent { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.mode.to_tokens(tokens); |
| self.ident.to_tokens(tokens); |
| if self.subpat.is_some() { |
| TokensOrDefault(&self.at_token).to_tokens(tokens); |
| self.subpat.to_tokens(tokens); |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatStruct { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.path.to_tokens(tokens); |
| self.brace_token.surround(tokens, |tokens| { |
| self.fields.to_tokens(tokens); |
| // NOTE: We need a comma before the dot2 token if it is present. |
| if !self.fields.empty_or_trailing() && self.dot2_token.is_some() { |
| <Token![,]>::default().to_tokens(tokens); |
| } |
| self.dot2_token.to_tokens(tokens); |
| }); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatTupleStruct { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.path.to_tokens(tokens); |
| self.pat.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatPath { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| ::PathTokens(&self.qself, &self.path).to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatTuple { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.paren_token.surround(tokens, |tokens| { |
| for (i, token) in self.pats.iter().enumerate() { |
| if Some(i) == self.dots_pos { |
| TokensOrDefault(&self.dot2_token).to_tokens(tokens); |
| TokensOrDefault(&self.comma_token).to_tokens(tokens); |
| } |
| token.to_tokens(tokens); |
| } |
| |
| if Some(self.pats.len()) == self.dots_pos { |
| // Ensure there is a comma before the .. token. |
| if !self.pats.empty_or_trailing() { |
| <Token![,]>::default().to_tokens(tokens); |
| } |
| self.dot2_token.to_tokens(tokens); |
| } |
| }); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatBox { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.box_token.to_tokens(tokens); |
| self.pat.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatRef { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.and_token.to_tokens(tokens); |
| self.mutbl.to_tokens(tokens); |
| self.pat.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatLit { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.expr.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatRange { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.lo.to_tokens(tokens); |
| self.limits.to_tokens(tokens); |
| self.hi.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for PatSlice { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| // XXX: This is a mess, and it will be so easy to screw it up. How |
| // do we make this correct itself better? |
| self.bracket_token.surround(tokens, |tokens| { |
| self.front.to_tokens(tokens); |
| |
| // If we need a comma before the middle or standalone .. token, |
| // then make sure it's present. |
| if !self.front.empty_or_trailing() && |
| (self.middle.is_some() || self.dot2_token.is_some()) |
| { |
| <Token![,]>::default().to_tokens(tokens); |
| } |
| |
| // If we have an identifier, we always need a .. token. |
| if self.middle.is_some() { |
| self.middle.to_tokens(tokens); |
| TokensOrDefault(&self.dot2_token).to_tokens(tokens); |
| } else if self.dot2_token.is_some() { |
| self.dot2_token.to_tokens(tokens); |
| } |
| |
| // Make sure we have a comma before the back half. |
| if !self.back.is_empty() { |
| TokensOrDefault(&self.comma_token).to_tokens(tokens); |
| self.back.to_tokens(tokens); |
| } else { |
| self.comma_token.to_tokens(tokens); |
| } |
| }) |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for RangeLimits { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| match *self { |
| RangeLimits::HalfOpen(ref t) => t.to_tokens(tokens), |
| RangeLimits::Closed(ref t) => t.to_tokens(tokens), |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for FieldPat { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| // XXX: Override is_shorthand if it was wrong? |
| if !self.is_shorthand { |
| self.ident.to_tokens(tokens); |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| } |
| self.pat.to_tokens(tokens); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for BindingMode { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| match *self { |
| BindingMode::ByRef(ref t, ref m) => { |
| t.to_tokens(tokens); |
| m.to_tokens(tokens); |
| } |
| BindingMode::ByValue(ref m) => { |
| m.to_tokens(tokens); |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for CaptureBy { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| match *self { |
| CaptureBy::Value(ref t) => t.to_tokens(tokens), |
| CaptureBy::Ref => { |
| // nothing |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for Block { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| self.brace_token.surround(tokens, |tokens| { |
| tokens.append_all(&self.stmts); |
| }); |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for Stmt { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| match *self { |
| Stmt::Local(ref local) => local.to_tokens(tokens), |
| Stmt::Item(ref item) => item.to_tokens(tokens), |
| Stmt::Expr(ref expr) => expr.to_tokens(tokens), |
| Stmt::Semi(ref expr, ref semi) => { |
| expr.to_tokens(tokens); |
| semi.to_tokens(tokens); |
| } |
| Stmt::Macro(ref mac) => { |
| let (ref mac, ref style, ref attrs) = **mac; |
| tokens.append_all(attrs.outer()); |
| mac.to_tokens(tokens); |
| match *style { |
| MacStmtStyle::Semicolon(ref s) => s.to_tokens(tokens), |
| MacStmtStyle::Braces | MacStmtStyle::NoBraces => { |
| // no semicolon |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| #[cfg(feature = "full")] |
| impl ToTokens for Local { |
| fn to_tokens(&self, tokens: &mut Tokens) { |
| tokens.append_all(self.attrs.outer()); |
| self.let_token.to_tokens(tokens); |
| self.pat.to_tokens(tokens); |
| if self.ty.is_some() { |
| TokensOrDefault(&self.colon_token).to_tokens(tokens); |
| self.ty.to_tokens(tokens); |
| } |
| if self.init.is_some() { |
| TokensOrDefault(&self.eq_token).to_tokens(tokens); |
| self.init.to_tokens(tokens); |
| } |
| self.semi_token.to_tokens(tokens); |
| } |
| } |
| } |