Enum parse_js::ast::Syntax

source ·

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