Enum php_parser_rs::parser::ast::Expression

source ·

pub enum Expression {
Show 65 variants    Eval {
        eval: Span,
        argument: Box<SingleArgument>,
    },
    Empty {
        empty: Span,
        argument: Box<SingleArgument>,
    },
    Die {
        die: Span,
        argument: Option<Box<SingleArgument>>,
    },
    Exit {
        exit: Span,
        argument: Option<Box<SingleArgument>>,
    },
    Isset {
        isset: Span,
        arguments: ArgumentList,
    },
    Unset {
        unset: Span,
        arguments: ArgumentList,
    },
    Print {
        print: Span,
        value: Option<Box<Self>>,
        argument: Option<Box<SingleArgument>>,
    },
    Literal(Literal),
    ArithmeticOperation(ArithmeticOperation),
    AssignmentOperation(AssignmentOperation),
    BitwiseOperation(BitwiseOperation),
    ComparisonOperation(ComparisonOperation),
    LogicalOperation(LogicalOperation),
    Concat {
        left: Box<Self>,
        dot: Span,
        right: Box<Self>,
    },
    Instanceof {
        left: Box<Self>,
        instanceof: Span,
        right: Box<Self>,
    },
    Reference {
        ampersand: Span,
        right: Box<Self>,
    },
    Parenthesized {
        start: Span,
        expr: Box<Self>,
        end: Span,
    },
    ErrorSuppress {
        at: Span,
        expr: Box<Self>,
    },
    Identifier(Identifier),
    Variable(Variable),
    Include {
        include: Span,
        path: Box<Self>,
    },
    IncludeOnce {
        include_once: Span,
        path: Box<Self>,
    },
    Require {
        require: Span,
        path: Box<Self>,
    },
    RequireOnce {
        require_once: Span,
        path: Box<Self>,
    },
    FunctionCall {
        target: Box<Self>,
        arguments: ArgumentList,
    },
    FunctionClosureCreation {
        target: Box<Self>,
        placeholder: ArgumentPlaceholder,
    },
    MethodCall {
        target: Box<Self>,
        arrow: Span,
        method: Box<Self>,
        arguments: ArgumentList,
    },
    MethodClosureCreation {
        target: Box<Self>,
        arrow: Span,
        method: Box<Self>,
        placeholder: ArgumentPlaceholder,
    },
    NullsafeMethodCall {
        target: Box<Self>,
        question_arrow: Span,
        method: Box<Self>,
        arguments: ArgumentList,
    },
    StaticMethodCall {
        target: Box<Self>,
        double_colon: Span,
        method: Identifier,
        arguments: ArgumentList,
    },
    StaticVariableMethodCall {
        target: Box<Self>,
        double_colon: Span,
        method: Variable,
        arguments: ArgumentList,
    },
    StaticMethodClosureCreation {
        target: Box<Self>,
        double_colon: Span,
        method: Identifier,
        placeholder: ArgumentPlaceholder,
    },
    StaticVariableMethodClosureCreation {
        target: Box<Self>,
        double_colon: Span,
        method: Variable,
        placeholder: ArgumentPlaceholder,
    },
    PropertyFetch {
        target: Box<Self>,
        arrow: Span,
        property: Box<Self>,
    },
    NullsafePropertyFetch {
        target: Box<Self>,
        question_arrow: Span,
        property: Box<Self>,
    },
    StaticPropertyFetch {
        target: Box<Self>,
        double_colon: Span,
        property: Variable,
    },
    ConstantFetch {
        target: Box<Self>,
        double_colon: Span,
        constant: Identifier,
    },
    Static,
    Self_,
    Parent,
    ShortArray {
        start: Span,
        items: CommaSeparated<ArrayItem>,
        end: Span,
    },
    Array {
        array: Span,
        start: Span,
        items: CommaSeparated<ArrayItem>,
        end: Span,
    },
    List {
        list: Span,
        start: Span,
        items: Vec<ListEntry>,
        end: Span,
    },
    Closure(Closure),
    ArrowFunction(ArrowFunction),
    New {
        new: Span,
        target: Box<Self>,
        arguments: Option<ArgumentList>,
    },
    InterpolatedString {
        parts: Vec<StringPart>,
    },
    Heredoc {
        parts: Vec<StringPart>,
    },
    Nowdoc {
        value: ByteString,
    },
    ShellExec {
        parts: Vec<StringPart>,
    },
    AnonymousClass(AnonymousClass),
    Bool {
        value: bool,
    },
    ArrayIndex {
        array: Box<Self>,
        left_bracket: Span,
        index: Option<Box<Self>>,
        right_bracket: Span,
    },
    Null,
    MagicConstant(MagicConstant),
    ShortTernary {
        condition: Box<Self>,
        question_colon: Span,
        else: Box<Self>,
    },
    Ternary {
        condition: Box<Self>,
        question: Span,
        then: Box<Self>,
        colon: Span,
        else: Box<Self>,
    },
    Coalesce {
        lhs: Box<Self>,
        double_question: Span,
        rhs: Box<Self>,
    },
    Clone {
        target: Box<Self>,
    },
    Match {
        keyword: Span,
        left_parenthesis: Span,
        condition: Box<Self>,
        right_parenthesis: Span,
        left_brace: Span,
        default: Option<Box<DefaultMatchArm>>,
        arms: Vec<MatchArm>,
        right_brace: Span,
    },
    Throw {
        value: Box<Self>,
    },
    Yield {
        key: Option<Box<Self>>,
        value: Option<Box<Self>>,
    },
    YieldFrom {
        value: Box<Self>,
    },
    Cast {
        cast: Span,
        kind: CastKind,
        value: Box<Self>,
    },
    Noop,
}