Module rustc_ap_rustc_ast::ast [−][src]
Expand description
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:
TyandTyKind: A parsed Rust type.ExprandExprKind: A parsed Rust expression.PatandPatKind: A parsed Rust pattern. Patterns are often dual to expressions.StmtandStmtKind: An executable action that does not return a value.FnDecl,FnHeaderandParam: Metadata associated with a function declaration.Generics,GenericParam,WhereClause: Metadata associated with generic parameters.EnumDefandVariant: Enum declaration.LitandLitKind: Literal expressions.MacroDef,MacStmtStyle,MacCall,MacDelimiter: Macro definition and invocation.Attribute: Metadata associated with item.UnOp,BinOp, andBinOpKind: Unary and binary operators.
Re-exports
pub use crate::util::parser::ExprPrecedence;pub use GenericArgs::*;pub use UnsafeSource::*;pub use crate::node_id::NodeId;pub use crate::node_id::CRATE_NODE_ID;pub use crate::node_id::DUMMY_NODE_ID;Structs
A path like Foo<'a, T>.
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.
An arm of a ‘match’.
A constraint on an associated type (e.g., A = Bar in Foo<A = Bar> or
A: TraitA + TraitB in Foo<A: TraitA + TraitB>).
Metadata associated with an item.
A block ({ .. }).
An expression.
A single field in a struct expression, e.g. x: value and y in Foo { x: value, y }.
Field definition in a struct, variant or union.
A signature (not the body) of a function declaration.
A function header.
Represents a function’s signature in a trait declaration, trait implementation, or free function.
Foreign module declaration.
Represents lifetime, type and const parameters attached to a declaration of a function, enum, trait, etc.
Inline assembly.
An item definition.
A “Label” is an identifier of some point in sources, e.g. in the following code:
A “Lifetime” is an annotation of the scope in which variable
can be used, e.g. 'a in &'a i32.
An AST literal.
LLVM-style inline assembly.
LLVM-style inline assembly.
Local represents a let statement, e.g., let <pat>:<ty> = <expr>;.
Represents a macro invocation. The path indicates which macro
is being invoked, and the args are arguments passed to it.
Represents a macro definition.
A spanned compile-time attribute item.
A parameter in a function header.
A path like Foo(A, B) -> C.
A match pattern.
A single field in a struct pattern.
A “Path” is essentially Rust’s notion of a name.
A segment of a path: an identifier, an optional lifetime, and a set of types.
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.
A statement
Same as Lit, but restricted to string literals.
TraitRefs appear in impls.
A tree of paths sharing common prefixes.
Used in use items both at top-level and inside of braces in import groups.
Enum variant.
A type bound.
A where-clause in a definition.
An equality predicate (unsupported).
A lifetime predicate.
Enums
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.
Represents associated item kinds.
The kinds of an AssocTyConstraint.
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.
The kind of borrow in an AddrOf expression,
e.g., &place or &raw const place.
A capture clause used in closures and async blocks.
Item defaultness. For details see the RFC #2532.
extern qualifier on a function item or function type.
An item in extern block.
Concrete argument in the sequence of generic args.
The arguments of a path segment.
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.
Inline assembly operand.
Inline assembly operand explicit register or register class.
Is the trait definition an auto trait?
Type of the float literal based on provided suffix.
Type of the integer literal based on provided suffix.
Literal kind.
Inline assembly dialect.
Arguments passed to an attribute or a function-like macro.
A compile-time attribute item.
Module item kind.
The movability of a generator / closure literal:
whether a generator contains self-references, causing it to be !Unpin.
Possible values inside of compile-time attribute lists.
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.
Limit types of a range (inclusive or exclusive)
Alternative representation for Args describing self parameter of methods.
A modifier on a bound, e.g., ?Sized or ?const Trait.
Syntax used to declare a trait object.
The various kinds of type recognized by the compiler.
Unary operator.
Part of use item to the right of its prefix.
Fields and constructor ids of enum variants and structs.
A single predicate in a where-clause.
Type Definitions
Represents associated items.
These include items in impl and trait definitions.
A list of attributes.