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 GenericArgs::*;
• pub use UnsafeSource::*;
• pub use crate::format::*;

Modules

• size_asserts 🔒

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’.
• AssocItemConstraint
  A constraint on an associated item.
• AttrId
• AttrItem
• Attribute
  A syntax-level representation of an attribute.
• BareFnTy
• BindingMode
  The mode of a binding (mut, ref mut, etc). Used for both the explicit binding annotations given in the HIR for a binding and the final binding mode that we infer after type inference/match ergonomics. .0 is the by-reference mode (ref, ref mut, or by value), .1 is the mutability of the binding.
• Block
  A block ({ .. }).
• Closure
• ConstItem
• Crate
• Delegation
• DelegationMac
• 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. No attrs or tokens fields because each StmtKind variant contains an AST node with those fields. (Except for StmtKind::Empty, which never has attrs or tokens)
• StrLit
  Similar to MetaItemLit, but restricted to string literals.
• StructExpr
• Trait
• TraitBoundModifiers
  Modifiers on a trait bound like ~const, ? and !.
• 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.
• TyAliasWhereClauses
  The span information for the two where clauses on a TyAlias.
• 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 generic parameter or a constraint on an associated item.
• AssocItemConstraintKind
  The kind of associated item constraint.
• AssocItemKind
  Represents associated item kinds.
• 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.
• BoundAsyncness
  The asyncness of a trait bound.
• BoundConstness
  The constness of a trait bound.
• BoundPolarity
  The polarity of a trait bound.
• 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
• CoroutineKind
  Describes what kind of coroutine markers, if any, a function has.
• Defaultness
  Item defaultness. For details see the RFC #2532.
• ExprKind
• Extern
  extern qualifier on a function item or function type.
• FloatTy
• FnRetTy
• ForLoopKind
  Used to differentiate between for loops and for await loops.
• ForeignItemKind
  An item in extern block.
• GenBlockKind
  Used to differentiate between async {} blocks and gen {} blocks.
• GenericArg
  Concrete argument in the sequence of generic args.
• GenericArgs
  The generic arguments and associated item constraints of a path segment.
• GenericBound
• 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
• MatchKind
  The kind of match expression
• MetaItemKind
  The meta item kind, containing the data after the initial path.
• ModKind
  Module item kind.
• Movability
  The movability of a coroutine / closure literal: whether a coroutine 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.
• PatFieldsRest
  Whether the .. is present in a struct fields pattern.
• PatKind
  All the different flavors of pattern that Rust recognizes.
• PreciseCapturingArg
• RangeEnd
• RangeLimits
  Limit types of a range (inclusive or exclusive).
• RangeSyntax
• Recovered
  Was parsing recovery performed?
• Safety
  Safety of items.
• SelfKind
  Alternative representation for Args describing self parameter of methods.
• StmtKind
• StrStyle
• StructRest
• Term
• TraitObjectSyntax
  Syntax used to declare a trait object.
• TyKind
  The various kinds of type recognized by the compiler.
• UintTy
• UnOp
  Unary operator.
• 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