Enum Expr 

pub enum Expr {
    Literal(Literal),
    Path(Path),
    MethodCall {
        receiver: Option<Box<Expr>>,
        name: Ident,
        args: Vec<Expr>,
    },
    Field {
        value: Box<Expr>,
        name: Ident,
    },
    Index {
        value: Box<Expr>,
        index: Box<Expr>,
    },
    New {
        type_: Box<Type>,
        args: Vec<Expr>,
    },
    NewArray {
        element: Box<Type>,
        lengths: Vec<Expr>,
        elements: Vec<Expr>,
    },
    Binary {
        op: &'static str,
        lhs: Box<Expr>,
        rhs: Box<Expr>,
    },
    Paren(Box<Expr>),
    Cast {
        type_: Box<Type>,
        value: Box<Expr>,
    },
    InstanceOf {
        value: Box<Expr>,
        type_: Box<Type>,
    },
    Ternary {
        condition: Box<Expr>,
        then: Box<Expr>,
        otherwise: Box<Expr>,
    },
    This,
    Lambda {
        params: Vec<Ident>,
        body: Box<Expr>,
    },
    Annotation(Annotation),
    ArrayInit(Vec<Expr>),
}

An expression.

Variants

Literal(Literal)

A literal.

Path(Path)

A name or qualified name.

MethodCall

receiver.name(args)

Fields

receiver: Option<Box<Expr>>

The receiver, absent for an unqualified call.

name: Ident

The method.

args: Vec<Expr>

Arguments.

Field

value.name

Fields

value: Box<Expr>

The value.

name: Ident

The field.

Index

a[i]

Fields

value: Box<Expr>

The array.

index: Box<Expr>

The index.

New

new T(args)

Fields

type_: Box<Type>

The type.

args: Vec<Expr>

Arguments.

NewArray

new T[]{ a, b }, new T[n], new T[n][m], new T[n][].

Fields

element: Box<Type>

The element type, which may itself be an array.

Its own []s are written after the sized dimensions: new int[n][] allocates n rows of int[], and new int[][n] is not a form Java has. A sequence of a fixed-size array reaches exactly that shape.

lengths: Vec<Expr>

One per sized dimension, outermost first. Empty asks for the initialiser form.

elements: Vec<Expr>

The elements, for the initialiser form.

Binary

a op b

Fields

op: &'static str

The operator, as written.

lhs: Box<Expr>

Left.

rhs: Box<Expr>

Right.

Paren(Box<Expr>)

(value), written because the writer meant it.

The tree carries no precedence and the renderer adds no brackets, so a caller that needs one says so. Java’s & binds looser than !=, which makes bits & mask != 0 a type error where C reads it as a comparison — and looser than ^, which makes bits & a ^ b a different number with nothing to say so.

Cast

(T) value

Fields

type_: Box<Type>

The target type.

value: Box<Expr>

The value.

InstanceOf

value instanceof T

Fields

value: Box<Expr>

The value.

type_: Box<Type>

The type.

Ternary

cond ? a : b

Fields

condition: Box<Expr>

The condition.

then: Box<Expr>

The then-value.

otherwise: Box<Expr>

The else-value.

This

this

Lambda

A lambda: (a, b) -> body.

Fields

params: Vec<Ident>

Parameter names.

body: Box<Expr>

The body as an expression.

Annotation(Annotation)

An annotation used as a value: an element of an annotation type that is itself an annotation, or of an array of them.

ArrayInit(Vec<Expr>)

{ a, b }, the array initialiser of an annotation element.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Self

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 PartialEq for Expr

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Expr