Enum php_parser_rs::parser::ast::Expression

source ·

pub enum Expression {
Show 59 variants    Eval {
        value: Box<Expression>,
    },
    Die {
        value: Option<Box<Expression>>,
    },
    Exit {
        value: Option<Box<Expression>>,
    },
    ArithmeticOperation(ArithmeticOperation),
    AssignmentOperation(AssignmentOperation),
    BitwiseOperation(BitwiseOperation),
    ComparisonOperation(ComparisonOperation),
    LogicalOperation(LogicalOperation),
    Concat {
        left: Box<Expression>,
        span: Span,
        right: Box<Expression>,
    },
    Instanceof {
        left: Box<Expression>,
        span: Span,
        right: Box<Expression>,
    },
    Reference {
        span: Span,
        right: Box<Expression>,
    },
    Parenthesized {
        start: Span,
        expr: Box<Expression>,
        end: Span,
    },
    List {
        items: Vec<ListItem>,
    },
    Empty,
    ErrorSuppress {
        span: Span,
        expr: Box<Self>,
    },
    LiteralInteger {
        span: Span,
        value: ByteString,
    },
    LiteralFloat {
        span: Span,
        value: ByteString,
    },
    Identifier(Identifier),
    Variable(Variable),
    Include {
        span: Span,
        kind: IncludeKind,
        path: Box<Expression>,
    },
    FunctionCall {
        target: Box<Self>,
        arguments: ArgumentList,
    },
    FunctionClosureCreation {
        target: Box<Self>,
        placeholder: ArgumentPlaceholder,
    },
    MethodCall {
        target: Box<Self>,
        span: Span,
        method: Box<Self>,
        arguments: ArgumentList,
    },
    MethodClosureCreation {
        target: Box<Self>,
        span: Span,
        method: Box<Self>,
        placeholder: ArgumentPlaceholder,
    },
    NullsafeMethodCall {
        target: Box<Self>,
        span: Span,
        method: Box<Self>,
        arguments: ArgumentList,
    },
    StaticMethodCall {
        target: Box<Self>,
        span: Span,
        method: Box<Self>,
        arguments: ArgumentList,
    },
    StaticMethodClosureCreation {
        target: Box<Self>,
        span: Span,
        method: Box<Self>,
        placeholder: ArgumentPlaceholder,
    },
    Static,
    Self_,
    Parent,
    Array {
        items: Vec<ArrayItem>,
    },
    Closure(Closure),
    ArrowFunction(ArrowFunction),
    New {
        span: Span,
        target: Box<Self>,
        arguments: Option<ArgumentList>,
    },
    LiteralString {
        span: Span,
        value: ByteString,
    },
    InterpolatedString {
        parts: Vec<StringPart>,
    },
    Heredoc {
        parts: Vec<StringPart>,
    },
    Nowdoc {
        value: ByteString,
    },
    ShellExec {
        parts: Vec<StringPart>,
    },
    PropertyFetch {
        target: Box<Self>,
        property: Box<Self>,
    },
    NullsafePropertyFetch {
        target: Box<Self>,
        property: Box<Self>,
    },
    StaticPropertyFetch {
        target: Box<Self>,
        property: Box<Self>,
    },
    ConstFetch {
        target: Box<Self>,
        constant: SimpleIdentifier,
    },
    AnonymousClass(AnonymousClass),
    Bool {
        value: bool,
    },
    ArrayIndex {
        array: Box<Self>,
        index: Option<Box<Self>>,
    },
    Null,
    MagicConst {
        span: Span,
        constant: MagicConst,
    },
    Ternary {
        condition: Box<Self>,
        then: Box<Self>,
        else: Box<Self>,
    },
    ShortTernary {
        condition: Box<Self>,
        span: Span,
        else: Box<Self>,
    },
    Coalesce {
        lhs: Box<Self>,
        rhs: Box<Self>,
    },
    Clone {
        target: Box<Self>,
    },
    Match {
        condition: Box<Self>,
        default: Option<Box<DefaultMatchArm>>,
        arms: Vec<MatchArm>,
    },
    Throw {
        value: Box<Expression>,
    },
    Yield {
        key: Option<Box<Self>>,
        value: Option<Box<Self>>,
    },
    YieldFrom {
        value: Box<Self>,
    },
    BitwiseNot {
        span: Span,
        value: Box<Self>,
    },
    Print {
        span: Span,
        value: Box<Self>,
    },
    Cast {
        span: Span,
        kind: CastKind,
        value: Box<Self>,
    },
}