Enum parse_js::ast::Syntax

source ·

pub enum Syntax<'a> {
Show 67 variants    IdentifierPattern {
        name: SourceRange<'a>,
    },
    ArrayPattern {
        elements: SessionVec<'a, Option<ArrayPatternElement<'a>>>,
        rest: Option<Node<'a>>,
    },
    ObjectPattern {
        properties: SessionVec<'a, Node<'a>>,
        rest: Option<Node<'a>>,
    },
    ClassOrFunctionName {
        name: SourceRange<'a>,
    },
    FunctionSignature {
        parameters: SessionVec<'a, Node<'a>>,
    },
    ClassDecl {
        export: bool,
        export_default: bool,
        name: Option<Node<'a>>,
        extends: Option<Node<'a>>,
        members: SessionVec<'a, ClassMember<'a>>,
    },
    FunctionDecl {
        export: bool,
        export_default: bool,
        generator: bool,
        is_async: bool,
        name: Option<Node<'a>>,
        signature: Node<'a>,
        body: Node<'a>,
    },
    ParamDecl {
        rest: bool,
        pattern: Node<'a>,
        default_value: Option<Node<'a>>,
    },
    VarDecl {
        export: bool,
        mode: VarDeclMode,
        declarators: SessionVec<'a, VariableDeclarator<'a>>,
    },
    ArrowFunctionExpr {
        parenthesised: bool,
        is_async: bool,
        signature: Node<'a>,
        body: Node<'a>,
    },
    BinaryExpr {
        parenthesised: bool,
        operator: OperatorName,
        left: Node<'a>,
        right: Node<'a>,
    },
    CallExpr {
        optional_chaining: bool,
        parenthesised: bool,
        callee: Node<'a>,
        arguments: SessionVec<'a, Node<'a>>,
    },
    ClassExpr {
        parenthesised: bool,
        name: Option<Node<'a>>,
        extends: Option<Node<'a>>,
        members: SessionVec<'a, ClassMember<'a>>,
    },
    ConditionalExpr {
        parenthesised: bool,
        test: Node<'a>,
        consequent: Node<'a>,
        alternate: Node<'a>,
    },
    ComputedMemberExpr {
        optional_chaining: bool,
        object: Node<'a>,
        member: Node<'a>,
    },
    FunctionExpr {
        parenthesised: bool,
        is_async: bool,
        generator: bool,
        name: Option<Node<'a>>,
        signature: Node<'a>,
        body: Node<'a>,
    },
    IdentifierExpr {
        name: SourceRange<'a>,
    },
    ImportExpr {
        module: Node<'a>,
    },
    ImportMeta {},
    JsxAttribute {
        name: Node<'a>,
        value: Option<Node<'a>>,
    },
    JsxElement {
        name: Option<Node<'a>>,
        attributes: SessionVec<'a, Node<'a>>,
        children: SessionVec<'a, Node<'a>>,
    },
    JsxExpressionContainer {
        value: Node<'a>,
    },
    JsxMember {
        base: SourceRange<'a>,
        path: SessionVec<'a, SourceRange<'a>>,
    },
    JsxName {
        namespace: Option<SourceRange<'a>>,
        name: SourceRange<'a>,
    },
    JsxSpreadAttribute {
        value: Node<'a>,
    },
    JsxText {
        value: SourceRange<'a>,
    },
    LiteralArrayExpr {
        elements: SessionVec<'a, ArrayElement<'a>>,
    },
    LiteralBigIntExpr {
        value: SessionString<'a>,
    },
    LiteralBooleanExpr {
        value: bool,
    },
    LiteralNull {},
    LiteralNumberExpr {
        value: JsNumber,
    },
    LiteralObjectExpr {
        members: SessionVec<'a, Node<'a>>,
    },
    LiteralRegexExpr {},
    LiteralStringExpr {
        value: SessionString<'a>,
    },
    LiteralTemplateExpr {
        parts: SessionVec<'a, LiteralTemplatePart<'a>>,
    },
    LiteralUndefined {},
    MemberExpr {
        parenthesised: bool,
        optional_chaining: bool,
        left: Node<'a>,
        right: SourceRange<'a>,
    },
    SuperExpr {},
    ThisExpr {},
    UnaryExpr {
        parenthesised: bool,
        operator: OperatorName,
        argument: Node<'a>,
    },
    UnaryPostfixExpr {
        parenthesised: bool,
        operator: OperatorName,
        argument: Node<'a>,
    },
    BlockStmt {
        body: SessionVec<'a, Node<'a>>,
    },
    BreakStmt {
        label: Option<SourceRange<'a>>,
    },
    ContinueStmt {
        label: Option<SourceRange<'a>>,
    },
    DebuggerStmt {},
    DoWhileStmt {
        condition: Node<'a>,
        body: Node<'a>,
    },
    EmptyStmt {},
    ExportDefaultExprStmt {
        expression: Node<'a>,
    },
    ExportListStmt {
        names: ExportNames<'a>,
        from: Option<SessionString<'a>>,
    },
    ExpressionStmt {
        expression: Node<'a>,
    },
    IfStmt {
        test: Node<'a>,
        consequent: Node<'a>,
        alternate: Option<Node<'a>>,
    },
    ImportStmt {
        default: Option<Node<'a>>,
        names: Option<ExportNames<'a>>,
        module: SessionString<'a>,
    },
    ForStmt {
        header: ForStmtHeader<'a>,
        body: Node<'a>,
    },
    LabelStmt {
        name: SourceRange<'a>,
        statement: Node<'a>,
    },
    ReturnStmt {
        value: Option<Node<'a>>,
    },
    SwitchStmt {
        test: Node<'a>,
        branches: SessionVec<'a, Node<'a>>,
    },
    ThrowStmt {
        value: Node<'a>,
    },
    TryStmt {
        wrapped: Node<'a>,
        catch: Option<Node<'a>>,
        finally: Option<Node<'a>>,
    },
    VarStmt {
        declaration: Node<'a>,
    },
    WhileStmt {
        condition: Node<'a>,
        body: Node<'a>,
    },
    TopLevel {
        body: SessionVec<'a, Node<'a>>,
    },
    CallArg {
        spread: bool,
        value: Node<'a>,
    },
    CatchBlock {
        parameter: Option<Node<'a>>,
        body: Node<'a>,
    },
    ObjectMember {
        typ: ObjectMemberType<'a>,
    },
    ObjectPatternProperty {
        key: ClassOrObjectMemberKey<'a>,
        target: Option<Node<'a>>,
        default_value: Option<Node<'a>>,
    },
    SwitchBranch {
        case: Option<Node<'a>>,
        body: SessionVec<'a, Node<'a>>,
    },
    _TakenNode {},
}