Module marker_api::ast

A module containing the AST of Marker, which is the main syntactic representation of the written code.

Structs

• ArrayExpr
  An expression constructing an array.
• ArrayTy
  The syntactic representation of an array with a known size like: [T; N]
• AsExpr
• AssignExpr
  An expression assigning a value to an assignee expression.
• AstPath
• AstPathSegment
• AstQPath
  AstPaths are used to identify items. A qualified path (QPath) can be used in expressions and types to identify associated items on types. For traits it’s additionally possible to specify the type that should be used as Self. This is sometimes needed to disambiguate an item, if it exists both as an associated item on a type, and as an associated item on traits, that this type implements.
• AwaitExpr
  An .await expression on a future, like:
• BinaryOpExpr
• BindingArg
  A generic bound in form <identifier=type>. For example, Item=i32 would be the generic binding here:
• BlockExpr
  A block expression is one of the most fundamental expressions in Rust. It is used by items and expressions to group statements together and express scopes.
• Body
  A body represents the expression of items.
• BoolLitExpr
• BoolTy
  The syntactic representation of the bool type.
• BreakExpr
  A break expression with an optional label and an optional value.
• CallExpr
  A call expression calling a function. The called function is identified using an expression, called operand. The following shows a few examples of call expressions:
• CharLitExpr
• ClosureExpr
  A closure expression
• ClosureParam
  A parameter for a ClosureExpr, with a pattern and an optional type, like:
• ConstArg
  A constant expression as an argument for a constant generic.
• ConstExpr
  An expression that is evaluated at compile time. These show up in array indices and constant generics.
• ConstItem
  A const item like:
• ConstParam
  A constant parameter with an optional constant value, like this:
• ContinueExpr
  A continue expression with an optional label.
• Crate
• CtorExpr
  An expression used to construct structs, unions and enum variants. For tuple constructors, the field names will correspond to the field indices.
• CtorField
  A single field inside a CtorExpr.
• EnumItem
  An enum item like:
• EnumVariant
• ExprStmt
• ExternBlockItem
  An extern block with items like this:
• ExternCrateItem
  An extern crate item like:
• FieldExpr
  An expression accessing a field or tuple index.
• FloatLitExpr
  A float literal like 1.0, 2e-2, 2_f32. The results of float operations can be hardware-dependent. For exact value checks, it might be better to check the written float literal by getting the code snipped from the expression span. See:
• FnItem
  A function item like:
• FnParam
  A parameter for a FnItem, like:
• FnPtrTy
  The syntactic representation of a function pointer, like fn (T) -> U
• FnTyParameter
  A parameter for the FnPtrTy.
• ForExpr
  A for loop iterating over values.
• GenericArgs
  The syntactic representation of generic arguments for an item or path.
• GenericParams
  This represents the generic parameters of a generic item. The bounds applied to the parameters in the declaration are stored as clauses in this struct.
• IdentPat
• IfExpr
  An if expression. If let expressions are expressed as an IfExpr with an LetExpr as the conditional expression.
• ImplItem
  An impl item like:
• ImplTraitTy
• IndexExpr
  An index expression.
• InferredTy
• IntLitExpr
  A integer literal like 16 or 8_u8. All integer literals in Rust are unsigned numbers < 2^128. Negative numbers have a unary negation operation as their parent.
• ItemField
  A single field inside a StructItem or UnionItem with an identifier type and span.
• ItemStmt
• LetExpr
  A let expression used in conditional statements, to check if the value of the scrutinee matches the pattern.
• LetStmt
• Lifetime
  A lifetime used as a generic argument or on a reference like this:
• LifetimeArg
  The syntactic representation of a generic argument, like this:
• LifetimeClause
• LifetimeParam
  A lifetime parameter like the 'long and 'short: 'long in:
• LitPat
  A literal expression inside a pattern.
• LoopExpr
  An unconditional loop expression
• MatchArm
  An arm inside a MatchExpr with an optional guard.
• MatchExpr
  A match expression with a scrutinee and MatchArms
• MethodExpr
• ModItem
  A module item like:
• NeverTy
  The syntactic representation of the never type !.
• NumTy
• OrPat
• PathExpr
• PathPat
• PathTy
  A type identified via a AstQPath. The kind and definition can be accessed via the ID returned by AstQPath::resolve().
• PlacePat
  Patterns are used as assignees in AssignExpr nodes. Assign expressions can target place expressions like variables, IndexExprs and FieldExprs. These expressions would be stored as this variant.
• RangeExpr
  A range expression, like these:
• RangePat
  A range expression, like these:
• RawPtrTy
  The syntactic representation of a raw pointer like *const T or *mut T
• RefExpr
• RefPat
• RefTy
  The syntactic representation of a reference like &T or &mut T
• RestPat
• ReturnExpr
  A return expression with an optional value.
• SlicePat
• SliceTy
  The syntactic representation of a variable length slice like [T]
• StaticItem
  A static item like:
• StrLitExpr
• StructFieldPat
  A pattern matching a field inside a StructPat instance.
• StructItem
  A struct item like:
• StructPat
• TextTy
  The syntactic representation of a textual type like char or str.
• TraitBound
• TraitItem
  A trait item like:
• TraitObjTy
  The syntactic representation of a trait object.
• TraitRef
• TryExpr
  The ? operator that unwraps valid values or propagates erroneous values to the calling function.
• TupleExpr
  An expression used to construct a tuple.
• TuplePat
• TupleTy
  The syntactic representation of a tuple type like () or (T, U)
• TyAliasItem
  A type alias like:
• TyArg
  The syntactic representation of a generic argument, like this:
• TyClause
• TyParam
  A type parameter with optional bounds like T and U in this example:
• UnaryOpExpr
• UnionItem
  A union item like:
• UnstableExpr
• UnstableItem
  A placeholder object for unstable items.
• UnstablePat
• UseItem
  A use declaration like:
• Visibility
  The declared visibility of an item or field.
• WhileExpr
  A while loop expression
• WildcardPat

Enums

• AssocItemKind
• AstPathTarget
• BinaryOpKind
• CaptureKind
• ExprKind
• ExprPrecedence
• ExternItemKind
• FloatSuffix
• GenericArgKind
  A singular generic argument.
• GenericParamKind
  A singular generic parameter, like 'a and T in this example:
• IntSuffix
• ItemKind
• LitExprKind
• PatKind
• StmtKind
• TyKind
• TyParamBound
• UnaryOpKind
• WhereClauseKind
  This represents a single clause in a where statement

Traits

• ExprData
  This trait combines methods, which are common between all expressions.
• ItemData
  This trait combines methods, which are common between all items.
• PatData
  This trait combines methods, which all patterns have in common.
• StmtData
  This trait combines methods, which all statements have in common.
• SynGenericParamData
  This trait is a collection of common information that is provided by all generic parameters.
• TyData
  This trait combines methods, which are common between all syntactic types.