Enum php_parser_rs::Statement

source ·

pub enum Statement {
Show 38 variants
    InlineHtml(ByteString),
    Goto {
        label: Identifier,
    },
    Label {
        label: Identifier,
    },
    HaltCompiler {
        content: Option<ByteString>,
    },
    Static {
        vars: Vec<StaticVar>,
    },
    DoWhile {
        condition: Expression,
        body: Block,
    },
    While {
        condition: Expression,
        body: Block,
    },
    For {
        init: Option<Expression>,
        condition: Option<Expression>,
        loop: Option<Expression>,
        then: Block,
    },
    Foreach {
        expr: Expression,
        by_ref: bool,
        key_var: Option<Expression>,
        value_var: Expression,
        body: Block,
    },
    Include {
        kind: IncludeKind,
        path: Expression,
    },
    Var {
        var: ByteString,
        value: Option<Expression>,
        type: Option<Type>,
    },
    Property {
        var: ByteString,
        value: Option<Expression>,
        type: Option<Type>,
        flags: Vec<PropertyFlag>,
    },
    Constant {
        constants: Vec<Constant>,
    },
    ClassConstant {
        name: Identifier,
        value: Expression,
        flags: Vec<ConstFlag>,
    },
    Function {
        name: Identifier,
        params: Vec<Param>,
        body: Block,
        return_type: Option<Type>,
        by_ref: bool,
    },
    Class {
        name: Identifier,
        extends: Option<Identifier>,
        implements: Vec<Identifier>,
        body: Block,
        flag: Option<ClassFlag>,
    },
    Trait {
        name: Identifier,
        body: Block,
    },
    TraitUse {
        traits: Vec<Identifier>,
    },
    Interface {
        name: Identifier,
        extends: Vec<Identifier>,
        body: Block,
    },
    Method {
        name: Identifier,
        params: Vec<Param>,
        body: Block,
        flags: Vec<MethodFlag>,
        return_type: Option<Type>,
        by_ref: bool,
    },
    If {
        condition: Expression,
        then: Block,
        else_ifs: Vec<ElseIf>,
        else: Option<Block>,
    },
    Return {
        value: Option<Expression>,
    },
    Switch {
        condition: Expression,
        cases: Vec<Case>,
    },
    Break {
        num: Option<Expression>,
    },
    Continue {
        num: Option<Expression>,
    },
    Echo {
        values: Vec<Expression>,
    },
    Expression {
        expr: Expression,
    },
    Namespace {
        name: Option<ByteString>,
        body: Block,
    },
    Use {
        uses: Vec<Use>,
        kind: UseKind,
    },
    GroupUse {
        prefix: Identifier,
        kind: UseKind,
        uses: Vec<Use>,
    },
    Comment {
        comment: ByteString,
    },
    Try {
        body: Block,
        catches: Vec<Catch>,
        finally: Option<Block>,
    },
    Enum {
        name: Identifier,
        implements: Vec<Identifier>,
        backed_type: Option<BackedEnumType>,
        body: Block,
    },
    EnumCase {
        name: Identifier,
        value: Option<Expression>,
    },
    Block {
        body: Block,
    },
    Global {
        vars: Vec<Identifier>,
    },
    Declare {
        declares: Vec<DeclareItem>,
        body: Block,
    },
    Noop,
}