Module lib_ruby_parser::nodes [−][src]
Expand description
Module with all known node types
Structs
Represents alias to from
statement.
Represents foo && bar
(or foo 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, see BlockArg
)
Represents a &blk
argument in the method definition (but not in the method call, see BlockPass
)
Represents a break
keyword (with optional argument)
Represents conditional method call using &.
operator
Represents a case
statement (for pattern matching see CaseMatch
node)
Represents a case
statement used for pattern matching (for regular case
see Case
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 an Complex
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, see Defs
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 (see ForwardArg
)
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
in def 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
in def m(foo: 42); end
)
Represents a keyword rest argument (i.e. foo
in def m(**foo); end
)
Represents a keyword arguments splat (i.e. **bar
in a call like foo(**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
in foo, 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
in m(foo = 1)
)
Represents foo || bar
(or foo 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
in def 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 like foo(*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.