Module AST

Provides classes for working with locations.

An add expression. rb x + 1

A series of add expressions, e.g. 1 + 2 + 3. This class is used to represent the root of such a series, and the getALeaf predicate can be used to get the leaf nodes.

An alias statement. For example: rb - alias alias_name method_name - alias foo :method_name - alias bar :"method_#{ name }"

A composite pattern matching one of the given sub-patterns, for example: rb in 1 | 2 | 3

A sequence of expressions in the right-hand side of an assignment or a return, break or next statement. rb x = 1, *items, 3, *more return 1, 2 next *list break **map return 1, 2, *items, k: 5, **map

An array literal.

An array pattern, for example: rb in [] in ["first", Integer => x, "last"] in ["a", Integer => x, *] in ["a", Integer => x, ] in [1, 2, *x, 7, 8] in [*init, 7, 8] in List["a", Integer => x, *tail]

A pattern match that binds to the specified local variable, for example Integer => a in the following: rb case 1 in Integer => a then puts "#{a} is an integer value" end

A += assignment expression. rb x += 1

An arithmetic assignment operation: +=, -=, *=, /=, **=, and %=.

A bitwise AND assignment operation. rb x &= 0xff

A bitwise assignment operation: <<=, >>=, &=, |= and ^=.

A bitwise OR assignment operation. rb x |= 0x01

An XOR (exclusive OR) assignment operation. rb x ^= y

A /= assignment expression. rb x /= y

A **= assignment expression. rb x **= 2

An assignment operation with the operator =. rb x = 123

A left-shift assignment operation. rb x <<= 3

A logical AND assignment operation. rb x &&= y.even?

A logical assignment operation: &&= and ||=.

A logical OR assignment operation. rb x ||= y

A %= assignment expression. rb x %= 4

A *= assignment expression. rb x *= 10

A binary assignment operation other than =.

A right-shift assignment operation. rb x >>= 3

A -= assignment expression. rb x -= 3

A binary assignment operation, including =, +=, &=, etc.

A node in the abstract syntax tree. This class is the base class for all Ruby program elements.

A BEGIN block. rb BEGIN { puts "starting ..." }

A begin statement. rb begin puts "hello world" end

A binary arithmetic operation.

A binary bitwise operation.

A binary logical operation.

A binary operation.

A bitwise AND operation. rb x & 0xff

A bitwise OR operation. rb x | 0x01

An XOR (exclusive OR) operation. rb x ^ y

A block.

A block argument in a method call. rb foo(&block)

A parameter that is a block. For example, &bar in the following code: rb def foo(&bar) bar.call if block_given? end

A sequence of statements representing the body of a method, class, module, or do-block. That is, any body that may also include rescue/ensure/else statements.

A Boolean literal. rb true false TRUE FALSE

A block defined using curly braces, e.g. in the following code: rb names.each { |name| puts name }

A break statement. rb break break value

A call.

A callable.

A case-equality (or ‘threequals’) expression. rb String === "foo"

A case statement. There are three forms of case statements:

A pattern used in a case-in expression. For example rb case expr in [ x ] then ... in Point(a:, b:) then ... in Integer => x then ... end

A character literal.

A class definition.

A class variable.

An access to a class variable.

An access to a class variable where the value is read.

An access to a class variable where the value is updated.

A comparison operation. That is, either an equality operation or a relational operation.

A complement (bitwise NOT) expression. rb ~x

A complex literal.

A conditional expression: if/unless (including expression-modifier variants), and ternary-if (?:) expressions.

A loop using a condition expression. That is, a while or until loop, or their expression-modifier variants.

An access to a constant.

A definition of a constant via assignment. For example, the left-hand operand in the following example:

A use (read) of a constant.

A constant value.

A definition of a constant.

A control expression that can be any of the following: - case - if/unless (including expression-modifier variants) - ternary-if (?:) - while/until (including expression-modifier variants) - for

A call to the special defined? operator. rb defined? some_method

A “left-hand-side” (LHS) expression of a destructured assignment.

A parameter defined using destructuring. For example

A divide expression. rb x / y

A block enclosed within do and end.

An element reference; a call to the [] method. rb a[0]

An empty statement (;).

An __ENCODING__ literal.

An END block. rb END { puts "shutting down" }

An equals expression. rb x == y

An equality operation.

A node in the ERB abstract syntax tree. This class is the base class for all ERB elements.

An ERB token appearing within a code directive. This will typically be interpreted as Ruby code or a GraphQL query, depending on context.

An ERB token appearing within a comment directive.

A comment directive in an ERB template. erb <%#= 2 + 2 %> <%# for x in xs do %>

A directive in an ERB template.

An execution directive in an ERB template. This code will be executed as Ruby, but not rendered. erb <% books = author.books for book in books do %>

A File containing an Embedded Ruby template. This is typically a file containing snippets of Ruby code that can be evaluated to create a compiled version of the file.

A GraphQL directive in an ERB template. erb <%graphql fragment Foo on Bar { some { queryText moreProperties } } %>

An output directive in an ERB template. erb <%= fragment Foo on Bar { some { queryText moreProperties } } %>

An ERB template. This can contain multiple directives to be executed when the template is compiled.

An ERB token. This could be embedded code, a comment, or arbitrary text.

An exponent expression. rb x ** 2

An expression.

A __FILE__ literal.

A find pattern, for example: rb in [*, "a", Integer => x, *] in List[*init, "a", Integer => x, *tail] in List[*, "a", Integer => x, *]

A floating-point literal.

A for loop. rb for val in 1..n sum += val end

A special ... parameter that forwards positional/keyword/block arguments: rb def foo(...) end

A ... expression that contains forwarded arguments. rb foo(...)

A greater-than-or-equal expression. rb x >= 0

A greater-than expression. rb x > 0

A global variable.

An access to a global variable.

An access to a global variable where the value is read.

An access to a global variable where the value is updated.

A hash literal.

A hash pattern, for example: rb in {} in { a: 1 } in { a: 1, **rest } in { a: 1, **nil } in Node{ label: , children: [] }

A hash-splat (or ‘double-splat’) expression. rb foo(**options)

A nil hash splat (**nil) indicating that there are no keyword parameters or keyword patterns. For example: rb def foo(bar, **nil) case bar in { x:, **nil } then puts x end end

A hash-splat (or double-splat) parameter. For example, **options in the following code: rb def foo(bar, **options) ... end

A “here document”. For example: rb query = <<SQL SELECT * FROM person WHERE age > 21 SQL

An if or elsif expression. rb if x a += 1 elsif y a += 2 end

An expression modified using if. rb foo if bar

An in clause of a case expression. rb case foo in [ a ] then a end

An instance variable.

An access to an instance variable.

An access to an instance variable where the value is read.

An access to an instance variable where the value is updated.

An integer literal.

A keyword parameter, including a default value if the parameter is optional. For example, in the following example, foo is a keyword parameter with a default value of 0, and bar is a mandatory keyword parameter with no default value mandatory parameter). rb def f(foo: 0, bar:) foo * 10 + bar end

A less-than-or-equal expression. rb x <= 10

A left-shift operation. rb x << n

A less-than expression. rb x < 10

A lambda (anonymous method). For example: rb -> (x) { x + 1 }

A “left-hand-side” (LHS) expression. An LhsExpr can occur on the left-hand side of operator assignments (AssignOperation), on the left-hand side of assignments (AssignExpr), as patterns in for loops (ForExpr), and as exception variables in rescue clauses (RescueClause).

A __LINE__ literal.

A literal.

A local variable.

An access to a local variable.

An access to a local variable where the value is read.

An access to a local variable where the value is updated.

A logical AND operation, using either and or &&. rb x and y a && b

A logical OR operation, using either or or ||. rb x or y a || b

A loop. That is, a for loop, a while or until loop, or their expression-modifier variants.

A one-line pattern match using the => operator. For example: rb foo => Point{ x:, y: }

A normal method.

A method.

A method call.

A method name literal. For example: rb method_name # a normal name + # an operator :method_name # a symbol :"eval_#{name}" # a complex symbol

A representation of a run-time module or class value.

The base class for classes, singleton classes, and modules.

A module definition.

A modulo expression. rb x % 2

A multiply expression. rb x * 10

A not-equals expression. rb x != y

A named parameter.

A class or module definition.

A next statement. rb next next value

A nil literal.

A regexp-doesn’t-match expression. rb input !~ /\d/

A logical NOT operation, using either ! or not. rb !x.nil? not params.empty?

A numeric literal, i.e. an integer, floating-point, rational, or complex value.

An operation.

An optional parameter. For example, the parameter name in the following code: rb def say_hello(name = 'Anon') puts "hello #{name}" end

A pair expression. For example, in a hash: rb { foo: bar } Or a keyword argument: rb baz(qux: 1)

A parameter.

A parenthesized expression sequence, typically containing a single expression: rb (x + 1) However, they can also contain multiple expressions (the value of the parenthesized expression is the last expression): rb (foo; bar) or even an empty sequence (value is nil): rb ()

A parenthesized pattern: rb in (1 ..) in (0 | "" | [] | {})

A right-shift operation. rb x >> n

A range literal.

A rational literal.

A redo statement. rb redo

A variable or value reference in a pattern, i.e. ^x, and ^(2 * x) in the following example: rb x = 10 case expr in ^x then puts "ok" in ^(2 * x) then puts "ok" end

The base class for a component of a regular expression literal.

An escape sequence component of a regex literal.

An interpolation expression component of a regex literal.

A regular expression literal.

A regexp match expression. rb input =~ /\d/

A component of a regex literal that is simply text.

A relational operation, that is, one of <=, <, >, or >=.

A rescue clause. For example:

An expression with a rescue modifier. For example: rb contents = read_file rescue ""

A retry statement. rb retry

A return statement. rb return return value

A statement that may return a value: return, break and next.

A Ruby source file

A variable scope. This is either a top-level (file), a module, a class, or a callable.

A scope in which a self variable exists.

A self variable.

An access to the self variable. For example: - self == other - self.method_name - def self.method_name ... end

An access to the self variable where the value is read.

A call to a setter method. rb self.foo = 10 a[0] = 10

A simple (normal) parameter.

A definition of a singleton class on an object.

A singleton method.

A three-way comparison (‘spaceship’) expression. rb a <=> b

A splat expression. rb foo(*args)

A splat parameter. For example, *values in the following code: rb def foo(bar, *values) ... end

A statement.

A sequence of expressions.

The base class for a component of a string: StringTextComponent, StringEscapeSequenceComponent, or StringInterpolationComponent.

A concatenation of string literals.

An escape sequence component of a string or string-like literal.

An interpolation expression component of a string or string-like literal.

A string literal.

A component of a string (or string-like) literal that is simply text.

A string, symbol, regexp, or subshell literal.

A subtract expression. rb x - 3

A subshell literal.

A call to super. rb class Foo < Bar def baz super end end

A symbol literal.

A conditional expression using the ternary (?:) operator. rb (a > b) ? a : b

A one-line pattern match using the in operator. For example: rb foo in Point{ x:, y: }

A Ruby source file.

A unary arithmetic operation.

A unary bitwise operation.

A unary logical operation.

A unary minus expression. rb - a

A unary operation.

A unary plus expression. rb + a

An undef statement. For example: rb - undef method_name - undef &&, :method_name - undef :"method_#{ name }"

A Method call that has no known target. These will typically be calls to methods inherited from a superclass. TODO: When API Graphs is able to resolve calls to methods like Kernel.send this class is no longer necessary and should be removed.

An unless expression. rb unless x == 0 y /= x end

An expression modified using unless. rb y /= x unless x == 0

An until loop. rb until a >= b p a a += 1 end

An expression looped using the until modifier. rb foo until bar

A variable declared in a scope.

An access to a variable.

An access to a variable where the value is read.

An access to a variable where the value is updated.

A when branch of a case expression. rb case when a > b then x end

A while loop. rb while a < b p a a += 2 end

An expression looped using the while modifier. rb foo while bar

A call to yield. rb yield x, y

Provides different sub classes of ConstantValue.