Enum lib_ruby_parser::nodes::Node[−][src]

#[repr(C)]pub enum Node {
    Alias(Alias),
    AndAsgn(AndAsgn),
    And(And),
    Arg(Arg),
    Args(Args),
    Array(Array),
    ArrayPattern(ArrayPattern),
    ArrayPatternWithTail(ArrayPatternWithTail),
    BackRef(BackRef),
    Begin(Begin),
    Block(Block),
    BlockPass(BlockPass),
    Blockarg(Blockarg),
    Break(Break),
    Case(Case),
    CaseMatch(CaseMatch),
    Casgn(Casgn),
    Cbase(Cbase),
    Class(Class),
    Complex(Complex),
    Const(Const),
    ConstPattern(ConstPattern),
    CSend(CSend),
    Cvar(Cvar),
    Cvasgn(Cvasgn),
    Def(Def),
    Defined(Defined),
    Defs(Defs),
    Dstr(Dstr),
    Dsym(Dsym),
    EFlipFlop(EFlipFlop),
    EmptyElse(EmptyElse),
    Encoding(Encoding),
    Ensure(Ensure),
    Erange(Erange),
    False(False),
    File(File),
    FindPattern(FindPattern),
    Float(Float),
    For(For),
    ForwardArg(ForwardArg),
    ForwardedArgs(ForwardedArgs),
    Gvar(Gvar),
    Gvasgn(Gvasgn),
    Hash(Hash),
    Kwargs(Kwargs),
    HashPattern(HashPattern),
    Heredoc(Heredoc),
    If(If),
    IfGuard(IfGuard),
    IfMod(IfMod),
    IfTernary(IfTernary),
    IFlipFlop(IFlipFlop),
    MatchPattern(MatchPattern),
    MatchPatternP(MatchPatternP),
    InPattern(InPattern),
    Index(Index),
    IndexAsgn(IndexAsgn),
    Int(Int),
    Irange(Irange),
    Ivar(Ivar),
    Ivasgn(Ivasgn),
    Kwarg(Kwarg),
    KwBegin(KwBegin),
    Kwnilarg(Kwnilarg),
    Kwoptarg(Kwoptarg),
    Kwrestarg(Kwrestarg),
    Kwsplat(Kwsplat),
    Lambda(Lambda),
    Line(Line),
    Lvar(Lvar),
    Lvasgn(Lvasgn),
    Masgn(Masgn),
    MatchAlt(MatchAlt),
    MatchAs(MatchAs),
    MatchCurrentLine(MatchCurrentLine),
    MatchNilPattern(MatchNilPattern),
    MatchRest(MatchRest),
    MatchVar(MatchVar),
    MatchWithLvasgn(MatchWithLvasgn),
    Mlhs(Mlhs),
    Module(Module),
    Next(Next),
    Nil(Nil),
    NthRef(NthRef),
    Numblock(Numblock),
    OpAsgn(OpAsgn),
    Optarg(Optarg),
    Or(Or),
    OrAsgn(OrAsgn),
    Pair(Pair),
    Pin(Pin),
    Postexe(Postexe),
    Preexe(Preexe),
    Procarg0(Procarg0),
    Rational(Rational),
    Redo(Redo),
    RegOpt(RegOpt),
    Regexp(Regexp),
    Rescue(Rescue),
    RescueBody(RescueBody),
    Restarg(Restarg),
    Retry(Retry),
    Return(Return),
    SClass(SClass),
    Self_(Self_),
    Send(Send),
    Shadowarg(Shadowarg),
    Splat(Splat),
    Str(Str),
    Super(Super),
    Sym(Sym),
    True(True),
    Undef(Undef),
    UnlessGuard(UnlessGuard),
    Until(Until),
    UntilPost(UntilPost),
    When(When),
    While(While),
    WhilePost(WhilePost),
    XHeredoc(XHeredoc),
    Xstr(Xstr),
    Yield(Yield),
    ZSuper(ZSuper),
}

Generic combination of all known nodes.

Variants

Alias(Alias)
AndAsgn(AndAsgn)
And(And)
Arg(Arg)
Args(Args)
Array(Array)
ArrayPattern(ArrayPattern)
ArrayPatternWithTail(ArrayPatternWithTail)
BackRef(BackRef)
Begin(Begin)
Block(Block)
BlockPass(BlockPass)
Blockarg(Blockarg)
Break(Break)
Case(Case)
CaseMatch(CaseMatch)
Casgn(Casgn)
Cbase(Cbase)
Class(Class)
Complex(Complex)
Const(Const)
ConstPattern(ConstPattern)
CSend(CSend)
Cvar(Cvar)
Cvasgn(Cvasgn)
Def(Def)
Defined(Defined)
Defs(Defs)
Dstr(Dstr)
Dsym(Dsym)
EFlipFlop(EFlipFlop)
EmptyElse(EmptyElse)
Encoding(Encoding)
Ensure(Ensure)
Erange(Erange)
False(False)
File(File)
FindPattern(FindPattern)
Float(Float)
For(For)
ForwardArg(ForwardArg)
ForwardedArgs(ForwardedArgs)
Gvar(Gvar)
Gvasgn(Gvasgn)
Hash(Hash)
Kwargs(Kwargs)
HashPattern(HashPattern)
Heredoc(Heredoc)
If(If)
IfGuard(IfGuard)
IfMod(IfMod)
IfTernary(IfTernary)
IFlipFlop(IFlipFlop)
MatchPattern(MatchPattern)
MatchPatternP(MatchPatternP)
InPattern(InPattern)
Index(Index)
IndexAsgn(IndexAsgn)
Int(Int)
Irange(Irange)
Ivar(Ivar)
Ivasgn(Ivasgn)
Kwarg(Kwarg)
KwBegin(KwBegin)
Kwnilarg(Kwnilarg)
Kwoptarg(Kwoptarg)
Kwrestarg(Kwrestarg)
Kwsplat(Kwsplat)
Lambda(Lambda)
Line(Line)
Lvar(Lvar)
Lvasgn(Lvasgn)
Masgn(Masgn)
MatchAlt(MatchAlt)
MatchAs(MatchAs)
MatchCurrentLine(MatchCurrentLine)
MatchNilPattern(MatchNilPattern)
MatchRest(MatchRest)
MatchVar(MatchVar)
MatchWithLvasgn(MatchWithLvasgn)
Mlhs(Mlhs)
Module(Module)
Next(Next)
Nil(Nil)
NthRef(NthRef)
Numblock(Numblock)
OpAsgn(OpAsgn)
Optarg(Optarg)
Or(Or)
OrAsgn(OrAsgn)
Pair(Pair)
Pin(Pin)
Postexe(Postexe)
Preexe(Preexe)
Procarg0(Procarg0)
Rational(Rational)
Redo(Redo)
RegOpt(RegOpt)
Regexp(Regexp)
Rescue(Rescue)
RescueBody(RescueBody)
Restarg(Restarg)
Retry(Retry)
Return(Return)
SClass(SClass)
Self_(Self_)
Send(Send)
Shadowarg(Shadowarg)
Splat(Splat)
Str(Str)
Super(Super)
Sym(Sym)
True(True)
Undef(Undef)
UnlessGuard(UnlessGuard)
Until(Until)
UntilPost(UntilPost)
When(When)
While(While)
WhilePost(WhilePost)
XHeredoc(XHeredoc)
Xstr(Xstr)
Yield(Yield)
ZSuper(ZSuper)

Implementations

impl Node[src]

pub fn inspect(&self, indent: usize) -> String[src]

Returs a whitequark/parser -like representation of self.

Used in tests and example scripts

pub fn expression(&self) -> &Loc[src]

Returns location of the full node expression

pub fn str_type(&self) -> &'static str[src]

Returns a whitequark/parser -like node name.

Used in tests and example scripts

pub fn print_with_locs(&self)[src]

Prints itself + location information

Trait Implementations

impl Clone for Node[src]

impl Debug for Node[src]

impl PartialEq<Node> for Node[src]

impl StructuralPartialEq for Node[src]

Auto Trait Implementations

impl RefUnwindSafe for Node

impl Send for Node

impl Sync for Node

impl Unpin for Node

impl UnwindSafe for Node

Blanket Implementations

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

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

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

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

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

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

type Owned = T

The resulting type after obtaining ownership.

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

type Error = Infallible

The type returned in the event of a conversion error.

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

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.