roan_engine::ast

Module expr

Source

Structs§

  • AccessExpr
    Represents an access expression in the AST. It includes accessing a field or indexing into a collection.
  • Assign
    Represents an assignment expression in the AST. An assignment binds a value to a variable.
  • BinOperator
    Represents a binary operator in the AST.
  • Binary
    Represents a binary expression in the AST. A binary expression consists of two operands and an operator (e.g., a + b).
  • CallExpr
    Represents a function call in the AST. It consists of a function name (callee) and a list of arguments.
  • Literal
    Represents a literal expression in the AST. It consists of a token and a specific literal value (e.g., integer, string).
  • ObjectExpr
    Represents an object expression in the AST.
  • Parenthesized
    Represents a parenthesized expression in the AST. Parenthesized expressions are used to override operator precedence.
  • Spread
    Spread operator for variadic arguments.
  • StructConstructor
    Represents a struct constructor expression in the AST.
  • ThenElse
    Represents a then-else expression in the AST.
  • UnOperator
    Represents a unary operator in the AST.
  • Unary
    Represents a unary expression in the AST. Unary expressions operate on a single operand (e.g., -a).
  • Variable
    Represents a variable in the AST. A variable refers to a named entity in the program.
  • VecExpr
    Represents a collection of expressions as a vector. Used to handle lists of expressions, such as arrays or argument lists.

Enums§

  • AccessKind
    Enum representing the kind of access in an access expression.
  • AssignOperator
  • BinOpAssociativity
    Enum representing the associativity of a binary operator.
  • BinOpKind
    Enum representing the various binary operators in the language. Binary operators are used in binary expressions (e.g., a + b).
  • Expr
    Enum representing an expression in the AST. Expressions include literals, binary operations, unary operations, and more.
  • LiteralType
    Enum that defines the possible literal types in the language. Literals are constant values such as numbers, strings, and booleans.
  • UnOpKind
    Enum representing unary operator kinds (e.g., -, ~).