Results for: "Logger"

Represents writing to an instance variable in a context that doesn’t have an explicit value.

@foo, @bar = baz
^^^^  ^^^^

Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.

if /foo #{bar} baz/ then end
   ^^^^^^^^^^^^^^^^

Represents a regular expression literal that contains interpolation.

/foo #{bar} baz/
^^^^^^^^^^^^^^^^

Represents a string literal that contains interpolation.

"foo #{bar} baz"
^^^^^^^^^^^^^^^^

Represents a symbol literal that contains interpolation.

:"foo #{bar} baz"
^^^^^^^^^^^^^^^^^

Represents an xstring literal that contains interpolation.

`foo #{bar} baz`
^^^^^^^^^^^^^^^^

Represents an implicit set of parameters through the use of the ‘it` keyword within a block or lambda.

-> { it + it }
^^^^^^^^^^^^^^

Represents a keyword rest parameter to a method, block, or lambda definition.

def a(**b)
      ^^^
end

Represents writing to a local variable.

foo = 1
^^^^^^^

Represents a multi-target expression.

a, (b, c) = 1, 2, 3
   ^^^^^^

This can be a part of ‘MultiWriteNode` as above, or the target of a `for` loop

for a, b in [[1, 2], [3, 4]]
    ^^^^

Represents the use of ‘**nil` inside method arguments.

def a(**nil)
      ^^^^^
end

Represents an optional keyword parameter to a method, block, or lambda definition.

def a(b: 1)
      ^^^^
end

Represents an optional parameter to a method, block, or lambda definition.

def a(b = 1)
      ^^^^^
end

Represents the list of parameters on a method, block, or lambda definition.

def a(b, c, d)
      ^^^^^^^
end

The top level node of any parse tree.

Represents the use of the ‘..` or `…` operators.

1..2
^^^^

c if a =~ /left/ ... b =~ /right/
     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Represents a required keyword parameter to a method, block, or lambda definition.

def a(b: )
      ^^
end

Represents a required parameter to a method, block, or lambda definition.

def a(b)
      ^
end

Represents an expression modified with a rescue.

foo rescue nil
^^^^^^^^^^^^^^

Represents a rest parameter to a method, block, or lambda definition.

def a(*b)
      ^^
end

Represents the use of the ‘super` keyword with parentheses or arguments.

super()
^^^^^^^

super foo, bar
^^^^^^^^^^^^^^

This represents a location in the source.

This represents an error that was encountered during parsing.

This is a result specific to the ‘parse` and `parse_file` methods.

A pattern is an object that wraps a Ruby pattern matching expression. The expression would normally be passed to an ‘in` clause within a `case` expression or a rightward assignment expression. For example, in the following snippet:

case node
in ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]
end

the pattern is the ConstantPathNode[...] expression.

The pattern gets compiled into an object that responds to call by running the compile method. This method itself will run back through Prism to parse the expression into a tree, then walk the tree to generate the necessary callable objects. For example, if you wanted to compile the expression above into a callable, you would:

callable = Prism::Pattern.new("ConstantPathNode[ConstantReadNode[name: :Prism], ConstantReadNode[name: :Pattern]]").compile
callable.call(node)

The callable object returned by compile is guaranteed to respond to call with a single argument, which is the node to match against. It also is guaranteed to respond to ===, which means it itself can be used in a ‘case` expression, as in:

case node
when callable
end

If the query given to the initializer cannot be compiled into a valid matcher (either because of a syntax error or because it is using syntax we do not yet support) then a Prism::Pattern::CompilationError will be raised.