Enum lib_ruby_parser::nodes::Node

#[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)

Tuple Fields of Alias

0: Alias

AndAsgn(AndAsgn)

Tuple Fields of AndAsgn

0: AndAsgn

And(And)

Tuple Fields of And

0: And

Arg(Arg)

Tuple Fields of Arg

0: Arg

Args(Args)

Tuple Fields of Args

0: Args

Array(Array)

Tuple Fields of Array

0: Array

ArrayPattern(ArrayPattern)

Tuple Fields of ArrayPattern

0: ArrayPattern

ArrayPatternWithTail(ArrayPatternWithTail)

Tuple Fields of ArrayPatternWithTail

0: ArrayPatternWithTail

BackRef(BackRef)

Tuple Fields of BackRef

0: BackRef

Begin(Begin)

Tuple Fields of Begin

0: Begin

Block(Block)

Tuple Fields of Block

0: Block

BlockPass(BlockPass)

Tuple Fields of BlockPass

0: BlockPass

Blockarg(Blockarg)

Tuple Fields of Blockarg

0: Blockarg

Break(Break)

Tuple Fields of Break

0: Break

Case(Case)

Tuple Fields of Case

0: Case

CaseMatch(CaseMatch)

Tuple Fields of CaseMatch

0: CaseMatch

Casgn(Casgn)

Tuple Fields of Casgn

0: Casgn

Cbase(Cbase)

Tuple Fields of Cbase

0: Cbase

Class(Class)

Tuple Fields of Class

0: Class

Complex(Complex)

Tuple Fields of Complex

0: Complex

Const(Const)

Tuple Fields of Const

0: Const

ConstPattern(ConstPattern)

Tuple Fields of ConstPattern

0: ConstPattern

CSend(CSend)

Tuple Fields of CSend

0: CSend

Cvar(Cvar)

Tuple Fields of Cvar

0: Cvar

Cvasgn(Cvasgn)

Tuple Fields of Cvasgn

0: Cvasgn

Def(Def)

Tuple Fields of Def

0: Def

Defined(Defined)

Tuple Fields of Defined

0: Defined

Defs(Defs)

Tuple Fields of Defs

0: Defs

Dstr(Dstr)

Tuple Fields of Dstr

0: Dstr

Dsym(Dsym)

Tuple Fields of Dsym

0: Dsym

EFlipFlop(EFlipFlop)

Tuple Fields of EFlipFlop

0: EFlipFlop

EmptyElse(EmptyElse)

Tuple Fields of EmptyElse

0: EmptyElse

Encoding(Encoding)

Tuple Fields of Encoding

0: Encoding

Ensure(Ensure)

Tuple Fields of Ensure

0: Ensure

Erange(Erange)

Tuple Fields of Erange

0: Erange

False(False)

Tuple Fields of False

0: False

File(File)

Tuple Fields of File

0: File

FindPattern(FindPattern)

Tuple Fields of FindPattern

0: FindPattern

Float(Float)

Tuple Fields of Float

0: Float

For(For)

Tuple Fields of For

0: For

ForwardArg(ForwardArg)

Tuple Fields of ForwardArg

0: ForwardArg

ForwardedArgs(ForwardedArgs)

Tuple Fields of ForwardedArgs

0: ForwardedArgs

Gvar(Gvar)

Tuple Fields of Gvar

0: Gvar

Gvasgn(Gvasgn)

Tuple Fields of Gvasgn

0: Gvasgn

Hash(Hash)

Tuple Fields of Hash

0: Hash

Kwargs(Kwargs)

Tuple Fields of Kwargs

0: Kwargs

HashPattern(HashPattern)

Tuple Fields of HashPattern

0: HashPattern

Heredoc(Heredoc)

Tuple Fields of Heredoc

0: Heredoc

If(If)

Tuple Fields of If

0: If

IfGuard(IfGuard)

Tuple Fields of IfGuard

0: IfGuard

IfMod(IfMod)

Tuple Fields of IfMod

0: IfMod

IfTernary(IfTernary)

Tuple Fields of IfTernary

0: IfTernary

IFlipFlop(IFlipFlop)

Tuple Fields of IFlipFlop

0: IFlipFlop

MatchPattern(MatchPattern)

Tuple Fields of MatchPattern

0: MatchPattern

MatchPatternP(MatchPatternP)

Tuple Fields of MatchPatternP

0: MatchPatternP

InPattern(InPattern)

Tuple Fields of InPattern

0: InPattern

Index(Index)

Tuple Fields of Index

0: Index

IndexAsgn(IndexAsgn)

Tuple Fields of IndexAsgn

0: IndexAsgn

Int(Int)

Tuple Fields of Int

0: Int

Irange(Irange)

Tuple Fields of Irange

0: Irange

Ivar(Ivar)

Tuple Fields of Ivar

0: Ivar

Ivasgn(Ivasgn)

Tuple Fields of Ivasgn

0: Ivasgn

Kwarg(Kwarg)

Tuple Fields of Kwarg

0: Kwarg

KwBegin(KwBegin)

Tuple Fields of KwBegin

0: KwBegin

Kwnilarg(Kwnilarg)

Tuple Fields of Kwnilarg

0: Kwnilarg

Kwoptarg(Kwoptarg)

Tuple Fields of Kwoptarg

0: Kwoptarg

Kwrestarg(Kwrestarg)

Tuple Fields of Kwrestarg

0: Kwrestarg

Kwsplat(Kwsplat)

Tuple Fields of Kwsplat

0: Kwsplat

Lambda(Lambda)

Tuple Fields of Lambda

0: Lambda

Line(Line)

Tuple Fields of Line

0: Line

Lvar(Lvar)

Tuple Fields of Lvar

0: Lvar

Lvasgn(Lvasgn)

Tuple Fields of Lvasgn

0: Lvasgn

Masgn(Masgn)

Tuple Fields of Masgn

0: Masgn

MatchAlt(MatchAlt)

Tuple Fields of MatchAlt

0: MatchAlt

MatchAs(MatchAs)

Tuple Fields of MatchAs

0: MatchAs

MatchCurrentLine(MatchCurrentLine)

Tuple Fields of MatchCurrentLine

0: MatchCurrentLine

MatchNilPattern(MatchNilPattern)

Tuple Fields of MatchNilPattern

0: MatchNilPattern

MatchRest(MatchRest)

Tuple Fields of MatchRest

0: MatchRest

MatchVar(MatchVar)

Tuple Fields of MatchVar

0: MatchVar

MatchWithLvasgn(MatchWithLvasgn)

Tuple Fields of MatchWithLvasgn

0: MatchWithLvasgn

Mlhs(Mlhs)

Tuple Fields of Mlhs

0: Mlhs

Module(Module)

Tuple Fields of Module

0: Module

Next(Next)

Tuple Fields of Next

0: Next

Nil(Nil)

Tuple Fields of Nil

0: Nil

NthRef(NthRef)

Tuple Fields of NthRef

0: NthRef

Numblock(Numblock)

Tuple Fields of Numblock

0: Numblock

OpAsgn(OpAsgn)

Tuple Fields of OpAsgn

0: OpAsgn

Optarg(Optarg)

Tuple Fields of Optarg

0: Optarg

Or(Or)

Tuple Fields of Or

0: Or

OrAsgn(OrAsgn)

Tuple Fields of OrAsgn

0: OrAsgn

Pair(Pair)

Tuple Fields of Pair

0: Pair

Pin(Pin)

Tuple Fields of Pin

0: Pin

Postexe(Postexe)

Tuple Fields of Postexe

0: Postexe

Preexe(Preexe)

Tuple Fields of Preexe

0: Preexe

Procarg0(Procarg0)

Tuple Fields of Procarg0

0: Procarg0

Rational(Rational)

Tuple Fields of Rational

0: Rational

Redo(Redo)

Tuple Fields of Redo

0: Redo

RegOpt(RegOpt)

Tuple Fields of RegOpt

0: RegOpt

Regexp(Regexp)

Tuple Fields of Regexp

0: Regexp

Rescue(Rescue)

Tuple Fields of Rescue

0: Rescue

RescueBody(RescueBody)

Tuple Fields of RescueBody

0: RescueBody

Restarg(Restarg)

Tuple Fields of Restarg

0: Restarg

Retry(Retry)

Tuple Fields of Retry

0: Retry

Return(Return)

Tuple Fields of Return

0: Return

SClass(SClass)

Tuple Fields of SClass

0: SClass

Self_(Self_)

Tuple Fields of Self_

0: Self_

Send(Send)

Tuple Fields of Send

0: Send

Shadowarg(Shadowarg)

Tuple Fields of Shadowarg

0: Shadowarg

Splat(Splat)

Tuple Fields of Splat

0: Splat

Str(Str)

Tuple Fields of Str

0: Str

Super(Super)

Tuple Fields of Super

0: Super

Sym(Sym)

Tuple Fields of Sym

0: Sym

True(True)

Tuple Fields of True

0: True

Undef(Undef)

Tuple Fields of Undef

0: Undef

UnlessGuard(UnlessGuard)

Tuple Fields of UnlessGuard

0: UnlessGuard

Until(Until)

Tuple Fields of Until

0: Until

UntilPost(UntilPost)

Tuple Fields of UntilPost

0: UntilPost

When(When)

Tuple Fields of When

0: When

While(While)

Tuple Fields of While

0: While

WhilePost(WhilePost)

Tuple Fields of WhilePost

0: WhilePost

XHeredoc(XHeredoc)

Tuple Fields of XHeredoc

0: XHeredoc

Xstr(Xstr)

Tuple Fields of Xstr

0: Xstr

Yield(Yield)

Tuple Fields of Yield

0: Yield

ZSuper(ZSuper)

Tuple Fields of ZSuper

0: ZSuper

Implementations

impl Node

pub fn is_alias(&self) -> bool

Returns true if self is Node::Alias

pub fn as_alias(&self) -> Option<&Alias>

Casts &Node to Option<&nodes::Alias>

pub fn as_alias_mut(&mut self) -> Option<&mut Alias>

Casts &Node to Option<&mut nodes::Alias>

pub fn into_alias(self) -> Alias

Casts self to nodes::Alias, panics if variant doesn’t match

pub fn is_and_asgn(&self) -> bool

Returns true if self is Node::AndAsgn

pub fn as_and_asgn(&self) -> Option<&AndAsgn>

Casts &Node to Option<&nodes::AndAsgn>

pub fn as_and_asgn_mut(&mut self) -> Option<&mut AndAsgn>

Casts &Node to Option<&mut nodes::AndAsgn>

pub fn into_and_asgn(self) -> AndAsgn

Casts self to nodes::AndAsgn, panics if variant doesn’t match

pub fn is_and(&self) -> bool

Returns true if self is Node::And

pub fn as_and(&self) -> Option<&And>

Casts &Node to Option<&nodes::And>

pub fn as_and_mut(&mut self) -> Option<&mut And>

Casts &Node to Option<&mut nodes::And>

pub fn into_and(self) -> And

Casts self to nodes::And, panics if variant doesn’t match

pub fn is_arg(&self) -> bool

Returns true if self is Node::Arg

pub fn as_arg(&self) -> Option<&Arg>

Casts &Node to Option<&nodes::Arg>

pub fn as_arg_mut(&mut self) -> Option<&mut Arg>

Casts &Node to Option<&mut nodes::Arg>

pub fn into_arg(self) -> Arg

Casts self to nodes::Arg, panics if variant doesn’t match

pub fn is_args(&self) -> bool

Returns true if self is Node::Args

pub fn as_args(&self) -> Option<&Args>

Casts &Node to Option<&nodes::Args>

pub fn as_args_mut(&mut self) -> Option<&mut Args>

Casts &Node to Option<&mut nodes::Args>

pub fn into_args(self) -> Args

Casts self to nodes::Args, panics if variant doesn’t match

pub fn is_array(&self) -> bool

Returns true if self is Node::Array

pub fn as_array(&self) -> Option<&Array>

Casts &Node to Option<&nodes::Array>

pub fn as_array_mut(&mut self) -> Option<&mut Array>

Casts &Node to Option<&mut nodes::Array>

pub fn into_array(self) -> Array

Casts self to nodes::Array, panics if variant doesn’t match

pub fn is_array_pattern(&self) -> bool

Returns true if self is Node::ArrayPattern

pub fn as_array_pattern(&self) -> Option<&ArrayPattern>

Casts &Node to Option<&nodes::ArrayPattern>

pub fn as_array_pattern_mut(&mut self) -> Option<&mut ArrayPattern>

Casts &Node to Option<&mut nodes::ArrayPattern>

pub fn into_array_pattern(self) -> ArrayPattern

Casts self to nodes::ArrayPattern, panics if variant doesn’t match

pub fn is_array_pattern_with_tail(&self) -> bool

Returns true if self is Node::ArrayPatternWithTail

pub fn as_array_pattern_with_tail(&self) -> Option<&ArrayPatternWithTail>

Casts &Node to Option<&nodes::ArrayPatternWithTail>

pub fn as_array_pattern_with_tail_mut(
    &mut self
) -> Option<&mut ArrayPatternWithTail>

Casts &Node to Option<&mut nodes::ArrayPatternWithTail>

pub fn into_array_pattern_with_tail(self) -> ArrayPatternWithTail

Casts self to nodes::ArrayPatternWithTail, panics if variant doesn’t match

pub fn is_back_ref(&self) -> bool

Returns true if self is Node::BackRef

pub fn as_back_ref(&self) -> Option<&BackRef>

Casts &Node to Option<&nodes::BackRef>

pub fn as_back_ref_mut(&mut self) -> Option<&mut BackRef>

Casts &Node to Option<&mut nodes::BackRef>

pub fn into_back_ref(self) -> BackRef

Casts self to nodes::BackRef, panics if variant doesn’t match

pub fn is_begin(&self) -> bool

Returns true if self is Node::Begin

pub fn as_begin(&self) -> Option<&Begin>

Casts &Node to Option<&nodes::Begin>

pub fn as_begin_mut(&mut self) -> Option<&mut Begin>

Casts &Node to Option<&mut nodes::Begin>

pub fn into_begin(self) -> Begin

Casts self to nodes::Begin, panics if variant doesn’t match

pub fn is_block(&self) -> bool

Returns true if self is Node::Block

pub fn as_block(&self) -> Option<&Block>

Casts &Node to Option<&nodes::Block>

pub fn as_block_mut(&mut self) -> Option<&mut Block>

Casts &Node to Option<&mut nodes::Block>

pub fn into_block(self) -> Block

Casts self to nodes::Block, panics if variant doesn’t match

pub fn is_block_pass(&self) -> bool

Returns true if self is Node::BlockPass

pub fn as_block_pass(&self) -> Option<&BlockPass>

Casts &Node to Option<&nodes::BlockPass>

pub fn as_block_pass_mut(&mut self) -> Option<&mut BlockPass>

Casts &Node to Option<&mut nodes::BlockPass>

pub fn into_block_pass(self) -> BlockPass

Casts self to nodes::BlockPass, panics if variant doesn’t match

pub fn is_blockarg(&self) -> bool

Returns true if self is Node::Blockarg

pub fn as_blockarg(&self) -> Option<&Blockarg>

Casts &Node to Option<&nodes::Blockarg>

pub fn as_blockarg_mut(&mut self) -> Option<&mut Blockarg>

Casts &Node to Option<&mut nodes::Blockarg>

pub fn into_blockarg(self) -> Blockarg

Casts self to nodes::Blockarg, panics if variant doesn’t match

pub fn is_break(&self) -> bool

Returns true if self is Node::Break

pub fn as_break(&self) -> Option<&Break>

Casts &Node to Option<&nodes::Break>

pub fn as_break_mut(&mut self) -> Option<&mut Break>

Casts &Node to Option<&mut nodes::Break>

pub fn into_break(self) -> Break

Casts self to nodes::Break, panics if variant doesn’t match

pub fn is_case(&self) -> bool

Returns true if self is Node::Case

pub fn as_case(&self) -> Option<&Case>

Casts &Node to Option<&nodes::Case>

pub fn as_case_mut(&mut self) -> Option<&mut Case>

Casts &Node to Option<&mut nodes::Case>

pub fn into_case(self) -> Case

Casts self to nodes::Case, panics if variant doesn’t match

pub fn is_case_match(&self) -> bool

Returns true if self is Node::CaseMatch

pub fn as_case_match(&self) -> Option<&CaseMatch>

Casts &Node to Option<&nodes::CaseMatch>

pub fn as_case_match_mut(&mut self) -> Option<&mut CaseMatch>

Casts &Node to Option<&mut nodes::CaseMatch>

pub fn into_case_match(self) -> CaseMatch

Casts self to nodes::CaseMatch, panics if variant doesn’t match

pub fn is_casgn(&self) -> bool

Returns true if self is Node::Casgn

pub fn as_casgn(&self) -> Option<&Casgn>

Casts &Node to Option<&nodes::Casgn>

pub fn as_casgn_mut(&mut self) -> Option<&mut Casgn>

Casts &Node to Option<&mut nodes::Casgn>

pub fn into_casgn(self) -> Casgn

Casts self to nodes::Casgn, panics if variant doesn’t match

pub fn is_cbase(&self) -> bool

Returns true if self is Node::Cbase

pub fn as_cbase(&self) -> Option<&Cbase>

Casts &Node to Option<&nodes::Cbase>

pub fn as_cbase_mut(&mut self) -> Option<&mut Cbase>

Casts &Node to Option<&mut nodes::Cbase>

pub fn into_cbase(self) -> Cbase

Casts self to nodes::Cbase, panics if variant doesn’t match

pub fn is_class(&self) -> bool

Returns true if self is Node::Class

pub fn as_class(&self) -> Option<&Class>

Casts &Node to Option<&nodes::Class>

pub fn as_class_mut(&mut self) -> Option<&mut Class>

Casts &Node to Option<&mut nodes::Class>

pub fn into_class(self) -> Class

Casts self to nodes::Class, panics if variant doesn’t match

pub fn is_complex(&self) -> bool

Returns true if self is Node::Complex

pub fn as_complex(&self) -> Option<&Complex>

Casts &Node to Option<&nodes::Complex>

pub fn as_complex_mut(&mut self) -> Option<&mut Complex>

Casts &Node to Option<&mut nodes::Complex>

pub fn into_complex(self) -> Complex

Casts self to nodes::Complex, panics if variant doesn’t match

pub fn is_const(&self) -> bool

Returns true if self is Node::Const

pub fn as_const(&self) -> Option<&Const>

Casts &Node to Option<&nodes::Const>

pub fn as_const_mut(&mut self) -> Option<&mut Const>

Casts &Node to Option<&mut nodes::Const>

pub fn into_const(self) -> Const

Casts self to nodes::Const, panics if variant doesn’t match

pub fn is_const_pattern(&self) -> bool

Returns true if self is Node::ConstPattern

pub fn as_const_pattern(&self) -> Option<&ConstPattern>

Casts &Node to Option<&nodes::ConstPattern>

pub fn as_const_pattern_mut(&mut self) -> Option<&mut ConstPattern>

Casts &Node to Option<&mut nodes::ConstPattern>

pub fn into_const_pattern(self) -> ConstPattern

Casts self to nodes::ConstPattern, panics if variant doesn’t match

pub fn is_c_send(&self) -> bool

Returns true if self is Node::CSend

pub fn as_c_send(&self) -> Option<&CSend>

Casts &Node to Option<&nodes::CSend>

pub fn as_c_send_mut(&mut self) -> Option<&mut CSend>

Casts &Node to Option<&mut nodes::CSend>

pub fn into_c_send(self) -> CSend

Casts self to nodes::CSend, panics if variant doesn’t match

pub fn is_cvar(&self) -> bool

Returns true if self is Node::Cvar

pub fn as_cvar(&self) -> Option<&Cvar>

Casts &Node to Option<&nodes::Cvar>

pub fn as_cvar_mut(&mut self) -> Option<&mut Cvar>

Casts &Node to Option<&mut nodes::Cvar>

pub fn into_cvar(self) -> Cvar

Casts self to nodes::Cvar, panics if variant doesn’t match

pub fn is_cvasgn(&self) -> bool

Returns true if self is Node::Cvasgn

pub fn as_cvasgn(&self) -> Option<&Cvasgn>

Casts &Node to Option<&nodes::Cvasgn>

pub fn as_cvasgn_mut(&mut self) -> Option<&mut Cvasgn>

Casts &Node to Option<&mut nodes::Cvasgn>

pub fn into_cvasgn(self) -> Cvasgn

Casts self to nodes::Cvasgn, panics if variant doesn’t match

pub fn is_def(&self) -> bool

Returns true if self is Node::Def

pub fn as_def(&self) -> Option<&Def>

Casts &Node to Option<&nodes::Def>

pub fn as_def_mut(&mut self) -> Option<&mut Def>

Casts &Node to Option<&mut nodes::Def>

pub fn into_def(self) -> Def

Casts self to nodes::Def, panics if variant doesn’t match

pub fn is_defined(&self) -> bool

Returns true if self is Node::Defined

pub fn as_defined(&self) -> Option<&Defined>

Casts &Node to Option<&nodes::Defined>

pub fn as_defined_mut(&mut self) -> Option<&mut Defined>

Casts &Node to Option<&mut nodes::Defined>

pub fn into_defined(self) -> Defined

Casts self to nodes::Defined, panics if variant doesn’t match

pub fn is_defs(&self) -> bool

Returns true if self is Node::Defs

pub fn as_defs(&self) -> Option<&Defs>

Casts &Node to Option<&nodes::Defs>

pub fn as_defs_mut(&mut self) -> Option<&mut Defs>

Casts &Node to Option<&mut nodes::Defs>

pub fn into_defs(self) -> Defs

Casts self to nodes::Defs, panics if variant doesn’t match

pub fn is_dstr(&self) -> bool

Returns true if self is Node::Dstr

pub fn as_dstr(&self) -> Option<&Dstr>

Casts &Node to Option<&nodes::Dstr>

pub fn as_dstr_mut(&mut self) -> Option<&mut Dstr>

Casts &Node to Option<&mut nodes::Dstr>

pub fn into_dstr(self) -> Dstr

Casts self to nodes::Dstr, panics if variant doesn’t match

pub fn is_dsym(&self) -> bool

Returns true if self is Node::Dsym

pub fn as_dsym(&self) -> Option<&Dsym>

Casts &Node to Option<&nodes::Dsym>

pub fn as_dsym_mut(&mut self) -> Option<&mut Dsym>

Casts &Node to Option<&mut nodes::Dsym>

pub fn into_dsym(self) -> Dsym

Casts self to nodes::Dsym, panics if variant doesn’t match

pub fn is_e_flip_flop(&self) -> bool

Returns true if self is Node::EFlipFlop

pub fn as_e_flip_flop(&self) -> Option<&EFlipFlop>

Casts &Node to Option<&nodes::EFlipFlop>

pub fn as_e_flip_flop_mut(&mut self) -> Option<&mut EFlipFlop>

Casts &Node to Option<&mut nodes::EFlipFlop>

pub fn into_e_flip_flop(self) -> EFlipFlop

Casts self to nodes::EFlipFlop, panics if variant doesn’t match

pub fn is_empty_else(&self) -> bool

Returns true if self is Node::EmptyElse

pub fn as_empty_else(&self) -> Option<&EmptyElse>

Casts &Node to Option<&nodes::EmptyElse>

pub fn as_empty_else_mut(&mut self) -> Option<&mut EmptyElse>

Casts &Node to Option<&mut nodes::EmptyElse>

pub fn into_empty_else(self) -> EmptyElse

Casts self to nodes::EmptyElse, panics if variant doesn’t match

pub fn is_encoding(&self) -> bool

Returns true if self is Node::Encoding

pub fn as_encoding(&self) -> Option<&Encoding>

Casts &Node to Option<&nodes::Encoding>

pub fn as_encoding_mut(&mut self) -> Option<&mut Encoding>

Casts &Node to Option<&mut nodes::Encoding>

pub fn into_encoding(self) -> Encoding

Casts self to nodes::Encoding, panics if variant doesn’t match

pub fn is_ensure(&self) -> bool

Returns true if self is Node::Ensure

pub fn as_ensure(&self) -> Option<&Ensure>

Casts &Node to Option<&nodes::Ensure>

pub fn as_ensure_mut(&mut self) -> Option<&mut Ensure>

Casts &Node to Option<&mut nodes::Ensure>

pub fn into_ensure(self) -> Ensure

Casts self to nodes::Ensure, panics if variant doesn’t match

pub fn is_erange(&self) -> bool

Returns true if self is Node::Erange

pub fn as_erange(&self) -> Option<&Erange>

Casts &Node to Option<&nodes::Erange>

pub fn as_erange_mut(&mut self) -> Option<&mut Erange>

Casts &Node to Option<&mut nodes::Erange>

pub fn into_erange(self) -> Erange

Casts self to nodes::Erange, panics if variant doesn’t match

pub fn is_false(&self) -> bool

Returns true if self is Node::False

pub fn as_false(&self) -> Option<&False>

Casts &Node to Option<&nodes::False>

pub fn as_false_mut(&mut self) -> Option<&mut False>

Casts &Node to Option<&mut nodes::False>

pub fn into_false(self) -> False

Casts self to nodes::False, panics if variant doesn’t match

pub fn is_file(&self) -> bool

Returns true if self is Node::File

pub fn as_file(&self) -> Option<&File>

Casts &Node to Option<&nodes::File>

pub fn as_file_mut(&mut self) -> Option<&mut File>

Casts &Node to Option<&mut nodes::File>

pub fn into_file(self) -> File

Casts self to nodes::File, panics if variant doesn’t match

pub fn is_find_pattern(&self) -> bool

Returns true if self is Node::FindPattern

pub fn as_find_pattern(&self) -> Option<&FindPattern>

Casts &Node to Option<&nodes::FindPattern>

pub fn as_find_pattern_mut(&mut self) -> Option<&mut FindPattern>

Casts &Node to Option<&mut nodes::FindPattern>

pub fn into_find_pattern(self) -> FindPattern

Casts self to nodes::FindPattern, panics if variant doesn’t match

pub fn is_float(&self) -> bool

Returns true if self is Node::Float

pub fn as_float(&self) -> Option<&Float>

Casts &Node to Option<&nodes::Float>

pub fn as_float_mut(&mut self) -> Option<&mut Float>

Casts &Node to Option<&mut nodes::Float>

pub fn into_float(self) -> Float

Casts self to nodes::Float, panics if variant doesn’t match

pub fn is_for(&self) -> bool

Returns true if self is Node::For

pub fn as_for(&self) -> Option<&For>

Casts &Node to Option<&nodes::For>

pub fn as_for_mut(&mut self) -> Option<&mut For>

Casts &Node to Option<&mut nodes::For>

pub fn into_for(self) -> For

Casts self to nodes::For, panics if variant doesn’t match

pub fn is_forward_arg(&self) -> bool

Returns true if self is Node::ForwardArg

pub fn as_forward_arg(&self) -> Option<&ForwardArg>

Casts &Node to Option<&nodes::ForwardArg>

pub fn as_forward_arg_mut(&mut self) -> Option<&mut ForwardArg>

Casts &Node to Option<&mut nodes::ForwardArg>

pub fn into_forward_arg(self) -> ForwardArg

Casts self to nodes::ForwardArg, panics if variant doesn’t match

pub fn is_forwarded_args(&self) -> bool

Returns true if self is Node::ForwardedArgs

pub fn as_forwarded_args(&self) -> Option<&ForwardedArgs>

Casts &Node to Option<&nodes::ForwardedArgs>

pub fn as_forwarded_args_mut(&mut self) -> Option<&mut ForwardedArgs>

Casts &Node to Option<&mut nodes::ForwardedArgs>

pub fn into_forwarded_args(self) -> ForwardedArgs

Casts self to nodes::ForwardedArgs, panics if variant doesn’t match

pub fn is_gvar(&self) -> bool

Returns true if self is Node::Gvar

pub fn as_gvar(&self) -> Option<&Gvar>

Casts &Node to Option<&nodes::Gvar>

pub fn as_gvar_mut(&mut self) -> Option<&mut Gvar>

Casts &Node to Option<&mut nodes::Gvar>

pub fn into_gvar(self) -> Gvar

Casts self to nodes::Gvar, panics if variant doesn’t match

pub fn is_gvasgn(&self) -> bool

Returns true if self is Node::Gvasgn

pub fn as_gvasgn(&self) -> Option<&Gvasgn>

Casts &Node to Option<&nodes::Gvasgn>

pub fn as_gvasgn_mut(&mut self) -> Option<&mut Gvasgn>

Casts &Node to Option<&mut nodes::Gvasgn>

pub fn into_gvasgn(self) -> Gvasgn

Casts self to nodes::Gvasgn, panics if variant doesn’t match

pub fn is_hash(&self) -> bool

Returns true if self is Node::Hash

pub fn as_hash(&self) -> Option<&Hash>

Casts &Node to Option<&nodes::Hash>

pub fn as_hash_mut(&mut self) -> Option<&mut Hash>

Casts &Node to Option<&mut nodes::Hash>

pub fn into_hash(self) -> Hash

Casts self to nodes::Hash, panics if variant doesn’t match

pub fn is_kwargs(&self) -> bool

Returns true if self is Node::Kwargs

pub fn as_kwargs(&self) -> Option<&Kwargs>

Casts &Node to Option<&nodes::Kwargs>

pub fn as_kwargs_mut(&mut self) -> Option<&mut Kwargs>

Casts &Node to Option<&mut nodes::Kwargs>

pub fn into_kwargs(self) -> Kwargs

Casts self to nodes::Kwargs, panics if variant doesn’t match

pub fn is_hash_pattern(&self) -> bool

Returns true if self is Node::HashPattern

pub fn as_hash_pattern(&self) -> Option<&HashPattern>

Casts &Node to Option<&nodes::HashPattern>

pub fn as_hash_pattern_mut(&mut self) -> Option<&mut HashPattern>

Casts &Node to Option<&mut nodes::HashPattern>

pub fn into_hash_pattern(self) -> HashPattern

Casts self to nodes::HashPattern, panics if variant doesn’t match

pub fn is_heredoc(&self) -> bool

Returns true if self is Node::Heredoc

pub fn as_heredoc(&self) -> Option<&Heredoc>

Casts &Node to Option<&nodes::Heredoc>

pub fn as_heredoc_mut(&mut self) -> Option<&mut Heredoc>

Casts &Node to Option<&mut nodes::Heredoc>

pub fn into_heredoc(self) -> Heredoc

Casts self to nodes::Heredoc, panics if variant doesn’t match

pub fn is_if(&self) -> bool

Returns true if self is Node::If

pub fn as_if(&self) -> Option<&If>

Casts &Node to Option<&nodes::If>

pub fn as_if_mut(&mut self) -> Option<&mut If>

Casts &Node to Option<&mut nodes::If>

pub fn into_if(self) -> If

Casts self to nodes::If, panics if variant doesn’t match

pub fn is_if_guard(&self) -> bool

Returns true if self is Node::IfGuard

pub fn as_if_guard(&self) -> Option<&IfGuard>

Casts &Node to Option<&nodes::IfGuard>

pub fn as_if_guard_mut(&mut self) -> Option<&mut IfGuard>

Casts &Node to Option<&mut nodes::IfGuard>

pub fn into_if_guard(self) -> IfGuard

Casts self to nodes::IfGuard, panics if variant doesn’t match

pub fn is_if_mod(&self) -> bool

Returns true if self is Node::IfMod

pub fn as_if_mod(&self) -> Option<&IfMod>

Casts &Node to Option<&nodes::IfMod>

pub fn as_if_mod_mut(&mut self) -> Option<&mut IfMod>

Casts &Node to Option<&mut nodes::IfMod>

pub fn into_if_mod(self) -> IfMod

Casts self to nodes::IfMod, panics if variant doesn’t match

pub fn is_if_ternary(&self) -> bool

Returns true if self is Node::IfTernary

pub fn as_if_ternary(&self) -> Option<&IfTernary>

Casts &Node to Option<&nodes::IfTernary>

pub fn as_if_ternary_mut(&mut self) -> Option<&mut IfTernary>

Casts &Node to Option<&mut nodes::IfTernary>

pub fn into_if_ternary(self) -> IfTernary

Casts self to nodes::IfTernary, panics if variant doesn’t match

pub fn is_i_flip_flop(&self) -> bool

Returns true if self is Node::IFlipFlop

pub fn as_i_flip_flop(&self) -> Option<&IFlipFlop>

Casts &Node to Option<&nodes::IFlipFlop>

pub fn as_i_flip_flop_mut(&mut self) -> Option<&mut IFlipFlop>

Casts &Node to Option<&mut nodes::IFlipFlop>

pub fn into_i_flip_flop(self) -> IFlipFlop

Casts self to nodes::IFlipFlop, panics if variant doesn’t match

pub fn is_match_pattern(&self) -> bool

Returns true if self is Node::MatchPattern

pub fn as_match_pattern(&self) -> Option<&MatchPattern>

Casts &Node to Option<&nodes::MatchPattern>

pub fn as_match_pattern_mut(&mut self) -> Option<&mut MatchPattern>

Casts &Node to Option<&mut nodes::MatchPattern>

pub fn into_match_pattern(self) -> MatchPattern

Casts self to nodes::MatchPattern, panics if variant doesn’t match

pub fn is_match_pattern_p(&self) -> bool

Returns true if self is Node::MatchPatternP

pub fn as_match_pattern_p(&self) -> Option<&MatchPatternP>

Casts &Node to Option<&nodes::MatchPatternP>

pub fn as_match_pattern_p_mut(&mut self) -> Option<&mut MatchPatternP>

Casts &Node to Option<&mut nodes::MatchPatternP>

pub fn into_match_pattern_p(self) -> MatchPatternP

Casts self to nodes::MatchPatternP, panics if variant doesn’t match

pub fn is_in_pattern(&self) -> bool

Returns true if self is Node::InPattern

pub fn as_in_pattern(&self) -> Option<&InPattern>

Casts &Node to Option<&nodes::InPattern>

pub fn as_in_pattern_mut(&mut self) -> Option<&mut InPattern>

Casts &Node to Option<&mut nodes::InPattern>

pub fn into_in_pattern(self) -> InPattern

Casts self to nodes::InPattern, panics if variant doesn’t match

pub fn is_index(&self) -> bool

Returns true if self is Node::Index

pub fn as_index(&self) -> Option<&Index>

Casts &Node to Option<&nodes::Index>

pub fn as_index_mut(&mut self) -> Option<&mut Index>

Casts &Node to Option<&mut nodes::Index>

pub fn into_index(self) -> Index

Casts self to nodes::Index, panics if variant doesn’t match

pub fn is_index_asgn(&self) -> bool

Returns true if self is Node::IndexAsgn

pub fn as_index_asgn(&self) -> Option<&IndexAsgn>

Casts &Node to Option<&nodes::IndexAsgn>

pub fn as_index_asgn_mut(&mut self) -> Option<&mut IndexAsgn>

Casts &Node to Option<&mut nodes::IndexAsgn>

pub fn into_index_asgn(self) -> IndexAsgn

Casts self to nodes::IndexAsgn, panics if variant doesn’t match

pub fn is_int(&self) -> bool

Returns true if self is Node::Int

pub fn as_int(&self) -> Option<&Int>

Casts &Node to Option<&nodes::Int>

pub fn as_int_mut(&mut self) -> Option<&mut Int>

Casts &Node to Option<&mut nodes::Int>

pub fn into_int(self) -> Int

Casts self to nodes::Int, panics if variant doesn’t match

pub fn is_irange(&self) -> bool

Returns true if self is Node::Irange

pub fn as_irange(&self) -> Option<&Irange>

Casts &Node to Option<&nodes::Irange>

pub fn as_irange_mut(&mut self) -> Option<&mut Irange>

Casts &Node to Option<&mut nodes::Irange>

pub fn into_irange(self) -> Irange

Casts self to nodes::Irange, panics if variant doesn’t match

pub fn is_ivar(&self) -> bool

Returns true if self is Node::Ivar

pub fn as_ivar(&self) -> Option<&Ivar>

Casts &Node to Option<&nodes::Ivar>

pub fn as_ivar_mut(&mut self) -> Option<&mut Ivar>

Casts &Node to Option<&mut nodes::Ivar>

pub fn into_ivar(self) -> Ivar

Casts self to nodes::Ivar, panics if variant doesn’t match

pub fn is_ivasgn(&self) -> bool

Returns true if self is Node::Ivasgn

pub fn as_ivasgn(&self) -> Option<&Ivasgn>

Casts &Node to Option<&nodes::Ivasgn>

pub fn as_ivasgn_mut(&mut self) -> Option<&mut Ivasgn>

Casts &Node to Option<&mut nodes::Ivasgn>

pub fn into_ivasgn(self) -> Ivasgn

Casts self to nodes::Ivasgn, panics if variant doesn’t match

pub fn is_kwarg(&self) -> bool

Returns true if self is Node::Kwarg

pub fn as_kwarg(&self) -> Option<&Kwarg>

Casts &Node to Option<&nodes::Kwarg>

pub fn as_kwarg_mut(&mut self) -> Option<&mut Kwarg>

Casts &Node to Option<&mut nodes::Kwarg>

pub fn into_kwarg(self) -> Kwarg

Casts self to nodes::Kwarg, panics if variant doesn’t match

pub fn is_kw_begin(&self) -> bool

Returns true if self is Node::KwBegin

pub fn as_kw_begin(&self) -> Option<&KwBegin>

Casts &Node to Option<&nodes::KwBegin>

pub fn as_kw_begin_mut(&mut self) -> Option<&mut KwBegin>

Casts &Node to Option<&mut nodes::KwBegin>

pub fn into_kw_begin(self) -> KwBegin

Casts self to nodes::KwBegin, panics if variant doesn’t match

pub fn is_kwnilarg(&self) -> bool

Returns true if self is Node::Kwnilarg

pub fn as_kwnilarg(&self) -> Option<&Kwnilarg>

Casts &Node to Option<&nodes::Kwnilarg>

pub fn as_kwnilarg_mut(&mut self) -> Option<&mut Kwnilarg>

Casts &Node to Option<&mut nodes::Kwnilarg>

pub fn into_kwnilarg(self) -> Kwnilarg

Casts self to nodes::Kwnilarg, panics if variant doesn’t match

pub fn is_kwoptarg(&self) -> bool

Returns true if self is Node::Kwoptarg

pub fn as_kwoptarg(&self) -> Option<&Kwoptarg>

Casts &Node to Option<&nodes::Kwoptarg>

pub fn as_kwoptarg_mut(&mut self) -> Option<&mut Kwoptarg>

Casts &Node to Option<&mut nodes::Kwoptarg>

pub fn into_kwoptarg(self) -> Kwoptarg

Casts self to nodes::Kwoptarg, panics if variant doesn’t match

pub fn is_kwrestarg(&self) -> bool

Returns true if self is Node::Kwrestarg

pub fn as_kwrestarg(&self) -> Option<&Kwrestarg>

Casts &Node to Option<&nodes::Kwrestarg>

pub fn as_kwrestarg_mut(&mut self) -> Option<&mut Kwrestarg>

Casts &Node to Option<&mut nodes::Kwrestarg>

pub fn into_kwrestarg(self) -> Kwrestarg

Casts self to nodes::Kwrestarg, panics if variant doesn’t match

pub fn is_kwsplat(&self) -> bool

Returns true if self is Node::Kwsplat

pub fn as_kwsplat(&self) -> Option<&Kwsplat>

Casts &Node to Option<&nodes::Kwsplat>

pub fn as_kwsplat_mut(&mut self) -> Option<&mut Kwsplat>

Casts &Node to Option<&mut nodes::Kwsplat>

pub fn into_kwsplat(self) -> Kwsplat

Casts self to nodes::Kwsplat, panics if variant doesn’t match

pub fn is_lambda(&self) -> bool

Returns true if self is Node::Lambda

pub fn as_lambda(&self) -> Option<&Lambda>

Casts &Node to Option<&nodes::Lambda>

pub fn as_lambda_mut(&mut self) -> Option<&mut Lambda>

Casts &Node to Option<&mut nodes::Lambda>

pub fn into_lambda(self) -> Lambda

Casts self to nodes::Lambda, panics if variant doesn’t match

pub fn is_line(&self) -> bool

Returns true if self is Node::Line

pub fn as_line(&self) -> Option<&Line>

Casts &Node to Option<&nodes::Line>

pub fn as_line_mut(&mut self) -> Option<&mut Line>

Casts &Node to Option<&mut nodes::Line>

pub fn into_line(self) -> Line

Casts self to nodes::Line, panics if variant doesn’t match

pub fn is_lvar(&self) -> bool

Returns true if self is Node::Lvar

pub fn as_lvar(&self) -> Option<&Lvar>

Casts &Node to Option<&nodes::Lvar>

pub fn as_lvar_mut(&mut self) -> Option<&mut Lvar>

Casts &Node to Option<&mut nodes::Lvar>

pub fn into_lvar(self) -> Lvar

Casts self to nodes::Lvar, panics if variant doesn’t match

pub fn is_lvasgn(&self) -> bool

Returns true if self is Node::Lvasgn

pub fn as_lvasgn(&self) -> Option<&Lvasgn>

Casts &Node to Option<&nodes::Lvasgn>

pub fn as_lvasgn_mut(&mut self) -> Option<&mut Lvasgn>

Casts &Node to Option<&mut nodes::Lvasgn>

pub fn into_lvasgn(self) -> Lvasgn

Casts self to nodes::Lvasgn, panics if variant doesn’t match

pub fn is_masgn(&self) -> bool

Returns true if self is Node::Masgn

pub fn as_masgn(&self) -> Option<&Masgn>

Casts &Node to Option<&nodes::Masgn>

pub fn as_masgn_mut(&mut self) -> Option<&mut Masgn>

Casts &Node to Option<&mut nodes::Masgn>

pub fn into_masgn(self) -> Masgn

Casts self to nodes::Masgn, panics if variant doesn’t match

pub fn is_match_alt(&self) -> bool

Returns true if self is Node::MatchAlt

pub fn as_match_alt(&self) -> Option<&MatchAlt>

Casts &Node to Option<&nodes::MatchAlt>

pub fn as_match_alt_mut(&mut self) -> Option<&mut MatchAlt>

Casts &Node to Option<&mut nodes::MatchAlt>

pub fn into_match_alt(self) -> MatchAlt

Casts self to nodes::MatchAlt, panics if variant doesn’t match

pub fn is_match_as(&self) -> bool

Returns true if self is Node::MatchAs

pub fn as_match_as(&self) -> Option<&MatchAs>

Casts &Node to Option<&nodes::MatchAs>

pub fn as_match_as_mut(&mut self) -> Option<&mut MatchAs>

Casts &Node to Option<&mut nodes::MatchAs>

pub fn into_match_as(self) -> MatchAs

Casts self to nodes::MatchAs, panics if variant doesn’t match

pub fn is_match_current_line(&self) -> bool

Returns true if self is Node::MatchCurrentLine

pub fn as_match_current_line(&self) -> Option<&MatchCurrentLine>

Casts &Node to Option<&nodes::MatchCurrentLine>

pub fn as_match_current_line_mut(&mut self) -> Option<&mut MatchCurrentLine>

Casts &Node to Option<&mut nodes::MatchCurrentLine>

pub fn into_match_current_line(self) -> MatchCurrentLine

Casts self to nodes::MatchCurrentLine, panics if variant doesn’t match

pub fn is_match_nil_pattern(&self) -> bool

Returns true if self is Node::MatchNilPattern

pub fn as_match_nil_pattern(&self) -> Option<&MatchNilPattern>

Casts &Node to Option<&nodes::MatchNilPattern>

pub fn as_match_nil_pattern_mut(&mut self) -> Option<&mut MatchNilPattern>

Casts &Node to Option<&mut nodes::MatchNilPattern>

pub fn into_match_nil_pattern(self) -> MatchNilPattern

Casts self to nodes::MatchNilPattern, panics if variant doesn’t match

pub fn is_match_rest(&self) -> bool

Returns true if self is Node::MatchRest

pub fn as_match_rest(&self) -> Option<&MatchRest>

Casts &Node to Option<&nodes::MatchRest>

pub fn as_match_rest_mut(&mut self) -> Option<&mut MatchRest>

Casts &Node to Option<&mut nodes::MatchRest>

pub fn into_match_rest(self) -> MatchRest

Casts self to nodes::MatchRest, panics if variant doesn’t match

pub fn is_match_var(&self) -> bool

Returns true if self is Node::MatchVar

pub fn as_match_var(&self) -> Option<&MatchVar>

Casts &Node to Option<&nodes::MatchVar>

pub fn as_match_var_mut(&mut self) -> Option<&mut MatchVar>

Casts &Node to Option<&mut nodes::MatchVar>

pub fn into_match_var(self) -> MatchVar

Casts self to nodes::MatchVar, panics if variant doesn’t match

pub fn is_match_with_lvasgn(&self) -> bool

Returns true if self is Node::MatchWithLvasgn

pub fn as_match_with_lvasgn(&self) -> Option<&MatchWithLvasgn>

Casts &Node to Option<&nodes::MatchWithLvasgn>

pub fn as_match_with_lvasgn_mut(&mut self) -> Option<&mut MatchWithLvasgn>

Casts &Node to Option<&mut nodes::MatchWithLvasgn>

pub fn into_match_with_lvasgn(self) -> MatchWithLvasgn

Casts self to nodes::MatchWithLvasgn, panics if variant doesn’t match

pub fn is_mlhs(&self) -> bool

Returns true if self is Node::Mlhs

pub fn as_mlhs(&self) -> Option<&Mlhs>

Casts &Node to Option<&nodes::Mlhs>

pub fn as_mlhs_mut(&mut self) -> Option<&mut Mlhs>

Casts &Node to Option<&mut nodes::Mlhs>

pub fn into_mlhs(self) -> Mlhs

Casts self to nodes::Mlhs, panics if variant doesn’t match

pub fn is_module(&self) -> bool

Returns true if self is Node::Module

pub fn as_module(&self) -> Option<&Module>

Casts &Node to Option<&nodes::Module>

pub fn as_module_mut(&mut self) -> Option<&mut Module>

Casts &Node to Option<&mut nodes::Module>

pub fn into_module(self) -> Module

Casts self to nodes::Module, panics if variant doesn’t match

pub fn is_next(&self) -> bool

Returns true if self is Node::Next

pub fn as_next(&self) -> Option<&Next>

Casts &Node to Option<&nodes::Next>

pub fn as_next_mut(&mut self) -> Option<&mut Next>

Casts &Node to Option<&mut nodes::Next>

pub fn into_next(self) -> Next

Casts self to nodes::Next, panics if variant doesn’t match

pub fn is_nil(&self) -> bool

Returns true if self is Node::Nil

pub fn as_nil(&self) -> Option<&Nil>

Casts &Node to Option<&nodes::Nil>

pub fn as_nil_mut(&mut self) -> Option<&mut Nil>

Casts &Node to Option<&mut nodes::Nil>

pub fn into_nil(self) -> Nil

Casts self to nodes::Nil, panics if variant doesn’t match

pub fn is_nth_ref(&self) -> bool

Returns true if self is Node::NthRef

pub fn as_nth_ref(&self) -> Option<&NthRef>

Casts &Node to Option<&nodes::NthRef>

pub fn as_nth_ref_mut(&mut self) -> Option<&mut NthRef>

Casts &Node to Option<&mut nodes::NthRef>

pub fn into_nth_ref(self) -> NthRef

Casts self to nodes::NthRef, panics if variant doesn’t match

pub fn is_numblock(&self) -> bool

Returns true if self is Node::Numblock

pub fn as_numblock(&self) -> Option<&Numblock>

Casts &Node to Option<&nodes::Numblock>

pub fn as_numblock_mut(&mut self) -> Option<&mut Numblock>

Casts &Node to Option<&mut nodes::Numblock>

pub fn into_numblock(self) -> Numblock

Casts self to nodes::Numblock, panics if variant doesn’t match

pub fn is_op_asgn(&self) -> bool

Returns true if self is Node::OpAsgn

pub fn as_op_asgn(&self) -> Option<&OpAsgn>

Casts &Node to Option<&nodes::OpAsgn>

pub fn as_op_asgn_mut(&mut self) -> Option<&mut OpAsgn>

Casts &Node to Option<&mut nodes::OpAsgn>

pub fn into_op_asgn(self) -> OpAsgn

Casts self to nodes::OpAsgn, panics if variant doesn’t match

pub fn is_optarg(&self) -> bool

Returns true if self is Node::Optarg

pub fn as_optarg(&self) -> Option<&Optarg>

Casts &Node to Option<&nodes::Optarg>

pub fn as_optarg_mut(&mut self) -> Option<&mut Optarg>

Casts &Node to Option<&mut nodes::Optarg>

pub fn into_optarg(self) -> Optarg

Casts self to nodes::Optarg, panics if variant doesn’t match

pub fn is_or(&self) -> bool

Returns true if self is Node::Or

pub fn as_or(&self) -> Option<&Or>

Casts &Node to Option<&nodes::Or>

pub fn as_or_mut(&mut self) -> Option<&mut Or>

Casts &Node to Option<&mut nodes::Or>

pub fn into_or(self) -> Or

Casts self to nodes::Or, panics if variant doesn’t match

pub fn is_or_asgn(&self) -> bool

Returns true if self is Node::OrAsgn

pub fn as_or_asgn(&self) -> Option<&OrAsgn>

Casts &Node to Option<&nodes::OrAsgn>

pub fn as_or_asgn_mut(&mut self) -> Option<&mut OrAsgn>

Casts &Node to Option<&mut nodes::OrAsgn>

pub fn into_or_asgn(self) -> OrAsgn

Casts self to nodes::OrAsgn, panics if variant doesn’t match

pub fn is_pair(&self) -> bool

Returns true if self is Node::Pair

pub fn as_pair(&self) -> Option<&Pair>

Casts &Node to Option<&nodes::Pair>

pub fn as_pair_mut(&mut self) -> Option<&mut Pair>

Casts &Node to Option<&mut nodes::Pair>

pub fn into_pair(self) -> Pair

Casts self to nodes::Pair, panics if variant doesn’t match

pub fn is_pin(&self) -> bool

Returns true if self is Node::Pin

pub fn as_pin(&self) -> Option<&Pin>

Casts &Node to Option<&nodes::Pin>

pub fn as_pin_mut(&mut self) -> Option<&mut Pin>

Casts &Node to Option<&mut nodes::Pin>

pub fn into_pin(self) -> Pin

Casts self to nodes::Pin, panics if variant doesn’t match

pub fn is_postexe(&self) -> bool

Returns true if self is Node::Postexe

pub fn as_postexe(&self) -> Option<&Postexe>

Casts &Node to Option<&nodes::Postexe>

pub fn as_postexe_mut(&mut self) -> Option<&mut Postexe>

Casts &Node to Option<&mut nodes::Postexe>

pub fn into_postexe(self) -> Postexe

Casts self to nodes::Postexe, panics if variant doesn’t match

pub fn is_preexe(&self) -> bool

Returns true if self is Node::Preexe

pub fn as_preexe(&self) -> Option<&Preexe>

Casts &Node to Option<&nodes::Preexe>

pub fn as_preexe_mut(&mut self) -> Option<&mut Preexe>

Casts &Node to Option<&mut nodes::Preexe>

pub fn into_preexe(self) -> Preexe

Casts self to nodes::Preexe, panics if variant doesn’t match

pub fn is_procarg0(&self) -> bool

Returns true if self is Node::Procarg0

pub fn as_procarg0(&self) -> Option<&Procarg0>

Casts &Node to Option<&nodes::Procarg0>

pub fn as_procarg0_mut(&mut self) -> Option<&mut Procarg0>

Casts &Node to Option<&mut nodes::Procarg0>

pub fn into_procarg0(self) -> Procarg0

Casts self to nodes::Procarg0, panics if variant doesn’t match

pub fn is_rational(&self) -> bool

Returns true if self is Node::Rational

pub fn as_rational(&self) -> Option<&Rational>

Casts &Node to Option<&nodes::Rational>

pub fn as_rational_mut(&mut self) -> Option<&mut Rational>

Casts &Node to Option<&mut nodes::Rational>

pub fn into_rational(self) -> Rational

Casts self to nodes::Rational, panics if variant doesn’t match

pub fn is_redo(&self) -> bool

Returns true if self is Node::Redo

pub fn as_redo(&self) -> Option<&Redo>

Casts &Node to Option<&nodes::Redo>

pub fn as_redo_mut(&mut self) -> Option<&mut Redo>

Casts &Node to Option<&mut nodes::Redo>

pub fn into_redo(self) -> Redo

Casts self to nodes::Redo, panics if variant doesn’t match

pub fn is_reg_opt(&self) -> bool

Returns true if self is Node::RegOpt

pub fn as_reg_opt(&self) -> Option<&RegOpt>

Casts &Node to Option<&nodes::RegOpt>

pub fn as_reg_opt_mut(&mut self) -> Option<&mut RegOpt>

Casts &Node to Option<&mut nodes::RegOpt>

pub fn into_reg_opt(self) -> RegOpt

Casts self to nodes::RegOpt, panics if variant doesn’t match

pub fn is_regexp(&self) -> bool

Returns true if self is Node::Regexp

pub fn as_regexp(&self) -> Option<&Regexp>

Casts &Node to Option<&nodes::Regexp>

pub fn as_regexp_mut(&mut self) -> Option<&mut Regexp>

Casts &Node to Option<&mut nodes::Regexp>

pub fn into_regexp(self) -> Regexp

Casts self to nodes::Regexp, panics if variant doesn’t match

pub fn is_rescue(&self) -> bool

Returns true if self is Node::Rescue

pub fn as_rescue(&self) -> Option<&Rescue>

Casts &Node to Option<&nodes::Rescue>

pub fn as_rescue_mut(&mut self) -> Option<&mut Rescue>

Casts &Node to Option<&mut nodes::Rescue>

pub fn into_rescue(self) -> Rescue

Casts self to nodes::Rescue, panics if variant doesn’t match

pub fn is_rescue_body(&self) -> bool

Returns true if self is Node::RescueBody

pub fn as_rescue_body(&self) -> Option<&RescueBody>

Casts &Node to Option<&nodes::RescueBody>

pub fn as_rescue_body_mut(&mut self) -> Option<&mut RescueBody>

Casts &Node to Option<&mut nodes::RescueBody>

pub fn into_rescue_body(self) -> RescueBody

Casts self to nodes::RescueBody, panics if variant doesn’t match

pub fn is_restarg(&self) -> bool

Returns true if self is Node::Restarg

pub fn as_restarg(&self) -> Option<&Restarg>

Casts &Node to Option<&nodes::Restarg>

pub fn as_restarg_mut(&mut self) -> Option<&mut Restarg>

Casts &Node to Option<&mut nodes::Restarg>

pub fn into_restarg(self) -> Restarg

Casts self to nodes::Restarg, panics if variant doesn’t match

pub fn is_retry(&self) -> bool

Returns true if self is Node::Retry

pub fn as_retry(&self) -> Option<&Retry>

Casts &Node to Option<&nodes::Retry>

pub fn as_retry_mut(&mut self) -> Option<&mut Retry>

Casts &Node to Option<&mut nodes::Retry>

pub fn into_retry(self) -> Retry

Casts self to nodes::Retry, panics if variant doesn’t match

pub fn is_return(&self) -> bool

Returns true if self is Node::Return

pub fn as_return(&self) -> Option<&Return>

Casts &Node to Option<&nodes::Return>

pub fn as_return_mut(&mut self) -> Option<&mut Return>

Casts &Node to Option<&mut nodes::Return>

pub fn into_return(self) -> Return

Casts self to nodes::Return, panics if variant doesn’t match

pub fn is_s_class(&self) -> bool

Returns true if self is Node::SClass

pub fn as_s_class(&self) -> Option<&SClass>

Casts &Node to Option<&nodes::SClass>

pub fn as_s_class_mut(&mut self) -> Option<&mut SClass>

Casts &Node to Option<&mut nodes::SClass>

pub fn into_s_class(self) -> SClass

Casts self to nodes::SClass, panics if variant doesn’t match

pub fn is_self(&self) -> bool

Returns true if self is Node::Self_

pub fn as_self(&self) -> Option<&Self_>

Casts &Node to Option<&nodes::Self_>

pub fn as_self_mut(&mut self) -> Option<&mut Self_>

Casts &Node to Option<&mut nodes::Self_>

pub fn into_self(self) -> Self_

Casts self to nodes::Self_, panics if variant doesn’t match

pub fn is_send(&self) -> bool

Returns true if self is Node::Send

pub fn as_send(&self) -> Option<&Send>

Casts &Node to Option<&nodes::Send>

pub fn as_send_mut(&mut self) -> Option<&mut Send>

Casts &Node to Option<&mut nodes::Send>

pub fn into_send(self) -> Send

Casts self to nodes::Send, panics if variant doesn’t match

pub fn is_shadowarg(&self) -> bool

Returns true if self is Node::Shadowarg

pub fn as_shadowarg(&self) -> Option<&Shadowarg>

Casts &Node to Option<&nodes::Shadowarg>

pub fn as_shadowarg_mut(&mut self) -> Option<&mut Shadowarg>

Casts &Node to Option<&mut nodes::Shadowarg>

pub fn into_shadowarg(self) -> Shadowarg

Casts self to nodes::Shadowarg, panics if variant doesn’t match

pub fn is_splat(&self) -> bool

Returns true if self is Node::Splat

pub fn as_splat(&self) -> Option<&Splat>

Casts &Node to Option<&nodes::Splat>

pub fn as_splat_mut(&mut self) -> Option<&mut Splat>

Casts &Node to Option<&mut nodes::Splat>

pub fn into_splat(self) -> Splat

Casts self to nodes::Splat, panics if variant doesn’t match

pub fn is_str(&self) -> bool

Returns true if self is Node::Str

pub fn as_str(&self) -> Option<&Str>

Casts &Node to Option<&nodes::Str>

pub fn as_str_mut(&mut self) -> Option<&mut Str>

Casts &Node to Option<&mut nodes::Str>

pub fn into_str(self) -> Str

Casts self to nodes::Str, panics if variant doesn’t match

pub fn is_super(&self) -> bool

Returns true if self is Node::Super

pub fn as_super(&self) -> Option<&Super>

Casts &Node to Option<&nodes::Super>

pub fn as_super_mut(&mut self) -> Option<&mut Super>

Casts &Node to Option<&mut nodes::Super>

pub fn into_super(self) -> Super

Casts self to nodes::Super, panics if variant doesn’t match

pub fn is_sym(&self) -> bool

Returns true if self is Node::Sym

pub fn as_sym(&self) -> Option<&Sym>

Casts &Node to Option<&nodes::Sym>

pub fn as_sym_mut(&mut self) -> Option<&mut Sym>

Casts &Node to Option<&mut nodes::Sym>

pub fn into_sym(self) -> Sym

Casts self to nodes::Sym, panics if variant doesn’t match

pub fn is_true(&self) -> bool

Returns true if self is Node::True

pub fn as_true(&self) -> Option<&True>

Casts &Node to Option<&nodes::True>

pub fn as_true_mut(&mut self) -> Option<&mut True>

Casts &Node to Option<&mut nodes::True>

pub fn into_true(self) -> True

Casts self to nodes::True, panics if variant doesn’t match

pub fn is_undef(&self) -> bool

Returns true if self is Node::Undef

pub fn as_undef(&self) -> Option<&Undef>

Casts &Node to Option<&nodes::Undef>

pub fn as_undef_mut(&mut self) -> Option<&mut Undef>

Casts &Node to Option<&mut nodes::Undef>

pub fn into_undef(self) -> Undef

Casts self to nodes::Undef, panics if variant doesn’t match

pub fn is_unless_guard(&self) -> bool

Returns true if self is Node::UnlessGuard

pub fn as_unless_guard(&self) -> Option<&UnlessGuard>

Casts &Node to Option<&nodes::UnlessGuard>

pub fn as_unless_guard_mut(&mut self) -> Option<&mut UnlessGuard>

Casts &Node to Option<&mut nodes::UnlessGuard>

pub fn into_unless_guard(self) -> UnlessGuard

Casts self to nodes::UnlessGuard, panics if variant doesn’t match

pub fn is_until(&self) -> bool

Returns true if self is Node::Until

pub fn as_until(&self) -> Option<&Until>

Casts &Node to Option<&nodes::Until>

pub fn as_until_mut(&mut self) -> Option<&mut Until>

Casts &Node to Option<&mut nodes::Until>

pub fn into_until(self) -> Until

Casts self to nodes::Until, panics if variant doesn’t match

pub fn is_until_post(&self) -> bool

Returns true if self is Node::UntilPost

pub fn as_until_post(&self) -> Option<&UntilPost>

Casts &Node to Option<&nodes::UntilPost>

pub fn as_until_post_mut(&mut self) -> Option<&mut UntilPost>

Casts &Node to Option<&mut nodes::UntilPost>

pub fn into_until_post(self) -> UntilPost

Casts self to nodes::UntilPost, panics if variant doesn’t match

pub fn is_when(&self) -> bool

Returns true if self is Node::When

pub fn as_when(&self) -> Option<&When>

Casts &Node to Option<&nodes::When>

pub fn as_when_mut(&mut self) -> Option<&mut When>

Casts &Node to Option<&mut nodes::When>

pub fn into_when(self) -> When

Casts self to nodes::When, panics if variant doesn’t match

pub fn is_while(&self) -> bool

Returns true if self is Node::While

pub fn as_while(&self) -> Option<&While>

Casts &Node to Option<&nodes::While>

pub fn as_while_mut(&mut self) -> Option<&mut While>

Casts &Node to Option<&mut nodes::While>

pub fn into_while(self) -> While

Casts self to nodes::While, panics if variant doesn’t match

pub fn is_while_post(&self) -> bool

Returns true if self is Node::WhilePost

pub fn as_while_post(&self) -> Option<&WhilePost>

Casts &Node to Option<&nodes::WhilePost>

pub fn as_while_post_mut(&mut self) -> Option<&mut WhilePost>

Casts &Node to Option<&mut nodes::WhilePost>

pub fn into_while_post(self) -> WhilePost

Casts self to nodes::WhilePost, panics if variant doesn’t match

pub fn is_x_heredoc(&self) -> bool

Returns true if self is Node::XHeredoc

pub fn as_x_heredoc(&self) -> Option<&XHeredoc>

Casts &Node to Option<&nodes::XHeredoc>

pub fn as_x_heredoc_mut(&mut self) -> Option<&mut XHeredoc>

Casts &Node to Option<&mut nodes::XHeredoc>

pub fn into_x_heredoc(self) -> XHeredoc

Casts self to nodes::XHeredoc, panics if variant doesn’t match

pub fn is_xstr(&self) -> bool

Returns true if self is Node::Xstr

pub fn as_xstr(&self) -> Option<&Xstr>

Casts &Node to Option<&nodes::Xstr>

pub fn as_xstr_mut(&mut self) -> Option<&mut Xstr>

Casts &Node to Option<&mut nodes::Xstr>

pub fn into_xstr(self) -> Xstr

Casts self to nodes::Xstr, panics if variant doesn’t match

pub fn is_yield(&self) -> bool

Returns true if self is Node::Yield

pub fn as_yield(&self) -> Option<&Yield>

Casts &Node to Option<&nodes::Yield>

pub fn as_yield_mut(&mut self) -> Option<&mut Yield>

Casts &Node to Option<&mut nodes::Yield>

pub fn into_yield(self) -> Yield

Casts self to nodes::Yield, panics if variant doesn’t match

pub fn is_z_super(&self) -> bool

Returns true if self is Node::ZSuper

pub fn as_z_super(&self) -> Option<&ZSuper>

Casts &Node to Option<&nodes::ZSuper>

pub fn as_z_super_mut(&mut self) -> Option<&mut ZSuper>

Casts &Node to Option<&mut nodes::ZSuper>

pub fn into_z_super(self) -> ZSuper

Casts self to nodes::ZSuper, panics if variant doesn’t match

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) -> &Loc

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

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl PartialEq<Node> for Node

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

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

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

This method tests for !=.

impl StructuralPartialEq for Node