Enum lib_ruby_parser::nodes::Node

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

Generic combination of all known nodes.

Variants

Alias(Box<Alias>)

And(Box<And>)

AndAsgn(Box<AndAsgn>)

Arg(Box<Arg>)

Args(Box<Args>)

Array(Box<Array>)

ArrayPattern(Box<ArrayPattern>)

ArrayPatternWithTail(Box<ArrayPatternWithTail>)

BackRef(Box<BackRef>)

Begin(Box<Begin>)

Block(Box<Block>)

Blockarg(Box<Blockarg>)

BlockPass(Box<BlockPass>)

Break(Box<Break>)

Case(Box<Case>)

CaseMatch(Box<CaseMatch>)

Casgn(Box<Casgn>)

Cbase(Box<Cbase>)

Class(Box<Class>)

Complex(Box<Complex>)

Const(Box<Const>)

ConstPattern(Box<ConstPattern>)

CSend(Box<CSend>)

Cvar(Box<Cvar>)

Cvasgn(Box<Cvasgn>)

Def(Box<Def>)

Defined(Box<Defined>)

Defs(Box<Defs>)

Dstr(Box<Dstr>)

Dsym(Box<Dsym>)

EFlipFlop(Box<EFlipFlop>)

EmptyElse(Box<EmptyElse>)

Encoding(Box<Encoding>)

Ensure(Box<Ensure>)

Erange(Box<Erange>)

False(Box<False>)

File(Box<File>)

FindPattern(Box<FindPattern>)

Float(Box<Float>)

For(Box<For>)

ForwardArg(Box<ForwardArg>)

ForwardedArgs(Box<ForwardedArgs>)

Gvar(Box<Gvar>)

Gvasgn(Box<Gvasgn>)

Hash(Box<Hash>)

HashPattern(Box<HashPattern>)

Heredoc(Box<Heredoc>)

If(Box<If>)

IfGuard(Box<IfGuard>)

IFlipFlop(Box<IFlipFlop>)

IfMod(Box<IfMod>)

IfTernary(Box<IfTernary>)

Index(Box<Index>)

IndexAsgn(Box<IndexAsgn>)

InMatch(Box<InMatch>)

InPattern(Box<InPattern>)

Int(Box<Int>)

Irange(Box<Irange>)

Ivar(Box<Ivar>)

Ivasgn(Box<Ivasgn>)

Kwarg(Box<Kwarg>)

KwBegin(Box<KwBegin>)

Kwnilarg(Box<Kwnilarg>)

Kwoptarg(Box<Kwoptarg>)

Kwrestarg(Box<Kwrestarg>)

Kwsplat(Box<Kwsplat>)

Lambda(Box<Lambda>)

Line(Box<Line>)

Lvar(Box<Lvar>)

Lvasgn(Box<Lvasgn>)

Masgn(Box<Masgn>)

MatchAlt(Box<MatchAlt>)

MatchAs(Box<MatchAs>)

MatchCurrentLine(Box<MatchCurrentLine>)

MatchNilPattern(Box<MatchNilPattern>)

MatchRest(Box<MatchRest>)

MatchVar(Box<MatchVar>)

MatchWithLvasgn(Box<MatchWithLvasgn>)

Mlhs(Box<Mlhs>)

Module(Box<Module>)

Next(Box<Next>)

Nil(Box<Nil>)

NthRef(Box<NthRef>)

Numblock(Box<Numblock>)

OpAsgn(Box<OpAsgn>)

Optarg(Box<Optarg>)

Or(Box<Or>)

OrAsgn(Box<OrAsgn>)

Pair(Box<Pair>)

Pin(Box<Pin>)

Postexe(Box<Postexe>)

Preexe(Box<Preexe>)

Procarg0(Box<Procarg0>)

Rational(Box<Rational>)

Redo(Box<Redo>)

Regexp(Box<Regexp>)

RegOpt(Box<RegOpt>)

Rescue(Box<Rescue>)

RescueBody(Box<RescueBody>)

Restarg(Box<Restarg>)

Retry(Box<Retry>)

Return(Box<Return>)

SClass(Box<SClass>)

Self_(Box<Self_>)

Send(Box<Send>)

Shadowarg(Box<Shadowarg>)

Splat(Box<Splat>)

Str(Box<Str>)

Super(Box<Super>)

Sym(Box<Sym>)

True(Box<True>)

Undef(Box<Undef>)

UnlessGuard(Box<UnlessGuard>)

Until(Box<Until>)

UntilPost(Box<UntilPost>)

When(Box<When>)

While(Box<While>)

WhilePost(Box<WhilePost>)

XHeredoc(Box<XHeredoc>)

Xstr(Box<Xstr>)

Yield(Box<Yield>)

ZSuper(Box<ZSuper>)

Implementations

impl Node

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

Returs a whitequark/parser -like representation of self.

Used in tests and example scripts

pub fn expression(&self) -> &Range

Returns location of the full node expression

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

Returns a whitequark/parser -like node name.

Used in tests and example scripts

pub fn print_with_locs(&self)

Prints itself + location information

Trait Implementations

impl Clone for Node

pub fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq<Node> for Node

pub fn eq(&self, other: &Node) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Node) -> bool

This method tests for !=.

impl StructuralPartialEq for Node