Module lib_ruby_parser::nodes
source · Expand description
Module with all known node types
Modules§
Structs§
- Represents
alias to from
statement. - Represents
foo && bar
(orfoo and bar
) statement. - Represents
a &&= 1
statement. - Represents a positional required block/method argument.
- Represents an arguments list
- Represents an array literal
- Represents an array pattern used in pattern matching
- Represents an array pattern with trailing comma used in pattern matching
- Represents special global variables:
- Represents compound statement (i.e. a multi-statement)
- Represents a Ruby block that is passed to a method (
proc { |foo| bar }
) - Represents a
&blk
argument of the method call (but not of the method definition, seeBlockArg
) - Represents a
&blk
argument in the method definition (but not in the method call, seeBlockPass
) - Represents a
break
keyword (with optional argument) - Represents conditional method call using
&.
operator - Represents a
case
statement (for pattern matching seeCaseMatch
node) - Represents a
case
statement used for pattern matching (for regularcase
seeCase
node) - Represents a constant assignment (i.e.
A = 1
) - Represents leading
::
part of the constant access/assignment that is used to get/set on a global namespace. - Represents a class definition (using a
class
keyword,Class.new
is just a method call) - Represents a
Complex
literal (that returns anComplex
number) - Represents constant access (i.e.
Foo::Bar
) - Const pattern used in pattern matching (e.g.
in A(1, 2)
) - Represents access to class variable (i.e.
@@var
) - Represents class variable assignment (i.e.
@@var = 42
) - Represents method definition using
def
keyword (not on a singleton, seeDefs
node). - Represents a
defined?(foo)
expression - Represents a singleton method definition (i.e.
def self.foo; end
) - Represents a string with interpolation (i.e.
"#{foo}"
) - Represents a symbol with interpolation (i.e.
:"#{foo}"
) - Represents exclusive flip-flop (i.e. in
if foo...bar; end
) - Represents a special empty else that is a part of the pattern matching.
- Represents a special
__ENCODING__
keyword - Represents a block of code with
ensure
(i.e.begin; ensure; end
) - Represents range literal with excluded
end
(i.e.1...3
) - Represents a
false
literal - Represents a special
__FILE__
literal - Represents a find pattern using in pattern matching (i.e.
in [*x, 1 => a, *y]
) - Represents a float literal (i.e.
42.5
) - Represents a
for
loop - Represents a special
...
argument that forwards positional/keyword/block arguments. - Represents a
...
operator that contains forwarded argument (seeForwardArg
) - Represents access to global variable (i.e.
$foo
) - Represents global variable assignment (i.e.
$foo = 42
) - Represents a hash literal (i.e.
{ foo: 42 }
) - Represents a hash pattern used in pattern matching (i.e.
in { a: 1 }
) - Represents a here-document literal (both with and without interpolation)
- Represents inclusive flip-flop (i.e. in
if foo..bar; end
) - Represents an
if
statement (i.e.if foo; bar; else; baz; end
) - Represents an
if
guard used in pattern matching (i.e.case foo; in pattern if guard; end
) - Represents an
if
/unless
modifier (i.e.stmt if cond
) - Represents ternary
if
statement (i.e.cond ? if_true : if_false
) - Represents an
in pattern
branch of the pattern matching - Represents indexing operation (i.e.
foo[1,2,3]
) - Represents assignment using indexing operation (i.e.
foo[1, 2, 3] = bar
) - Represents an integer literal (i.e.
42
) - Represents inclusive range (i.e.
2..4
) - Represents access to instance variable (i.e.
@foo
) - Represents instance variable assignment (i.e
@foo = 42
) - Represents an explicit
begin; end
block. - Represents required keyword argument (i.e.
foo
indef m(foo:); end
) - Represents kwargs that are given to a method call, super or yield (i.e.
foo(bar: 1)
) - Represents an special argument that rejects all keyword arguments (i.e.
def m(**nil); end
) - Represents an optional keyword argument (i.e.
foo
indef m(foo: 42); end
) - Represents a keyword rest argument (i.e.
foo
indef m(**foo); end
) - Represents a keyword arguments splat (i.e.
**bar
in a call likefoo(**bar)
) - Represents a lambda call using
->
(i.e.-> {}
) - Represents a special
__LINE__
literal - Represents access to a local variable (i.e.
foo
) - Represents local variable assignment (i.e.
foo = 42
) - Represents mass-assignment (i.e.
foo, bar = 1, 2
) - Represents pattern matching using one of the given patterns (i.e.
foo in 1 | 2
) - Represents matching with renaming into specified local variable (i.e.
case 1; in Integer => a; end
) - Represents implicit matching using
if /regex/
- Represents empty hash pattern that is used in pattern matching (i.e.
in **nil
) - Represents a one-line pattern matching that can throw an error (i.e.
foo => pattern
) - Represents a one-line pattern matching that never throws but returns true/false (i.e.
foo in pattern
) - Represents a wildcard pattern used in pattern matching (i.e.
in *foo
) - Represents matching with assignment into a local variable (i.e.
pattern => var
) - Represents matching a regex that produces local variables (i.e.
/(?<match>bar)/ =~ 'bar'
) - Represents left hand statement of the mass-assignment (i.e.
foo, bar
infoo, bar = 1, 2
) - Represents module declaration using
module
keyword - Represents
next
keyword - Represents
nil
literal - Represents numeric global variable (e.g.
$1
) - Represents a block that takes numbered parameters (i.e.
proc { _1 }
) - Represents an operation with assignment (e.g.
a += 1
) - Represents optional positional argument (i.e.
foo
inm(foo = 1)
) - Represents
foo || bar
(orfoo or bar
) statement. - Represents
lhs ||= rhs
assignment - Represents a key/value pair (e.g. a part of the
Hash
node) - Represents a pattern based on a “pinned” variable (e.g.
^foo
) - Represents
END { .. }
statement - Represents
BEGIN { ... }
statement - Represents a sole block argument (e.g.
|foo|
) - Represents rational literal (e.g.
1r
) - Represents
redo
keyword - Represents flags of the regex literal (i.e.
mix
for/foo/mix
) - Represents regex literal (e.g.
/foo/
) - Represents a
rescue
block - Represents a single
rescue
handler (i.e.rescue E => e ...
) - Represents positional rest argument (i.e.
*foo
indef m(*foo); end
) - Represents
retry
keyword - Represents
return
keyword - Represents opening a singleton class (i.e.
class << foo; ... end;
) - Represents
self
keyword - Represents a method call (e.g.
foo.bar(42)
) - Represents a special block argument that “shadows” outer variable (i.e.
|;foo|
) - Represents an arguments splat (i.e.
*bar
in a call likefoo(*bar)
) - Represents a plain non-interpolated string literal (e.g.
"foo"
) - Represents a
super
keyword - Represents a plain symbol literal (i.e.
:foo
) - Represents a
true
literal - Represents an
undef
keyword (e.g.undef foo, :bar
) - Represents an
unless
guard used in pattern matching (i.e.in pattern unless guard
) - Represents
until
loop - Represents a post-until loop
- Represents a branch of the
case
statement (i.e.when foo
) - Represents
while
loop - Represents a post-while loop
- Represents a executable here-document literal (both with and without interpolation)
- Represents an executable string (i.e.
`sh #{script_name}`
) - Represents an
yield
keyword - Represents a
super
call without arguments and parentheses
Enums§
- Generic combination of all known nodes.