Results for: "module_function"

A compiler is a visitor that returns the value of each node as it visits. This is as opposed to a visitor which will only walk the tree. This can be useful when you are trying to compile a tree into a different format.

For example, to build a representation of the tree as s-expressions, you could write:

class SExpressions < Prism::Compiler
  def visit_arguments_node(node) = [:arguments, super]
  def visit_call_node(node) = [:call, super]
  def visit_integer_node(node) = [:integer]
  def visit_program_node(node) = [:program, super]
end

Prism.parse("1 + 2").value.accept(SExpressions.new)
# => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]]

DesugarCompiler is a compiler that desugars Ruby code into a more primitive form. This is useful for consumers that want to deal with fewer node types.

This represents a node in the tree. It is the parent class of all of the various node types.

Represents the use of the ‘&&` operator or the `and` keyword.

left and right
^^^^^^^^^^^^^^

Represents a set of arguments to a method or a keyword.

return foo, bar, baz
       ^^^^^^^^^^^^^

Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.

[1, 2, 3]
^^^^^^^^^

Represents an array pattern in pattern matching.

foo in 1, 2
^^^^^^^^^^^

foo in [1, 2]
^^^^^^^^^^^^^

foo in *bar
^^^^^^^^^^^

foo in Bar[]
^^^^^^^^^^^^

foo in Bar[1, 2, 3]
^^^^^^^^^^^^^^^^^^^

Represents a hash key/value pair.

{ a => b }
  ^^^^^^

Represents a splat in a hash literal.

{ **foo }
  ^^^^^

Represents a begin statement.

begin
  foo
end
^^^^^

Represents a block argument using ‘&`.

bar(&args)
^^^^^^^^^^

Represents a block of ruby code.

[1, 2, 3].each { |i| puts x }
               ^^^^^^^^^^^^^^

Represents a block parameter of a method, block, or lambda definition.

def a(&b)
      ^^
end

Represents a block’s parameters declaration.

-> (a, b = 1; local) { }
   ^^^^^^^^^^^^^^^^^

foo do |a, b = 1; local|
       ^^^^^^^^^^^^^^^^^
end

Represents the use of the ‘break` keyword.

break foo
^^^^^^^^^

Represents the use of the ‘&&=` operator on a call.

foo.bar &&= value
^^^^^^^^^^^^^^^^^

Represents a method call, in all of the various forms that can take.

foo
^^^

foo()
^^^^^

+foo
^^^^

foo + bar
^^^^^^^^^

foo.bar
^^^^^^^

foo&.bar
^^^^^^^^

Represents the use of an assignment operator on a call.

foo.bar += baz
^^^^^^^^^^^^^^

Represents the use of the ‘||=` operator on a call.

foo.bar ||= value
^^^^^^^^^^^^^^^^^

Represents assigning to a method call.

foo.bar, = 1
^^^^^^^

begin
rescue => foo.bar
          ^^^^^^^
end

for foo.bar in baz do end
    ^^^^^^^

Represents assigning to a local variable in pattern matching.

foo => [bar => baz]
       ^^^^^^^^^^^^

Represents the use of a case statement for pattern matching.

case true
in false
end
^^^^^^^^^

Represents the use of a case statement.

case true
when false
end
^^^^^^^^^^

Represents a class declaration involving the ‘class` keyword.

class Foo end
^^^^^^^^^^^^^