From aa88da63179b8ccd3b809e98b489c25199b06cf7 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Tue, 10 Mar 2015 16:29:02 -0700 Subject: std: Tweak some unstable features of `str` This commit clarifies some of the unstable features in the `str` module by moving them out of the blanket `core` and `collections` features. The following methods were moved to the `str_char` feature which generally encompasses decoding specific characters from a `str` and dealing with the result. It is unclear if any of these methods need to be stabilized for 1.0 and the most conservative route for now is to continue providing them but to leave them as unstable under a more specific name. * `is_char_boundary` * `char_at` * `char_range_at` * `char_at_reverse` * `char_range_at_reverse` * `slice_shift_char` The following methods were moved into the generic `unicode` feature as they are specifically enabled by the `unicode` crate itself. * `nfd_chars` * `nfkd_chars` * `nfc_chars` * `graphemes` * `grapheme_indices` * `width` --- src/libsyntax/lib.rs | 1 + src/libsyntax/parse/lexer/comments.rs | 7 +++---- src/libsyntax/parse/lexer/mod.rs | 16 +++++++++------- 3 files changed, 13 insertions(+), 11 deletions(-) (limited to 'src/libsyntax') diff --git a/src/libsyntax/lib.rs b/src/libsyntax/lib.rs index b53bb4bc75e..9f217bba00a 100644 --- a/src/libsyntax/lib.rs +++ b/src/libsyntax/lib.rs @@ -38,6 +38,7 @@ #![feature(std_misc)] #![feature(unicode)] #![feature(path_ext)] +#![feature(str_char)] extern crate arena; extern crate fmt_macros; diff --git a/src/libsyntax/parse/lexer/comments.rs b/src/libsyntax/parse/lexer/comments.rs index fb9e0480ceb..277f5365db3 100644 --- a/src/libsyntax/parse/lexer/comments.rs +++ b/src/libsyntax/parse/lexer/comments.rs @@ -20,7 +20,6 @@ use parse::lexer; use print::pprust; use std::io::Read; -use std::str; use std::usize; #[derive(Clone, Copy, PartialEq)] @@ -210,11 +209,11 @@ fn all_whitespace(s: &str, col: CharPos) -> Option { let mut col = col.to_usize(); let mut cursor: usize = 0; while col > 0 && cursor < len { - let r: str::CharRange = s.char_range_at(cursor); - if !r.ch.is_whitespace() { + let ch = s.char_at(cursor); + if !ch.is_whitespace() { return None; } - cursor = r.next; + cursor += ch.len_utf8(); col -= 1; } return Some(cursor); diff --git a/src/libsyntax/parse/lexer/mod.rs b/src/libsyntax/parse/lexer/mod.rs index d9887c28e5c..bb8f9da8917 100644 --- a/src/libsyntax/parse/lexer/mod.rs +++ b/src/libsyntax/parse/lexer/mod.rs @@ -22,7 +22,6 @@ use std::fmt; use std::mem::replace; use std::num; use std::rc::Rc; -use std::str; pub use ext::tt::transcribe::{TtReader, new_tt_reader, new_tt_reader_with_doc_flag}; @@ -291,7 +290,8 @@ impl<'a> StringReader<'a> { s: &'b str, errmsg: &'b str) -> Cow<'b, str> { let mut i = 0; while i < s.len() { - let str::CharRange { ch, next } = s.char_range_at(i); + let ch = s.char_at(i); + let next = i + ch.len_utf8(); if ch == '\r' { if next < s.len() && s.char_at(next) == '\n' { return translate_crlf_(self, start, s, errmsg, i).into_cow(); @@ -309,7 +309,8 @@ impl<'a> StringReader<'a> { let mut buf = String::with_capacity(s.len()); let mut j = 0; while i < s.len() { - let str::CharRange { ch, next } = s.char_range_at(i); + let ch = s.char_at(i); + let next = i + ch.len_utf8(); if ch == '\r' { if j < i { buf.push_str(&s[j..i]); } j = next; @@ -335,10 +336,11 @@ impl<'a> StringReader<'a> { if current_byte_offset < self.source_text.len() { assert!(self.curr.is_some()); let last_char = self.curr.unwrap(); - let next = self.source_text.char_range_at(current_byte_offset); - let byte_offset_diff = next.next - current_byte_offset; + let ch = self.source_text.char_at(current_byte_offset); + let next = current_byte_offset + ch.len_utf8(); + let byte_offset_diff = next - current_byte_offset; self.pos = self.pos + Pos::from_usize(byte_offset_diff); - self.curr = Some(next.ch); + self.curr = Some(ch); self.col = self.col + CharPos(1); if last_char == '\n' { self.filemap.next_line(self.last_pos); @@ -370,7 +372,7 @@ impl<'a> StringReader<'a> { let offset = self.byte_offset(self.pos).to_usize(); let s = &self.source_text[..]; if offset >= s.len() { return None } - let str::CharRange { next, .. } = s.char_range_at(offset); + let next = offset + s.char_at(offset).len_utf8(); if next < s.len() { Some(s.char_at(next)) } else { -- cgit 1.4.1-3-g733a5 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