[−][src]Enum almond::ast::NodeKind

pub enum NodeKind<'a> {
    Identifier {
        name: String,
    },
    Literal {
        value: LiteralValue,
    },
    Program {
        body: Vec<Node<'a>>,
    },
    ExpressionStatement {
        expression: Box<Node<'a>>,
        directive: Option<String>,
    },
    BlockStatement {
        body: Vec<Node<'a>>,
    },
    EmptyStatement,
    DebuggerStatement,
    WithStatement {
        object: Box<Node<'a>>,
        body: Box<Node<'a>>,
    },
    ReturnStatement {
        argument: Box<Option<Node<'a>>>,
    },
    LabeledStatement {
        label: Box<Node<'a>>,
        body: Box<Node<'a>>,
    },
    BreakStatement {
        label: Box<Option<Node<'a>>>,
    },
    ContinueStatement {
        label: Box<Option<Node<'a>>>,
    },
    IfStatement {
        test: Box<Node<'a>>,
        consequent: Box<Node<'a>>,
        alternate: Box<Option<Node<'a>>>,
    },
    SwitchStatement {
        discriminant: Box<Node<'a>>,
        cases: Vec<Node<'a>>,
    },
    SwitchCase {
        test: Box<Option<Node<'a>>>,
        consequent: Vec<Node<'a>>,
    },
    ThrowStatement {
        argument: Box<Node<'a>>,
    },
    TryStatement {
        block: Box<Node<'a>>,
        handler: Box<Option<Node<'a>>>,
        finalizer: Box<Option<Node<'a>>>,
    },
    CatchClause {
        param: Box<Node<'a>>,
        body: Box<Node<'a>>,
    },
    WhileStatement {
        test: Box<Node<'a>>,
        body: Box<Node<'a>>,
    },
    DoWhileStatement {
        body: Box<Node<'a>>,
        test: Box<Node<'a>>,
    },
    ForStatement {
        init: Box<Option<Node<'a>>>,
        test: Box<Option<Node<'a>>>,
        update: Box<Option<Node<'a>>>,
        body: Box<Node<'a>>,
    },
    ForInStatement {
        left: Box<Node<'a>>,
        right: Box<Node<'a>>,
        body: Box<Node<'a>>,
    },
    FunctionDeclaration {
        function: Function<'a>,
    },
    VariableDeclaration {
        declarations: Vec<Node<'a>>,
        kind: VariableDeclarationKind,
    },
    VariableDeclarator {
        id: Box<Node<'a>>,
        init: Box<Option<Node<'a>>>,
    },
    ThisExpression,
    ArrayExpression {
        elements: Vec<Option<Node<'a>>>,
    },
    ObjectExpression {
        properties: Vec<Node<'a>>,
    },
    Property {
        key: Box<Node<'a>>,
        value: Box<Node<'a>>,
        kind: PropertyKind,
    },
    FunctionExpression {
        function: Function<'a>,
    },
    UnaryExpression {
        operator: UnaryOperator,
        prefix: bool,
        argument: Box<Node<'a>>,
    },
    UpdateExpression {
        operator: UpdateOperator,
        argument: Box<Node<'a>>,
        prefix: bool,
    },
    AwaitExpression {
        argument: Box<Node<'a>>,
    },
    BinaryExpression {
        operator: BinaryOperator,
        left: Box<Node<'a>>,
        right: Box<Node<'a>>,
    },
    AssignmentExpression {
        operator: AssignmentOperator,
        left: Box<Node<'a>>,
        right: Box<Node<'a>>,
    },
    LogicalExpression {
        operator: LogicalOperator,
        left: Box<Node<'a>>,
        right: Box<Node<'a>>,
    },
    MemberExpression {
        object: Box<Node<'a>>,
        property: Box<Node<'a>>,
        computed: bool,
    },
    ConditionalExpression {
        test: Box<Node<'a>>,
        consequent: Box<Node<'a>>,
        alternate: Box<Node<'a>>,
    },
    CallExpression {
        callee: Box<Node<'a>>,
        arguments: Vec<Node<'a>>,
    },
    NewExpression {
        callee: Box<Node<'a>>,
        arguments: Vec<Node<'a>>,
    },
    SequenceExpression {
        expressions: Vec<Node<'a>>,
    },
    Pattern,
    Error,
}

A mega enum with ever single possible AST node. Refer to https://github.com/estree/estree/blob/master/es5.md for spec on AST nodes.

Variants

Identifier

An identifier. Note that an identifier may be an expression or a destructuring pattern.

Fields of Identifier

name: String

Literal

A literal token. Note that a literal can be an expression.

Fields of Literal

value: LiteralValue

Program

A complete program source tree.

Fields of Program

body: Vec<Node<'a>>

type: [ Directive | Statement ]

ExpressionStatement

An expression statement, i.e., a statement consisting of a single expression.

or:

A directive from the directive prologue of a script or function. The directive property is the raw string source of the directive without quotes.

Note

There is no separate Directive case in the enum because the ESTree spec describes the Directive node as having a type field of ExpressionStatement.

Fields of ExpressionStatement

expression: Box<Node<'a>>

type: Expression

directive: Option<String>

The raw string source of the directive without quotes. If not a directive, should be None.

BlockStatement

A block statement, i.e., a sequence of statements surrounded by braces.

or:

The body of a function, which is a block statement that may begin with directives.

Note

There is no separate FunctionBody case in the enum because the ESTree spec describes the FunctionBody node as having a type field of BlockStatement.

Fields of BlockStatement

body: Vec<Node<'a>>

type: [ Statement ]

EmptyStatement

An empty statement, i.e., a solitary semicolon.

DebuggerStatement

A debugger statement.

WithStatement

A with statement.

Fields of WithStatement

object: Box<Node<'a>>

type: Expression

body: Box<Node<'a>>

type: Statement

ReturnStatement

A return statement.

Fields of ReturnStatement

argument: Box<Option<Node<'a>>>

type: Expression | null

LabeledStatement

A labeled statement, i.e., a statement prefixed by a break/continue label.

Fields of LabeledStatement

label: Box<Node<'a>>

type: Identifier

body: Box<Node<'a>>

type: Statement

BreakStatement

A break statement.

Fields of BreakStatement

label: Box<Option<Node<'a>>>

type: Identifier | null

ContinueStatement

A continue statement.

Fields of ContinueStatement

label: Box<Option<Node<'a>>>

type: Identifier | null

IfStatement

An if statement.

Fields of IfStatement

test: Box<Node<'a>>

type: Expression

consequent: Box<Node<'a>>

type: Statement

alternate: Box<Option<Node<'a>>>

type: Statement | null

SwitchStatement

A switch statement.

Fields of SwitchStatement

discriminant: Box<Node<'a>>

type: Expression

cases: Vec<Node<'a>>

type: [ SwitchCase ]

SwitchCase

A case (if test is an Expression) or default (if test === null) clause in the body of a switch statement.

Fields of SwitchCase

test: Box<Option<Node<'a>>>

type: Expression | null

consequent: Vec<Node<'a>>

type: [ Statement ]

ThrowStatement

A throw statement.

Fields of ThrowStatement

argument: Box<Node<'a>>

type: Expression

TryStatement

A try statement. If handler is null then finalizer must be a BlockStatement.

Fields of TryStatement

block: Box<Node<'a>>

type: BlockStatement

handler: Box<Option<Node<'a>>>

type: CatchClause | null

finalizer: Box<Option<Node<'a>>>

type: BlockStatement | null

CatchClause

Fields of CatchClause

param: Box<Node<'a>>

type: Pattern

body: Box<Node<'a>>

type: BlockStatement

WhileStatement

A while statement.

Fields of WhileStatement

test: Box<Node<'a>>

type: Expression

body: Box<Node<'a>>

type: Statement

DoWhileStatement

A do/while statement.

Fields of DoWhileStatement

body: Box<Node<'a>>

type: Statement

test: Box<Node<'a>>

type: Expression

ForStatement

A for statement.

Fields of ForStatement

init: Box<Option<Node<'a>>>

type: VariableDeclaration | Expression | null

test: Box<Option<Node<'a>>>

type: Expression | null

update: Box<Option<Node<'a>>>

type: Expression | null

body: Box<Node<'a>>

type: Statement

ForInStatement

A for/in statement.

Fields of ForInStatement

left: Box<Node<'a>>

type: VariableDeclaration | Pattern

right: Box<Node<'a>>

type: Expression

body: Box<Node<'a>>

type: Statement

FunctionDeclaration

A function declaration. Note that unlike in the parent interface Function, the id cannot be null.

Fields of FunctionDeclaration

function: Function<'a>

type: Function

VariableDeclaration

A variable declaration.

Fields of VariableDeclaration

declarations: Vec<Node<'a>>

type: [ VariableDeclarator ]

kind: VariableDeclarationKind

VariableDeclarator

A variable declarator.

Fields of VariableDeclarator

id: Box<Node<'a>>

type: Pattern

init: Box<Option<Node<'a>>>

type: Expression | null

ThisExpression

A this expression.

ArrayExpression

An array expression. An element might be null if it represents a hole in a sparse array. E.g. [1,,2].

Fields of ArrayExpression

elements: Vec<Option<Node<'a>>>

type: [ Expression | null ]

ObjectExpression

An object expression.

Fields of ObjectExpression

properties: Vec<Node<'a>>

type: [ Property ]

Property

A literal property in an object expression can have either a string or number as its value.

Fields of Property

key: Box<Node<'a>>

type: Literal | Identifier

value: Box<Node<'a>>

type: Expression

kind: PropertyKind

FunctionExpression

A function expression.

Fields of FunctionExpression

function: Function<'a>

type: Function

UnaryExpression

An unary operator expression.

Fields of UnaryExpression

operator: UnaryOperatorprefix: boolargument: Box<Node<'a>>

type: Expression

UpdateExpression

An update (increment or decrement) operator expression.

Fields of UpdateExpression

operator: UpdateOperatorargument: Box<Node<'a>>

type: Expression

prefix: bool

AwaitExpression

An await expression.

Fields of AwaitExpression

argument: Box<Node<'a>>

type: Expression

BinaryExpression

A binary operator expression.

Fields of BinaryExpression

operator: BinaryOperatorleft: Box<Node<'a>>

type: Expression

right: Box<Node<'a>>

type: Expression

AssignmentExpression

An assignment operator expression.

Fields of AssignmentExpression

operator: AssignmentOperatorleft: Box<Node<'a>>

type: Pattern | Expression

right: Box<Node<'a>>

type: Expression

LogicalExpression

A logical operator expression.

Fields of LogicalExpression

operator: LogicalOperatorleft: Box<Node<'a>>

type: Expression

right: Box<Node<'a>>

type: Expression

MemberExpression

A member expression. If computed is true, the node corresponds to a computed (a[b]) member expression and property is an Expression. If computed is false, the node corresponds to a static (a.b) member expression and property is an Identifier.

Fields of MemberExpression

object: Box<Node<'a>>

type: Expression

property: Box<Node<'a>>

type: Identifier | Literal

computed: bool

ConditionalExpression

A conditional expression, i.e., a ternary ?/: expression.

Fields of ConditionalExpression

test: Box<Node<'a>>

type: Expression

consequent: Box<Node<'a>>

type: Expression

alternate: Box<Node<'a>>

type: Expression

CallExpression

A function or method call expression.

Fields of CallExpression

callee: Box<Node<'a>>

type: Expression

arguments: Vec<Node<'a>>

type: [ Expression ]

NewExpression

A new expression.

Fields of NewExpression

callee: Box<Node<'a>>

type: Expression

arguments: Vec<Node<'a>>

type: [ Expression ]

SequenceExpression

A sequence expression, i.e., a comma-separated sequence of expressions.

Fields of SequenceExpression

expressions: Vec<Node<'a>>

type: [ Expression ]

Pattern

Error

An error node. Should be used when source is not syntaxically correct.

Implementations

`impl<'a> NodeKind<'a>`[src]

`pub fn with_pos( self, start: LocatedSpan<&'a str>, end: LocatedSpan<&'a str> ) -> Node<'a>`[src]

Creates a Node from NodeKind with specified pos.

Trait Implementations

`impl<'a> Clone for NodeKind<'a>`[src]

`pub fn clone(&self) -> NodeKind<'a>`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<'a> Debug for NodeKind<'a>`[src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

`impl<'a> From<LiteralValue> for NodeKind<'a>`[src]

`pub fn from(value: LiteralValue) -> Self`[src]

`impl<'a> PartialEq<NodeKind<'a>> for NodeKind<'a>`[src]

`pub fn eq(&self, other: &NodeKind<'a>) -> bool`[src]

`pub fn ne(&self, other: &NodeKind<'a>) -> bool`[src]

`impl<'a> Serialize for NodeKind<'a>`[src]

`pub fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,` [src]

`impl<'a> StructuralPartialEq for NodeKind<'a>`[src]

Auto Trait Implementations

`impl<'a> RefUnwindSafe for NodeKind<'a>`

`impl<'a> Send for NodeKind<'a>`

`impl<'a> Sync for NodeKind<'a>`

`impl<'a> Unpin for NodeKind<'a>`

`impl<'a> UnwindSafe for NodeKind<'a>`

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T where T: ?Sized,`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R ) -> R where R: 'a,`

`pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where B: 'a + ?Sized, R: 'a, Self: Borrow,`

`pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R where B: 'a + ?Sized, R: 'a, Self: BorrowMut,`

`pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where R: 'a, Self: AsRef, U: 'a + ?Sized,`

`pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R ) -> R where R: 'a, Self: AsMut, U: 'a + ?Sized,`

`pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: Deref<Target = T>, T: 'a + ?Sized,`

`pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized,`

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: AsRef<T>, T: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: AsMut<T>, T: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: Borrow<T>, T: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: BorrowMut<T>, T: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where R: 'a, Self: Deref,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where R: 'a, Self: DerefMut,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Tap for T`

`pub fn tap(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow(self, func: impl FnOnce(&B)) -> Self where B: ?Sized, Self: Borrow,`

`pub fn tap_borrow_mut(self, func: impl FnOnce(&mut B)) -> Self where B: ?Sized, Self: BorrowMut,`

`pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where R: ?Sized, Self: AsRef<R>,`

`pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where R: ?Sized, Self: AsMut<R>,`

`pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow_dbg(self, func: impl FnOnce(&B)) -> Self where B: ?Sized, Self: Borrow,`

`pub fn tap_borrow_mut_dbg(self, func: impl FnOnce(&mut B)) -> Self where B: ?Sized, Self: BorrowMut,`

`pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where R: ?Sized, Self: AsRef<R>,`

`pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where R: ?Sized, Self: AsMut<R>,`

`pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`impl<T> Tap for T`

`pub fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef for T where U: ?Sized,`

`pub fn tap_ref<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: AsRef<T>,`

`pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: AsRef<T>,`

`pub fn tap_ref_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: AsMut<T>,`

`pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: AsMut<T>,`

`impl<T, U> TapBorrow for T where U: ?Sized,`

`pub fn tap_borrow<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: Borrow<T>,`

`pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&T) -> R, Self: Borrow<T>,`

`pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: BorrowMut<T>,`

`pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut T) -> R, Self: BorrowMut<T>,`

`impl<T> TapDeref for T`

`pub fn tap_deref<F, R>(self, func: F) -> Self where F: FnOnce(&Self::Target) -> R, Self: Deref,`

`pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self::Target) -> R, Self: Deref,`

`pub fn tap_deref_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self::Target) -> R, Self: DerefMut,`

`pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self::Target) -> R, Self: DerefMut,`

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>`[src]

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

[−][src]Enum almond::ast::NodeKind

Variants

Fields of Identifier

Fields of Literal

Fields of Program

Note

Fields of ExpressionStatement

Note

Fields of BlockStatement

Fields of WithStatement

Fields of ReturnStatement

Fields of LabeledStatement

Fields of BreakStatement

Fields of ContinueStatement

Fields of IfStatement

Fields of SwitchStatement

Fields of SwitchCase

Fields of ThrowStatement

Fields of TryStatement

Fields of CatchClause

Fields of WhileStatement

Fields of DoWhileStatement

Fields of ForStatement

Fields of ForInStatement

Fields of FunctionDeclaration

Fields of VariableDeclaration

Fields of VariableDeclarator

Fields of ArrayExpression

Fields of ObjectExpression

Fields of Property

Fields of FunctionExpression

Fields of UnaryExpression

Fields of UpdateExpression

Fields of AwaitExpression

Fields of BinaryExpression

Fields of AssignmentExpression

Fields of LogicalExpression

Fields of MemberExpression

Fields of ConditionalExpression

Fields of CallExpression

Fields of NewExpression

Fields of SequenceExpression

Implementations

impl<'a> NodeKind<'a>[src]

pub fn with_pos( self, start: LocatedSpan<&'a str>, end: LocatedSpan<&'a str>) -> Node<'a>[src]

Trait Implementations

impl<'a> Clone for NodeKind<'a>[src]

pub fn clone(&self) -> NodeKind<'a>[src]

pub fn clone_from(&mut self, source: &Self)1.0.0[src]

impl<'a> Debug for NodeKind<'a>[src]

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

impl<'a> From<LiteralValue> for NodeKind<'a>[src]

pub fn from(value: LiteralValue) -> Self[src]

impl<'a> PartialEq<NodeKind<'a>> for NodeKind<'a>[src]

pub fn eq(&self, other: &NodeKind<'a>) -> bool[src]

pub fn ne(&self, other: &NodeKind<'a>) -> bool[src]

impl<'a> Serialize for NodeKind<'a>[src]

pub fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where __S: Serializer, [src]

impl<'a> StructuralPartialEq for NodeKind<'a>[src]

Auto Trait Implementations

impl<'a> RefUnwindSafe for NodeKind<'a>

impl<'a> Send for NodeKind<'a>

impl<'a> Sync for NodeKind<'a>

impl<'a> Unpin for NodeKind<'a>

impl<'a> UnwindSafe for NodeKind<'a>

Blanket Implementations

impl<T> Any for T where T: 'static + ?Sized, [src]

pub fn type_id(&self) -> TypeId[src]

impl<T> Borrow<T> for T where T: ?Sized, [src]

pub fn borrow(&self) -> &T[src]

impl<T> BorrowMut<T> for T where T: ?Sized, [src]

pub fn borrow_mut(&mut self) -> &mut T[src]

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> Conv for T

pub fn conv<T>(self) -> T where Self: Into<T>,

impl<T> FmtForward for T

pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,

pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,

pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,

`impl<'a> NodeKind<'a>`[src]

`pub fn with_pos( self, start: LocatedSpan<&'a str>, end: LocatedSpan<&'a str> ) -> Node<'a>`[src]

`impl<'a> Clone for NodeKind<'a>`[src]

`pub fn clone(&self) -> NodeKind<'a>`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<'a> Debug for NodeKind<'a>`[src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result`[src]

`impl<'a> From<LiteralValue> for NodeKind<'a>`[src]

`pub fn from(value: LiteralValue) -> Self`[src]

`impl<'a> PartialEq<NodeKind<'a>> for NodeKind<'a>`[src]

`pub fn eq(&self, other: &NodeKind<'a>) -> bool`[src]

`pub fn ne(&self, other: &NodeKind<'a>) -> bool`[src]

`impl<'a> Serialize for NodeKind<'a>`[src]

`pub fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer,` [src]

`impl<'a> StructuralPartialEq for NodeKind<'a>`[src]

`impl<'a> RefUnwindSafe for NodeKind<'a>`

`impl<'a> Send for NodeKind<'a>`

`impl<'a> Sync for NodeKind<'a>`

`impl<'a> Unpin for NodeKind<'a>`

`impl<'a> UnwindSafe for NodeKind<'a>`

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T where T: ?Sized,`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R ) -> R where R: 'a,`

`pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where B: 'a + ?Sized, R: 'a, Self: Borrow<B>,`

`pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R where B: 'a + ?Sized, R: 'a, Self: BorrowMut<B>,`

`pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where R: 'a, Self: AsRef<U>, U: 'a + ?Sized,`

`pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R ) -> R where R: 'a, Self: AsMut<U>, U: 'a + ?Sized,`

`pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: Deref<Target = T>, T: 'a + ?Sized,`

`pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized,`

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: AsRef<T>, T: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: AsMut<T>, T: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where R: 'a, Self: Borrow<T>, T: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where R: 'a, Self: BorrowMut<T>, T: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where R: 'a, Self: Deref,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where R: 'a, Self: DerefMut,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Tap for T`

`pub fn tap(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where B: ?Sized, Self: Borrow<B>,`

`pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where B: ?Sized, Self: BorrowMut<B>,`

`pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where R: ?Sized, Self: AsRef<R>,`

`pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where R: ?Sized, Self: AsMut<R>,`

`pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where B: ?Sized, Self: Borrow<B>,`

`pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where B: ?Sized, Self: BorrowMut<B>,`