Enum parse_js::ast::Syntax

source ·

pub enum Syntax {
Show 66 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 {
        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>,
    },
    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>,
    },
}

Variants

`IdentifierPattern`

Fields

name: SourceRange

`ArrayPattern`

Fields

elements: Vec<Option<ArrayPatternElement>>

rest: Option<NodeId>

`ObjectPattern`

Fields

properties: Vec<NodeId>

rest: Option<NodeId>

`ClassOrFunctionName`

Fields

name: SourceRange

`FunctionSignature`

Fields

parameters: Vec<NodeId>

`ClassDecl`

Fields

name: Option<NodeId>

extends: Option<NodeId>

members: Vec<ClassMember>

`FunctionDecl`

Fields

generator: bool

is_async: bool

name: Option<NodeId>

signature: NodeId

body: NodeId

`ParamDecl`

Fields

rest: bool

pattern: NodeId

default_value: Option<NodeId>

`VarDecl`

Fields

mode: VarDeclMode

declarators: Vec<VariableDeclarator>

`ArrowFunctionExpr`

Fields

is_async: bool

signature: NodeId

body: NodeId

`BinaryExpr`

Fields

parenthesised: bool

operator: OperatorName

left: NodeId

right: NodeId

`CallExpr`

Fields

optional_chaining: bool

parenthesised: bool

callee: NodeId

arguments: Vec<NodeId>

`ClassExpr`

Fields

parenthesised: bool

name: Option<NodeId>

extends: Option<NodeId>

members: Vec<ClassMember>

`ConditionalExpr`

Fields

parenthesised: bool

test: NodeId

consequent: NodeId

alternate: NodeId

`ComputedMemberExpr`

Fields

optional_chaining: bool

object: NodeId

member: NodeId

`FunctionExpr`

Fields

parenthesised: bool

is_async: bool

generator: bool

name: Option<NodeId>

signature: NodeId

body: NodeId

`IdentifierExpr`

Fields

name: SourceRange

`ImportExpr`

Fields

module: NodeId

`ImportMeta`

Fields

`JsxAttribute`

Fields

name: NodeId

value: Option<NodeId>

`JsxElement`

Fields

name: Option<NodeId>

attributes: Vec<NodeId>

children: Vec<NodeId>

`JsxExpressionContainer`

Fields

value: NodeId

`JsxMember`

Fields

base: SourceRange

path: Vec<SourceRange>

`JsxName`

Fields

namespace: Option<SourceRange>

name: SourceRange

`JsxSpreadAttribute`

Fields

value: NodeId

`JsxText`

Fields

value: SourceRange

`LiteralArrayExpr`

Fields

elements: Vec<ArrayElement>

`LiteralBooleanExpr`

Fields

value: bool

`LiteralNull`

Fields

`LiteralNumberExpr`

Fields

value: JsNumber

`LiteralObjectExpr`

Fields

members: Vec<NodeId>

`LiteralRegexExpr`

Fields

`LiteralStringExpr`

Fields

value: String

`LiteralTemplateExpr`

Fields

parts: Vec<LiteralTemplatePart>

`LiteralUndefined`

Fields

`MemberExpr`

Fields

parenthesised: bool

optional_chaining: bool

left: NodeId

right: SourceRange

`SuperExpr`

Fields

`ThisExpr`

Fields

`UnaryExpr`

Fields

parenthesised: bool

operator: OperatorName

argument: NodeId

`UnaryPostfixExpr`

Fields

parenthesised: bool

operator: OperatorName

argument: NodeId

`BlockStmt`

Fields

body: Vec<NodeId>

`BreakStmt`

Fields

label: Option<SourceRange>

`ContinueStmt`

Fields

label: Option<SourceRange>

`DebuggerStmt`

Fields

`DoWhileStmt`

Fields

condition: NodeId

body: NodeId

`EmptyStmt`

Fields

`ExportDeclStmt`

Fields

declaration: NodeId

default: bool

`ExportDefaultExprStmt`

Fields

expression: NodeId

`ExportListStmt`

Fields

names: ExportNames

from: Option<String>

`ExpressionStmt`

Fields

expression: NodeId

`IfStmt`

Fields

test: NodeId

consequent: NodeId

alternate: Option<NodeId>

`ImportStmt`

Fields

default: Option<NodeId>

names: Option<ExportNames>

module: String

`ForStmt`

Fields

header: ForStmtHeader

body: NodeId

`LabelStmt`

Fields

name: SourceRange

statement: NodeId

`ReturnStmt`

Fields

value: Option<NodeId>

`SwitchStmt`

Fields

test: NodeId

branches: Vec<NodeId>

`ThrowStmt`

Fields

value: NodeId

`TryStmt`

Fields

wrapped: NodeId

catch: Option<NodeId>

finally: Option<NodeId>

`VarStmt`

Fields

declaration: NodeId

`WhileStmt`

Fields

condition: NodeId

body: NodeId

`TopLevel`

Fields

body: Vec<NodeId>

`CallArg`

Fields

spread: bool

value: NodeId

`CatchBlock`

Fields

parameter: Option<NodeId>

body: NodeId

`ObjectMember`

Fields

typ: ObjectMemberType

`ObjectPatternProperty`

Fields

key: ClassOrObjectMemberKey

target: Option<NodeId>

default_value: Option<NodeId>

`SwitchBranch`

Fields

case: Option<NodeId>

body: Vec<NodeId>

Trait Implementations

source

impl Clone for Syntax

source

fn clone(&self) -> Syntax

Returns a copy of the value. Read more

1.0.0 · source

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

source

impl Debug for Syntax

source

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations

impl RefUnwindSafe for Syntax

impl !Send for Syntax

impl !Sync for Syntax

impl Unpin for Syntax

impl UnwindSafe for Syntax

Blanket Implementations

source

impl<T> Any for Twhere
T: 'static + ?Sized,

source

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

source

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

impl<T> BorrowMut<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

source

impl<T, U> Into for Twhere
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source

impl<T> ToOwned for Twhere
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

source

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

impl<T, U> TryFrom for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

source

impl<T, U> TryInto for Twhere
U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.