Primitive type Expr

If this expression is an array literal [elem1, ..., elemN], this returns a slice of each element in the array.

If this expression is an assert, this returns the assert expression and the optional message.

If this expression is an assert_eq, this returns the left-hand-side and right-hand-side expressions, together with the optional message.

If this expression is an assignment, this returns a tuple with the left hand side and right hand side in order.

If this expression is a binary operator operation <lhs> <op> <rhs>, return the left-hand side, operator, and the right-hand side of the operation.

If this expression is a block { stmt1; stmt2; ...; stmtN }, return a slice containing each statement.

If this expression is a boolean literal, return that literal.

If this expression is a cast expression expr as type, returns the casted expression and the type to cast to.

If this expression is a comptime { stmt1; stmt2; ...; stmtN } block, return each statement in the block.

If this expression is a constructor Type { field1: expr1, ..., fieldN: exprN }, return the type and the fields.

If this expression is a for statement over a single expression, return the identifier, the expression and the for loop body.

If this expression is a for statement over a range, return the identifier, the range start, the range end and the for loop body.

If this expression is a function call foo(arg1, ..., argN), return the function and a slice of each argument.

If this expression is an if condition { then_branch } else { else_branch }, return the condition, then branch, and else branch. If there is no else branch, None is returned for that branch instead.

If this expression is an index into an array array[index], return the array and the index.

If this expression is an integer literal, return the integer as a field as well as whether the integer is negative (true) or not (false).

If this expression is a lambda, returns the parameters, return type and body.

If this expression is a let statement, returns the let pattern as an Expr, the optional type annotation, and the assigned expression.

If this expression is a member access foo.bar, return the struct/tuple expression and the field. The field will be represented as a quoted value.

If this expression is a method call foo.bar::<generic1, ..., genericM>(arg1, ..., argN), return the receiver, method name, a slice of each generic argument, and a slice of each argument.

If this expression is a repeated element array [elem; length], return the repeated element and the length expressions.

If this expression is a repeated element slice [elem; length], return the repeated element and the length expressions.

If this expression is a slice literal &[elem1, ..., elemN], return each element of the slice.

If this expression is a tuple (field1, ..., fieldN), return each element of the tuple.

If this expression is a unary operation <op> <rhs>, return the unary operator as well as the right-hand side expression.

If this expression is an unsafe { stmt1; ...; stmtN } block, return each statement inside in a slice.

Returns true if this expression is trailed by a semicolon.

Example:

comptime {
    let expr1 = quote { 1 + 2 }.as_expr().unwrap();
    let expr2 = quote { 1 + 2; }.as_expr().unwrap();

    assert(expr1.as_binary_op().is_some());
    assert(expr2.as_binary_op().is_some());

    assert(!expr1.has_semicolon());
    assert(expr2.has_semicolon());
}

Returns true if this expression is break.

Returns true if this expression is continue.

Applies a mapping function to this expression and to all of its sub-expressions. f will be applied to each sub-expression first, then applied to the expression itself.

This happens recursively for every expression within self.

For example, calling modify on (&[1], &[2, 3]) with an f that returns Option::some for expressions that are integers, doubling them, would return (&[2], &[4, 6]).

Returns this expression as a Quoted value. It's the same as quote { $self }.

Resolves and type-checks this expression and returns the result as a TypedExpr.

The in_function argument specifies where the expression is resolved:

• If it's none, the expression is resolved in the function where resolve was called
• If it's some, the expression is resolved in the given function

If any names used by this expression are not in scope or if there are any type errors, this will give compiler errors as if the expression was written directly into the current comptime function.