Class: Prism::Translation::Ripper::SexpBuilder

Tokenizes the Ruby program and returns an array of an array, which is formatted like [[lineno, column], type, token, state].

Create a new ::Prism::Translation::Ripper object with the given source.

Parses the given Ruby program read from src.

Parses src and create S-exp tree.

Parses src and create S-exp tree.

The current column number of the parser.

True if the parser encountered an error during parsing.

The filename of the source being parsed.

The current line number of the parser.

The source that is being parsed.

Parse the source and return the result.

alias $foo $bar ^^^^^^^^^^^^^^^.

alias foo bar ^^^^^^^^^^^^^.

foo => bar | baz.

a and b ^^^^^^^.

foo(bar).

^^.

foo => [bar].

{ a: 1 }

def foo(**); bar(**); end.

$+ ^^.

begin end ^^^^^^^^^.

foo(&bar).

foo { |; bar| }

Visit a BlockNode.

def foo(&bar); end.

A block’s parameters.

break ^^^^^.

foo.bar &&= baz ^^^^^^^^^^^^^^^.

foo ^^^.

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

foo.bar ||= baz ^^^^^^^^^^^^^^^.

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

foo => bar => baz.

case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^.

case foo; when bar; end ^^^^^^^^^^^^^^^^^^^^^^^.

class Foo; end ^^^^^^^^^^^^^^.

@@foo &&= bar ^^^^^^^^^^^^^.

@@foo += bar ^^^^^^^^^^^^.

@@foo ||= bar ^^^^^^^^^^^^^.

@@foo ^^^^^.

@@foo, = bar ^^^^^.

@@foo = 1 ^^^^^^^^^.

Foo &&= bar ^^^^^^^^^^^^.

Foo += bar ^^^^^^^^^^^.

Foo ||= bar ^^^^^^^^^^^^.

Foo::Bar &&= baz ^^^^^^^^^^^^^^^^.

Foo::Bar ^^^^^^^^.

Foo::Bar += baz ^^^^^^^^^^^^^^^.

Foo::Bar ||= baz ^^^^^^^^^^^^^^^^.

Foo::Bar, = baz ^^^^^^^^.

Foo::Bar = 1 ^^^^^^^^^^^^.

Foo ^^^.

Foo, = bar ^^^.

Foo = 1 ^^^^^^^.

def foo; end ^^^^^^^^^^^^.

defined? a ^^^^^^^^^^.

if foo then bar else baz end.

“foo #bar”.

“foo #@bar”.

Visit an EnsureNode node.

false ^^^^^.

foo => [*, bar, *].

if foo ..

1.0 ^^^.

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

def foo(…); bar(…); end.

def foo(…); end.

super ^^^^^.

$foo &&= bar ^^^^^^^^^^^^.

$foo += bar ^^^^^^^^^^^.

$foo ||= bar ^^^^^^^^^^^^.

$foo ^^^^.

$foo, = bar ^^^^.

$foo = 1 ^^^^^^^^.

{} ^^.

foo => {}

if foo then bar end ^^^^^^^^^^^^^^^^^^^.

1i ^^.

{ foo: }

foo { |bar,| }

case foo; in bar; end ^^^^^^^^^^^^^^^^^^^^^.

foo &&= baz ^^^^^^^^^^^^^^^^.

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

foo ||= baz ^^^^^^^^^^^^^^^^.

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

^^^^^^^^^^^^.

^^^^^^^^^^^.

^^^^^^^^^^^^.

^^^^.

@foo, = bar ^^^^.

^^^^^^^^.

1 ^.

if /foo #bar/ then end.

/foo #bar/ ^^^^^^^^^^^^.

“foo #bar” ^^^^^^^^^^^^.

:“foo #bar” ^^^^^^^^^^^^^.

foo #{bar} ^^^^^^^^^^^^.

-> { it }

-> { it } ^^^^^^^^^.

foo(bar: baz).

def foo(**bar); end.

-> {}

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

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

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

foo ^^^.

foo, = bar ^^^.

foo = 1 ^^^^^^^.

if /foo/ then end.

foo in bar ^^^^^^^^^^.

foo => bar ^^^^^^^^^^.

/(?<foo>foo)/ =~ bar ^^^^^^^^^^^^^^^^^^^^.

A node that is missing from the syntax tree.

module Foo; end ^^^^^^^^^^^^^^^.

(foo, bar), bar = qux ^^^^^^^^^^.

foo, bar = baz ^^^^^^^^^^^^^^.

next ^^^^.

nil ^^^.

def foo(**nil); end.

-> { _1 + _2 } ^^^^^^^^^^^^^^.

$1 ^^.

def foo(bar: baz); end.

def foo(bar = 1); end.

a or b ^^^^^^.

def foo(bar, *baz); end.

() ^^.

foo => ^(bar).

foo = 1 and bar => ^foo.

END {} ^^^^^^.

BEGIN {} ^^^^^^^^.

The top-level program node.

0..5 ^^^^.

1r ^^.

redo ^^^^.

/foo/ ^^^^^.

def foo(bar:); end.

def foo(bar); end.

foo rescue bar ^^^^^^^^^^^^^^.

begin; rescue; end.

def foo(*bar); end.

retry ^^^^^.

return ^^^^^^.

self ^^^^.

A shareable constant.

class << self; end ^^^^^^^^^^^^^^^^^^.

__ENCODING__ ^^^^^^^^^^^^.

__FILE__ ^^^^^^^^.

__LINE__ ^^^^^^^^.

foo(*bar).

A list of statements.

“foo” ^^^^^.

super(foo) ^^^^^^^^^^.

:foo ^^^^.

true ^^^^.

undef foo ^^^^^^^^^.

unless foo; bar end ^^^^^^^^^^^^^^^^^^^.

until foo; bar end ^^^^^^^^^^^^^^^^^.

case foo; when bar; end.

while foo; bar end ^^^^^^^^^^^^^^^^^^.

foo ^^^^^.

yield ^^^^^.

This method is responsible for updating lineno and column information to reflect the current node.

Returns true if the given node is a command node.

This method is called when the parser found syntax error.

This method is provided by the ::Prism::Translation::Ripper C extension.

Lazily initialize the parse result.

Returns true if there is a comma between the two locations.

Visit one side of an alias global variable node.

Visit a list of elements, like the elements of an array or arguments.

Visit the clauses of a begin node to form an on_bodystmt call.

Visit the body of a structure that can have either a set of statements or statements wrapped in rescue/else/ensure.

Visit the arguments and block of a call node and return the arguments and block as they should be used.

Visit a constant path that is part of a write node.

Visit a destructured positional parameter node.

Visit a string that is expressed using a <<~ heredoc.

::Prism::Translation::Ripper gives back the escaped string content but strips out the common leading whitespace.

Visit a heredoc node that is representing a string.

Visit a heredoc node that is representing an xstring.

Visit the targets of a multi-target node.

Visit a node that represents a number.

Visit a pattern within a pattern match.

Visit the list of statements of a statements node.

Visit an individual part of a string-like node.

Visit the string content of a particular node.

Dispatch a words_sep event that contains the space between the elements of list literals.

Visit a node that represents a write value.

Returns true if there is a semicolon between the two locations.

This method is called when weak warning is produced by the parser.

This method is called when strong warning is produced by the parser.