Enum ExprKind 

pub enum ExprKind<'arena, 'src> {
    Int(i64),
    Float(f64),
    String(Cow<'src, str>),
    InterpolatedString(ArenaVec<'arena, StringPart<'arena, 'src>>),
    Heredoc {
        label: &'src str,
        parts: ArenaVec<'arena, StringPart<'arena, 'src>>,
    },
    Nowdoc {
        label: &'src str,
        value: Cow<'src, str>,
    },
    ShellExec(ArenaVec<'arena, StringPart<'arena, 'src>>),
    Bool(bool),
    Null,
    Variable(Cow<'src, str>),
    VariableVariable(&'arena Expr<'arena, 'src>),
    Identifier(Cow<'src, str>),
    Assign(AssignExpr<'arena, 'src>),
    Binary(BinaryExpr<'arena, 'src>),
    UnaryPrefix(UnaryPrefixExpr<'arena, 'src>),
    UnaryPostfix(UnaryPostfixExpr<'arena, 'src>),
    Ternary(TernaryExpr<'arena, 'src>),
    NullCoalesce(NullCoalesceExpr<'arena, 'src>),
    FunctionCall(FunctionCallExpr<'arena, 'src>),
    Array(ArenaVec<'arena, ArrayElement<'arena, 'src>>),
    ArrayAccess(ArrayAccessExpr<'arena, 'src>),
    Print(&'arena Expr<'arena, 'src>),
    Parenthesized(&'arena Expr<'arena, 'src>),
    Cast(CastKind, &'arena Expr<'arena, 'src>),
    ErrorSuppress(&'arena Expr<'arena, 'src>),
    Isset(ArenaVec<'arena, Expr<'arena, 'src>>),
    Empty(&'arena Expr<'arena, 'src>),
    Include(IncludeKind, &'arena Expr<'arena, 'src>),
    Eval(&'arena Expr<'arena, 'src>),
    Exit(Option<&'arena Expr<'arena, 'src>>),
    MagicConst(MagicConstKind),
    Clone(&'arena Expr<'arena, 'src>),
    New(NewExpr<'arena, 'src>),
    PropertyAccess(PropertyAccessExpr<'arena, 'src>),
    NullsafePropertyAccess(PropertyAccessExpr<'arena, 'src>),
    MethodCall(&'arena MethodCallExpr<'arena, 'src>),
    NullsafeMethodCall(&'arena MethodCallExpr<'arena, 'src>),
    StaticPropertyAccess(StaticAccessExpr<'arena, 'src>),
    StaticMethodCall(&'arena StaticMethodCallExpr<'arena, 'src>),
    ClassConstAccess(StaticAccessExpr<'arena, 'src>),
    ClassConstAccessDynamic {
        class: &'arena Expr<'arena, 'src>,
        member: &'arena Expr<'arena, 'src>,
    },
    StaticPropertyAccessDynamic {
        class: &'arena Expr<'arena, 'src>,
        member: &'arena Expr<'arena, 'src>,
    },
    Closure(&'arena ClosureExpr<'arena, 'src>),
    ArrowFunction(&'arena ArrowFunctionExpr<'arena, 'src>),
    Match(MatchExpr<'arena, 'src>),
    ThrowExpr(&'arena Expr<'arena, 'src>),
    Yield(YieldExpr<'arena, 'src>),
    AnonymousClass(&'arena ClassDecl<'arena, 'src>),
    CallableCreate(CallableCreateExpr<'arena, 'src>),
    Error,
}

Variants

Int(i64)

Integer literal

Float(f64)

Float literal

String(Cow<'src, str>)

String literal

InterpolatedString(ArenaVec<'arena, StringPart<'arena, 'src>>)

Interpolated string: "Hello $name, you are {$age} years old"

Heredoc

Heredoc: <<<EOT ... EOT

Fields

label: &'src str

parts: ArenaVec<'arena, StringPart<'arena, 'src>>

Nowdoc

Nowdoc: <<<'EOT' ... EOT

Fields

label: &'src str

value: Cow<'src, str>

ShellExec(ArenaVec<'arena, StringPart<'arena, 'src>>)

Shell execution: `command $var`

Bool(bool)

Boolean literal

Null

Null literal

Variable(Cow<'src, str>)

Variable: $name

VariableVariable(&'arena Expr<'arena, 'src>)

Variable variable: $$var, $$$var, ${expr}

Identifier(Cow<'src, str>)

Identifier (bare name, e.g. function name in a call)

Assign(AssignExpr<'arena, 'src>)

Assignment: $x = expr or $x += expr

Binary(BinaryExpr<'arena, 'src>)

Binary operation: expr op expr

UnaryPrefix(UnaryPrefixExpr<'arena, 'src>)

Unary prefix: -expr, !expr, ~expr, ++$x, --$x

UnaryPostfix(UnaryPostfixExpr<'arena, 'src>)

Unary postfix: $x++, $x--

Ternary(TernaryExpr<'arena, 'src>)

Ternary: cond ? then : else or short cond ?: else

NullCoalesce(NullCoalesceExpr<'arena, 'src>)

Null coalescing: expr ?? fallback

FunctionCall(FunctionCallExpr<'arena, 'src>)

Function call: name(args)

Array(ArenaVec<'arena, ArrayElement<'arena, 'src>>)

Array literal: [1, 2, 3] or ['a' => 1]

ArrayAccess(ArrayAccessExpr<'arena, 'src>)

Array access: $arr[index]

Print(&'arena Expr<'arena, 'src>)

Print expression: print expr

Parenthesized(&'arena Expr<'arena, 'src>)

Parenthesized expression: (expr)

Cast(CastKind, &'arena Expr<'arena, 'src>)

Cast expression: (int)$x, (string)$x, etc.

ErrorSuppress(&'arena Expr<'arena, 'src>)

Error suppression: @expr

Isset(ArenaVec<'arena, Expr<'arena, 'src>>)

Isset: isset($a, $b)

Empty(&'arena Expr<'arena, 'src>)

Empty: empty($a)

Include(IncludeKind, &'arena Expr<'arena, 'src>)

Include/require: include 'file.php'

Eval(&'arena Expr<'arena, 'src>)

Eval: eval('code')

Exit(Option<&'arena Expr<'arena, 'src>>)

Exit/die: exit, exit(1), die('msg')

MagicConst(MagicConstKind)

Magic constant: __LINE__, __FILE__, etc.

Clone(&'arena Expr<'arena, 'src>)

Clone: clone $obj

New(NewExpr<'arena, 'src>)

New: new Class(args)

PropertyAccess(PropertyAccessExpr<'arena, 'src>)

Property access: $obj->prop

NullsafePropertyAccess(PropertyAccessExpr<'arena, 'src>)

Nullsafe property access: $obj?->prop

MethodCall(&'arena MethodCallExpr<'arena, 'src>)

Method call: $obj->method(args)

NullsafeMethodCall(&'arena MethodCallExpr<'arena, 'src>)

Nullsafe method call: $obj?->method(args)

StaticPropertyAccess(StaticAccessExpr<'arena, 'src>)

Static property access: Class::$prop

StaticMethodCall(&'arena StaticMethodCallExpr<'arena, 'src>)

Static method call: Class::method(args)

ClassConstAccess(StaticAccessExpr<'arena, 'src>)

Class constant access: Class::CONST

ClassConstAccessDynamic

Dynamic class constant access: Foo::{expr}

Fields

class: &'arena Expr<'arena, 'src>

member: &'arena Expr<'arena, 'src>

StaticPropertyAccessDynamic

Dynamic static property access: A::$$b, A::${'b'}

Fields

class: &'arena Expr<'arena, 'src>

member: &'arena Expr<'arena, 'src>

Closure(&'arena ClosureExpr<'arena, 'src>)

Closure: function($x) use($y) { }

ArrowFunction(&'arena ArrowFunctionExpr<'arena, 'src>)

Arrow function: fn($x) => expr

Match(MatchExpr<'arena, 'src>)

Match: match(expr) { ... }

ThrowExpr(&'arena Expr<'arena, 'src>)

Throw as expression (PHP 8)

Yield(YieldExpr<'arena, 'src>)

Yield: yield / yield $val / yield $key => $val

AnonymousClass(&'arena ClassDecl<'arena, 'src>)

Anonymous class: new class(args) extends Foo implements Bar { ... }

CallableCreate(CallableCreateExpr<'arena, 'src>)

First-class callable: strlen(...), $obj->method(...), Foo::bar(...)

Error

Error placeholder

Trait Implementations

impl<'arena, 'src> Debug for ExprKind<'arena, 'src>

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

Formats the value using the given formatter.

impl<'arena, 'src> Serialize for ExprKind<'arena, 'src>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.