| Copyright | (c) Alec Theriault 2017-2018 |
|---|---|
| License | BSD-style |
| Maintainer | alec.theriault@gmail.com |
| Stability | experimental |
| Portability | GHC |
| Safe Haskell | None |
| Language | Haskell2010 |
Language.Rust.Syntax
Contents
Description
This module defines Haskell data types corresponding to the abstract syntax tree(s) of the Rust
language, based on the definitions rustc uses (defined in libsyntax) whenever possible.
Unfortunately, since the internals of rustc are not exposed, there are no official
docs. https://manishearth.github.io/rust-internals-docs/syntax/ast/index.html are the
unofficial docs.
- data SourceFile a = SourceFile (Maybe Name) [Attribute a] [Item a]
- data Mutability
- data Unsafety
- data Arg a
- = Arg (Maybe (Pat a)) (Ty a) a
- | SelfValue Mutability a
- | SelfRegion (Maybe (Lifetime a)) Mutability a
- | SelfExplicit (Ty a) Mutability a
- data FnDecl a = FnDecl [Arg a] (Maybe (Ty a)) Bool a
- data Path a = Path Bool [PathSegment a] a
- data PathParameters a
- = AngleBracketed [Lifetime a] [Ty a] [(Ident, Ty a)] a
- | Parenthesized [Ty a] (Maybe (Ty a)) a
- data PathSegment a = PathSegment Ident (Maybe (PathParameters a)) a
- data QSelf a = QSelf (Ty a) Int
- data Attribute a
- = Attribute AttrStyle (Path a) TokenStream a
- | SugaredDoc AttrStyle Bool Name a
- data AttrStyle
- data Lit a
- byteStr :: String -> StrStyle -> Suffix -> a -> Lit a
- data Suffix
- suffix :: Lit a -> Suffix
- data IntRep
- data StrStyle
- data Expr a
- = Box [Attribute a] (Expr a) a
- | InPlace [Attribute a] (Expr a) (Expr a) a
- | Vec [Attribute a] [Expr a] a
- | Call [Attribute a] (Expr a) [Expr a] a
- | MethodCall [Attribute a] (Expr a) Ident (Maybe [Ty a]) [Expr a] a
- | TupExpr [Attribute a] [Expr a] a
- | Binary [Attribute a] BinOp (Expr a) (Expr a) a
- | Unary [Attribute a] UnOp (Expr a) a
- | Lit [Attribute a] (Lit a) a
- | Cast [Attribute a] (Expr a) (Ty a) a
- | TypeAscription [Attribute a] (Expr a) (Ty a) a
- | If [Attribute a] (Expr a) (Block a) (Maybe (Expr a)) a
- | IfLet [Attribute a] (NonEmpty (Pat a)) (Expr a) (Block a) (Maybe (Expr a)) a
- | While [Attribute a] (Expr a) (Block a) (Maybe (Label a)) a
- | WhileLet [Attribute a] (NonEmpty (Pat a)) (Expr a) (Block a) (Maybe (Label a)) a
- | ForLoop [Attribute a] (Pat a) (Expr a) (Block a) (Maybe (Label a)) a
- | Loop [Attribute a] (Block a) (Maybe (Label a)) a
- | Match [Attribute a] (Expr a) [Arm a] a
- | Closure [Attribute a] Movability CaptureBy (FnDecl a) (Expr a) a
- | BlockExpr [Attribute a] (Block a) a
- | Catch [Attribute a] (Block a) a
- | Assign [Attribute a] (Expr a) (Expr a) a
- | AssignOp [Attribute a] BinOp (Expr a) (Expr a) a
- | FieldAccess [Attribute a] (Expr a) Ident a
- | TupField [Attribute a] (Expr a) Int a
- | Index [Attribute a] (Expr a) (Expr a) a
- | Range [Attribute a] (Maybe (Expr a)) (Maybe (Expr a)) RangeLimits a
- | PathExpr [Attribute a] (Maybe (QSelf a)) (Path a) a
- | AddrOf [Attribute a] Mutability (Expr a) a
- | Break [Attribute a] (Maybe (Label a)) (Maybe (Expr a)) a
- | Continue [Attribute a] (Maybe (Label a)) a
- | Ret [Attribute a] (Maybe (Expr a)) a
- | MacExpr [Attribute a] (Mac a) a
- | Struct [Attribute a] (Path a) [Field a] (Maybe (Expr a)) a
- | Repeat [Attribute a] (Expr a) (Expr a) a
- | ParenExpr [Attribute a] (Expr a) a
- | Try [Attribute a] (Expr a) a
- | Yield [Attribute a] (Maybe (Expr a)) a
- data Abi
- data Arm a = Arm [Attribute a] (NonEmpty (Pat a)) (Maybe (Expr a)) (Expr a) a
- data UnOp
- data BinOp
- data Label a = Label Name a
- data CaptureBy
- data Movability
- data Field a = Field Ident (Maybe (Expr a)) a
- data RangeLimits
- data Ty a
- = Slice (Ty a) a
- | Array (Ty a) (Expr a) a
- | Ptr Mutability (Ty a) a
- | Rptr (Maybe (Lifetime a)) Mutability (Ty a) a
- | BareFn Unsafety Abi [LifetimeDef a] (FnDecl a) a
- | Never a
- | TupTy [Ty a] a
- | PathTy (Maybe (QSelf a)) (Path a) a
- | TraitObject (NonEmpty (TyParamBound a)) a
- | ImplTrait (NonEmpty (TyParamBound a)) a
- | ParenTy (Ty a) a
- | Typeof (Expr a) a
- | Infer a
- | MacTy (Mac a) a
- data Generics a = Generics [LifetimeDef a] [TyParam a] (WhereClause a) a
- data Lifetime a = Lifetime Name a
- data LifetimeDef a = LifetimeDef [Attribute a] (Lifetime a) [Lifetime a] a
- data TyParam a = TyParam [Attribute a] Ident [TyParamBound a] (Maybe (Ty a)) a
- data TyParamBound a
- = TraitTyParamBound (PolyTraitRef a) TraitBoundModifier a
- | RegionTyParamBound (Lifetime a) a
- partitionTyParamBounds :: [TyParamBound a] -> ([TyParamBound a], [TyParamBound a])
- data WhereClause a = WhereClause [WherePredicate a] a
- whereClause :: Generics a -> WhereClause a
- data WherePredicate a
- = BoundPredicate [LifetimeDef a] (Ty a) [TyParamBound a] a
- | RegionPredicate (Lifetime a) [Lifetime a] a
- | EqPredicate (Ty a) (Ty a) a
- data PolyTraitRef a = PolyTraitRef [LifetimeDef a] (TraitRef a) a
- newtype TraitRef a = TraitRef (Path a)
- data TraitBoundModifier
- data Pat a
- = WildP a
- | IdentP BindingMode Ident (Maybe (Pat a)) a
- | StructP (Path a) [FieldPat a] Bool a
- | TupleStructP (Path a) [Pat a] (Maybe Int) a
- | PathP (Maybe (QSelf a)) (Path a) a
- | TupleP [Pat a] (Maybe Int) a
- | BoxP (Pat a) a
- | RefP (Pat a) Mutability a
- | LitP (Expr a) a
- | RangeP (Expr a) (Expr a) a
- | SliceP [Pat a] (Maybe (Pat a)) [Pat a] a
- | MacP (Mac a) a
- data BindingMode
- data FieldPat a = FieldPat (Maybe Ident) (Pat a) a
- data Stmt a
- data Item a
- = ExternCrate [Attribute a] (Visibility a) Ident (Maybe Ident) a
- | Use [Attribute a] (Visibility a) (UseTree a) a
- | Static [Attribute a] (Visibility a) Ident (Ty a) Mutability (Expr a) a
- | ConstItem [Attribute a] (Visibility a) Ident (Ty a) (Expr a) a
- | Fn [Attribute a] (Visibility a) Ident (FnDecl a) Unsafety Constness Abi (Generics a) (Block a) a
- | Mod [Attribute a] (Visibility a) Ident (Maybe [Item a]) a
- | ForeignMod [Attribute a] (Visibility a) Abi [ForeignItem a] a
- | TyAlias [Attribute a] (Visibility a) Ident (Ty a) (Generics a) a
- | Enum [Attribute a] (Visibility a) Ident [Variant a] (Generics a) a
- | StructItem [Attribute a] (Visibility a) Ident (VariantData a) (Generics a) a
- | Union [Attribute a] (Visibility a) Ident (VariantData a) (Generics a) a
- | Trait [Attribute a] (Visibility a) Ident Bool Unsafety (Generics a) [TyParamBound a] [TraitItem a] a
- | TraitAlias [Attribute a] (Visibility a) Ident (Generics a) (NonEmpty (TyParamBound a)) a
- | Impl [Attribute a] (Visibility a) Defaultness Unsafety ImplPolarity (Generics a) (Maybe (TraitRef a)) (Ty a) [ImplItem a] a
- | MacItem [Attribute a] (Maybe Ident) (Mac a) a
- | MacroDef [Attribute a] Ident TokenStream a
- data ForeignItem a
- = ForeignFn [Attribute a] (Visibility a) Ident (FnDecl a) (Generics a) a
- | ForeignStatic [Attribute a] (Visibility a) Ident (Ty a) Mutability a
- | ForeignTy [Attribute a] (Visibility a) Ident a
- data ImplItem a
- = ConstI [Attribute a] (Visibility a) Defaultness Ident (Ty a) (Expr a) a
- | MethodI [Attribute a] (Visibility a) Defaultness Ident (Generics a) (MethodSig a) (Block a) a
- | TypeI [Attribute a] (Visibility a) Defaultness Ident (Ty a) a
- | MacroI [Attribute a] Defaultness (Mac a) a
- data TraitItem a
- data Defaultness
- data ImplPolarity
- data StructField a = StructField (Maybe Ident) (Visibility a) (Ty a) [Attribute a] a
- data Variant a = Variant Ident [Attribute a] (VariantData a) (Maybe (Expr a)) a
- data VariantData a
- = StructD [StructField a] a
- | TupleD [StructField a] a
- | UnitD a
- data UseTree a
- = UseTreeSimple (Path a) (Maybe Ident) a
- | UseTreeGlob (Path a) a
- | UseTreeNested (Path a) [UseTree a] a
- data Visibility a
- = PublicV
- | CrateV
- | RestrictedV (Path a)
- | InheritedV
- data Constness
- data MethodSig a = MethodSig Unsafety Constness Abi (FnDecl a)
- data Block a = Block [Stmt a] Unsafety a
- data TokenTree
- data TokenStream
- = Tree TokenTree
- | Stream [TokenStream]
- unconsTokenStream :: TokenStream -> Maybe (TokenTree, TokenStream)
- data Nonterminal a
- data Mac a = Mac (Path a) TokenStream a
- data MacStmtStyle
- data Token
- = Equal
- | Less
- | Greater
- | Ampersand
- | Pipe
- | Exclamation
- | Tilde
- | Plus
- | Minus
- | Star
- | Slash
- | Percent
- | Caret
- | GreaterEqual
- | GreaterGreaterEqual
- | AmpersandAmpersand
- | PipePipe
- | LessLess
- | GreaterGreater
- | EqualEqual
- | NotEqual
- | LessEqual
- | LessLessEqual
- | MinusEqual
- | AmpersandEqual
- | PipeEqual
- | PlusEqual
- | StarEqual
- | SlashEqual
- | CaretEqual
- | PercentEqual
- | At
- | Dot
- | DotDot
- | DotDotEqual
- | DotDotDot
- | Comma
- | Semicolon
- | Colon
- | ModSep
- | RArrow
- | LArrow
- | FatArrow
- | Pound
- | Dollar
- | Question
- | OpenDelim !Delim
- | CloseDelim !Delim
- | LiteralTok LitTok (Maybe Name)
- | IdentTok Ident
- | LifetimeTok Ident
- | Space Space Name
- | Doc String !AttrStyle !Bool
- | Shebang
- | Eof
- | Interpolated (Nonterminal Span)
- spaceNeeded :: Token -> Token -> Bool
- data Space
- data Delim
- data LitTok
- data AttrStyle
Abstract syntax trees
Top level
data SourceFile a Source #
This is the fundamental unit of parsing - it represents the contents of one source file. It is composed of an optional shebang line, inner attributes that follow, and then the module items.
Example:
#!/usr/bin/env rust
#![allow(dead_code)]
fn main() {
println!("Hello world")
}
Constructors
| SourceFile (Maybe Name) [Attribute a] [Item a] |
Instances
| Functor SourceFile Source # | |
| PrettyAnnotated SourceFile Source # | |
| Eq a => Eq (SourceFile a) Source # | |
| Data a => Data (SourceFile a) Source # | |
| Ord a => Ord (SourceFile a) Source # | |
| Show a => Show (SourceFile a) Source # | |
| Generic (SourceFile a) Source # | |
| NFData a => NFData (SourceFile a) Source # | |
| (Typeable * a, Monoid a) => Resolve (SourceFile a) Source # | |
| Pretty (SourceFile a) Source # | |
| Parse (SourceFile Span) Source # | |
| Generic1 * SourceFile Source # | |
| type Rep (SourceFile a) Source # | |
| type Rep1 * SourceFile Source # | |
General
data Mutability Source #
Encodes whether something can be updated or changed (syntax::ast::Mutability).
Instances
Qualifies whether something is using unsafe Rust or not (syntax::ast::Unsafety). Note that we
also use this to describe whether a Block is unsafe or not, while Rust has a seperate structure
(syntax::ast::BlockCheckMode) for that. This is because they also need to keep track of whether
an unsafe block is compiler generated.
An argument in a function header (syntax::ast::Arg, except with SelfKind and ExplicitSelf
inlined).
Example: x: usize, self, mut self, &self, &'lt mut self, mut self: Foo as in
trait Foo {
// Regular argument
fn new(x: usize) -> Foo;
// Self argument, by value
fn foo(self) -> i32;
fn bar(mut self);
// Self argument, by reference
fn baz(&self) -> Bar<'lt>;
fn qux(&'lt mut self) -> Bar<'lt>;
// Explicit self argument
fn quux(mut self: Foo);
}
Constructors
| Arg (Maybe (Pat a)) (Ty a) a | Regular argument |
| SelfValue Mutability a | Self argument, by value |
| SelfRegion (Maybe (Lifetime a)) Mutability a | Self argument, by reference |
| SelfExplicit (Ty a) Mutability a | Explicit self argument |
Instances
| Functor Arg Source # | |
| Eq a => Eq (Arg a) Source # | |
| Data a => Data (Arg a) Source # | |
| Ord a => Ord (Arg a) Source # | |
| Show a => Show (Arg a) Source # | |
| Generic (Arg a) Source # | |
| NFData a => NFData (Arg a) Source # | |
| Located a => Located (Arg a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Arg a) Source # | |
| Generic1 * Arg Source # | |
| type Rep (Arg a) Source # | |
| type Rep1 * Arg Source # | |
Header (not the body) of a function declaration (syntax::ast::FnDecl). The Bool argument
indicates whether the header is variadic (so whether the argument list ends in ...).
Example: (bar: i32) -> i32 as in
fn foo(bar: i32) -> i32 {
bar + 2
}
Instances
| Functor FnDecl Source # | |
| PrettyAnnotated FnDecl Source # | |
| Eq a => Eq (FnDecl a) Source # | |
| Data a => Data (FnDecl a) Source # | |
| Ord a => Ord (FnDecl a) Source # | |
| Show a => Show (FnDecl a) Source # | |
| Generic (FnDecl a) Source # | |
| NFData a => NFData (FnDecl a) Source # | |
| Located a => Located (FnDecl a) Source # | |
| (Typeable * a, Monoid a) => Resolve (FnDecl a) Source # | |
| Pretty (FnDecl a) Source # | |
| Generic1 * FnDecl Source # | |
| type Rep (FnDecl a) Source # | |
| type Rep1 * FnDecl Source # | |
Paths
Everything in Rust is namespaced using nested modules. A Path represents a path into nested
modules, possibly instantiating type parameters along the way (syntax::ast::Path). Much like
file paths, these paths can be relative or absolute (global) with respect to the crate root.
Paths are used to identify expressions (see PathExpr), types (see PathTy), and modules
(indirectly through ViewPath and such).
The Bool argument identifies whether the path is relative or absolute.
Example: std::cmp::PartialEq
Constructors
| Path Bool [PathSegment a] a |
Instances
| Functor Path Source # | |
| PrettyAnnotated Path Source # | |
| Eq a => Eq (Path a) Source # | |
| Data a => Data (Path a) Source # | |
| Ord a => Ord (Path a) Source # | |
| Show a => Show (Path a) Source # | |
| Generic (Path a) Source # | |
| NFData a => NFData (Path a) Source # | |
| Located a => Located (Path a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Path a) Source # | There are three potential instances for resolving a path (depending on what type it is). The
|
| Pretty (Path a) Source # | |
| Generic1 * Path Source # | |
| type Rep (Path a) Source # | |
| type Rep1 * Path Source # | |
data PathParameters a Source #
Parameters on a path segment (syntax::ast::PathParameters).
Constructors
| AngleBracketed [Lifetime a] [Ty a] [(Ident, Ty a)] a | Parameters in a chevron comma-delimited list ( Example: |
| Parenthesized [Ty a] (Maybe (Ty a)) a | Parameters in a parenthesized comma-delimited list, with an optional output type
( Example: |
Instances
| Functor PathParameters Source # | |
| Eq a => Eq (PathParameters a) Source # | |
| Data a => Data (PathParameters a) Source # | |
| Ord a => Ord (PathParameters a) Source # | |
| Show a => Show (PathParameters a) Source # | |
| Generic (PathParameters a) Source # | |
| NFData a => NFData (PathParameters a) Source # | |
| Located a => Located (PathParameters a) Source # | |
| (Typeable * a, Monoid a) => Resolve (PathParameters a) Source # | |
| Generic1 * PathParameters Source # | |
| type Rep (PathParameters a) Source # | |
| type Rep1 * PathParameters Source # | |
data PathSegment a Source #
Segment of a path (syntax::ast::PathSegment).
Constructors
| PathSegment Ident (Maybe (PathParameters a)) a |
Instances
| Functor PathSegment Source # | |
| Eq a => Eq (PathSegment a) Source # | |
| Data a => Data (PathSegment a) Source # | |
| Ord a => Ord (PathSegment a) Source # | |
| Show a => Show (PathSegment a) Source # | |
| Generic (PathSegment a) Source # | |
| NFData a => NFData (PathSegment a) Source # | |
| Located a => Located (PathSegment a) Source # | |
| Generic1 * PathSegment Source # | |
| type Rep (PathSegment a) Source # | |
| type Rep1 * PathSegment Source # | |
The explicit Self type in a "qualified path". The actual path, including the trait and the
associated item, is stored separately. The first argument is the type given to Self and the
second is the index of the associated qualified with this Self type
Instances
| Functor QSelf Source # | |
| Eq a => Eq (QSelf a) Source # | |
| Data a => Data (QSelf a) Source # | |
| Ord a => Ord (QSelf a) Source # | |
| Show a => Show (QSelf a) Source # | |
| Generic (QSelf a) Source # | |
| NFData a => NFData (QSelf a) Source # | |
| (Typeable * a, Monoid a) => Resolve (QSelf a) Source # | |
| Generic1 * QSelf Source # | |
| type Rep (QSelf a) Source # | |
| type Rep1 * QSelf Source # | |
Attributes
Attributes are annotations for other AST nodes (syntax::ast::Attribute). Note that
doc-comments are promoted to attributes.
Example: #[derive(Copy,Clone)] as in
#[derive(Clone, Copy)]
struct Complex { re: f32, im: f32 }
Constructors
| Attribute AttrStyle (Path a) TokenStream a | Regular attributes of the form |
| SugaredDoc AttrStyle Bool Name a | Doc comment attributes. The |
Instances
| Functor Attribute Source # | |
| PrettyAnnotated Attribute Source # | This instance prints attributes inline |
| Eq a => Eq (Attribute a) Source # | |
| Data a => Data (Attribute a) Source # | |
| Ord a => Ord (Attribute a) Source # | |
| Show a => Show (Attribute a) Source # | |
| Generic (Attribute a) Source # | |
| NFData a => NFData (Attribute a) Source # | |
| Located a => Located (Attribute a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Attribute a) Source # | |
| Pretty (Attribute a) Source # | |
| Parse (Attribute Span) Source # | |
| Generic1 * Attribute Source # | |
| type Rep (Attribute a) Source # | |
| type Rep1 * Attribute Source # | |
Distinguishes between attributes that are associated with the node that follows them and
attributes that are associated with the node that contains them (syntax::ast::AttrStyle).
These two cases need to be distinguished only for pretty printing - they are otherwise
fundamentally equivalent.
Example: #[repr(C)] is an outer attribute while #![feature(slice_patterns)] is an inner one
Literals
Literals in Rust (syntax::ast::Lit). As discussed in Suffix, Rust AST is designed to parse
suffixes for all literals, even if they are currently only valid on Int and Float literals.
Constructors
| Str String StrStyle Suffix a | string (example: |
| ByteStr [Word8] StrStyle Suffix a | byte string (example: |
| Char Char Suffix a | character (example: |
| Byte Word8 Suffix a | byte (example: |
| Int IntRep Integer Suffix a | integer (example: |
| Float Double Suffix a | float (example: |
| Bool Bool Suffix a | boolean (example: |
Instances
| Functor Lit Source # | |
| PrettyAnnotated Lit Source # | |
| Eq a => Eq (Lit a) Source # | |
| Data a => Data (Lit a) Source # | |
| Ord a => Ord (Lit a) Source # | |
| Show a => Show (Lit a) Source # | |
| Generic (Lit a) Source # | |
| NFData a => NFData (Lit a) Source # | |
| Located a => Located (Lit a) Source # | |
| Resolve (Lit a) Source # | |
| Pretty (Lit a) Source # | |
| Parse (Lit Span) Source # | |
| Generic1 * Lit Source # | |
| type Rep (Lit a) Source # | |
| type Rep1 * Lit Source # | |
The suffix on a literal (unifies syntax::ast::LitIntType, syntax::ast::IntTy,
syntax::ast::UintTy, and syntax::ast::FloatTy). As of today, only numeric types can have
suffixes, but the possibility of adding more (possibly arbitrary) suffixes to literals in general
is being kept open intentionally. RFC about future-proofing literal
suffixes
Examples: i32, isize, and f32
The base of the number in an Int literal can be binary (e.g. 0b1100), octal (e.g. 0o14),
decimal (e.g. 12), or hexadecimal (e.g. 0xc).
Style of a string literal (syntax::ast::StrStyle).
Expressions
Expression (syntax::ast::Expr). Note that Rust pushes into expressions an unusual number
of constructs including if, while, match, etc.
Constructors
| Box [Attribute a] (Expr a) a | box expression (example: |
| InPlace [Attribute a] (Expr a) (Expr a) a | in-place expression - first |
| Vec [Attribute a] [Expr a] a | array literal (example: |
| Call [Attribute a] (Expr a) [Expr a] a | function call where the first |
| MethodCall [Attribute a] (Expr a) Ident (Maybe [Ty a]) [Expr a] a | method call where the first |
| TupExpr [Attribute a] [Expr a] a | tuple (example: |
| Binary [Attribute a] BinOp (Expr a) (Expr a) a | binary operation (example: |
| Unary [Attribute a] UnOp (Expr a) a | unary operation (example: |
| Lit [Attribute a] (Lit a) a | literal (example: |
| Cast [Attribute a] (Expr a) (Ty a) a | cast (example: |
| TypeAscription [Attribute a] (Expr a) (Ty a) a | type annotation (example: |
| If [Attribute a] (Expr a) (Block a) (Maybe (Expr a)) a | if expression, with an optional |
| IfLet [Attribute a] (NonEmpty (Pat a)) (Expr a) (Block a) (Maybe (Expr a)) a | if-let expression with an optional else block (example: |
| While [Attribute a] (Expr a) (Block a) (Maybe (Label a)) a | while loop, with an optional label (example: |
| WhileLet [Attribute a] (NonEmpty (Pat a)) (Expr a) (Block a) (Maybe (Label a)) a | while-let loop, with an optional label (example: |
| ForLoop [Attribute a] (Pat a) (Expr a) (Block a) (Maybe (Label a)) a | for loop, with an optional label (example: |
| Loop [Attribute a] (Block a) (Maybe (Label a)) a | conditionless loop (can be exited with |
| Match [Attribute a] (Expr a) [Arm a] a | match block |
| Closure [Attribute a] Movability CaptureBy (FnDecl a) (Expr a) a | closure (example: |
| BlockExpr [Attribute a] (Block a) a | (possibly unsafe) block (example: |
| Catch [Attribute a] (Block a) a | a catch block (example: |
| Assign [Attribute a] (Expr a) (Expr a) a | assignment (example: |
| AssignOp [Attribute a] BinOp (Expr a) (Expr a) a | assignment with an operator (example: |
| FieldAccess [Attribute a] (Expr a) Ident a | access of a named struct field (example: |
| TupField [Attribute a] (Expr a) Int a | access of an unnamed field of a struct or tuple-struct (example: |
| Index [Attribute a] (Expr a) (Expr a) a | indexing operation (example: |
| Range [Attribute a] (Maybe (Expr a)) (Maybe (Expr a)) RangeLimits a | range (examples: |
| PathExpr [Attribute a] (Maybe (QSelf a)) (Path a) a | variable reference |
| AddrOf [Attribute a] Mutability (Expr a) a | referencing operation (example: |
| Break [Attribute a] (Maybe (Label a)) (Maybe (Expr a)) a |
|
| Continue [Attribute a] (Maybe (Label a)) a |
|
| Ret [Attribute a] (Maybe (Expr a)) a |
|
| MacExpr [Attribute a] (Mac a) a | macro invocation before expansion |
| Struct [Attribute a] (Path a) [Field a] (Maybe (Expr a)) a | struct literal expression (examples: |
| Repeat [Attribute a] (Expr a) (Expr a) a | array literal constructed from one repeated element (example: |
| ParenExpr [Attribute a] (Expr a) a | no-op: used solely so we can pretty print faithfully |
| Try [Attribute a] (Expr a) a | sugar for error handling with |
| Yield [Attribute a] (Maybe (Expr a)) a |
|
Instances
| Functor Expr Source # | |
| PrettyAnnotated Expr Source # | |
| Eq a => Eq (Expr a) Source # | |
| Data a => Data (Expr a) Source # | |
| Ord a => Ord (Expr a) Source # | |
| Show a => Show (Expr a) Source # | |
| Generic (Expr a) Source # | |
| NFData a => NFData (Expr a) Source # | |
| Located a => Located (Expr a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Expr a) Source # | |
| Pretty (Expr a) Source # | |
| Parse (Expr Span) Source # | |
| Generic1 * Expr Source # | |
| type Rep (Expr a) Source # | |
| type Rep1 * Expr Source # | |
ABIs support by Rust's foreign function interface (syntax::abi::Abi). Note that of these,
only Rust, C, System, RustIntrinsic, RustCall, and PlatformIntrinsic and Unadjusted
are cross-platform - all the rest are platform-specific.
Example: "C" as in extern "C" fn foo(x: i32);
An arm of a Match expression (syntax::ast::Arm). An arm has at least one patten, possibly a
guard expression, and a body expression.
Example: n if n % 4 == 3 => { println!("{} % 4 = 3", n) } as in
match n {
n if n % 4 == 3 => { println!("{} % 4 = 3", n) }
n if n % 4 == 1 => { println!("{} % 4 = 1", n) }
_ => println!("{} % 2 = 0", n)
}
Instances
| Functor Arm Source # | |
| Eq a => Eq (Arm a) Source # | |
| Data a => Data (Arm a) Source # | |
| Ord a => Ord (Arm a) Source # | |
| Show a => Show (Arm a) Source # | |
| Generic (Arm a) Source # | |
| NFData a => NFData (Arm a) Source # | |
| Located a => Located (Arm a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Arm a) Source # | |
| Generic1 * Arm Source # | |
| type Rep (Arm a) Source # | |
| type Rep1 * Arm Source # | |
Binary operators, used in the Binary and AssignOp constructors of Expr
(syntax::ast::BinOp).
Example: + as in 1 + 1 or 1 += 1
Constructors
| AddOp |
|
| SubOp |
|
| MulOp |
|
| DivOp |
|
| RemOp |
|
| AndOp |
|
| OrOp |
|
| BitXorOp |
|
| BitAndOp |
|
| BitOrOp |
|
| ShlOp |
|
| ShrOp |
|
| EqOp |
|
| LtOp |
|
| LeOp |
|
| NeOp |
|
| GeOp |
|
| GtOp |
|
Used to annotate loops, breaks, continues, etc.
Instances
| Functor Label Source # | |
| Eq a => Eq (Label a) Source # | |
| Data a => Data (Label a) Source # | |
| Ord a => Ord (Label a) Source # | |
| Show a => Show (Label a) Source # | |
| Generic (Label a) Source # | |
| NFData a => NFData (Label a) Source # | |
| Located a => Located (Label a) Source # | |
| Generic1 * Label Source # | |
| type Rep (Label a) Source # | |
| type Rep1 * Label Source # | |
Describes how a Closure should close over its free variables (syntax::ast::CaptureBy).
data Movability Source #
The movability of a generator / closure literal (syntax::ast::Movability).
Instances
Field in a struct literal expression (syntax::ast::Field).
Example: x: 1 in Point { x: 1, y: 2 }
Instances
| Functor Field Source # | |
| PrettyAnnotated Field Source # | |
| Eq a => Eq (Field a) Source # | |
| Data a => Data (Field a) Source # | |
| Ord a => Ord (Field a) Source # | |
| Show a => Show (Field a) Source # | |
| Generic (Field a) Source # | |
| NFData a => NFData (Field a) Source # | |
| Located a => Located (Field a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Field a) Source # | |
| Pretty (Field a) Source # | |
| Generic1 * Field Source # | |
| type Rep (Field a) Source # | |
| type Rep1 * Field Source # | |
data RangeLimits Source #
Limit types of a Range
Types and lifetimes
Types (syntax::ast::Ty).
Constructors
| Slice (Ty a) a | variable length slice (example: |
| Array (Ty a) (Expr a) a | fixed length array (example: |
| Ptr Mutability (Ty a) a | raw pointer (example: |
| Rptr (Maybe (Lifetime a)) Mutability (Ty a) a | reference (example: |
| BareFn Unsafety Abi [LifetimeDef a] (FnDecl a) a | bare function (example: |
| Never a | never type: |
| TupTy [Ty a] a | tuple (example: |
| PathTy (Maybe (QSelf a)) (Path a) a | path type (examples: |
| TraitObject (NonEmpty (TyParamBound a)) a | trait object type (example: |
| ImplTrait (NonEmpty (TyParamBound a)) a | impl trait type (see the
RFC)
(example: |
| ParenTy (Ty a) a | no-op; kept solely so that we can pretty print faithfully |
| Typeof (Expr a) a | typeof, currently unsupported in |
| Infer a | inferred type: |
| MacTy (Mac a) a | generated from a call to a macro (example: |
Instances
| Functor Ty Source # | |
| PrettyAnnotated Ty Source # | |
| Eq a => Eq (Ty a) Source # | |
| Data a => Data (Ty a) Source # | |
| Ord a => Ord (Ty a) Source # | |
| Show a => Show (Ty a) Source # | |
| Generic (Ty a) Source # | |
| NFData a => NFData (Ty a) Source # | |
| Located a => Located (Ty a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Ty a) Source # | |
| Pretty (Ty a) Source # | |
| Parse (Ty Span) Source # | |
| Generic1 * Ty Source # | |
| type Rep (Ty a) Source # | |
| type Rep1 * Ty Source # | |
Represents lifetimes and type parameters attached to a declaration of a functions, enums,
traits, etc. (syntax::ast::Generics). Note that lifetime definitions are always required to be
before the type parameters.
This one AST node is also a bit weird: it is the only node whose source representation is not
compact - the lifetimes and type parameters occur by themselves between < and > then a
bit further the where clause occurs after a where.
Example: <'a, 'b: 'c, T: 'a> and where Option<T>: Copy as in
fn nonsense<'a, 'b: 'c, T: 'a>(x: i32) -> i32
where Option<T>: Copy {
1
}.
Constructors
| Generics [LifetimeDef a] [TyParam a] (WhereClause a) a |
Instances
| Functor Generics Source # | |
| PrettyAnnotated Generics Source # | |
| Eq a => Eq (Generics a) Source # | |
| Data a => Data (Generics a) Source # | |
| Ord a => Ord (Generics a) Source # | |
| Show a => Show (Generics a) Source # | |
| Generic (Generics a) Source # | |
| Semigroup a => Semigroup (Generics a) Source # | |
| (Semigroup a, Monoid a) => Monoid (Generics a) Source # | |
| NFData a => NFData (Generics a) Source # | |
| Located a => Located (Generics a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Generics a) Source # | |
| Pretty (Generics a) Source # | |
| Parse (Generics Span) Source # | |
| Generic1 * Generics Source # | |
| type Rep (Generics a) Source # | |
| type Rep1 * Generics Source # | |
A lifetime is a name for a scope in a program (syntax::ast::Lifetime). One of the novel
features of Rust is that code can be parametrized over lifetimes. Syntactically, they are like
regular identifiers, but start with a tick ' mark. The Name argument is not supposed to
include that tick.
Examples: 'a or 'static
Instances
| Functor Lifetime Source # | |
| PrettyAnnotated Lifetime Source # | |
| Eq a => Eq (Lifetime a) Source # | |
| Data a => Data (Lifetime a) Source # | |
| Ord a => Ord (Lifetime a) Source # | |
| Show a => Show (Lifetime a) Source # | |
| Generic (Lifetime a) Source # | |
| NFData a => NFData (Lifetime a) Source # | |
| Located a => Located (Lifetime a) Source # | |
| Typeable * a => Resolve (Lifetime a) Source # | |
| Pretty (Lifetime a) Source # | |
| Generic1 * Lifetime Source # | |
| type Rep (Lifetime a) Source # | |
| type Rep1 * Lifetime Source # | |
data LifetimeDef a Source #
A lifetime definition, introducing a lifetime and the other lifetimes that bound it
(syntax::ast::LifetimeDef).
Example: 'a: 'b + 'c + 'd
Constructors
| LifetimeDef [Attribute a] (Lifetime a) [Lifetime a] a |
Instances
| Functor LifetimeDef Source # | |
| PrettyAnnotated LifetimeDef Source # | |
| Eq a => Eq (LifetimeDef a) Source # | |
| Data a => Data (LifetimeDef a) Source # | |
| Ord a => Ord (LifetimeDef a) Source # | |
| Show a => Show (LifetimeDef a) Source # | |
| Generic (LifetimeDef a) Source # | |
| NFData a => NFData (LifetimeDef a) Source # | |
| Located a => Located (LifetimeDef a) Source # | |
| (Typeable * a, Monoid a) => Resolve (LifetimeDef a) Source # | |
| Pretty (LifetimeDef a) Source # | |
| Parse (LifetimeDef Span) Source # | |
| Generic1 * LifetimeDef Source # | |
| type Rep (LifetimeDef a) Source # | |
| type Rep1 * LifetimeDef Source # | |
Type parameter definition used in Generics (syntax::ast::TyParam). Note that each
parameter can have any number of (lifetime or trait) bounds, as well as possibly a default type.
Instances
| Functor TyParam Source # | |
| PrettyAnnotated TyParam Source # | |
| Eq a => Eq (TyParam a) Source # | |
| Data a => Data (TyParam a) Source # | |
| Ord a => Ord (TyParam a) Source # | |
| Show a => Show (TyParam a) Source # | |
| Generic (TyParam a) Source # | |
| NFData a => NFData (TyParam a) Source # | |
| Located a => Located (TyParam a) Source # | |
| (Typeable * a, Monoid a) => Resolve (TyParam a) Source # | |
| Pretty (TyParam a) Source # | |
| Parse (TyParam Span) Source # | |
| Generic1 * TyParam Source # | |
| type Rep (TyParam a) Source # | |
| type Rep1 * TyParam Source # | |
data TyParamBound a Source #
Bounds that can be placed on types (syntax::ast::TyParamBound). These can be either traits or
lifetimes.
Constructors
| TraitTyParamBound (PolyTraitRef a) TraitBoundModifier a | trait bound |
| RegionTyParamBound (Lifetime a) a | lifetime bound |
Instances
| Functor TyParamBound Source # | |
| PrettyAnnotated TyParamBound Source # | |
| Eq a => Eq (TyParamBound a) Source # | |
| Data a => Data (TyParamBound a) Source # | |
| Ord a => Ord (TyParamBound a) Source # | |
| Show a => Show (TyParamBound a) Source # | |
| Generic (TyParamBound a) Source # | |
| NFData a => NFData (TyParamBound a) Source # | |
| Located a => Located (TyParamBound a) Source # | |
| (Typeable * a, Monoid a) => Resolve (TyParamBound a) Source # | |
| Pretty (TyParamBound a) Source # | |
| Generic1 * TyParamBound Source # | |
| type Rep (TyParamBound a) Source # | |
| type Rep1 * TyParamBound Source # | |
partitionTyParamBounds :: [TyParamBound a] -> ([TyParamBound a], [TyParamBound a]) Source #
Partition a list of TyParamBound into a tuple of the TraitTyParamBound and
RegionTyParamBound variants.
data WhereClause a Source #
A where clause in a definition, where one can apply a series of constraints to the types
introduced and used by a Generic clause (syntax::ast::WhereClause). In many cases, where
is the only way to express certain bounds (since those bounds may not be immediately on a type
defined in the generic, but on a type derived from types defined in the generic).
Note that while WhereClause is a field of Generic, not all uses of generics are coupled with
a where clause. In those cases, we leave the list of predicates empty.
Example: where Option<T>: Debug as in
impl<T> PrintInOption for T where Option<T>: Debug { }
Constructors
| WhereClause [WherePredicate a] a |
Instances
| Functor WhereClause Source # | |
| PrettyAnnotated WhereClause Source # | |
| Eq a => Eq (WhereClause a) Source # | |
| Data a => Data (WhereClause a) Source # | |
| Ord a => Ord (WhereClause a) Source # | |
| Show a => Show (WhereClause a) Source # | |
| Generic (WhereClause a) Source # | |
| Semigroup a => Semigroup (WhereClause a) Source # | |
| (Semigroup a, Monoid a) => Monoid (WhereClause a) Source # | |
| NFData a => NFData (WhereClause a) Source # | |
| Located a => Located (WhereClause a) Source # | |
| (Typeable * a, Monoid a) => Resolve (WhereClause a) Source # | |
| Pretty (WhereClause a) Source # | |
| Parse (WhereClause Span) Source # | |
| Generic1 * WhereClause Source # | |
| type Rep (WhereClause a) Source # | |
| type Rep1 * WhereClause Source # | |
whereClause :: Generics a -> WhereClause a Source #
Extract the where clause from a Generics.
data WherePredicate a Source #
An individual predicate in a WhereClause (syntax::ast::WherePredicate).
Constructors
| BoundPredicate [LifetimeDef a] (Ty a) [TyParamBound a] a | type bound ( |
| RegionPredicate (Lifetime a) [Lifetime a] a | lifetime predicate ( |
| EqPredicate (Ty a) (Ty a) a | equality predicate ( |
Instances
| Functor WherePredicate Source # | |
| PrettyAnnotated WherePredicate Source # | |
| Eq a => Eq (WherePredicate a) Source # | |
| Data a => Data (WherePredicate a) Source # | |
| Ord a => Ord (WherePredicate a) Source # | |
| Show a => Show (WherePredicate a) Source # | |
| Generic (WherePredicate a) Source # | |
| NFData a => NFData (WherePredicate a) Source # | |
| Located a => Located (WherePredicate a) Source # | |
| (Typeable * a, Monoid a) => Resolve (WherePredicate a) Source # | |
| Pretty (WherePredicate a) Source # | |
| Generic1 * WherePredicate Source # | |
| type Rep (WherePredicate a) Source # | |
| type Rep1 * WherePredicate Source # | |
data PolyTraitRef a Source #
Trait ref parametrized over lifetimes introduced by a for (syntax::ast::PolyTraitRef).
Example: for<'a,'b> Foo<&'a Bar>
Constructors
| PolyTraitRef [LifetimeDef a] (TraitRef a) a |
Instances
| Functor PolyTraitRef Source # | |
| PrettyAnnotated PolyTraitRef Source # | |
| Eq a => Eq (PolyTraitRef a) Source # | |
| Data a => Data (PolyTraitRef a) Source # | |
| Ord a => Ord (PolyTraitRef a) Source # | |
| Show a => Show (PolyTraitRef a) Source # | |
| Generic (PolyTraitRef a) Source # | |
| NFData a => NFData (PolyTraitRef a) Source # | |
| Located a => Located (PolyTraitRef a) Source # | |
| (Typeable * a, Monoid a) => Resolve (PolyTraitRef a) Source # | |
| Pretty (PolyTraitRef a) Source # | |
| Generic1 * PolyTraitRef Source # | |
| type Rep (PolyTraitRef a) Source # | |
| type Rep1 * PolyTraitRef Source # | |
A TraitRef is a path which identifies a trait (syntax::ast::TraitRef).
Instances
| Functor TraitRef Source # | |
| PrettyAnnotated TraitRef Source # | |
| Eq a => Eq (TraitRef a) Source # | |
| Data a => Data (TraitRef a) Source # | |
| Ord a => Ord (TraitRef a) Source # | |
| Show a => Show (TraitRef a) Source # | |
| Generic (TraitRef a) Source # | |
| NFData a => NFData (TraitRef a) Source # | |
| Located a => Located (TraitRef a) Source # | |
| (Typeable * a, Monoid a) => Resolve (TraitRef a) Source # | |
| Pretty (TraitRef a) Source # | |
| Generic1 * TraitRef Source # | |
| type Rep (TraitRef a) Source # | |
| type Rep1 * TraitRef Source # | |
data TraitBoundModifier Source #
Modifier on a bound, currently this is only used for ?Sized, where the modifier is Maybe.
Negative bounds should also be handled here.
Instances
Patterns
Patterns (syntax::ast::Pat).
Constructors
| WildP a | wildcard pattern: |
| IdentP BindingMode Ident (Maybe (Pat a)) a | identifier pattern - either a new bound variable or a unit (tuple) struct pattern, or a
const pattern. Disambiguation cannot be done with parser alone, so it happens during name
resolution. (example: |
| StructP (Path a) [FieldPat a] Bool a | struct pattern. The |
| TupleStructP (Path a) [Pat a] (Maybe Int) a | tuple struct pattern. If the |
| PathP (Maybe (QSelf a)) (Path a) a | path pattern (example |
| TupleP [Pat a] (Maybe Int) a | tuple pattern. If the |
| BoxP (Pat a) a | box pattern (example: |
| RefP (Pat a) Mutability a | reference pattern (example: |
| LitP (Expr a) a | literal (example: |
| RangeP (Expr a) (Expr a) a | range pattern (example: |
| SliceP [Pat a] (Maybe (Pat a)) [Pat a] a | slice pattern where, as per this RFC,
the pattern is split into the patterns before/after the |
| MacP (Mac a) a | generated from a call to a macro (example: |
Instances
| Functor Pat Source # | |
| PrettyAnnotated Pat Source # | |
| Eq a => Eq (Pat a) Source # | |
| Data a => Data (Pat a) Source # | |
| Ord a => Ord (Pat a) Source # | |
| Show a => Show (Pat a) Source # | |
| Generic (Pat a) Source # | |
| NFData a => NFData (Pat a) Source # | |
| Located a => Located (Pat a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Pat a) Source # | |
| Pretty (Pat a) Source # | |
| Parse (Pat Span) Source # | |
| Generic1 * Pat Source # | |
| type Rep (Pat a) Source # | |
| type Rep1 * Pat Source # | |
data BindingMode Source #
Describes how a value bound to an identifier in a pattern is going to be borrowed
(syntax::ast::BindingMode).
Example: &mut in |&mut x: i32| -> { x += 1 }
Constructors
| ByRef Mutability | |
| ByValue Mutability |
Instances
Field in a struct literal pattern (syntax::ast::FieldPat). The field name Ident is optional
but, when it is Nothing, the pattern the field is destructured to must be IdentP.
Example: x in Point { x, y }
Instances
| Functor FieldPat Source # | |
| PrettyAnnotated FieldPat Source # | |
| Eq a => Eq (FieldPat a) Source # | |
| Data a => Data (FieldPat a) Source # | |
| Ord a => Ord (FieldPat a) Source # | |
| Show a => Show (FieldPat a) Source # | |
| Generic (FieldPat a) Source # | |
| NFData a => NFData (FieldPat a) Source # | |
| Located a => Located (FieldPat a) Source # | |
| (Typeable * a, Monoid a) => Resolve (FieldPat a) Source # | |
| Pretty (FieldPat a) Source # | |
| Generic1 * FieldPat Source # | |
| type Rep (FieldPat a) Source # | |
| type Rep1 * FieldPat Source # | |
Statements
A statement (syntax::ast::Stmt). Rust has relatively few types of statements by turning both
expressions (sometimes with a required semicolon at the end) and items into statements.
Constructors
| Local (Pat a) (Maybe (Ty a)) (Maybe (Expr a)) [Attribute a] a | A local |
| ItemStmt (Item a) a | Item definition (example: |
| NoSemi (Expr a) a | Expression without a trailing semicolon (example: |
| Semi (Expr a) a | Expression with a trailing semicolon (example: |
| MacStmt (Mac a) MacStmtStyle [Attribute a] a | A macro call (example: |
Instances
| Functor Stmt Source # | |
| PrettyAnnotated Stmt Source # | |
| Eq a => Eq (Stmt a) Source # | |
| Data a => Data (Stmt a) Source # | |
| Ord a => Ord (Stmt a) Source # | |
| Show a => Show (Stmt a) Source # | |
| Generic (Stmt a) Source # | |
| NFData a => NFData (Stmt a) Source # | |
| Located a => Located (Stmt a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Stmt a) Source # | |
| Pretty (Stmt a) Source # | |
| Parse (Stmt Span) Source # | |
| Generic1 * Stmt Source # | |
| type Rep (Stmt a) Source # | |
| type Rep1 * Stmt Source # | |
Items
A top-level item, possibly in a Mod or a ItemStmt (syntax::ast::Item with
syntax::ast::ItemKind inlined).
Example: fn main() { return; }
Constructors
| ExternCrate [Attribute a] (Visibility a) Ident (Maybe Ident) a | extern crate item, with optional original crate name.
Examples: |
| Use [Attribute a] (Visibility a) (UseTree a) a | use declaration ( |
| Static [Attribute a] (Visibility a) Ident (Ty a) Mutability (Expr a) a | static item ( |
| ConstItem [Attribute a] (Visibility a) Ident (Ty a) (Expr a) a | constant item ( |
| Fn [Attribute a] (Visibility a) Ident (FnDecl a) Unsafety Constness Abi (Generics a) (Block a) a | function declaration ( |
| Mod [Attribute a] (Visibility a) Ident (Maybe [Item a]) a | module declaration ( |
| ForeignMod [Attribute a] (Visibility a) Abi [ForeignItem a] a | external module ( |
| TyAlias [Attribute a] (Visibility a) Ident (Ty a) (Generics a) a | type alias ( |
| Enum [Attribute a] (Visibility a) Ident [Variant a] (Generics a) a | enum definition ( |
| StructItem [Attribute a] (Visibility a) Ident (VariantData a) (Generics a) a | struct definition ( |
| Union [Attribute a] (Visibility a) Ident (VariantData a) (Generics a) a | union definition ( |
| Trait [Attribute a] (Visibility a) Ident Bool Unsafety (Generics a) [TyParamBound a] [TraitItem a] a | trait declaration ( |
| TraitAlias [Attribute a] (Visibility a) Ident (Generics a) (NonEmpty (TyParamBound a)) a | trait alias
Example: |
| Impl [Attribute a] (Visibility a) Defaultness Unsafety ImplPolarity (Generics a) (Maybe (TraitRef a)) (Ty a) [ImplItem a] a | implementation
Example: |
| MacItem [Attribute a] (Maybe Ident) (Mac a) a | generated from a call to a macro
Example: |
| MacroDef [Attribute a] Ident TokenStream a | definition of a macro via |
Instances
| Functor Item Source # | |
| PrettyAnnotated Item Source # | |
| Eq a => Eq (Item a) Source # | |
| Data a => Data (Item a) Source # | |
| Ord a => Ord (Item a) Source # | |
| Show a => Show (Item a) Source # | |
| Generic (Item a) Source # | |
| NFData a => NFData (Item a) Source # | |
| Located a => Located (Item a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Item a) Source # | |
| Pretty (Item a) Source # | |
| Parse (Item Span) Source # | |
| Generic1 * Item Source # | |
| type Rep (Item a) Source # | |
| type Rep1 * Item Source # | |
data ForeignItem a Source #
An item within an extern block (syntax::ast::ForeignItem with syntax::ast::ForeignItemKind
inlined).
Example: static ext: u8 in extern "C" { static ext: u8 }
Constructors
| ForeignFn [Attribute a] (Visibility a) Ident (FnDecl a) (Generics a) a | Foreign function Example: |
| ForeignStatic [Attribute a] (Visibility a) Ident (Ty a) Mutability a | Foreign static variable, optionally mutable Example: |
| ForeignTy [Attribute a] (Visibility a) Ident a | Foreign type Example: |
Instances
| Functor ForeignItem Source # | |
| PrettyAnnotated ForeignItem Source # | |
| Eq a => Eq (ForeignItem a) Source # | |
| Data a => Data (ForeignItem a) Source # | |
| Ord a => Ord (ForeignItem a) Source # | |
| Show a => Show (ForeignItem a) Source # | |
| Generic (ForeignItem a) Source # | |
| NFData a => NFData (ForeignItem a) Source # | |
| Located a => Located (ForeignItem a) Source # | |
| (Typeable * a, Monoid a) => Resolve (ForeignItem a) Source # | |
| Pretty (ForeignItem a) Source # | |
| Generic1 * ForeignItem Source # | |
| type Rep (ForeignItem a) Source # | |
| type Rep1 * ForeignItem Source # | |
An item within an impl (syntax::ast::ImplItem with syntax::ast::ImplItemKind inlined).
Examples:
impl MyTrait {
// Associated constant
const ID: i32 = 1;
// Method
fn area(&self) -> f64 { 1f64 }
// Associated type
type N = i32;
// Call to a macro
foo!{}
}
Constructors
| ConstI [Attribute a] (Visibility a) Defaultness Ident (Ty a) (Expr a) a | Associated constant |
| MethodI [Attribute a] (Visibility a) Defaultness Ident (Generics a) (MethodSig a) (Block a) a | Method |
| TypeI [Attribute a] (Visibility a) Defaultness Ident (Ty a) a | Associated type |
| MacroI [Attribute a] Defaultness (Mac a) a | Macro call |
Instances
| Functor ImplItem Source # | |
| PrettyAnnotated ImplItem Source # | |
| Eq a => Eq (ImplItem a) Source # | |
| Data a => Data (ImplItem a) Source # | |
| Ord a => Ord (ImplItem a) Source # | |
| Show a => Show (ImplItem a) Source # | |
| Generic (ImplItem a) Source # | |
| NFData a => NFData (ImplItem a) Source # | |
| Located a => Located (ImplItem a) Source # | |
| (Typeable * a, Monoid a) => Resolve (ImplItem a) Source # | |
| Pretty (ImplItem a) Source # | |
| Parse (ImplItem Span) Source # | |
| Generic1 * ImplItem Source # | |
| type Rep (ImplItem a) Source # | |
| type Rep1 * ImplItem Source # | |
Item declaration within a trait declaration (syntax::ast::TraitItem with
syntax::ast::TraitItemKind inlined), possibly including a default implementation. A trait item
is either required (meaning it doesn't have an implementation, just a signature) or provided
(meaning it has a default implementation).
Examples:
trait MyTrait {
// Associated constant
const ID: i32 = 1;
// Method
fn area(&self) -> f64;
// Associated type
type N: fmt::Display;
// Call to a macro
foo!{}
}
Constructors
| ConstT [Attribute a] Ident (Ty a) (Maybe (Expr a)) a | Associated constants |
| MethodT [Attribute a] Ident (Generics a) (MethodSig a) (Maybe (Block a)) a | Method with optional body |
| TypeT [Attribute a] Ident [TyParamBound a] (Maybe (Ty a)) a | Possibly abstract associated types |
| MacroT [Attribute a] (Mac a) a | Call to a macro |
Instances
| Functor TraitItem Source # | |
| PrettyAnnotated TraitItem Source # | |
| Eq a => Eq (TraitItem a) Source # | |
| Data a => Data (TraitItem a) Source # | |
| Ord a => Ord (TraitItem a) Source # | |
| Show a => Show (TraitItem a) Source # | |
| Generic (TraitItem a) Source # | |
| NFData a => NFData (TraitItem a) Source # | |
| Located a => Located (TraitItem a) Source # | |
| (Typeable * a, Monoid a) => Resolve (TraitItem a) Source # | |
| Pretty (TraitItem a) Source # | |
| Parse (TraitItem Span) Source # | |
| Generic1 * TraitItem Source # | |
| type Rep (TraitItem a) Source # | |
| type Rep1 * TraitItem Source # | |
data Defaultness Source #
An ImplItem can be marked default (syntax::ast::Defaultness).
data ImplPolarity Source #
For traits with a default impl, one can "opt out" of that impl with a negative impl, by adding
! mark before the trait name. RFC on builtin
traits
Example: ! as in impl !Trait for Foo { }
data StructField a Source #
Field of a struct (syntax::ast::StructField) used in declarations
Example: bar: usize as in struct Foo { bar: usize }
Constructors
| StructField (Maybe Ident) (Visibility a) (Ty a) [Attribute a] a |
Instances
| Functor StructField Source # | |
| PrettyAnnotated StructField Source # | |
| Eq a => Eq (StructField a) Source # | |
| Data a => Data (StructField a) Source # | |
| Ord a => Ord (StructField a) Source # | |
| Show a => Show (StructField a) Source # | |
| Generic (StructField a) Source # | |
| NFData a => NFData (StructField a) Source # | |
| Located a => Located (StructField a) Source # | |
| (Typeable * a, Monoid a) => Resolve (StructField a) Source # | |
| Pretty (StructField a) Source # | |
| Generic1 * StructField Source # | |
| type Rep (StructField a) Source # | |
| type Rep1 * StructField Source # | |
A variant in Rust is a constructor (either in a StructItem, Union, or Enum) which groups
together fields (syntax::ast::Variant). In the case of a unit variant, there can also be an
explicit discriminant expression.
Instances
| Functor Variant Source # | |
| PrettyAnnotated Variant Source # | |
| Eq a => Eq (Variant a) Source # | |
| Data a => Data (Variant a) Source # | |
| Ord a => Ord (Variant a) Source # | |
| Show a => Show (Variant a) Source # | |
| Generic (Variant a) Source # | |
| NFData a => NFData (Variant a) Source # | |
| Located a => Located (Variant a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Variant a) Source # | |
| Pretty (Variant a) Source # | |
| Generic1 * Variant Source # | |
| type Rep (Variant a) Source # | |
| type Rep1 * Variant Source # | |
data VariantData a Source #
Main payload in a Variant (syntax::ast::VariantData).
Examples:
enum Foo {
// Struct variant
Bar { x: f64 },
// Tuple variant
Baz(i32, i32),
// Unit variant
Qux,
}
Constructors
| StructD [StructField a] a | Struct variant |
| TupleD [StructField a] a | Tuple variant |
| UnitD a | Unit variant |
Instances
| Functor VariantData Source # | |
| Eq a => Eq (VariantData a) Source # | |
| Data a => Data (VariantData a) Source # | |
| Ord a => Ord (VariantData a) Source # | |
| Show a => Show (VariantData a) Source # | |
| Generic (VariantData a) Source # | |
| NFData a => NFData (VariantData a) Source # | |
| Located a => Located (VariantData a) Source # | |
| (Typeable * a, Monoid a) => Resolve (VariantData a) Source # | |
| Generic1 * VariantData Source # | |
| type Rep (VariantData a) Source # | |
| type Rep1 * VariantData Source # | |
Paths used in Use items (ast::syntax::UseTree).
Examples:
// Simple use paths
use foo::bar::baz as quux;
use foo::bar::baz;
// Glob use paths
use foo::bar::*;
// Nested use paths
use foo::bar::{a, b, c::quux as d}
Constructors
| UseTreeSimple (Path a) (Maybe Ident) a | Simple path, optionally ending in an |
| UseTreeGlob (Path a) a | Path ending in a glob pattern |
| UseTreeNested (Path a) [UseTree a] a | Path ending in a list of more paths |
Instances
| Functor UseTree Source # | |
| PrettyAnnotated UseTree Source # | |
| Eq a => Eq (UseTree a) Source # | |
| Data a => Data (UseTree a) Source # | |
| Ord a => Ord (UseTree a) Source # | |
| Show a => Show (UseTree a) Source # | |
| Generic (UseTree a) Source # | |
| NFData a => NFData (UseTree a) Source # | |
| Located a => Located (UseTree a) Source # | |
| (Typeable * a, Monoid a) => Resolve (UseTree a) Source # | |
| Pretty (UseTree a) Source # | |
| Generic1 * UseTree Source # | |
| type Rep (UseTree a) Source # | |
| type Rep1 * UseTree Source # | |
data Visibility a Source #
The visibility modifier dictates from where one can access something
(ast::syntax::Visibility). RFC about adding restricted
visibility
Constructors
| PublicV |
|
| CrateV |
|
| RestrictedV (Path a) | for some path |
| InheritedV | if no visbility is specified, this is the default |
Instances
| Functor Visibility Source # | |
| PrettyAnnotated Visibility Source # | |
| Eq a => Eq (Visibility a) Source # | |
| Data a => Data (Visibility a) Source # | |
| Ord a => Ord (Visibility a) Source # | |
| Show a => Show (Visibility a) Source # | |
| Generic (Visibility a) Source # | |
| NFData a => NFData (Visibility a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Visibility a) Source # | |
| Pretty (Visibility a) Source # | |
| Generic1 * Visibility Source # | |
| type Rep (Visibility a) Source # | |
| type Rep1 * Visibility Source # | |
Const annotation to specify if a function or method is allowed to be called in constants
context with constant arguments (syntax::ast::Constness). Relevant
RFC
Example: const in const fn inc(x: i32) -> i32 { x + 1 }
Represents a method's signature in a trait declaration, or in an implementation.
Instances
| Functor MethodSig Source # | |
| Eq a => Eq (MethodSig a) Source # | |
| Data a => Data (MethodSig a) Source # | |
| Ord a => Ord (MethodSig a) Source # | |
| Show a => Show (MethodSig a) Source # | |
| Generic (MethodSig a) Source # | |
| NFData a => NFData (MethodSig a) Source # | |
| (Typeable * a, Monoid a) => Resolve (MethodSig a) Source # | |
| Generic1 * MethodSig Source # | |
| type Rep (MethodSig a) Source # | |
| type Rep1 * MethodSig Source # | |
Blocks
A curly brace delimited sequence of statements (syntax::ast::Block). The last statement in
the block can always be a NoSemi expression.
Example: { let x = 1; return x + y } as in fn foo() { let x = 1; return x + y }
Instances
| Functor Block Source # | |
| PrettyAnnotated Block Source # | |
| Eq a => Eq (Block a) Source # | |
| Data a => Data (Block a) Source # | |
| Ord a => Ord (Block a) Source # | |
| Show a => Show (Block a) Source # | |
| Generic (Block a) Source # | |
| NFData a => NFData (Block a) Source # | |
| Located a => Located (Block a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Block a) Source # | |
| Pretty (Block a) Source # | |
| Parse (Block Span) Source # | |
| Generic1 * Block Source # | |
| type Rep (Block a) Source # | |
| type Rep1 * Block Source # | |
Token trees
When the parser encounters a macro call, it parses what follows as a Delimited token tree.
Basically, token trees let you store raw tokens or Sequence forms inside of balanced
parens, braces, or brackets. This is a very loose structure, such that all sorts of different
AST-fragments can be passed to syntax extensions using a uniform type.
data TokenStream Source #
An abstract sequence of tokens, organized into a sequence (e.g. stream) of TokenTree, each of
which is a single Token or a Delimited subsequence of tokens.
Constructors
| Tree TokenTree | a single token or a single set of delimited tokens |
| Stream [TokenStream] | stream of streams of tokens |
Instances
| Eq TokenStream Source # | |
| Data TokenStream Source # | |
| Ord TokenStream Source # | |
| Show TokenStream Source # | |
| Generic TokenStream Source # | |
| NFData TokenStream Source # | |
| Located TokenStream Source # |
|
| Resolve TokenStream Source # | |
| Pretty TokenStream Source # | |
| Parse TokenStream Source # | |
| type Rep TokenStream Source # | |
unconsTokenStream :: TokenStream -> Maybe (TokenTree, TokenStream) Source #
A TokenStream is at its core just a stream of TokenTree. This function lets you get at that
directly. For example, you can use 'Data.List.unfoldr unconsTokenStream' to convert between a
TokenStream and '[TokenTree]'.
data Nonterminal a Source #
For interpolation during macro expansion (syntax::ast::NonTerminal).
Constructors
| NtItem (Item a) | |
| NtBlock (Block a) | |
| NtStmt (Stmt a) | |
| NtPat (Pat a) | |
| NtExpr (Expr a) | |
| NtTy (Ty a) | |
| NtIdent Ident | |
| NtPath (Path a) | |
| NtTT TokenTree | |
| NtArm (Arm a) | |
| NtImplItem (ImplItem a) | |
| NtTraitItem (TraitItem a) | |
| NtGenerics (Generics a) | |
| NtWhereClause (WhereClause a) | |
| NtArg (Arg a) | |
| NtLit (Lit a) |
Instances
| Functor Nonterminal Source # | |
| PrettyAnnotated Nonterminal Source # | |
| Eq a => Eq (Nonterminal a) Source # | |
| Data a => Data (Nonterminal a) Source # | |
| Ord a => Ord (Nonterminal a) Source # | |
| Show a => Show (Nonterminal a) Source # | |
| Generic (Nonterminal a) Source # | |
| NFData a => NFData (Nonterminal a) Source # | |
| Pretty (Nonterminal a) Source # | |
| Generic1 * Nonterminal Source # | |
| type Rep (Nonterminal a) Source # | |
| type Rep1 * Nonterminal Source # | |
Represents a macro invocation (syntax::ast::Mac). The Path indicates which macro is being
invoked, and the TokenStream contains the source of the macro invocation.
Constructors
| Mac (Path a) TokenStream a |
Instances
| Functor Mac Source # | |
| PrettyAnnotated Mac Source # | |
| Eq a => Eq (Mac a) Source # | |
| Data a => Data (Mac a) Source # | |
| Ord a => Ord (Mac a) Source # | |
| Show a => Show (Mac a) Source # | |
| Generic (Mac a) Source # | |
| NFData a => NFData (Mac a) Source # | |
| Located a => Located (Mac a) Source # | |
| (Typeable * a, Monoid a) => Resolve (Mac a) Source # | |
| Pretty (Mac a) Source # | |
| Generic1 * Mac Source # | |
| type Rep (Mac a) Source # | |
| type Rep1 * Mac Source # | |
data MacStmtStyle Source #
Style of the macro statement (syntax::ast::MacStmtStyle).
Constructors
| SemicolonMac | trailing semicolon (example: |
| BracesMac | braces (example: |
Tokens
A general token (based on syntax::parse::token::Token).
Unlike its libsyntax counterpart, Token has folded in syntax::parse::token::BinOpToken
and syntax::parse::token::BinOpEqToken as regular tokens.
Constructors
| Equal |
|
| Less |
|
| Greater |
|
| Ampersand |
|
| Pipe |
|
| Exclamation |
|
| Tilde |
|
| Plus |
|
| Minus |
|
| Star |
|
| Slash |
|
| Percent |
|
| Caret |
|
| GreaterEqual |
|
| GreaterGreaterEqual |
|
| AmpersandAmpersand |
|
| PipePipe |
|
| LessLess |
|
| GreaterGreater |
|
| EqualEqual |
|
| NotEqual |
|
| LessEqual |
|
| LessLessEqual |
|
| MinusEqual |
|
| AmpersandEqual |
|
| PipeEqual |
|
| PlusEqual |
|
| StarEqual |
|
| SlashEqual |
|
| CaretEqual |
|
| PercentEqual |
|
| At |
|
| Dot |
|
| DotDot |
|
| DotDotEqual |
|
| DotDotDot |
|
| Comma |
|
| Semicolon |
|
| Colon |
|
| ModSep |
|
| RArrow |
|
| LArrow |
|
| FatArrow |
|
| Pound |
|
| Dollar |
|
| Question |
|
| OpenDelim !Delim | One of |
| CloseDelim !Delim | One of |
| LiteralTok LitTok (Maybe Name) | a literal token with an optional suffix (something like |
| IdentTok Ident | an arbitrary identifier (something like |
| LifetimeTok Ident | a lifetime (something like |
| Space Space Name | whitespace |
| Doc String !AttrStyle !Bool | doc comment with its contents, whether it is outer/inner, and whether it is inline or not |
| Shebang |
|
| Eof | end of file token |
| Interpolated (Nonterminal Span) | can be expanded into several tokens in macro-expansion |
spaceNeeded :: Token -> Token -> Bool Source #
Check whether a space is needed between two tokens to avoid confusion.
Rust is whitespace independent. Short of providing space between tokens, whitespace is all the same to the parser.
Constructors
| Whitespace | usual white space: |
| Comment | comment (either inline or not) |
A delimiter token (syntax::parse::token::DelimToken).
A literal token (syntax::parse::token::Lit)
Constructors
| ByteTok Name | byte |
| CharTok Name | character |
| IntegerTok Name | integral literal (could have type |
| FloatTok Name | floating point literal (could have type |
| StrTok Name | string literal |
| StrRawTok Name !Int | raw string literal and the number of |
| ByteStrTok Name | byte string literal |
| ByteStrRawTok Name !Int | raw byte string literal and the number of |
Distinguishes between attributes that are associated with the node that follows them and
attributes that are associated with the node that contains them (syntax::ast::AttrStyle).
These two cases need to be distinguished only for pretty printing - they are otherwise
fundamentally equivalent.
Example: #[repr(C)] is an outer attribute while #![feature(slice_patterns)] is an inner one