From c42067c9e9ac605fc330c3ed11d29477ac251d8a Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 17 Mar 2015 03:41:23 +0530 Subject: ast: Document Expr_, UnOp, and BinOp --- src/libsyntax/ast.rs | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 70 insertions(+), 1 deletion(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 657ffcaece9..1188e2921eb 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -594,23 +594,41 @@ pub enum Mutability { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum BinOp_ { + /// The `+` operator (addition) BiAdd, + /// The `-` operator (subtraction) BiSub, + /// The `*` operator (multiplication) BiMul, + /// The `/` operator (division) BiDiv, + /// The `%` operator (modulus) BiRem, + /// The `&&` operator (logical and) BiAnd, + /// The `||` operator (logical or) BiOr, + /// The `^` operator (bitwise xor) BiBitXor, + /// The `&` operator (bitwise and) BiBitAnd, + /// The `|` operator (bitwise or) BiBitOr, + /// The `<<` operator (shift left) BiShl, + /// The `>>` operator (shift right) BiShr, + /// The `==` operator (equality) BiEq, + /// The `<` operator (less than) BiLt, + /// The `<=` operator (less than or equal to) BiLe, + /// The `!=` operator (not equal to) BiNe, + /// The `>=` operator (greater than or equal to) BiGe, + /// The `>` operator (greater than) BiGt, } @@ -618,9 +636,13 @@ pub type BinOp = Spanned; #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum UnOp { + /// The `box` operator UnUniq, + /// The `*` operator for dereferencing UnDeref, + /// The `!` operator for logical inversion UnNot, + /// The `-` operator for negation UnNeg } @@ -725,34 +747,73 @@ pub struct Expr { pub enum Expr_ { /// First expr is the place; second expr is the value. ExprBox(Option>, P), + /// An array (`[a, b, c, d]`) ExprVec(Vec>), + /// A function cal ExprCall(P, Vec>), + /// A method call (`x.foo::(a, b, c, d)`) + /// The `SpannedIdent` is the identifier for the method name + /// The vector of `Ty`s are the ascripted type parameters for the method + /// (within the angle brackets) + /// The first element of the vector of `Expr`s is the expression that evaluates + /// to the object on which the method is being called on, and the remaining elements + /// are the arguments ExprMethodCall(SpannedIdent, Vec>, Vec>), + /// A tuple (`(a, b, c ,d)`) ExprTup(Vec>), + /// A binary operation (For example: `a + b`, `a * b`) ExprBinary(BinOp, P, P), + /// A unary operation (For example: `!x`, `*x`) ExprUnary(UnOp, P), + /// A literal (For example: `1u8`, `"foo"`) ExprLit(P), + /// A cast (`foo as f64`) ExprCast(P, P), + /// An `if` block, with an optional else block + /// `if expr { block } else { expr }` ExprIf(P, P, Option>), + /// An `if let` expression with an optional else block + /// `if let pat = expr { block } else { expr }` + /// This is desugared to a `match` expression ExprIfLet(P, P, P, Option>), // FIXME #6993: change to Option ... or not, if these are hygienic. + /// A while loop, with an optional label + /// `'label while expr { block }` ExprWhile(P, P, Option), // FIXME #6993: change to Option ... or not, if these are hygienic. + /// A while-let loop, with an optional label + /// `'label while let pat = expr { block }` + /// This is desugared to a combination of `loop` and `match` expressions ExprWhileLet(P, P, P, Option), // FIXME #6993: change to Option ... or not, if these are hygienic. + /// A for loop, with an optional label + /// `'label for pat in expr { block }` + /// This is desugared to a combination of `loop` and `match` expressions ExprForLoop(P, P, P, Option), - // Conditionless loop (can be exited with break, cont, or ret) + /// Conditionless loop (can be exited with break, cont, or ret) + /// `'label loop { block }` // FIXME #6993: change to Option ... or not, if these are hygienic. ExprLoop(P, Option), + /// A `match` block, with a desugar source ExprMatch(P, Vec, MatchSource), + /// A closure (for example, `move |a, b, c| {a + b + c}`) ExprClosure(CaptureClause, P, P), + /// A block ExprBlock(P), + /// An assignment (`a = foo()`) ExprAssign(P, P), + /// An assignment with an operator + /// For example, `a += 1` ExprAssignOp(BinOp, P, P), + /// Access of a named struct field (`obj.foo`) ExprField(P, SpannedIdent), + /// Access of an unnamed field of a struct or tuple-struct + /// For example, `foo.0` ExprTupField(P, Spanned), + /// An indexing operation (`foo[2]`) ExprIndex(P, P), + /// A range (`[1..2]`, `[1..]`, or `[..2]`) ExprRange(Option>, Option>), /// Variable reference, possibly containing `::` and/or type @@ -760,19 +821,27 @@ pub enum Expr_ { /// e.g. ` as SomeTrait>::SomeType`. ExprPath(Option, Path), + /// A referencing operation (`&a` or `&mut a`) ExprAddrOf(Mutability, P), + /// A `break`, with an optional label to break ExprBreak(Option), + /// A `continue`, with an optional label ExprAgain(Option), + /// A `return`, with an optional value to be returned ExprRet(Option>), + /// Output of the `asm!()` macro ExprInlineAsm(InlineAsm), + /// A macro invocation; pre-expansion ExprMac(Mac), /// A struct literal expression. + /// For example, `Foo {x: 1, y: 2}` ExprStruct(Path, Vec, Option> /* base */), /// A vector literal constructed from one repeated element. + /// For example, `[u8; 5]` ExprRepeat(P /* element */, P /* count */), /// No-op: used solely so we can pretty-print faithfully -- cgit 1.4.1-3-g733a5 From 1debe9d112010a23c76711f557ee6fdc4728f4ec Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 17 Mar 2015 04:02:29 +0530 Subject: ast: Document paths and `where` clauses --- src/libsyntax/ast.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 1188e2921eb..ec4316150fb 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -150,7 +150,7 @@ impl PartialEq for Ident { /// A SyntaxContext represents a chain of macro-expandings /// and renamings. Each macro expansion corresponds to -/// a fresh usize +/// a fresh u32 // I'm representing this syntax context as an index into // a table, in order to work around a compiler bug @@ -216,6 +216,7 @@ pub struct Lifetime { } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +/// A lifetime definition, eg `'a: 'b+'c+'d` pub struct LifetimeDef { pub lifetime: Lifetime, pub bounds: Vec @@ -251,7 +252,9 @@ pub struct PathSegment { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum PathParameters { + /// The `<'a, A,B,C>` in `foo::bar::baz::<'a, A,B,C>` AngleBracketedParameters(AngleBracketedParameterData), + /// The `(A,B)` and `C` in `Foo(A,B) -> C` ParenthesizedParameters(ParenthesizedParameterData), } @@ -436,27 +439,37 @@ impl Generics { } } +/// A `where` clause in a definition #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct WhereClause { pub id: NodeId, pub predicates: Vec, } +/// A single predicate in a `where` clause #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum WherePredicate { + /// A type binding, eg `for<'c> Foo: Send+Clone+'c` BoundPredicate(WhereBoundPredicate), + /// A lifetime predicate, e.g. `'a: 'b+'c` RegionPredicate(WhereRegionPredicate), + /// An equality predicate (unsupported) EqPredicate(WhereEqPredicate) } +/// A type bound, eg `for<'c> Foo: Send+Clone+'c` #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct WhereBoundPredicate { pub span: Span, + /// Any lifetimes from a `for` binding pub bound_lifetimes: Vec, + /// The type being bounded pub bounded_ty: P, + /// Trait and lifetime bounds (`Clone+Send+'static`) pub bounds: OwnedSlice, } +/// A lifetime predicate, e.g. `'a: 'b+'c` #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct WhereRegionPredicate { pub span: Span, @@ -464,6 +477,7 @@ pub struct WhereRegionPredicate { pub bounds: Vec, } +/// An equality predicate (unsupported), e.g. `T=int` #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct WhereEqPredicate { pub id: NodeId, -- cgit 1.4.1-3-g733a5 From b08d5eee6a1bb3aaf7385c84b255be964caff9d1 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 17 Mar 2015 04:19:27 +0530 Subject: ast: Document Pat and Block --- src/libsyntax/ast.rs | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index ec4316150fb..479ae40f0d6 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -535,9 +535,13 @@ impl PartialEq for MetaItem_ { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct Block { + /// Statements in a block pub stmts: Vec>, + /// An expression at the end of the block + /// without a semicolon, if any pub expr: Option>, pub id: NodeId, + /// Unsafety of the block pub rules: BlockCheckMode, pub span: Span, } @@ -550,8 +554,14 @@ pub struct Pat { } #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] +/// A single field in a struct pattern +/// +/// For patterns like `Foo {x, y, z}`, `pat` and `ident` point to the same identifier +/// and `is_shorthand` is true. pub struct FieldPat { + /// The identifier for the field pub ident: Ident, + /// The pattern the field is destructured to pub pat: P, pub is_shorthand: bool, } @@ -588,15 +598,23 @@ pub enum Pat_ { /// "None" means a * pattern where we don't bind the fields to names. PatEnum(Path, Option>>), + /// Destructuring of a struct, e.g. `Foo {x, y, ..}` + /// The `bool` is `true` in the presence of a `..` PatStruct(Path, Vec>, bool), + /// A tuple pattern (`a, b`) PatTup(Vec>), + /// A `box` pattern PatBox(P), - PatRegion(P, Mutability), // reference pattern + /// A reference pattern, e.g. `&mut (a, b)` + PatRegion(P, Mutability), + /// A literal PatLit(P), + /// A range pattern, e.g. `[1...2]` PatRange(P, P), /// [a, b, ..i, y, z] is represented as: /// PatVec(box [a, b], Some(i), box [y, z]) PatVec(Vec>, Option>, Vec>), + /// A macro pattern; pre-expansion PatMac(Mac), } -- cgit 1.4.1-3-g733a5 From 084f3bcfd4e378d5c2b6daccda5c963c757c1bc5 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 17 Mar 2015 04:32:58 +0530 Subject: ast: Document Lit --- src/libsyntax/ast.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 479ae40f0d6..a16cd8bfa19 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -678,6 +678,7 @@ pub enum UnOp { UnNeg } +/// A statement pub type Stmt = Spanned; #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] @@ -722,6 +723,7 @@ pub enum LocalSource { pub struct Local { pub pat: P, pub ty: Option>, + /// Initializer expression to set the value, if any pub init: Option>, pub id: NodeId, pub span: Span, @@ -768,6 +770,7 @@ pub enum UnsafeSource { UserProvided, } +/// An expression #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct Expr { pub id: NodeId, @@ -981,7 +984,6 @@ pub enum KleeneOp { /// The RHS of an MBE macro is the only place `SubstNt`s are substituted. /// Nothing special happens to misnamed or misplaced `SubstNt`s. #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] -#[doc="For macro invocations; parsing is delegated to the macro"] pub enum TokenTree { /// A single token TtToken(Span, token::Token), @@ -1092,10 +1094,14 @@ pub enum Mac_ { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum StrStyle { + /// A regular string, like `"fooo"` CookedStr, + /// A raw string, like `r##"foo"##` + /// The uint is the number of `#` symbols used RawStr(usize) } +/// A literal pub type Lit = Spanned; #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] @@ -1133,13 +1139,21 @@ impl LitIntType { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum Lit_ { + /// A string literal (`"foo"`) LitStr(InternedString, StrStyle), + /// A byte string (`b"foo"`) LitBinary(Rc>), + /// A byte char (`b'f'`) LitByte(u8), + /// A character literal (`'a'`) LitChar(char), + /// An integer liteal (`1u8`) LitInt(u64, LitIntType), + /// A float literal (`1f64` or `1E10f64`) LitFloat(InternedString, FloatTy), + /// A float literal without a suffix (`1.0 or 1.0E10`) LitFloatUnsuffixed(InternedString), + /// A boolean literal LitBool(bool), } -- cgit 1.4.1-3-g733a5 From edf65c43f64861bc7fb660db32f9a10c38105957 Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 17 Mar 2015 05:06:13 +0530 Subject: ast: Document Item and ForeignItem --- src/libsyntax/ast.rs | 36 +++++++++++++++++++++++++++--------- 1 file changed, 27 insertions(+), 9 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index a16cd8bfa19..ccccc3bfb04 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -1476,9 +1476,9 @@ impl fmt::Display for Unsafety { #[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash)] pub enum ImplPolarity { - /// impl Trait for Type + /// `impl Trait for Type` Positive, - /// impl !Trait for Type + /// `impl !Trait for Type` Negative, } @@ -1494,10 +1494,10 @@ impl fmt::Debug for ImplPolarity { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum FunctionRetTy { - /// Functions with return type ! that always + /// Functions with return type `!`that always /// raise an error or exit (i.e. never return to the caller) NoReturn(Span), - /// Return type is not specified. Functions default to () and + /// Return type is not specified. Functions default to `()` and /// closures default to inference. Span points to where return /// type would be inserted. DefaultReturn(Span), @@ -1553,7 +1553,9 @@ pub struct VariantArg { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum VariantKind { + /// Tuple variant, e.g. `Foo(A, B)` TupleVariantKind(Vec), + /// Struct variant, e.g. `Foo {x: A, y: B}` StructVariantKind(P), } @@ -1568,6 +1570,7 @@ pub struct Variant_ { pub attrs: Vec, pub kind: VariantKind, pub id: NodeId, + /// Explicit discriminant, eg `Foo = 1` pub disr_expr: Option>, pub vis: Visibility, } @@ -1718,6 +1721,9 @@ pub struct StructDef { FIXME (#3300): Should allow items to be anonymous. Right now we just use dummy names for anon items. */ +/// An item +/// +/// The name might be a dummy name in case of anonymous items #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct Item { pub ident: Ident, @@ -1730,19 +1736,27 @@ pub struct Item { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum Item_ { - // Optional location (containing arbitrary characters) from which - // to fetch the crate sources. - // For example, extern crate whatever = "github.com/rust-lang/rust". + /// An`extern crate` item, with optional original crate name, + /// e.g. `extern crate foo` or `extern crate "foo-bar" as foo` ItemExternCrate(Option<(InternedString, StrStyle)>), + /// A `use` or `pub use` item ItemUse(P), + /// A `static` item ItemStatic(P, Mutability, P), + /// A `const` item ItemConst(P, P), + /// A function declaration ItemFn(P, Unsafety, Abi, Generics, P), + /// A module ItemMod(Mod), + /// An external module ItemForeignMod(ForeignMod), + /// A type alias, e.g. `type Foo = Bar` ItemTy(P, Generics), + /// An enum definition, e.g. `enum Foo {C, D}` ItemEnum(EnumDef, Generics), + /// A struct definition, e.g. `struct Foo {x: A}` ItemStruct(P, Generics), /// Represents a Trait Declaration ItemTrait(Unsafety, @@ -1751,8 +1765,9 @@ pub enum Item_ { Vec>), // Default trait implementations - // `impl Trait for ..` + // `impl Trait for .. {}` ItemDefaultImpl(Unsafety, TraitRef), + /// An implementation, eg `impl Trait for Foo { .. }` ItemImpl(Unsafety, ImplPolarity, Generics, @@ -1794,10 +1809,13 @@ pub struct ForeignItem { pub vis: Visibility, } +/// An item within an `extern` block #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub enum ForeignItem_ { + /// A foreign function ForeignItemFn(P, Generics), - ForeignItemStatic(P, /* is_mutbl */ bool), + /// A foreign static item (`static ext: u8`), with optional mutability + ForeignItemStatic(P, bool), } impl ForeignItem_ { -- cgit 1.4.1-3-g733a5 From 13881df1b2a188b1505b50fde47dfdd8c95a99ee Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Tue, 17 Mar 2015 17:42:20 +0530 Subject: Clarify Expr --- src/libsyntax/ast.rs | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index ccccc3bfb04..26e10a35150 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -784,15 +784,19 @@ pub enum Expr_ { ExprBox(Option>, P), /// An array (`[a, b, c, d]`) ExprVec(Vec>), - /// A function cal + /// A function call + /// The first field resolves to the function itself, + /// and the second field is the list of arguments ExprCall(P, Vec>), /// A method call (`x.foo::(a, b, c, d)`) /// The `SpannedIdent` is the identifier for the method name /// The vector of `Ty`s are the ascripted type parameters for the method /// (within the angle brackets) /// The first element of the vector of `Expr`s is the expression that evaluates - /// to the object on which the method is being called on, and the remaining elements - /// are the arguments + /// to the object on which the method is being called on (the receiver), + /// and the remaining elements are the rest of the arguments. + /// Thus, `x.foo::(a, b, c, d)` is represented as + /// `ExprMethodCall(foo, [Bar, Baz], [x, a, b, c, d])` ExprMethodCall(SpannedIdent, Vec>, Vec>), /// A tuple (`(a, b, c ,d)`) ExprTup(Vec>), @@ -829,7 +833,8 @@ pub enum Expr_ { /// `'label loop { block }` // FIXME #6993: change to Option ... or not, if these are hygienic. ExprLoop(P, Option), - /// A `match` block, with a desugar source + /// A `match` block, with a source that indicates whether or not it is + /// the result of a desugaring, and if so, which kind ExprMatch(P, Vec, MatchSource), /// A closure (for example, `move |a, b, c| {a + b + c}`) ExprClosure(CaptureClause, P, P), @@ -1094,7 +1099,7 @@ pub enum Mac_ { #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug, Copy)] pub enum StrStyle { - /// A regular string, like `"fooo"` + /// A regular string, like `"foo"` CookedStr, /// A raw string, like `r##"foo"##` /// The uint is the number of `#` symbols used -- cgit 1.4.1-3-g733a5 From a5828ff7b0203ac378974c2d30ed94a14073895a Mon Sep 17 00:00:00 2001 From: Manish Goregaokar Date: Wed, 18 Mar 2015 18:06:10 +0530 Subject: Address huon's comments --- src/libsyntax/ast.rs | 38 +++++++++++++++++++++----------------- 1 file changed, 21 insertions(+), 17 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/ast.rs b/src/libsyntax/ast.rs index 26e10a35150..5c275715352 100644 --- a/src/libsyntax/ast.rs +++ b/src/libsyntax/ast.rs @@ -541,7 +541,7 @@ pub struct Block { /// without a semicolon, if any pub expr: Option>, pub id: NodeId, - /// Unsafety of the block + /// Distinguishes between `unsafe { ... }` and `{ ... }` pub rules: BlockCheckMode, pub span: Span, } @@ -553,11 +553,12 @@ pub struct Pat { pub span: Span, } -#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] /// A single field in a struct pattern /// -/// For patterns like `Foo {x, y, z}`, `pat` and `ident` point to the same identifier -/// and `is_shorthand` is true. +/// 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 +#[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)] pub struct FieldPat { /// The identifier for the field pub ident: Ident, @@ -601,7 +602,7 @@ pub enum Pat_ { /// Destructuring of a struct, e.g. `Foo {x, y, ..}` /// The `bool` is `true` in the presence of a `..` PatStruct(Path, Vec>, bool), - /// A tuple pattern (`a, b`) + /// A tuple pattern `(a, b)` PatTup(Vec>), /// A `box` pattern PatBox(P), @@ -609,7 +610,7 @@ pub enum Pat_ { PatRegion(P, Mutability), /// A literal PatLit(P), - /// A range pattern, e.g. `[1...2]` + /// A range pattern, e.g. `1...2` PatRange(P, P), /// [a, b, ..i, y, z] is represented as: /// PatVec(box [a, b], Some(i), box [y, z]) @@ -817,20 +818,20 @@ pub enum Expr_ { ExprIfLet(P, P, P, Option>), // FIXME #6993: change to Option ... or not, if these are hygienic. /// A while loop, with an optional label - /// `'label while expr { block }` + /// `'label: while expr { block }` ExprWhile(P, P, Option), // FIXME #6993: change to Option ... or not, if these are hygienic. /// A while-let loop, with an optional label - /// `'label while let pat = expr { block }` + /// `'label: while let pat = expr { block }` /// This is desugared to a combination of `loop` and `match` expressions ExprWhileLet(P, P, P, Option), // FIXME #6993: change to Option ... or not, if these are hygienic. /// A for loop, with an optional label - /// `'label for pat in expr { block }` + /// `'label: for pat in expr { block }` /// This is desugared to a combination of `loop` and `match` expressions ExprForLoop(P, P, P, Option), - /// Conditionless loop (can be exited with break, cont, or ret) - /// `'label loop { block }` + /// Conditionless loop (can be exited with break, continue, or return) + /// `'label: loop { block }` // FIXME #6993: change to Option ... or not, if these are hygienic. ExprLoop(P, Option), /// A `match` block, with a source that indicates whether or not it is @@ -838,7 +839,7 @@ pub enum Expr_ { ExprMatch(P, Vec, MatchSource), /// A closure (for example, `move |a, b, c| {a + b + c}`) ExprClosure(CaptureClause, P, P), - /// A block + /// A block (`{ ... }`) ExprBlock(P), /// An assignment (`a = foo()`) @@ -853,7 +854,7 @@ pub enum Expr_ { ExprTupField(P, Spanned), /// An indexing operation (`foo[2]`) ExprIndex(P, P), - /// A range (`[1..2]`, `[1..]`, or `[..2]`) + /// A range (`1..2`, `1..`, or `..2`) ExprRange(Option>, Option>), /// Variable reference, possibly containing `::` and/or type @@ -877,12 +878,14 @@ pub enum Expr_ { ExprMac(Mac), /// A struct literal expression. - /// For example, `Foo {x: 1, y: 2}` - ExprStruct(Path, Vec, Option> /* base */), + /// For example, `Foo {x: 1, y: 2}`, or + /// `Foo {x: 1, .. base}`, where `base` is the `Option` + ExprStruct(Path, Vec, Option>), /// A vector literal constructed from one repeated element. - /// For example, `[u8; 5]` - ExprRepeat(P /* element */, P /* count */), + /// For example, `[1u8; 5]`. The first expression is the element + /// to be repeated; the second is the number of times to repeat it + ExprRepeat(P, P), /// No-op: used solely so we can pretty-print faithfully ExprParen(P) @@ -1820,6 +1823,7 @@ pub enum ForeignItem_ { /// A foreign function ForeignItemFn(P, Generics), /// A foreign static item (`static ext: u8`), with optional mutability + /// (the boolean is true when mutable) ForeignItemStatic(P, bool), } -- cgit 1.4.1-3-g733a5