Enum Expr 

pub enum Expr {
    Literal(Lit),
    Ident(Ident),
    This(Span),
    Super(Span),
    Paren {
        paren_span: (Span, Span),
        expr: Box<Expr>,
    },
    ClassLit {
        type_expr: Box<Type>,
        dot_span: Span,
        class_span: Span,
    },
    FieldAccess(FieldAccessExpr),
    MethodCall(MethodCallExpr),
    ArrayAccess(ArrayAccessExpr),
    MethodRef(MethodRefExpr),
    ArrayNew(ArrayNewExpr),
    Cast(CastExpr),
    Binary(BinaryExpr),
    Unary(UnaryExpr),
    Instanceof(InstanceofExpr),
    Assign(AssignExpr),
    Conditional(ConditionalExpr),
    Lambda(LambdaExpr),
    Switch(SwitchExpr),
    NewClass(NewClassExpr),
    ArrayInit(ArrayInitExpr),
}

A Java expression.

Expressions are represented in a mostly-desugared form, following the JLS grammar hierarchy.

Variants

Literal(Lit)

A literal value.

Ident(Ident)

An identifier expression.

This(Span)

this

Super(Span)

Super

Paren

Parenthesized expression: (expr)

Fields

paren_span: (Span, Span)

expr: Box<Expr>

ClassLit

Class literal: String.class, int[].class

Fields

type_expr: Box<Type>

dot_span: Span

class_span: Span

FieldAccess(FieldAccessExpr)

Field access: expr.field

MethodCall(MethodCallExpr)

Method invocation: method(args), obj.method(args)

ArrayAccess(ArrayAccessExpr)

Array access: array[index]

MethodRef(MethodRefExpr)

Method reference: String::valueOf, System.out::println

ArrayNew(ArrayNewExpr)

Array creation: new int[]{1, 2, 3}, new String[10]

Cast(CastExpr)

Type cast: (int) expr

Binary(BinaryExpr)

Binary operation: a + b

Unary(UnaryExpr)

Unary operation: -x, !flag

Instanceof(InstanceofExpr)

instanceof: obj instanceof String, obj instanceof String s

Assign(AssignExpr)

Assignment: x = 5, x += 1

Conditional(ConditionalExpr)

Ternary conditional: cond ? a : b

Lambda(LambdaExpr)

Lambda expression: x -> x + 1, (x, y) -> x + y

Switch(SwitchExpr)

Switch expression (Java 14+): switch (x) { case 1 -> "one"; ... }

NewClass(NewClassExpr)

Class instance creation (anonymous class): new Foo() { ... }

ArrayInit(ArrayInitExpr)

Array initializer: {1, 2, 3}

Implementations

impl Expr

pub fn span(&self) -> Span

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Expr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for Expr

impl Hash for Expr

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Expr

fn eq(&self, other: &Expr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Expr