Module rustc_ast::ast

The Rust abstract syntax tree module.

This module contains common structures forming the language AST. Two main entities in the module are Item (which represents an AST element with additional metadata), and ItemKind (which represents a concrete type and contains information specific to the type of the item).

Other module items worth mentioning:

• Ty and TyKind: A parsed Rust type.
• Expr and ExprKind: A parsed Rust expression.
• Pat and PatKind: A parsed Rust pattern. Patterns are often dual to expressions.
• Stmt and StmtKind: An executable action that does not return a value.
• FnDecl, FnHeader and Param: Metadata associated with a function declaration.
• Generics, GenericParam, WhereClause: Metadata associated with generic parameters.
• EnumDef and Variant: Enum declaration.
• MetaItemLit and LitKind: Literal expressions.
• MacroDef, MacStmtStyle, MacCall: Macro definition and invocation.
• Attribute: Metadata associated with item.
• UnOp, BinOp, and BinOpKind: Unary and binary operators.

Re-exports

• pub use crate::util::parser::ExprPrecedence;
• pub use crate::node_id::NodeId;
• pub use crate::node_id::CRATE_NODE_ID;
• pub use crate::node_id::DUMMY_NODE_ID;
• pub use crate::format::*;
• pub use GenericArgs::*;
• pub use UnsafeSource::*;

Structs

• AngleBracketedArgs
  A path like Foo<'a, T>.
• AnonConst
  A constant (expression) that’s not an item or associated item, but needs its own DefId for type-checking, const-eval, etc. These are usually found nested inside types (e.g., array lengths) or expressions (e.g., repeat counts), and also used to define explicit discriminant values for enum variants.
• Arm
  An arm of a ‘match’.
• AssocConstraint
  A constraint on an associated type (e.g., A = Bar in Foo<A = Bar> or A: TraitA + TraitB in Foo<A: TraitA + TraitB>).
• AttrId
• AttrItem
• Attribute
  A syntax-level representation of an attribute.
• BareFnTy
• BindingAnnotation
  Explicit binding annotations given in the HIR for a binding. Note that this is not the final binding mode that we infer after type inference.
• Block
  A block ({ .. }).
• Closure
• ConstItem
• Crate
• DelimArgs
  Delimited arguments, as used in #[attr()/[]/{}] or mac!()/[]/{}.
• EnumDef
• Expr
  An expression.
• ExprField
  A single field in a struct expression, e.g. x: value and y in Foo { x: value, y }.
• FieldDef
  Field definition in a struct, variant or union.
• Fn
• FnDecl
  A signature (not the body) of a function declaration.
• FnHeader
  A function header.
• FnSig
  Represents a function’s signature in a trait declaration, trait implementation, or free function.
• ForeignMod
  Foreign module declaration.
• GenericParam
• Generics
  Represents lifetime, type and const parameters attached to a declaration of a function, enum, trait, etc.
• Impl
• InlineAsm
  Inline assembly.
• InlineAsmOptions
• InlineAsmSym
  Inline assembly symbol operands get their own AST node that is somewhat similar to AnonConst.
• Item
  An item definition.
• Label
  A “Label” is an identifier of some point in sources, e.g. in the following code:
• Lifetime
  A “Lifetime” is an annotation of the scope in which variable can be used, e.g. 'a in &'a i32.
• Local
  Local represents a let statement, e.g., let <pat>:<ty> = <expr>;.
• MacCall
  Represents a macro invocation. The path indicates which macro is being invoked, and the args are arguments passed to it.
• MacCallStmt
• MacroDef
  Represents a macro definition.
• MetaItem
  A semantic representation of a meta item. A meta item is a slightly restricted form of an attribute – it can only contain expressions in certain leaf positions, rather than arbitrary token streams – that is used for most built-in attributes.
• MetaItemLit
  A literal in a meta item.
• MethodCall
  A method call (e.g. x.foo::<Bar, Baz>(a, b, c)).
• ModSpans
• MutTy
• NormalAttr
• Param
  A parameter in a function header.
• ParenthesizedArgs
  A path like Foo(A, B) -> C.
• Pat
  A match pattern.
• PatField
  A single field in a struct pattern.
• Path
  A “Path” is essentially Rust’s notion of a name.
• PathSegment
  A segment of a path: an identifier, an optional lifetime, and a set of types.
• PolyTraitRef
• QSelf
  The explicit Self type in a “qualified path”. The actual path, including the trait and the associated item, is stored separately. position represents the index of the associated item qualified with this Self type.
• StaticItem
• Stmt
  A statement
• StrLit
  Similar to MetaItemLit, but restricted to string literals.
• StructExpr
• Trait
• TraitRef
  TraitRefs appear in impls.
• Ty
• TyAlias
• TyAliasWhereClause
  The location of a where clause on a TyAlias (Span) and whether there was a where keyword (bool). This is split out from WhereClause, since there are two locations for where clause on type aliases, but their predicates are concatenated together.
• UseTree
  A tree of paths sharing common prefixes. Used in use items both at top-level and inside of braces in import groups.
• Variant
  Enum variant.
• Visibility
• WhereBoundPredicate
  A type bound.
• WhereClause
  A where-clause in a definition.
• WhereEqPredicate
  An equality predicate (unsupported).
• WhereRegionPredicate
  A lifetime predicate.

Enums

• AngleBracketedArg
  Either an argument for a parameter e.g., 'a, Vec<u8>, 0, or a constraint on an associated item, e.g., Item = String or Item: Bound.
• AssocConstraintKind
  The kinds of an AssocConstraint.
• AssocItemKind
  Represents associated item kinds.
• Async
• AttrArgs
  Arguments passed to an attribute macro.
• AttrArgsEq
• AttrKind
• AttrStyle
  Distinguishes between Attributes that decorate items and Attributes that are contained as statements within items. These two cases need to be distinguished for pretty-printing.
• BinOpKind
• BlockCheckMode
• BorrowKind
  The kind of borrow in an AddrOf expression, e.g., &place or &raw const place.
• BoundPolarity
• ByRef
• CaptureBy
  A capture clause used in closures and async blocks.
• ClosureBinder
  Closure lifetime binder, for<'a, 'b> in for<'a, 'b> |_: &'a (), _: &'b ()|.
• Const
• Defaultness
  Item defaultness. For details see the RFC #2532.
• ExprKind
• Extern
  extern qualifier on a function item or function type.
• FloatTy
• FnRetTy
• ForeignItemKind
  An item in extern block.
• GenericArg
  Concrete argument in the sequence of generic args.
• GenericArgs
  The arguments of a path segment.
• GenericBound
  The AST represents all type param bounds as types. typeck::collect::compute_bounds matches these against the “special” built-in traits (see middle::lang_items) and detects Copy, Send and Sync.
• GenericParamKind
• ImplPolarity
• Inline
• InlineAsmOperand
  Inline assembly operand.
• InlineAsmRegOrRegClass
  Inline assembly operand explicit register or register class.
• InlineAsmTemplatePiece
• IntTy
• IsAuto
  Is the trait definition an auto trait?
• ItemKind
• LitFloatType
  Type of the float literal based on provided suffix.
• LitIntType
  Type of the integer literal based on provided suffix.
• LitKind
  This type is used within both ast::MetaItemLit and hir::Lit.
• LocalKind
• MacStmtStyle
• MetaItemKind
  The meta item kind, containing the data after the initial path.
• ModKind
  Module item kind.
• Movability
  The movability of a generator / closure literal: whether a generator contains self-references, causing it to be !Unpin.
• Mutability
• NestedMetaItem
  Values inside meta item lists.
• ParamKindOrd
  Specifies the enforced ordering for generic parameters. In the future, if we wanted to relax this order, we could override PartialEq and PartialOrd, to allow the kinds to be unordered.
• PatKind
  All the different flavors of pattern that Rust recognizes.
• RangeEnd
• RangeLimits
  Limit types of a range (inclusive or exclusive)
• RangeSyntax
• SelfKind
  Alternative representation for Args describing self parameter of methods.
• StmtKind
• StrStyle
• StructRest
• Term
  The kinds of an AssocConstraint.
• TraitBoundModifier
  A modifier on a bound, e.g., ?Trait or ~const Trait.
• TraitObjectSyntax
  Syntax used to declare a trait object.
• TyKind
  The various kinds of type recognized by the compiler.
• UintTy
• UnOp
  Unary operator.
• Unsafe
• UnsafeSource
• UseTreeKind
  Part of use item to the right of its prefix.
• VariantData
  Fields and constructor ids of enum variants and structs.
• VisibilityKind
• WherePredicate
  A single predicate in a where-clause.

Type Aliases

• AssocItem
  Represents associated items. These include items in impl and trait definitions.
• AttrVec
  A list of attributes.
• BinOp
• ExplicitSelf
• ForeignItem
• GenericBounds