Module lib_ruby_parser::nodes

Module with all known node types

Modules

• types

Structs

• Alias
  Represents alias to from statement.
• And
  Represents foo && bar (or foo and bar) statement.
• AndAsgn
  Represents a &&= 1 statement.
• Arg
  Represents a positional required block/method argument.
• Args
  Represents an arguments list
• Array
  Represents an array literal
• ArrayPattern
  Represents an array pattern used in pattern matching
• ArrayPatternWithTail
  Represents an array pattern with trailing comma used in pattern matching
• BackRef
  Represents special global variables:
• Begin
  Represents compound statement (i.e. a multi-statement)
• Block
  Represents a Ruby block that is passed to a method (proc { |foo| bar })
• BlockPass
  Represents a &blk argument of the method call (but not of the method definition, see BlockArg)
• Blockarg
  Represents a &blk argument in the method definition (but not in the method call, see BlockPass)
• Break
  Represents a break keyword (with optional argument)
• CSend
  Represents conditional method call using &. operator
• Case
  Represents a case statement (for pattern matching see CaseMatch node)
• CaseMatch
  Represents a case statement used for pattern matching (for regular case see Case node)
• Casgn
  Represents a constant assignment (i.e. A = 1)
• Cbase
  Represents leading :: part of the constant access/assignment that is used to get/set on a global namespace.
• Class
  Represents a class definition (using a class keyword, Class.new is just a method call)
• Complex
  Represents a Complex literal (that returns an Complex number)
• Const
  Represents constant access (i.e. Foo::Bar)
• ConstPattern
  Const pattern used in pattern matching (e.g. in A(1, 2))
• Cvar
  Represents access to class variable (i.e. @@var)
• Cvasgn
  Represents class variable assignment (i.e. @@var = 42)
• Def
  Represents method definition using def keyword (not on a singleton, see Defs node).
• Defined
  Represents a defined?(foo) expression
• Defs
  Represents a singleton method definition (i.e. def self.foo; end)
• Dstr
  Represents a string with interpolation (i.e. "#{foo}")
• Dsym
  Represents a symbol with interpolation (i.e. :"#{foo}")
• EFlipFlop
  Represents exclusive flip-flop (i.e. in if foo...bar; end)
• EmptyElse
  Represents a special empty else that is a part of the pattern matching.
• Encoding
  Represents a special __ENCODING__ keyword
• Ensure
  Represents a block of code with ensure (i.e. begin; ensure; end)
• Erange
  Represents range literal with excluded end (i.e. 1...3)
• False
  Represents a false literal
• File
  Represents a special __FILE__ literal
• FindPattern
  Represents a find pattern using in pattern matching (i.e. in [*x, 1 => a, *y])
• Float
  Represents a float literal (i.e. 42.5)
• For
  Represents a for loop
• ForwardArg
  Represents a special ... argument that forwards positional/keyword/block arguments.
• ForwardedArgs
  Represents a ... operator that contains forwarded argument (see ForwardArg)
• Gvar
  Represents access to global variable (i.e. $foo)
• Gvasgn
  Represents global variable assignment (i.e. $foo = 42)
• Hash
  Represents a hash literal (i.e. { foo: 42 })
• HashPattern
  Represents a hash pattern used in pattern matching (i.e. in { a: 1 })
• Heredoc
  Represents a here-document literal (both with and without interpolation)
• IFlipFlop
  Represents inclusive flip-flop (i.e. in if foo..bar; end)
• If
  Represents an if statement (i.e. if foo; bar; else; baz; end)
• IfGuard
  Represents an if guard used in pattern matching (i.e. case foo; in pattern if guard; end)
• IfMod
  Represents an if/unless modifier (i.e. stmt if cond)
• IfTernary
  Represents ternary if statement (i.e. cond ? if_true : if_false)
• InPattern
  Represents an in pattern branch of the pattern matching
• Index
  Represents indexing operation (i.e. foo[1,2,3])
• IndexAsgn
  Represents assignment using indexing operation (i.e. foo[1, 2, 3] = bar)
• Int
  Represents an integer literal (i.e. 42)
• Irange
  Represents inclusive range (i.e. 2..4)
• Ivar
  Represents access to instance variable (i.e. @foo)
• Ivasgn
  Represents instance variable assignment (i.e @foo = 42)
• KwBegin
  Represents an explicit begin; end block.
• Kwarg
  Represents required keyword argument (i.e. foo in def m(foo:); end)
• Kwargs
  Represents kwargs that are given to a method call, super or yield (i.e. foo(bar: 1))
• Kwnilarg
  Represents an special argument that rejects all keyword arguments (i.e. def m(**nil); end)
• Kwoptarg
  Represents an optional keyword argument (i.e. foo in def m(foo: 42); end)
• Kwrestarg
  Represents a keyword rest argument (i.e. foo in def m(**foo); end)
• Kwsplat
  Represents a keyword arguments splat (i.e. **bar in a call like foo(**bar))
• Lambda
  Represents a lambda call using -> (i.e. -> {})
• Line
  Represents a special __LINE__ literal
• Lvar
  Represents access to a local variable (i.e. foo)
• Lvasgn
  Represents local variable assignment (i.e. foo = 42)
• Masgn
  Represents mass-assignment (i.e. foo, bar = 1, 2)
• MatchAlt
  Represents pattern matching using one of the given patterns (i.e. foo in 1 | 2)
• MatchAs
  Represents matching with renaming into specified local variable (i.e. case 1; in Integer => a; end)
• MatchCurrentLine
  Represents implicit matching using if /regex/
• MatchNilPattern
  Represents empty hash pattern that is used in pattern matching (i.e. in **nil)
• MatchPattern
  Represents a one-line pattern matching that can throw an error (i.e. foo => pattern)
• MatchPatternP
  Represents a one-line pattern matching that never throws but returns true/false (i.e. foo in pattern)
• MatchRest
  Represents a wildcard pattern used in pattern matching (i.e. in *foo)
• MatchVar
  Represents matching with assignment into a local variable (i.e. pattern => var)
• MatchWithLvasgn
  Represents matching a regex that produces local variables (i.e. /(?<match>bar)/ =~ 'bar')
• Mlhs
  Represents left hand statement of the mass-assignment (i.e. foo, bar in foo, bar = 1, 2)
• Module
  Represents module declaration using module keyword
• Next
  Represents next keyword
• Nil
  Represents nil literal
• NthRef
  Represents numeric global variable (e.g. $1)
• Numblock
  Represents a block that takes numbered parameters (i.e. proc { _1 })
• OpAsgn
  Represents an operation with assignment (e.g. a += 1)
• Optarg
  Represents optional positional argument (i.e. foo in m(foo = 1))
• Or
  Represents foo || bar (or foo or bar) statement.
• OrAsgn
  Represents lhs ||= rhs assignment
• Pair
  Represents a key/value pair (e.g. a part of the Hash node)
• Pin
  Represents a pattern based on a “pinned” variable (e.g. ^foo)
• Postexe
  Represents END { .. } statement
• Preexe
  Represents BEGIN { ... } statement
• Procarg0
  Represents a sole block argument (e.g. |foo|)
• Rational
  Represents rational literal (e.g. 1r)
• Redo
  Represents redo keyword
• RegOpt
  Represents flags of the regex literal (i.e. mix for /foo/mix)
• Regexp
  Represents regex literal (e.g. /foo/)
• Rescue
  Represents a rescue block
• RescueBody
  Represents a single rescue handler (i.e. rescue E => e ...)
• Restarg
  Represents positional rest argument (i.e. *foo in def m(*foo); end)
• Retry
  Represents retry keyword
• Return
  Represents return keyword
• SClass
  Represents opening a singleton class (i.e. class << foo; ... end;)
• Self_
  Represents self keyword
• Send
  Represents a method call (e.g. foo.bar(42))
• Shadowarg
  Represents a special block argument that “shadows” outer variable (i.e. |;foo|)
• Splat
  Represents an arguments splat (i.e. *bar in a call like foo(*bar))
• Str
  Represents a plain non-interpolated string literal (e.g. "foo")
• Super
  Represents a super keyword
• Sym
  Represents a plain symbol literal (i.e. :foo)
• True
  Represents a true literal
• Undef
  Represents an undef keyword (e.g. undef foo, :bar)
• UnlessGuard
  Represents an unless guard used in pattern matching (i.e. in pattern unless guard)
• Until
  Represents until loop
• UntilPost
  Represents a post-until loop
• When
  Represents a branch of the case statement (i.e. when foo)
• While
  Represents while loop
• WhilePost
  Represents a post-while loop
• XHeredoc
  Represents a executable here-document literal (both with and without interpolation)
• Xstr
  Represents an executable string (i.e. `sh #{script_name}`)
• Yield
  Represents an yield keyword
• ZSuper
  Represents a super call without arguments and parentheses

Enums

• Node
  Generic combination of all known nodes.