// This file is autogenerated by codegen/types.d.ts.liquid
export function parse(
input: string,
buffer_name: string,
decoder: (encoding: string, input: Uint8Array) => Uint8Array
): ParserResult;
export class ParserResult {
ast: Node | null;
tokens: Token[];
diagnostics: Diagnostic[];
comments: Comment[];
magic_comments: MagicComment[];
input: DecodedInput;
constructor(
ast: Node | null,
tokens: Token[],
diagnostics: Diagnostic[],
comments: Comment[],
magic_comments: MagicComment[],
input: DecodedInput,
);
}
export class Token {
token_type: number;
token_value: Uint8Array;
loc: Loc;
lex_state_before: number;
lex_state_after: number;
constructor(
token_type: number,
token_value: Uint8Array,
loc: Loc,
lex_state_before: number,
lex_state_after: number,
);
name(): string;
}
export class Loc {
begin: number;
end: number;
constructor(
begin: number,
end: number,
);
}
export class Comment {
loc: Loc;
kind: CommentKind;
constructor(
loc: Loc,
kind: CommentKind,
);
}
export type CommentKind =
| "inline"
| "document"
| "unknown";
export class MagicComment {
kind: MagicCommentKind;
key_l: Loc;
value_l: Loc;
constructor(
kind: MagicCommentKind,
key_l: Loc,
value_l: Loc,
);
}
export type MagicCommentKind =
| "encoding"
| "frozen_string_literal"
| "warn_indent"
| "shareable_constant_value";
export class DecodedInput {
name: string;
lines: SourceLine[];
bytes: Uint8Array;
constructor(
name: string,
lines: SourceLine[],
bytes: Uint8Array,
);
}
export class SourceLine {
start: number;
end: number;
ends_with_eof: boolean;
constructor(
start: number,
end: number,
ends_with_eof: boolean,
);
}
export class Diagnostic {
level: ErrorLevel;
message: DiagnosticMessage;
loc: Loc;
constructor(
level: ErrorLevel,
message: DiagnosticMessage,
loc: Loc,
);
}
export type ErrorLevel =
| "warning"
| "error";
export class Node {}
export namespace nodes {
// Represents `alias to from` statement.
export class Alias {
// Target of the `alias`.
//
// `Sym("foo")` node for `alias :foo :bar`
to: Node;
// Source of the `alias`.
//
// `Sym("bar")` node for `alias :foo :bar`
from: Node;
// Location of the `alias` keyword
//
// ```text
// alias foo bar
// ~~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// alias foo bar
// ~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
to: Node,
from: Node,
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents `foo && bar` (or `foo and bar`) statement.
export class And {
// Left hand statament of the `&&` operation.
//
// `Lvar("foo")` node for `foo && bar`
lhs: Node;
// Right hand statement of the `&&` operation.
//
// `Lvar("bar")` node for `foo && bar`
rhs: Node;
// Location of the `&&` (or `and`) operator
//
// ```text
// a && b
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// a && b
// ~~~~~~
// ```
expression_l: Loc;
constructor(
lhs: Node,
rhs: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents `a &&= 1` statement.
export class AndAsgn {
// Receiver of the `&&=` operation.
//
// `Lvasgn("a")` node for `a &&= 1`
recv: Node;
// Right hand statement of assignment
//
// `Int("1")` node for `a &&= 1`
value: Node;
// Location of the `&&=` operator
//
// ```text
// a &&= 1
// ~~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// a &&= 1
// ~~~~~~~
// ```
expression_l: Loc;
constructor(
recv: Node,
value: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a positional required block/method argument.
//
// `a` in `def m(a); end` or `proc { |a| }`
export class Arg {
// Name of the argument
name: string;
// Location of the full expression
//
// ```text
// def m(argument); end
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents an arguments list
//
// `Args(vec![Arg("a"), Optarg("b", Int("1"))])` in `def m(a, b = 1); end`
export class Args {
// List of arguments
args: Node[];
// Location of the full expression
//
// ```text
// def m(a, b = 1, c:, &blk); end
// ~~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
// Location of the open parenthesis
//
// ```text
// def m(a, b = 1, c:, &blk); end
// ~
// ```
//
// `None` for code like `def m; end` or `def m arg; end`
begin_l: Loc | null;
// Location of the closing parenthesis
//
// ```text
// def m(a, b = 1, c:, &blk); end
// ~
// ```
//
// `None` for code like `def m; end` or `def m arg; end`
end_l: Loc | null;
constructor(
args: Node[],
expression_l: Loc,
begin_l: Loc | null,
end_l: Loc | null,
);
}
// Represents an array literal
export class Array {
// A list of elements
elements: Node[];
// Location of the open bracket
//
// ```text
// [1, 2, 3]
// ~
// ```
begin_l: Loc | null;
// Location of the closing bracket
//
// ```text
// [1, 2, 3]
// ~
// ```
end_l: Loc | null;
// Location of the full expression
//
// ```text
// [1, 2, 3]
// ~~~~~~~~~
// ```
expression_l: Loc;
constructor(
elements: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents an array pattern used in pattern matching
export class ArrayPattern {
// A list of elements
elements: Node[];
// Location of the open bracket
//
// ```text
// [1, ^a, 3 => foo]
// ~
// ```
//
// `None` for pattern like `1, 2` without brackets
begin_l: Loc | null;
// Location of the closing bracket
//
// ```text
// [1, ^a, 3 => foo]
// ~
// ```
//
// `None` for pattern like `1, 2` without brackets
end_l: Loc | null;
// Location of the full expression
//
// ```text
// [1, ^a, 3 => foo]
// ~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
elements: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents an array pattern *with trailing comma* used in pattern matching
//
// It's slightly different from `ArrayPattern`, trailing comma at the end works as `, *`
export class ArrayPatternWithTail {
// A list of elements
elements: Node[];
// Location of the open bracket
//
// ```text
// [1, ^a, 3 => foo,]
// ~
// ```
//
// `None` for pattern like `1, 2,` without brackets
begin_l: Loc | null;
// Location of the closing bracket
//
// ```text
// [1, ^a, 3 => foo,]
// ~
// ```
//
// `None` for pattern like `1, 2,` without brackets
end_l: Loc | null;
// Location of the full expression
//
// ```text
// [1, ^a, 3 => foo,]
// ~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
elements: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents special global variables:
// 1. `` $` ``
// 2. `$&`
// 3. `$'`
// 4. `$+`
export class BackRef {
// Name of the variable (`"$+"` for `$+`)
name: string;
// Location of the full expression
//
// ```text
// $+
// ~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents compound statement (i.e. a multi-statement)
//
// Basically all blocks of code are wrapped into `Begin` node (e.g. method/block body, rescue/ensure handler etc)
export class Begin {
// A list of statements
statements: Node[];
// Begin of the block
//
// ```text
// (1; 2)
// ~
// ```
//
// `None` if the block of code is "implicit", like
//
// ```text
// if true; 1; 2; end
// ```
begin_l: Loc | null;
// End of the block
//
// ```text
// (1; 2)
// ~
// ```
//
// `None` if the block of code is "implicit", like
//
// ```text
// if true; 1; 2; end
// ```
end_l: Loc | null;
// Location of the full expression
//
// ```text
// (1; 2)
// ~~~~~~
// ```
expression_l: Loc;
constructor(
statements: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a Ruby block that is passed to a method (`proc { |foo| bar }`)
export class Block {
// Method call that takes a block
//
// `Send("foo")` in `foo {}`
call: Node;
// A list of argument that block takes
//
// `vec![ Arg("a"), Optarg("b", Int("1")) ]` for `proc { |a, b = 1| }`
//
// `None` if the block takes no arguments
args: Node | null;
// Block body, `None` if block has no body.
body: Node | null;
// Location of the open brace
//
// ```text
// proc { }
// ~
// ```
begin_l: Loc;
// Location of the closing brace
//
// ```text
// proc { }
// ~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// proc { }
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
call: Node,
args: Node | null,
body: Node | null,
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents a `&blk` argument in the method definition (but not in the method call, see `BlockPass`)
export class Blockarg {
// Name of the argument, `String("foo")` for `def m(&foo)`
name: string | null;
// Location of the `&` operator
//
// ```text
// def m(&foo); end
// ~
// ```
operator_l: Loc;
// Location of the name
//
// ```text
// def m(&foo); end
// ~~~
// ```
name_l: Loc | null;
// Location of the full expression
//
// ```text
// def m(&foo); end
// ~~~~
// ```
expression_l: Loc;
constructor(
name: string | null,
operator_l: Loc,
name_l: Loc | null,
expression_l: Loc,
);
}
// Represents a `&blk` argument of the method call (but not of the method definition, see `BlockArg`)
export class BlockPass {
// Value that is converted to a block
//
// `Int("1")` in `foo(&1)` (yes, it's possible)
value: Node | null;
// Location of the `&` operator
//
// ```text
// foo(&blk)
// ~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo(&bar)
// ~~~~
// ```
expression_l: Loc;
constructor(
value: Node | null,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a `break` keyword (with optional argument)
export class Break {
// A list of arguments
args: Node[];
// Location of the `break` keyword
//
// ```text
// break :foo
// ~~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// break(:foo)
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
args: Node[],
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents a `case` statement (for pattern matching see `CaseMatch` node)
export class Case {
// Expression given to `case`, `Int("1")` for `case 1; end`
// `None` for code like
//
// ```text
// case
// when pattern
// end
// ```
expr: Node | null;
// A list of `When` nodes (each has `patterns` and `body`)
when_bodies: Node[];
// Body of the `else` branch, `None` if there's no `else` branch
else_body: Node | null;
// Location of the `case` keyword
//
// ```text
// case 1; end
// ~~~~
// ```
keyword_l: Loc;
// Location of the `else` keyword
//
// ```text
// case 1; else; end
// ~~~~
// ```
//
// `None` if there's no `else` branch
else_l: Loc | null;
// Location of the `end` keyword
//
// ```text
// case 1; end
// ~~~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// case 1; end
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
expr: Node | null,
when_bodies: Node[],
else_body: Node | null,
keyword_l: Loc,
else_l: Loc | null,
end_l: Loc,
expression_l: Loc,
);
}
// Represents a `case` statement used for pattern matching (for regular `case` see `Case` node)
export class CaseMatch {
// Expression given to `case`, `Int("1")` for `case 1; in 1; end`
// `None` for code like
//
// ```text
// case
// in pattern
// end
// ```
expr: Node;
// A list of `InPattern` nodes (each has `pattern`, `guard` and `body`)
in_bodies: Node[];
// Body of the `else` branch, `None` if there's no `else` branch
else_body: Node | null;
// Location of the `case` keyword
//
// ```text
// case 1; in 2; end
// ~~~~
// ```
keyword_l: Loc;
// Location of the `else` keyword
//
// ```text
// case 1; in 2; else; end
// ~~~~
// ```
//
// `None` if there's no `else` branch
else_l: Loc | null;
// Location of the `end` keyword
//
// ```text
// case 1; in 2; end
// ~~~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// case 1; in 2; end
// ~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
expr: Node,
in_bodies: Node[],
else_body: Node | null,
keyword_l: Loc,
else_l: Loc | null,
end_l: Loc,
expression_l: Loc,
);
}
// Represents a constant assignment (i.e. `A = 1`)
export class Casgn {
// Scope where the constant is defined:
// 1. `Some(Const("A"))` for `A::B = 1`
// 2. `None` if it's defined in the current scope (i.e. `A = 1`)
// 3. `Some(Cbase)` if it's defined in the global scope (i.e. `::A = 1`)
scope: Node | null;
// Name of the constant, `String("A")` for `A = 1`
name: string;
// Value that is assigned to a constant, `Int("1")` for `A = 1`.
//
// **Note**: `None` if constant assignment is a part of the multi-assignment.
// In such case `value` belongs to `Masgn` node of the multi-assignment.
value: Node | null;
// Location of the `::` operator
//
// ```text
// A::B = 1
// ~~
//
// ::A = 1
// ~~
// ```
//
// `None` if the constant is defined in the current scope
double_colon_l: Loc | null;
// Location of the constant name
//
// ```text
// A::CONST = 1
// ~~~~~
// ```
name_l: Loc;
// Location of the `=` operator
//
// ```text
// A = 1
// ~
// ```
//
// `None` if constant assignment is a part of the multi-assignment.
// In such case `=` belongs to a `Masgn` node
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// A = 1
// ~~~~~
// ```
expression_l: Loc;
constructor(
scope: Node | null,
name: string,
value: Node | null,
double_colon_l: Loc | null,
name_l: Loc,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents leading `::` part of the constant access/assignment that is used to get/set on a global namespace.
export class Cbase {
// Location of the full expression
//
// ```text
// ::A
// ~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a class definition (using a `class` keyword, `Class.new` is just a method call)
export class Class {
// Name of the class, `String("Foo")` for `class Foo; end`
name: Node;
// Superclass. Can be an expression in cases like `class A < (obj.foo + 1); end`
//
// `None` if no explicit superclass given (i.e. `class Foo; end`)
superclass: Node | null;
// Body of the method, `None` if there's no body.
body: Node | null;
// Location of the `class` keyword.
//
// ```text
// class Foo; end
// ~~~~~
// ```
keyword_l: Loc;
// Location of the `<` operator
//
// ```text
// class A < B; end
// ~
// ```
//
// `None` if there's no explicit superclass given.
operator_l: Loc | null;
// Location of the `end` keyword.
//
// ```text
// class Foo; end
// ~~~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// class Foo; end
// ~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: Node,
superclass: Node | null,
body: Node | null,
keyword_l: Loc,
operator_l: Loc | null,
end_l: Loc,
expression_l: Loc,
);
}
// Represents a `Complex` literal (that returns an `Complex` number)
export class Complex {
// Value of the complex literal, returned as a `String`, `String("1i")` for `1i`
value: string;
// Location of the `-` (but not `+`) operator. `+` is a part of the literal:
// 1. `+1i` is `String("+1i")` with `operator = None`
// 2. `-1i` is `String("1i")` with `operator = String("-")`
//
// ```text
// -1i
// ~
// ```
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// -1i
// ~~~
// ```
expression_l: Loc;
constructor(
value: string,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents constant access (i.e. `Foo::Bar`)
export class Const {
// Scope where the constant is taken from:
// 1. `Some(Const("A"))` for `A::B`
// 2. `None` if it's taken from the current scope (i.e. `A`)
// 3. `Some(Cbase)` if it's taken from the global scope (i.e. `::A`)
scope: Node | null;
// Name of the constant, `String("Foo")` for `Foo`
name: string;
// Location of the `::` operator. `None` if constant is taken from the current scope.
//
// ```text
// A::B
// ~~
// ```
double_colon_l: Loc | null;
// Location of the constant name
//
// ```text
// Foo::Bar
// ~~~
// ```
name_l: Loc;
// Location of the full expression
//
// ```text
// Foo::Bar
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
scope: Node | null,
name: string,
double_colon_l: Loc | null,
name_l: Loc,
expression_l: Loc,
);
}
// Const pattern used in pattern matching (e.g. `in A(1, 2)`)
export class ConstPattern {
// Constant that is used, `Const("Foo")` for `in For(42)`
const_: Node;
// Inner part of the constant pattern
//
// `ArrayPattern(vec![ Int("1") ])` for `Foo(1)`
pattern: Node;
// Location of the open parenthesis
//
// ```text
// case 1; in Foo(42); end
// ~
// ```
begin_l: Loc;
// Location of the closing parenthesis
//
// ```text
// case 1; in Foo(42); end
// ~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// case 1; in Foo(42); end
// ~~~~~~~
// ```
expression_l: Loc;
constructor(
const_: Node,
pattern: Node,
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents conditional method call using `&.` operator
export class CSend {
// Receiver of the method call, `Int("1")` for `1&.foo`
recv: Node;
// Name of the method, `String("foo")` for `1&.foo`
method_name: string;
// List of arguments
//
// ```text
// foo&.bar(42)
// # and also setters like
// foo&.bar = 42
// ```
args: Node[];
// Location of the `&.` operator
//
// ```text
// foo&.bar
// ~~
// ```
dot_l: Loc;
// Location of the method name
//
// ```text
// foo&.bar(42)
// ~~~
// ```
//
// `None` in a very special case when method call is implicit (i.e. `foo&.()`)
selector_l: Loc | null;
// Location of the open parenthesis
//
// ```text
// foo&.bar(42)
// ~
// ```
//
// `None` if there are no parentheses
begin_l: Loc | null;
// Location of the closing parenthesis
//
// ```text
// foo&.bar(42)
// ~
// ```
//
// `None` if there are no parentheses
end_l: Loc | null;
// Location of the operator if `CSend` is a part of assignment like
//
// ```text
// foo&.bar = 1
// ~
// ```
//
// `None` for a regular call.
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// foo&.bar(42)
// ~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
recv: Node,
method_name: string,
args: Node[],
dot_l: Loc,
selector_l: Loc | null,
begin_l: Loc | null,
end_l: Loc | null,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents access to class variable (i.e. `@@var`)
export class Cvar {
// Name of the class variable, `String("@@foo")` for `@@foo`
name: string;
// Location of the full expression
//
// ```text
// @@foo
// ~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents class variable assignment (i.e. `@@var = 42`)
export class Cvasgn {
// Name of the class variable, `String("@@foo")` for `@@foo = 1`
name: string;
// Value that is assigned to class variable, `Int("1")` for `@@foo = 1`
value: Node | null;
// Location of the class variable name
//
// ```text
// @@foo = 1
// ~~~~~
// ```
name_l: Loc;
// Location of the `=` operator
//
// ```text
// @@foo = 1
// ~
// ```
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// @@foo = 1
// ~~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
value: Node | null,
name_l: Loc,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents method definition using `def` keyword (not on a singleton, see `Defs` node).
export class Def {
// Name of the method, `String("foo")` for `def foo; end`
name: string;
// Arguments of a method, `None` if there's no arguments.
//
// All information about parentheses around arguments is stored in this node.
args: Node | null;
// Body of a method, `None` if there's no body.
body: Node | null;
// Location of the `def` keyword.
//
// ```text
// def foo; end
// ~~~
// ```
keyword_l: Loc;
// Location of the method name.
//
// ```text
// def foo; end
// ~~~
// ```
name_l: Loc;
// Location of the `end` keyword.
//
// ```text
// def foo; end
// ~~~
// ```
//
// `None` for endless method definition
end_l: Loc | null;
// Location of the `=` operator for endless method definition
//
// ```text
// def m() = 1
// ~
// ```
//
// `None` for regular method definition
assignment_l: Loc | null;
// Location of the full expression
//
// ```text
// def m(a); foo; end
// ~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
args: Node | null,
body: Node | null,
keyword_l: Loc,
name_l: Loc,
end_l: Loc | null,
assignment_l: Loc | null,
expression_l: Loc,
);
}
// Represents a `defined?(foo)` expression
export class Defined {
// Value given to `defined?`
value: Node;
// Location of the `defined?` keyword
//
// ```text
// defined?(foo)
// ~~~~~~~~
// ```
keyword_l: Loc;
// Location of the open parenthesis
//
// ```text
// defined?(foo)
// ~
// ```
//
// `None` if there are no parentheses
begin_l: Loc | null;
// Location of the closing parenthesis
//
// ```text
// defined?(foo)
// ~
// ```
//
// `None` if there are no parentheses
end_l: Loc | null;
// Location of the full expression
//
// ```text
// defined?(foo)
// ~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
value: Node,
keyword_l: Loc,
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a singleton method definition (i.e. `def self.foo; end`)
export class Defs {
// Definee of a method definition, `Lvar("x")` for `def x.foo; end`
definee: Node;
// Name of the method, `String("foo")` for `def x.foo; end`
name: string;
// Arguments of a method, `None` if there's no arguments.
//
// All information about parentheses around arguments is stored in this node.
args: Node | null;
// Body of the method, `None` if there's no body.
body: Node | null;
// Location of the `def` keyword
//
// ```text
// def self.foo; end
// ~~~
// ```
keyword_l: Loc;
// Location of the `.`
//
// ```text
// def self.foo; end
// ~
// ```
operator_l: Loc;
// Location of the method name
//
// ```text
// def self.foo; end
// ~~~
// ```
name_l: Loc;
// Location of the `=` operator for endless method definition
//
// ```text
// def self.foo() = 42
// ~
// ```
//
// `None` for regular method definition
assignment_l: Loc | null;
// Location of the `end` keyword
//
// ```text
// def self.foo; end
// ~~~
// ```
//
// `None` for endless method definition
end_l: Loc | null;
// Location of the full expression
//
// ```text
// def self.foo; end
// ~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
definee: Node,
name: string,
args: Node | null,
body: Node | null,
keyword_l: Loc,
operator_l: Loc,
name_l: Loc,
assignment_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a string with interpolation (i.e. `"#{foo}"`)
export class Dstr {
// A list of string parts (static literals and interpolated expressions)
parts: Node[];
// Location of the string begin
//
// ```text
// "#{foo}"
// ~
//
// %Q{#{foo}}
// ~~~
// ```
begin_l: Loc | null;
// Location of the string end
//
// ```text
// "#{foo}"
// ~
//
// %Q{#{foo}}
// ~
// ```
end_l: Loc | null;
// Location of the full expression
//
// ```text
// "#{foo}"
// ~~~~~~~~
//
// %Q{#{foo}}
// ~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
parts: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a symbol with interpolation (i.e. `:"#{foo}"`)
export class Dsym {
// A list of symbol parts (static literals and interpolated expressions)
parts: Node[];
// Location of the symbol begin
//
// ```text
// :"#{foo}"
// ~~
// ```
//
// `None` if `Dsym` is a part of the interpolated symbol array:
//
// ```text
// %I[#{bar}]
// ```
begin_l: Loc | null;
// Location of the symbol begin
//
// ```text
// :"#{foo}"
// ~
// ```
//
// `None` if `Dsym` is a part of the interpolated symbol array:
//
// ```text
// %I[#{bar}]
// ```
end_l: Loc | null;
// Location of the full expression
//
// ```text
// :"#{foo}"
// ~~~~~~~~~
// ```
expression_l: Loc;
constructor(
parts: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents exclusive flip-flop (i.e. in `if foo...bar; end`)
export class EFlipFlop {
// Left part of the flip-flop. `None` if based on a range without begin (`...bar`)
left: Node | null;
// Right part of the flip-flop. `None` if based on a range without end (`foo...`)
right: Node | null;
// Location of the `...` operator
//
// ```text
// if foo...bar; end
// ~~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// if foo...bar; end
// ~~~~~~~~~
// ```
expression_l: Loc;
constructor(
left: Node | null,
right: Node | null,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a special empty else that is a part of the pattern matching.
//
// Usually empty else (e.g. part of the `if` statement) doesn't mean anything,
// however in pattern matching it prevents raising a `NoPatternError`.
//
// Throwing away this `else` may affect your code.
export class EmptyElse {
// Location of the `else` keyword
//
// ```text
// case foo; in 1; else; end
// ~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a special `__ENCODING__` keyword
export class Encoding {
// Location of the `__ENCODING__` keyword
//
// ```text
// __ENCODING__
// ~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a block of code with `ensure` (i.e. `begin; ensure; end`)
export class Ensure {
// Block of code that is wrapped into `ensure`
// **Note**: that's the body of the `ensure` block
//
// `Int("1")` for `begin; 1; ensure; 2; end`
body: Node | null;
// Body of the `ensure` block
//
// `Int("2")` for `begin; 1; ensure; 2; end`
ensure: Node | null;
// Location of the `ensure` keyword
//
// ```text
// begin; ensure; end
// ~~~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// begin; 1; rescue; 2; else; 3; ensure; 4; end
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ```
//
// **Note**: begin/end belong to `KwBegin` node.
expression_l: Loc;
constructor(
body: Node | null,
ensure: Node | null,
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents range literal with excluded `end` (i.e. `1...3`)
export class Erange {
// Begin of the range, `None` if range has no begin (i.e `...42`)
left: Node | null;
// End of the range, `None` if range has no end (i.e `42...`)
right: Node | null;
// Location of the `...` operator
//
// ```text
// 1...3
// ~~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// 1...3
// ~~~~~
// ```
expression_l: Loc;
constructor(
left: Node | null,
right: Node | null,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a `false` literal
export class False {
// Location of the `false` literal
//
// ```text
// false
// ~~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a special `__FILE__` literal
export class File {
// Location of the `__FILE__` literal
//
// ```text
// __FILE__
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a find pattern using in pattern matching (i.e. `in [*x, 1 => a, *y]`)
//
// It's different from `ArrayPattern`/`ConstPattern` because it supports multiple wildcard pattern
export class FindPattern {
// Inner part of the find pattern
elements: Node[];
// Location of the begin
//
// ```text
// case foo; in [*x, 1 => a, *y]; end
// ~
// ```
//
// `None` if there are no brackets/parentheses
begin_l: Loc | null;
// Location of the end
//
// ```text
// case foo; in [*x, 1 => a, *y]; end
// ~
// ```
//
// `None` if there are no brackets/parentheses
end_l: Loc | null;
// Location of the full expression
//
// ```text
// case foo; in [*x, 1 => a, *y]; end
// ~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
elements: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a float literal (i.e. `42.5`)
export class Float {
// String value of the literal, `String("42.5")` for `42.5`
value: string;
// Location of unary `-` (but not `+`)
//
// ```text
// -42.5
// ~
// ```
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// -42.5
// ~~~~~
// ```
expression_l: Loc;
constructor(
value: string,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents a `for` loop
export class For {
// Variable that is used in loop, `Lvasgn("a")` in `for a in b; end`
iterator: Node;
// Collection that is for iteration. `Lvar("b")` in `for a in b; end`
iteratee: Node;
// Body of the loop. `None` if there's no body
body: Node | null;
// Location of the `for` keyword
//
// ```text
// for a in b; end
// ~~~
// ```
keyword_l: Loc;
// Location of the `in` keyword
//
// ```text
// for a in b; end
// ~~
// ```
operator_l: Loc;
// Location of the `do` keyword
//
// ```text
// for a in b do; end
// ~~
// ```
//
// **Note**: this `do` is optional, and so `begin_l` can be `None`.
begin_l: Loc;
// Location of the `end` keyword
//
// ```text
// for a in b; end
// ~~~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// for a in b; end
// ~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
iterator: Node,
iteratee: Node,
body: Node | null,
keyword_l: Loc,
operator_l: Loc,
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents a special `...` argument that forwards positional/keyword/block arguments.
export class ForwardArg {
// Location of the `...`
//
// ```text
// def m(...); end
// ~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a `...` operator that contains forwarded argument (see `ForwardArg`)
export class ForwardedArgs {
// Location of the `...`
//
// ```text
// def m(...); foo(...); end
// ~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents access to global variable (i.e. `$foo`)
export class Gvar {
// Name of the global variable, `String("$foo")` for `$foo`
name: string;
// Location of the full expression
//
// ```text
// $foo
// ~~~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents global variable assignment (i.e. `$foo = 42`)
export class Gvasgn {
// Name of the global variable, `String("$foo")` for `$foo`
name: string;
// Value that is assigned to global variable, `Int("42")` for `$foo = 42`
//
// `None` if global variable assignment is a part of the multi-assignment.
// In such case `value` is a part of the `Masgn` node.
value: Node | null;
// Location of the global variable name
//
// ```text
// $foo = 42
// ~~~~
// ```
name_l: Loc;
// Location of the `=` operator
//
// ```text
// $foo = 42
// ~
// ```
//
// `None` if global variable assignment is a part of the multi-assignment.
// In such case `=` operator belongs to the `Masgn` node.
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// $foo = 42
// ~~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
value: Node | null,
name_l: Loc,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents a hash literal (i.e. `{ foo: 42 }`)
export class Hash {
// A list of key-value pairs
pairs: Node[];
// Location of the open parenthesis
//
// ```text
// { a: 1 }
// ~
// ```
//
// `None` if hash literal is implicit, e.g. `foo(key: "value")`
begin_l: Loc | null;
// Location of the closing parenthesis
//
// ```text
// { a: 1 }
// ~
// ```
//
// `None` if hash literal is implicit, e.g. `foo(key: "value")`
end_l: Loc | null;
// Location of the full expression
//
// ```text
// { a: 1 }
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
pairs: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a hash pattern used in pattern matching (i.e. `in { a: 1 }`)
export class HashPattern {
// A list of inner patterns
elements: Node[];
// Location of the open parenthesis
//
// ```text
// case foo; in { a: 1 }; end
// ~
// ```
//
// `None` if there are no parentheses
begin_l: Loc | null;
// Location of the open parenthesis
//
// ```text
// case foo; in { a: 1 }; end
// ~
// ```
//
// `None` if there are no parentheses
end_l: Loc | null;
// Location of the full expression
//
// ```text
// case foo; in { a: 1 }; end
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
elements: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a here-document literal (both with and without interpolation)
//
// It's similar to `Dstr` in terms of abstract syntax tree, but has different source maps.
export class Heredoc {
// A list of string parts (static literals and interpolated expressions)
parts: Node[];
// Location of the here-document body
//
// ```text
// <<-HERE\n a\n #{42}\nHERE
// ~~~~~~~~~~~~~~~
// ```
heredoc_body_l: Loc;
// Location of the here-document end
//
// ```text
// <<-HERE\n a\n #{42}\nHERE
// ~~~~
// ```
heredoc_end_l: Loc;
// Location of the here-document identifier
//
// ```text
// <<-HERE\n a\n #{42}\nHERE
// ~~~~~~~
// ```
//
// **Note**: This is the only node (with `XHeredoc`) that has `expression_l` smaller that all other sub-locations merged.
// The reason for that is that it's possible to add more code after here-document ID:
//
// ```text
// <<-HERE + "rest"
// content
// HERE
// ```
expression_l: Loc;
constructor(
parts: Node[],
heredoc_body_l: Loc,
heredoc_end_l: Loc,
expression_l: Loc,
);
}
// Represents an `if` statement (i.e. `if foo; bar; else; baz; end`)
export class If {
// Condition given to the `if` statement, `Lvar("a")` for `if a; b; else; c; end`
cond: Node;
// True-branch of the `if` statement, `Lvar("b")` for `if a; b; else; c; end`
if_true: Node | null;
// False-branch of the `if` statement, `Lvar("c")` for `if a; b; else; c; end`
if_false: Node | null;
// Location of the `if` keyword
//
// ```text
// if foo; end
// ~~
// ```
keyword_l: Loc;
// Location of the `then` keyword
//
// ```text
// if foo then; end
// ~~~~
// ```
//
// `None` if `then` keyword is omitted
begin_l: Loc;
// Location of the `else` keyword
//
// ```text
// if foo; else; end
// ~~~~
// ```
//
// `None` if there's no `else` branch
else_l: Loc | null;
// Location of the `end` keyword
//
// ```text
// if foo; end
// ~~~
// ```
end_l: Loc | null;
// Location of the full expression
//
// ```text
// if a then; b; else; c end
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
if_true: Node | null,
if_false: Node | null,
keyword_l: Loc,
begin_l: Loc,
else_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents an `if` guard used in pattern matching (i.e. `case foo; in pattern if guard; end`)
export class IfGuard {
// Condition of the guard, `Lvar("foo")` in `in pattern if guard`
cond: Node;
// Location of the `if` keyword
//
// ```text
// case foo; in pattern if cond; end
// ~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// case foo; in pattern if cond; end
// ~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents inclusive flip-flop (i.e. in `if foo..bar; end`)
export class IFlipFlop {
// Left part of the flip-flop. `None` if based on a range without begin (`..bar`)
left: Node | null;
// Right part of the flip-flop. `None` if based on a range without end (`foo..`)
right: Node | null;
// Location of the `..` operator
//
// ```text
// if foo..bar; end
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// if foo..bar; end
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
left: Node | null,
right: Node | null,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents an `if`/`unless` modifier (i.e. `stmt if cond`)
export class IfMod {
// Condition of the modifier
cond: Node;
// True-branch of the modifier.
//
// Always set for `if` modifier.
// Always `None` for `unless` modifier.
if_true: Node | null;
// False-branch of the modifier.
//
// Always set for `unless` modifier.
// Always `None` for `if` modifier.
if_false: Node | null;
// Location of the `if`/`unless` keyword
//
// ```text
// stmt if cond
// ~~
//
// stmt unless cond
// ~~~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// stmt if cond
// ~~~~~~~~~~~~
//
// stmt unless cond
// ~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
if_true: Node | null,
if_false: Node | null,
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents ternary `if` statement (i.e. `cond ? if_true : if_false`)
export class IfTernary {
// Condition of the `if` statement
cond: Node;
// True-branch
if_true: Node;
// True-branch
if_false: Node;
// Location of the `?` operator
//
// ```text
// cond ? if_true : if_false
// ~
// ```
question_l: Loc;
// Location of the `:` operator
//
// ```text
// cond ? if_true : if_false
// ~
// ```
colon_l: Loc;
// Location of the full expression
//
// ```text
// cond ? if_true : if_false
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
if_true: Node,
if_false: Node,
question_l: Loc,
colon_l: Loc,
expression_l: Loc,
);
}
// Represents indexing operation (i.e. `foo[1,2,3]`)
export class Index {
// Receiver of indexing
recv: Node;
// A list of indexes
indexes: Node[];
// Location of open bracket
//
// ```text
// foo[1, 2, 3]
// ~
// ```
begin_l: Loc;
// Location of closing bracket
//
// ```text
// foo[1, 2, 3]
// ~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// foo[1, 2, 3]
// ~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
recv: Node,
indexes: Node[],
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents assignment using indexing operation (i.e. `foo[1, 2, 3] = bar`)
export class IndexAsgn {
// Receiver of the indexing
recv: Node;
// A list of indexes
indexes: Node[];
// Value that is assigned
//
// `None` if assignment is a part of the multi-assignment.
// In such case `value` belongs to `Masgn` node.
value: Node | null;
// Location of open bracket
//
// ```text
// foo[1, 2, 3] = bar
// ~
// ```
begin_l: Loc;
// Location of closing bracket
//
// ```text
// foo[1, 2, 3] = bar
// ~
// ```
end_l: Loc;
// Location of the `=` operator
//
// ```text
// foo[1, 2, 3] = bar
// ~
// ```
//
// `None` if assignment is a part of the multi-assignment.
// In such case operator `=` belongs to `Masgn` node.
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// foo[1, 2, 3] = bar
// ~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
recv: Node,
indexes: Node[],
value: Node | null,
begin_l: Loc,
end_l: Loc,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents an `in pattern` branch of the pattern matching
export class InPattern {
// Value that is used for matching
pattern: Node;
// Guard that is used for matching
//
// Optional, so can be `None`
guard: Node | null;
// Body of the branch that is invoked if value matches pattern
body: Node | null;
// Location of the `in` keyword
//
// ```text
// case value; in pattern; end
// ~~
// ```
keyword_l: Loc;
// Location of the `then` keyword
//
// ```text
// case value; in pattern then; end
// ~~~~
// ```
begin_l: Loc;
// Location of the full expression
//
// ```text
// case value; in pattern then; 42; end
// ~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
pattern: Node,
guard: Node | null,
body: Node | null,
keyword_l: Loc,
begin_l: Loc,
expression_l: Loc,
);
}
// Represents an integer literal (i.e. `42`)
export class Int {
// String value of the literal, `String("42")` for `42`
value: string;
// Location of unary `-` (but not `+`)
//
// ```text
// -42
// ~
// ```
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// -42
// ~~~
// ```
expression_l: Loc;
constructor(
value: string,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents inclusive range (i.e. `2..4`)
export class Irange {
// Begin of the range, `None` if range has no `begin` (i.e. `..4`)
left: Node | null;
// End of the range, `None` if range has no `end` (i.e. `2..`)
right: Node | null;
// Location of the `..` operator
//
// ```text
// 2..4
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// 2..4
// ~~~~
// ```
expression_l: Loc;
constructor(
left: Node | null,
right: Node | null,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents access to instance variable (i.e. `@foo`)
export class Ivar {
// Name of the instance variable, `String("@foo")` in `@foo`
name: string;
// Location of the full expression
//
// ```text
// @foo
// ~~~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents instance variable assignment (i.e `@foo = 42`)
export class Ivasgn {
// Name of the instance variable, `String("@foo")` in `@foo = 42`
name: string;
// Value that is assigned to instance variable.
//
// `None` if instance variable assignment is a part of the multi-assignment.
// In such case `value` is a part of the `Masgn` node.
value: Node | null;
// Location of the instance variable name.
//
// ```text
// @foo = 1
// ~~~~
// ```
name_l: Loc;
// Location of the `=` operator.
//
// ```text
// @foo = 1
// ~
// ```
//
// `None` if instance variable assignment is a part of the multi-assignment.
// In such case `value` is a part of the `Masgn` node.
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// @foo = 42
// ~~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
value: Node | null,
name_l: Loc,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents required keyword argument (i.e. `foo` in `def m(foo:); end`)
export class Kwarg {
// Name of the keyword argument
name: string;
// Location of the name
//
// ```text
// def foo(bar:); end
// ~~~
// ```
name_l: Loc;
// Location of the full expression
//
// ```text
// def foo(bar:); end
// ~~~~
// ```
expression_l: Loc;
constructor(
name: string,
name_l: Loc,
expression_l: Loc,
);
}
// Represents kwargs that are given to a method call, super or yield (i.e. `foo(bar: 1)`)
export class Kwargs {
// A list of key-value pairs
pairs: Node[];
// Location of the full expression
//
// ```text
// foo(bar: 1)
// ~~~~~~
// ```
expression_l: Loc;
constructor(
pairs: Node[],
expression_l: Loc,
);
}
// Represents an explicit `begin; end` block.
//
// The reason why it's different is that
// ```text
// begin; foo; end while cond
// ```
// is a post-while loop (same with post-until loop)
export class KwBegin {
// A list of statements
statements: Node[];
// Location of the `begin` keyword
//
// ```text
// begin; foo; end
// ~~~~~
// ```
begin_l: Loc | null;
// Location of the `end` keyword
//
// ```text
// begin; foo; end
// ~~~
// ```
end_l: Loc | null;
// Location of the full expression
//
// ```text
// begin; foo; bar
// ~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
statements: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents an special argument that rejects all keyword arguments (i.e. `def m(**nil); end`)
export class Kwnilarg {
// Location of the `nil`
//
// ```text
// def m(**nil); end
// ~~~
// ```
name_l: Loc;
// Location of the `nil`
//
// ```text
// def m(**nil); end
// ~~~~~
// ```
expression_l: Loc;
constructor(
name_l: Loc,
expression_l: Loc,
);
}
// Represents an optional keyword argument (i.e. `foo` in `def m(foo: 42); end`)
export class Kwoptarg {
// Name of the optional keyword argument
name: string;
// Default value of the optional keyword argument
default_: Node;
// Location of the argument name
//
// ```text
// def m(foo: 1); end
// ~~~
// ```
name_l: Loc;
// Location of the argument name
//
// ```text
// def m(foo: 1); end
// ~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
default_: Node,
name_l: Loc,
expression_l: Loc,
);
}
// Represents a keyword rest argument (i.e. `foo` in `def m(**foo); end`)
export class Kwrestarg {
// Name of the keyword rest argument, `String("foo")` in `def m(**foo); end`.
//
// `None` if argument has no name (`def m(**); end`)
name: string | null;
// Location of the `**` operator
//
// ```text
// def m(**foo); end
// ~~
// ```
operator_l: Loc;
// Location of the argument name
//
// ```text
// def m(**foo); end
// ~~~
// ```
//
// `None` if argument has no name (`def m(**); end`)
name_l: Loc | null;
// Location of the full expression
//
// ```text
// def m(**foo); end
// ~~~~~
// ```
expression_l: Loc;
constructor(
name: string | null,
operator_l: Loc,
name_l: Loc | null,
expression_l: Loc,
);
}
// Represents a keyword arguments splat (i.e. `**bar` in a call like `foo(**bar)`)
export class Kwsplat {
// Value that is converted into a `Hash` using `**`
value: Node;
// Location of the `**` operator
//
// ```text
// foo(**bar)
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo(**bar)
// ~~~~~
// ```
expression_l: Loc;
constructor(
value: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a lambda call using `->` (i.e. `-> {}`)
//
// Note that `Lambda` is a part of the `Block`, not other way around.
export class Lambda {
// Location of the `->`
//
// ```text
// -> {}
// ~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a special `__LINE__` literal
export class Line {
// Location of the `__LINE__` literal
//
// ```text
// __LINE__
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents access to a local variable (i.e. `foo`)
//
// Parser knows that it's a local variable because:
// 1. there was an assignment to this variable **before** accessing it
// 2. it's an argument of the current method / block
// 3. it's been implicitly declared by `MatchWithLvasgn` node
//
// Otherwise it's a method call (see `Send`)
export class Lvar {
// Name of the local variable
name: string;
// Location of the local variable
//
// ```text
// foo
// ~~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents local variable assignment (i.e. `foo = 42`)
export class Lvasgn {
// Name of the local variable
name: string;
// Value that is assigned to a local variable
value: Node | null;
// Location of the local variable name
//
// ```text
// foo = 42
// ~~~
// ```
name_l: Loc;
// Location of the `=` operator
//
// ```text
// foo = 42
// ~
// ```
//
// `None` if local variable assignment is a part of the multi-assignment.
// In such case `value` is a part of the `Masgn` node.
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// foo = 42
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
value: Node | null,
name_l: Loc,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents mass-assignment (i.e. `foo, bar = 1, 2`)
export class Masgn {
// Left hand statement of the assignment
lhs: Node;
// Left hand statement of the assignment
rhs: Node;
// Location of the `=` operator
//
// ```text
// foo, bar = 1, 2
// ~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo, bar = 1, 2
// ~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
lhs: Node,
rhs: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents pattern matching using one of the given patterns (i.e. `foo in 1 | 2`)
export class MatchAlt {
// Left pattern
lhs: Node;
// Right pattern
rhs: Node;
// Location of the `|` operator
//
// ```text
// foo in 1 | 2
// ~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo in 1 | 2
// ~~~~~
// ```
expression_l: Loc;
constructor(
lhs: Node,
rhs: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents matching with renaming into specified local variable (i.e. `case 1; in Integer => a; end`)
export class MatchAs {
// Pattern that is used for matching
value: Node;
// Variable that is assigned if matched (see `MatchVar` node)
as: Node;
// Location of the `=>` operator
//
// ```text
// case 1; in Integer => a; end
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// case 1; in Integer => a; end
// ~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
value: Node,
as: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents implicit matching using `if /regex/`
//
// ```text
// if /.*/
// puts 'true'
// else
// puts 'false'
// end
// ```
// Prints "false".
//
// Under the hood this construction matches regex against `$_`, so the following works:
// ```text
// $_ = 'match_me'
// if /match_me/
// puts 'true'
// else
// puts 'false'
// end
// ```
// this code prints "true".
export class MatchCurrentLine {
// Given regex
re: Node;
// Location of the regex
//
// ```text
// if /re/; end
// ~~~~
// ```
//
// Technically this location is redundant, but keeping it is the only way to
// have the same interface for all nodes.
expression_l: Loc;
constructor(
re: Node,
expression_l: Loc,
);
}
// Represents empty hash pattern that is used in pattern matching (i.e. `in **nil`)
export class MatchNilPattern {
// Location of the `**` operator
//
// ```text
// in **nil
// ~~
// ```
operator_l: Loc;
// Location of the name
//
// ```text
// in **nil
// ~~~
// ```
name_l: Loc;
// Location of the full expression
//
// ```text
// in **nil
// ~~~~~
// ```
expression_l: Loc;
constructor(
operator_l: Loc,
name_l: Loc,
expression_l: Loc,
);
}
// Represents a one-line pattern matching that can throw an error (i.e. `foo => pattern`)
export class MatchPattern {
// Value that is used for matching
value: Node;
// Pattern that is used for matching
pattern: Node;
// Location of the `=>` operator
//
// ```text
// foo => pattern
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo => pattern
// ~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
value: Node,
pattern: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a one-line pattern matching that never throws but returns true/false (i.e. `foo in pattern`)
export class MatchPatternP {
// Value that is used for matching
value: Node;
// Pattern that is used for matching
pattern: Node;
// Location of the `in` operator
//
// ```text
// foo in pattern
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo in pattern
// ~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
value: Node,
pattern: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a wildcard pattern used in pattern matching (i.e. `in *foo`)
export class MatchRest {
// Name of the variable name
//
// `None` if there's no name (i.e. `in *`)
name: Node | null;
// Location of the `*` operator
//
// ```text
// case foo; in *bar; end
// ~
// ```
operator_l: Loc;
// Location of the `*` operator
//
// ```text
// case foo; in *bar; end
// ~~~~
// ```
expression_l: Loc;
constructor(
name: Node | null,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents matching with assignment into a local variable (i.e. `pattern => var`)
export class MatchVar {
// Name of the variable that is assigned if matching succeeds
name: string;
// Location of the name
//
// ```text
// case foo; in pattern => bar; end
// ~~~
// ```
//
// **Note** it can also be produced by a hash pattern
//
// ```text
// case foo; in { a: }; end
// ~
// ```
name_l: Loc;
// Location of the full expression
//
// ```text
// case foo; in pattern => bar; end
// ~~~
// ```
//
// **Note** it can also be produced by a hash pattern
//
// ```text
// case foo; in { a: }; end
// ~~
// ```
expression_l: Loc;
constructor(
name: string,
name_l: Loc,
expression_l: Loc,
);
}
// Represents matching a regex that produces local variables (i.e. `/(?<match>bar)/ =~ 'bar'`)
//
// Each named group in regex declares a local variable.
export class MatchWithLvasgn {
// Regex that is used for matching
re: Node;
// Value that is used for matching
value: Node;
// Location of the `=~` operatir
//
// ```text
// /(?<match>bar)/ =~ 'bar'
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// /(?<match>bar)/ =~ 'bar'
// ~~~~~~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
re: Node,
value: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents left hand statement of the mass-assignment (i.e. `foo, bar` in `foo, bar = 1, 2`)
export class Mlhs {
// A list of items that are assigned
items: Node[];
// Location of the open parenthesis
//
// ```text
// (a, b) = 1, 2
// ~
// ```
//
// `None` if there are no parentheses
begin_l: Loc | null;
// Location of the closing parenthesis
//
// ```text
// (a, b) = 1, 2
// ~
// ```
//
// `None` if there are no parentheses
end_l: Loc | null;
// Location of the full expression
//
// ```text
// (a, b) = 1, 2
// ~~~~~~
// ```
expression_l: Loc;
constructor(
items: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents module declaration using `module` keyword
export class Module {
// Name of the module
name: Node;
// Body of the module
//
// `None` if module has no body
body: Node | null;
// Location of the `module` keyword
//
// ```text
// module M; end
// ~~~~~~
// ```
keyword_l: Loc;
// Location of the `end` keyword
//
// ```text
// module M; end
// ~~~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// module M; end
// ~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
name: Node,
body: Node | null,
keyword_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents `next` keyword
export class Next {
// Arguments given to `next`
args: Node[];
// Location of the `next` keyword
//
// ```text
// next 42
// ~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// next(42)
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
args: Node[],
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents `nil` literal
export class Nil {
// Location of the `nil` keyword
//
// ```text
// nil
// ~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents numeric global variable (e.g. `$1`)
export class NthRef {
// Name of the variable, `String("1")` for `$1`
name: string;
// Location of the full expression
//
// ```text
// $1
// ~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents a block that takes numbered parameters (i.e. `proc { _1 }`)
export class Numblock {
// Method call that takes a block
call: Node;
// Number of parameters that block takes
numargs: number;
// Block body
body: Node;
// Location of the open brace
//
// ```text
// proc { _1 }
// ~
// ```
begin_l: Loc;
// Location of the closing brace
//
// ```text
// proc { _1 }
// ~
// ```
end_l: Loc;
// Location of the open brace
//
// ```text
// proc { _1 }
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
call: Node,
numargs: number,
body: Node,
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents an operation with assignment (e.g. `a += 1`)
export class OpAsgn {
// Left hand statement of the assignment
recv: Node;
// Operator, can be one of:
// 1. `+=`
// 2. `-=`
// 3. `*=`
// 4. `/=`
// 5. `|=`
// 6. `&=`
// 7. `>>=`
// 8. `<<=`
// 9. `%=`
// 10. `^=`
// 11. `**=`
operator: string;
// Right hand statement of the assignment
value: Node;
// Location of the operator
//
// ```text
// a.b <<= c
// ~~~
// ```
operator_l: Loc;
// Location of the operator
//
// ```text
// a.b <<= c
// ~~~~~~~~~
// ```
expression_l: Loc;
constructor(
recv: Node,
operator: string,
value: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents optional positional argument (i.e. `foo` in `m(foo = 1)`)
export class Optarg {
// Name of the argument
name: string;
// Default value of the argument
default_: Node;
// Location of the argument name
//
// ```text
// def m(foo = 1); end
// ~~~
// ```
name_l: Loc;
// Location of the `=` operator
//
// ```text
// def m(foo = 1); end
// ~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// def m(foo = 1); end
// ~~~~~~~
// ```
expression_l: Loc;
constructor(
name: string,
default_: Node,
name_l: Loc,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents `foo || bar` (or `foo or bar`) statement.
export class Or {
// Left hand statement
lhs: Node;
// Right hand statement
rhs: Node;
// Location of the `||`/`or` operator
//
// ```text
// foo || bar
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo || bar
// ~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
lhs: Node,
rhs: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents `lhs ||= rhs` assignment
export class OrAsgn {
// Left hand statement
recv: Node;
// Right hand statement
value: Node;
// Location of the `||=` operator
//
// ```text
// foo ||= bar
// ~~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo ||= bar
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
recv: Node,
value: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a key/value pair (e.g. a part of the `Hash` node)
export class Pair {
// Key of the pair
key: Node;
// Value of the pair
value: Node;
// Location of the `:` or `=>` operator
//
// ```text
// { foo: bar }
// ~
//
// { :foo => bar }
// ~~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// { foo: bar }
// ~~~~~~~~
//
// { :foo => bar }
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
key: Node,
value: Node,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a pattern based on a "pinned" variable (e.g. `^foo`)
export class Pin {
// Variable that is pinned
var_: Node;
// Location of the `^` operator
//
// ```text
// case foo; in ^bar; end
// ~
// ```
selector_l: Loc;
// Location of the full expression
//
// ```text
// case foo; in ^bar; end
// ~~~~
// ```
expression_l: Loc;
constructor(
var_: Node,
selector_l: Loc,
expression_l: Loc,
);
}
// Represents `END { .. }` statement
export class Postexe {
// Body of the block
body: Node | null;
// Location of the `END` keyword
//
// ```text
// END { 42 }
// ~~~
// ```
keyword_l: Loc;
// Location of the open parenthesis
//
// ```text
// END { 42 }
// ~
// ```
begin_l: Loc;
// Location of the closing parenthesis
//
// ```text
// END { 42 }
// ~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// END { 42 }
// ~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
body: Node | null,
keyword_l: Loc,
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents `BEGIN { ... }` statement
export class Preexe {
// Body of the block
body: Node | null;
// Location of the `BEGIN` keyword
//
// ```text
// BEGIN { 42 }
// ~~~~~
// ```
keyword_l: Loc;
// Location of the open parenthesis
//
// ```text
// BEGIN { 42 }
// ~
// ```
begin_l: Loc;
// Location of the closing parenthesis
//
// ```text
// BEGIN { 42 }
// ~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// BEGIN { 42 }
// ~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
body: Node | null,
keyword_l: Loc,
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents a sole block argument (e.g. `|foo|`)
//
// Block that takes a single array argument automatically expands it.
// Adding trailing comma after block argument disables this behavior (and then the only argument is emitted as `Arg`).
export class Procarg0 {
// Parts of the sole block argument.
//
// `proc { |(a, b)| }` also counts as a sole argument, so this list may contain:
// 1. A single `Arg` node (for `proc { |a| }` case)
// 2. Multiple `Arg` nodes (for `proc { |(a, b, c)| }` case)
args: Node[];
// Location of the open parenthesis
//
// ```text
// proc { |(foo, bar)| }
// ~
// ```
//
// `None` if there's only one argument
begin_l: Loc | null;
// Location of the open parenthesis
//
// ```text
// proc { |(foo, bar)| }
// ~
// ```
//
// `None` if there's only one argument
end_l: Loc | null;
// Location of the full expression
//
// ```text
// proc { |(foo, bar)| }
// ~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
args: Node[],
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents rational literal (e.g. `1r`)
export class Rational {
// String value of the literal, `String("1r")` for `1r`
value: string;
// Location of the unary `-` (but not `+`)
//
// ```text
// -1r
// ~
// ```
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// -1r
// ~~~
// ```
expression_l: Loc;
constructor(
value: string,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents `redo` keyword
export class Redo {
// Location of the full expression
//
// ```text
// redo
// ~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents regex literal (e.g. `/foo/`)
export class Regexp {
// A list of static and dynamic regex parts
parts: Node[];
// Regex options.
//
// `None` if regex has no explicit flags
options: Node | null;
// Location of the regex begin
//
// ```text
// /foo/
// ~
//
// %r{foo}
// ~~
// ```
begin_l: Loc;
// Location of the regex end
//
// ```text
// /foo/
// ~
//
// %r{foo}
// ~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// /foo/mix
// ~~~~~~~~
// ```
expression_l: Loc;
constructor(
parts: Node[],
options: Node | null,
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents flags of the regex literal (i.e. `mix` for `/foo/mix`)
export class RegOpt {
// A list of flags
options: string | null;
// Location of the full expression
//
// ```text
// /foo/mix
// ~~~
// ```
expression_l: Loc;
constructor(
options: string | null,
expression_l: Loc,
);
}
// Represents a `rescue` block
export class Rescue {
// Body of the block that is wrapped into `rescue` (i.e. the part that may throw an error)
body: Node | null;
// A list of `rescue` handlers (see `RescueBody` node)
rescue_bodies: Node[];
// Else branch.
//
// `None` if there's no `else` branch
else_: Node | null;
// Location of the `else` keyword
//
// ```text
// begin; 1; rescue StandardError => e; 2; else; 3; end
// ~~~~
// ```
//
// `None` if there's no `else` branch
else_l: Loc | null;
// Location of the full expression
//
// ```text
// begin; 1; rescue StandardError => e; 2; else; 3; end
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// ```
//
// **Note**: `begin/end` keywords belong to `KwBegin` node
expression_l: Loc;
constructor(
body: Node | null,
rescue_bodies: Node[],
else_: Node | null,
else_l: Loc | null,
expression_l: Loc,
);
}
// Represents a single `rescue` handler (i.e. `rescue E => e ...`)
export class RescueBody {
// A list of exception classes
//
// `None` if no classes specified (i.e. `rescue => e; ...` or just `rescue; ...`)
exc_list: Node | null;
// Variable that captures exception
//
// `None` if no variable specified (i.e. `rescue E; ...` or just `rescue; ... `)
exc_var: Node | null;
// Body of the handler
body: Node | null;
// Location of the `rescue` keyword
//
// ```text
// begin; 1; rescue E => e; 2; end
// ~~~~~~
// ```
keyword_l: Loc;
// Location of the `=>` operator
//
// ```text
// begin; 1; rescue E => e; 2; end
// ~~
// ```
//
// `None` if exception is not captured.
assoc_l: Loc | null;
// Location of the `then` keyword
//
// ```text
// begin; 1; rescue E => e then; 2; end
// ~~~~
// ```
//
// `then` is optional, so `begin_l` can be `None`
begin_l: Loc | null;
// Location of the full expression
//
// ```text
// begin; 1; rescue E => e then; 2; end
// ~~~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
exc_list: Node | null,
exc_var: Node | null,
body: Node | null,
keyword_l: Loc,
assoc_l: Loc | null,
begin_l: Loc | null,
expression_l: Loc,
);
}
// Represents positional rest argument (i.e. `*foo` in `def m(*foo); end`)
export class Restarg {
// Name of the argument.
//
// `None` if argument has no name (i.e. `def m(*); end`)
name: string | null;
// Location of the `*` operator
//
// ```text
// def m(*foo); end
// ~
// ```
operator_l: Loc;
// Location of the argument name
//
// ```text
// def m(*foo); end
// ~~~
// ```
name_l: Loc | null;
// Location of the full expression
//
// ```text
// def m(*foo); end
// ~~~~
// ```
expression_l: Loc;
constructor(
name: string | null,
operator_l: Loc,
name_l: Loc | null,
expression_l: Loc,
);
}
// Represents `retry` keyword
export class Retry {
// Location of the `retry` keyword
//
// ```text
// retry
// ~~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents `return` keyword
export class Return {
// A list of values that is returned
args: Node[];
// Location of the `return` keyword
//
// ```text
// return 1, 2
// ~~~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// return 1, 2
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
args: Node[],
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents opening a singleton class (i.e. `class << foo; ... end;`)
export class SClass {
// Expression that is used to get a singleton class
//
// `Lvar("foo")` for `class << foo; end`
expr: Node;
// Body of the block
body: Node | null;
// Location of the `class` keyword
//
// ```text
// class << foo; end
// ~~~~~
// ```
keyword_l: Loc;
// Location of the `<<` operator
//
// ```text
// class << foo; end
// ~~
// ```
operator_l: Loc;
// Location of the `end` keyword
//
// ```text
// class << foo; end
// ~~~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// class << foo; end
// ~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
expr: Node,
body: Node | null,
keyword_l: Loc,
operator_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents `self` keyword
export class Self_ {
// Location of the `self` keyword
//
// ```text
// self
// ~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents a method call (e.g. `foo.bar(42)`)
export class Send {
// Receiver of the method call
//
// `None` for implicit method call (e.g. `foo(42)`)
recv: Node | null;
// Name of the method that is called
method_name: string;
// A list of arguments
args: Node[];
// Location of the `.` operator
//
// ```text
// foo.bar(42)
// ~
// ```
//
// `None` for implicit method call (e.g. `foo(42)`)
dot_l: Loc | null;
// Location of the method name
//
// ```text
// foo.bar(42)
// ~~~
// ```
//
// `None` in a very special case when method call is implicit (i.e. `foo.(42)`)
selector_l: Loc | null;
// Location of open parenthesis
//
// ```text
// foo(42)
// ~
// ```
//
// `None` if there are no parentheses
begin_l: Loc | null;
// Location of closing parenthesis
//
// ```text
// foo(42)
// ~
// ```
//
// `None` if there are no parentheses
end_l: Loc | null;
// Location of the operator if method is a setter
//
// ```text
// foo.bar = 42
// ~
// ```
//
// `None` otherwise
operator_l: Loc | null;
// Location of the full expression
//
// ```text
// foo.bar(42)
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
recv: Node | null,
method_name: string,
args: Node[],
dot_l: Loc | null,
selector_l: Loc | null,
begin_l: Loc | null,
end_l: Loc | null,
operator_l: Loc | null,
expression_l: Loc,
);
}
// Represents a special block argument that "shadows" outer variable (i.e. `|;foo|`)
export class Shadowarg {
// Name of the argument
name: string;
// Location of the argument
//
// ```text
// proc { |;foo|}
// ~~~
// ```
expression_l: Loc;
constructor(
name: string,
expression_l: Loc,
);
}
// Represents an arguments splat (i.e. `*bar` in a call like `foo(*bar)`)
export class Splat {
// Value that is converted to array
value: Node | null;
// Location of the `*` operator
//
// ```text
// foo(*bar)
// ~
// ```
operator_l: Loc;
// Location of the full expression
//
// ```text
// foo(*bar)
// ~~~~
// ```
expression_l: Loc;
constructor(
value: Node | null,
operator_l: Loc,
expression_l: Loc,
);
}
// Represents a plain non-interpolated string literal (e.g. `"foo"`)
export class Str {
// Value of the string literal
//
// Note that it's a `StringValue`, not a `String`.
// The reason is that you can get UTF-8 incompatible strings
// from a valid UTF-8 source using escape sequences like `"\xFF"`
//
// These "\", "x", "F", "F" chars are valid separately, but together
// they construct a char with code = 255 that is invalid for UTF-8.
//
// You can use `to_string_lossy` or `to_string` methods to get a raw string value.
value: Uint8Array;
// Location of the string begin
//
// ```text
// "foo"
// ~
// ```
//
// `None` if string literal is a part of the words array (like `%w[foo bar baz]`)
begin_l: Loc | null;
// Location of the string begin
//
// ```text
// "foo"
// ~
// ```
//
// `None` if string literal is a part of the words array (like `%w[foo bar baz]`)
end_l: Loc | null;
// Location of the full expression
//
// ```text
// "foo"
// ~~~~~
// ```
expression_l: Loc;
constructor(
value: Uint8Array,
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a `super` keyword
export class Super {
// A list of arguments given to `super`
args: Node[];
// Location of the `super` keyword
//
// ```text
// super(1, 2)
// ~~~~~
// ```
keyword_l: Loc;
// Location of the open parenthesis
//
// ```text
// super(1, 2)
// ~
// ```
//
// `None` if there are no parentheses
begin_l: Loc | null;
// Location of the closing parenthesis
//
// ```text
// super(1, 2)
// ~
// ```
//
// `None` if there are no parentheses
end_l: Loc | null;
// Location of the full expression
//
// ```text
// super(1, 2)
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
args: Node[],
keyword_l: Loc,
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a plain symbol literal (i.e. `:foo`)
//
// Note that `:` in `{ foo: bar }` belongs to a `pair` node.
export class Sym {
// Value of the symbol literal
//
// Note that it's a `StringValue`, not a `String`.
// The reason is that you can get UTF-8 incompatible strings
// from a valid UTF-8 source using escape sequences like `"\xFF"`
//
// These "\", "x", "F", "F" chars are valid separately, but together
// they construct a char with code = 255 that is invalid for UTF-8.
//
// You can use `to_string_lossy` or `to_string` methods to get a raw symbol value.
name: Uint8Array;
// Location of the symbol begin
//
// ```text
// :foo
// ~
// ```
//
// `None` if symbol is a label (`{ foo: 1 }`) or a part of the symbols array (`%i[foo bar baz]`)
begin_l: Loc | null;
// Location of the symbol end
//
// ```text
// { 'foo': 1 }
// ~
// ```
//
// `None` if symbol is **not** a string label (`:foo`) or a part of the symbols array (`%i[foo bar baz]`)
end_l: Loc | null;
// Location of the full expression
//
// ```text
// :foo
// ~~~~
//
// { foo: 1 }
// ~~~~
//
// %i[foo]
// ~~~
// ```
expression_l: Loc;
constructor(
name: Uint8Array,
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a `true` literal
export class True {
// Location of the `true` keyword
//
// ```text
// true
// ~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
// Represents an `undef` keyword (e.g. `undef foo, :bar`)
export class Undef {
// A list of names to `undef`
names: Node[];
// Location the `undef` keyword
//
// ```text
// undef foo, :bar
// ~~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// undef :foo, bar
// ~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
names: Node[],
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents an `unless` guard used in pattern matching (i.e. `in pattern unless guard`)
export class UnlessGuard {
// Condition of the guard, `Lvar("foo")` in `in pattern unless guard`
cond: Node;
// Location of the `unless` keyword
//
// ```text
// case foo; in pattern unless cond; end
// ~~~~~~
// ```
keyword_l: Loc;
// Location of the full expression
//
// ```text
// case foo; in pattern unless cond; end
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents `until` loop
export class Until {
// Condition of the loop
cond: Node;
// Body of the loop.
//
// `None` if body is empty
body: Node | null;
// Location of the `until` keyword
//
// ```text
// until cond do; foo; end
// ~~~~~
// ```
keyword_l: Loc;
// Location of the `do` keyword
//
// ```text
// until cond do; foo; end
// ~~
// ```
//
// `do` is optional, and so `begin_l` can be `None`
begin_l: Loc | null;
// Location of the `end` keyword
//
// ```text
// until cond do; foo; end
// ~~~
// ```
//
// `None` if loop is a modifier (i.e. `foo until bar`)
end_l: Loc | null;
// Location of the full expression
//
// ```text
// until cond do; foo; end
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// foo until bar
// ~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
body: Node | null,
keyword_l: Loc,
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a post-until loop
//
// ```text
// begin
// foo
// end until bar
// ```
export class UntilPost {
// Condition of the loop
cond: Node;
// Body of the loop
body: Node;
// Location of the `until` keyword
//
// ```text
// begin; foo; end until bar
// ~~~~~
// ```
keyword_l: Loc;
// Location of the `until` keyword
//
// ```text
// begin; foo; end until bar
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
body: Node,
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents a branch of the `case` statement (i.e. `when foo`)
export class When {
// A list of values to compare/match against
patterns: Node[];
// Body of the `when` branch
body: Node | null;
// Location of the `when` keyword
//
// ```text
// case foo; when bar; end
// ~~~~
// ```
keyword_l: Loc;
// Location of the `then` keyword
//
// ```text
// case foo; when bar then baz; end
// ~~~~
// ```
//
// `then` is optional, and so `begin_l` can be `None`
begin_l: Loc;
// Location of the full expression
//
// ```text
// case foo; when bar then baz; end
// ~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
patterns: Node[],
body: Node | null,
keyword_l: Loc,
begin_l: Loc,
expression_l: Loc,
);
}
// Represents `while` loop
export class While {
// Condition of the loop
cond: Node;
// Body of the loop.
//
// `None` if body is empty
body: Node | null;
// Location of the `while` keyword
//
// ```text
// while cond do; foo; end
// ~~~~~
// ```
keyword_l: Loc;
// Location of the `do` keyword
//
// ```text
// while cond do; foo; end
// ~~
// ```
//
// `do` is optional, and so `begin_l` can be `None`
begin_l: Loc | null;
// Location of the `end` keyword
//
// ```text
// while cond do; foo; end
// ~~~
// ```
//
// `None` if loop is a modifier (i.e. `foo while bar`)
end_l: Loc | null;
// Location of the full expression
//
// ```text
// while cond do; foo; end
// ~~~~~~~~~~~~~~~~~~~~~~~
//
// foo while bar
// ~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
body: Node | null,
keyword_l: Loc,
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a post-while loop
//
// ```text
// begin
// foo
// end while bar
// ```
export class WhilePost {
// Condition of the loop
cond: Node;
// Body of the loop
body: Node;
// Location of the `while` keyword
//
// ```text
// begin; foo; end while bar
// ~~~~~
// ```
keyword_l: Loc;
// Location of the `while` keyword
//
// ```text
// begin; foo; end while bar
// ~~~~~~~~~~~~~~~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
cond: Node,
body: Node,
keyword_l: Loc,
expression_l: Loc,
);
}
// Represents a executable here-document literal (both with and without interpolation)
//
// It's similar to `Xstr` in terms of abstract syntax tree, but has different source maps.
export class XHeredoc {
// A list of string parts (static literals and interpolated expressions)
parts: Node[];
// Location of the executable here-document body
//
// ```text
// <<-`HERE`\n a\n #{42}\nHERE
// ~~~~~~~~~~~~~~~
// ```
heredoc_body_l: Loc;
// Location of the executable here-document end
//
// ```text
// <<-`HERE`\n a\n #{42}\nHERE
// ~~~~
// ```
heredoc_end_l: Loc;
// Location of the executable here-document identifier
//
// ```text
// <<-`HERE`\n a\n #{42}\nHERE
// ~~~~~~~
// ```
//
// **Note**: This is the only node (with `Heredoc`) that has `expression_l` smaller that all other sub-locations merged.
// The reason for that is that it's possible to add more code after here-document ID:
//
// ```text
// <<-`HERE` + "rest"
// content
// HERE
// ```
expression_l: Loc;
constructor(
parts: Node[],
heredoc_body_l: Loc,
heredoc_end_l: Loc,
expression_l: Loc,
);
}
// Represents an executable string (i.e. `` `sh #{script_name}` ``)
export class Xstr {
// A list of string parts (static literals and interpolated expressions)
parts: Node[];
// Location of the string begin
//
// ```text
// `#{foo}`
// ~
//
// %X{#{foo}}
// ~~~
// ```
begin_l: Loc;
// Location of the string end
//
// ```text
// `#{foo}`
// ~
//
// %X{#{foo}}
// ~
// ```
end_l: Loc;
// Location of the full expression
//
// ```text
// `#{foo}`
// ~~~~~~~~
//
// %X{#{foo}}
// ~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
parts: Node[],
begin_l: Loc,
end_l: Loc,
expression_l: Loc,
);
}
// Represents an `yield` keyword
export class Yield {
// A list of arguments given to `yield`
args: Node[];
// Location of the `yield` keyword
//
// ```text
// yield 1, 2
// ~~~~~
// ```
keyword_l: Loc;
// Location of the open parenthesis
//
// ```text
// yield(1, 2)
// ~
// ```
//
// `None` if there are no parentheses
begin_l: Loc | null;
// Location of the closing parenthesis
//
// ```text
// yield(1, 2)
// ~
// ```
//
// `None` if there are no parentheses
end_l: Loc | null;
// Location of the full expression
//
// ```text
// yield(1, 2)
// ~~~~~~~~~~~
// ```
expression_l: Loc;
constructor(
args: Node[],
keyword_l: Loc,
begin_l: Loc | null,
end_l: Loc | null,
expression_l: Loc,
);
}
// Represents a `super` call without arguments and parentheses
//
// It's different from `super()` as it implicitly forwards current arguments
export class ZSuper {
// Location of the `super` keyword
//
// ```text
// super
// ~~~~~
// ```
expression_l: Loc;
constructor(
expression_l: Loc,
);
}
}
export class DiagnosticMessage {}
export namespace messages {
// Emitted for code
//
// ```text
// 1.2.3
// ```
export class FractionAfterNumeric {
constructor(
);
}
// Emitted for code like
//
// ```text
// foo.2
// ```
export class NoDigitsAfterDot {
constructor(
);
}
// Emitted for code like
//
// ```text
// %k[foo]
// ```
export class UnknownTypeOfPercentString {
constructor(
);
}
// Emitted for code like
//
// ```text
// 0b
// ```
export class NumericLiteralWithoutDigits {
constructor(
);
}
// Emitted for code like
//
// ```text
// %w[foo bar
// ```
export class UnterminatedList {
constructor(
);
}
// Emitted for code like
//
// ```text
// /foo
// ```
export class UnterminatedRegexp {
constructor(
);
}
// Emitted for code like
//
// ```text
// "foo
// ```
export class UnterminatedString {
constructor(
);
}
// Emitted for code like
//
// ```text
// %s
// // ^ EOF, not "
//
// ```
export class UnterminatedQuotedString {
constructor(
);
}
// Emitted for code like
//
// ```text
// "\ufoo"
// ```
export class InvalidUnicodeEscape {
constructor(
);
}
// Emitted for code like
//
// ```text
// "\u{999999}"
// ```
export class TooLargeUnicodeCodepoint {
constructor(
);
}
// Emitted for code like
//
// ```text
// "\u{d800}"
// ```
export class InvalidUnicodeCodepoint {
constructor(
);
}
// Emitted for code like
//
// ```text
// ?\u{41 42}
// ```
export class MultipleCodepointAtSingleChar {
constructor(
);
}
// Emitted for code like
//
// ```text
// "\M-"
// ```
export class InvalidEscapeCharacter {
constructor(
);
}
// Emitted for code like
//
// ```text
// "\xZZ"
// ```
export class InvalidHexEscape {
constructor(
);
}
// Emitted for code like
//
// ```text
// <<-HERE
// ```
export class UnterminatedHeredoc {
// Heredoc identifier
heredoc_id: string;
constructor(
heredoc_id: string,
);
}
// Emitted for code like
//
// ```text
// <<-"HERE
// ```
export class UnterminatedHeredocId {
constructor(
);
}
// Emitted for code like
//
// ```text
// eval("foo \r = 42")
// ```
export class SlashRAtMiddleOfLine {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// foo **arg
// ```
export class DStarInterpretedAsArgPrefix {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// foo *arg
// ```
export class StarInterpretedAsArgPrefix {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// foo &arg
// ```
export class AmpersandInterpretedAsArgPrefix {
constructor(
);
}
// Emitted for code like
//
// ```text
// range = 1...
// ```
export class TripleDotAtEol {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// def m (a, b, c); end
// ```
export class ParenthesesIterpretedAsArglist {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// m +foo
// ```
export class AmbiguousFirstArgument {
// Operator that is ambiguous
operator: number;
constructor(
operator: number,
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// 1 *2
// ```
export class AmbiguousOperator {
// Operator that is ambiguous
operator: string;
// Interpretation of this operator
interpreted_as: string;
constructor(
operator: string,
interpreted_as: string,
);
}
// Emitted for code like
//
// ```text
// "\M- "
// ```
export class InvalidCharacterSyntax {
// Valid syntax sugestions
suggestion: string;
constructor(
suggestion: string,
);
}
// Emitted for code like
//
// ```text
// 09
// ```
export class InvalidOctalDigit {
constructor(
);
}
// Emitted for code like
//
// ```text
// 0_a
// ```
export class TrailingCharInNumber {
// Invalid trailing char
c: number;
constructor(
c: number,
);
}
// Emitted for code like
//
// ```text
// =begin
// ```
export class EmbeddedDocumentMeetsEof {
constructor(
);
}
// Emitted for code like
//
// ```text
// eval("\x01foo")
// ```
export class InvalidChar {
// char
c: number;
constructor(
c: number,
);
}
// It is unknown how to trigger this error.
// Code that triggers it in MRI can be dead.
export class IncompleteCharacterSyntax {
constructor(
);
}
// Emitted for code like
//
// ```text
// $
// ```
export class GvarWithoutId {
constructor(
);
}
// Emitted for code like
//
// ```text
// $@
// ```
export class InvalidGvarName {
// char after `$`
c: number;
constructor(
c: number,
);
}
// Emitted for code like
//
// ```text
// @
// ```
export class IvarWithoutId {
constructor(
);
}
// Emitted for code like
//
// ```text
// @1
// ```
export class InvalidIvarName {
// char after `@`
c: number;
constructor(
c: number,
);
}
// Emitted for code like
//
// ```text
// @@
// ```
export class CvarWithoutId {
constructor(
);
}
// Emitted for code like
//
// ```text
// @@1
// ```
export class InvalidCvarName {
// char after `@@`
c: number;
constructor(
c: number,
);
}
// Emitted for code like
//
// ```text
// /re/foo
// ```
export class UnknownRegexOptions {
// Concatenated unknown options
options: string;
constructor(
options: string,
);
}
// Emitted for code like
//
// ```text
// "\u{1234"
// ```
export class UnterminatedUnicodeEscape {
constructor(
);
}
// Emitted for code like
//
// ```text
// # encoding: foo
// ```
export class EncodingError {
// Error from decoder
error: string;
constructor(
error: string,
);
}
// Emitter for code like
//
// ```text
// eval("\xFF = 42")
// ```
export class InvalidMultibyteChar {
constructor(
);
}
// Emitted for code like
//
// ```text
// a ?AA : 2
// ```
export class AmbiguousTernaryOperator {
// Source of the condition expression
condition: string;
constructor(
condition: string,
);
}
// Emitted for code like
//
// ```text
// m /foo/
// ```
export class AmbiguousRegexp {
constructor(
);
}
// Emitted for code like
//
// ```text
// begin; else; end
// ```
export class ElseWithoutRescue {
constructor(
);
}
// Emitted for code like
//
// ```text
// def f; BEGIN{}; end
// ```
export class BeginNotAtTopLevel {
constructor(
);
}
// Emitted for code like
//
// ```text
// alias $a $1
// ```
export class AliasNthRef {
constructor(
);
}
// Emitted for code like
//
// ```text
// *a&.x = 0
// ```
export class CsendInsideMasgn {
constructor(
);
}
// Emitted for code like
//
// ```text
// module foo; end
// ```
export class ClassOrModuleNameMustBeConstant {
constructor(
);
}
// Emitted for code like
//
// ```text
// def foo=() = 42
// ```
export class EndlessSetterDefinition {
constructor(
);
}
// Emitted for any code that produces invalid sequence of tokens
export class UnexpectedToken {
// Name of the token
token_name: string;
constructor(
token_name: string,
);
}
// Emitted for code like
//
// ```text
// def a; class Foo; end; end
// ```
export class ClassDefinitionInMethodBody {
constructor(
);
}
// Emitted for code like
//
// ```text
// def a; module Foo; end; end
// ```
export class ModuleDefinitionInMethodBody {
constructor(
);
}
// Emitted for code like
//
// ```text
// class A; return; end
// ```
export class InvalidReturnInClassOrModuleBody {
constructor(
);
}
// Emitted for code like
//
// ```text
// def foo(Abc); end
// ```
export class ConstArgument {
constructor(
);
}
// Emitted for code like
//
// ```text
// def foo(@abc); end
// ```
export class IvarArgument {
constructor(
);
}
// Emitted for code like
//
// ```text
// def foo($abc); end
// ```
export class GvarArgument {
constructor(
);
}
// Emitted for code like
//
// ```text
// def foo(@@abc); end
// ```
export class CvarArgument {
constructor(
);
}
// Emitted for code like
//
// ```text
// case 0; in ^a; true; end
// ```
export class NoSuchLocalVariable {
// Variable name
var_name: string;
constructor(
var_name: string,
);
}
// Emitted for code like
//
// ```text
// m { |a| _1 }
// ```
export class OrdinaryParamDefined {
constructor(
);
}
// Emitted for code like
//
// ```text
// foo { _1; bar { _2 }; }
// ```
export class NumparamUsed {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// if
// 42
// end
// ```
export class TokAtEolWithoutExpression {
// Name of the token
token_name: string;
constructor(
token_name: string,
);
}
// Emitted for code like
//
// ```text
// { foo?: }
// # or
// { foo!: }
// ```
export class InvalidIdToGet {
// Identifier
identifier: string;
constructor(
identifier: string,
);
}
// Emitted for code like
//
// ```text
// def foo *rest, ...
// end
// ```
export class ForwardArgAfterRestarg {
constructor(
);
}
// Emitted for code like
//
// ```text
// def foo(); bar(&); end
// ```
export class NoAnonymousBlockarg {
constructor(
);
}
// Emitted for code like
//
// ```text
// def m; END {}; end
// ```
export class EndInMethod {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// a < b < c
// ```
export class ComparisonAfterComparison {
// Source of the first comparison
comparison: string;
constructor(
comparison: string,
);
}
// Emitted for code like
//
// ```text
// { 42 => value, 42 => another_value }
// ```
export class DuplicateHashKey {
constructor(
);
}
// Emitted for code like
//
// ```text
// def m(foo = foo) end
// ```
export class CircularArgumentReference {
// Name of the argument
arg_name: string;
constructor(
arg_name: string,
);
}
// Emitted for code like
//
// ```text
// def m; FOO = 1; end
// ```
export class DynamicConstantAssignment {
constructor(
);
}
// Emitted for code like
//
// ```text
// self = foo
// ```
export class CantAssignToSelf {
constructor(
);
}
// Emitted for code like
//
// ```text
// nil = foo
// ```
export class CantAssignToNil {
constructor(
);
}
// Emitted for code like
//
// ```text
// true = foo
// ```
export class CantAssignToTrue {
constructor(
);
}
// Emitted for code like
//
// ```text
// false = foo
// ```
export class CantAssignToFalse {
constructor(
);
}
// Emitted for code like
//
// ```text
// __FILE__ = foo
// ```
export class CantAssignToFile {
constructor(
);
}
// Emitted for code like
//
// ```text
// __LINE__ = foo
// ```
export class CantAssignToLine {
constructor(
);
}
// Emitted for code like
//
// ```text
// __ENCODING__ = foo
// ```
export class CantAssignToEncoding {
constructor(
);
}
// Emitted for code like
//
// ```text
// proc {_1; _1 = nil}
// ```
export class CantAssignToNumparam {
// Source of the numbered parameter
numparam: string;
constructor(
numparam: string,
);
}
// Emitted for code like
//
// ```text
// $1 = foo
// ```
export class CantSetVariable {
// Source of the read-only variable that is assigned
var_name: string;
constructor(
var_name: string,
);
}
// Emitted for code like
//
// ```text
// yield(&foo)
// ```
export class BlockGivenToYield {
constructor(
);
}
// Emitted for code like
//
// ```text
// fun(&bar) do end
// ```
export class BlockAndBlockArgGiven {
constructor(
);
}
// Emitted for code like
//
// ```text
// case a; in "#{a}": 1; end
// ```
export class SymbolLiteralWithInterpolation {
constructor(
);
}
// Emitted for code like
//
// ```text
// _1 = 1
// ```
export class ReservedForNumparam {
// Numbered parameter that is treated as a local variable
numparam: string;
constructor(
numparam: string,
);
}
// Emitted for code like
//
// ```text
// case a; in a?:; end
// ```
export class KeyMustBeValidAsLocalVariable {
constructor(
);
}
// Emitted for code like
//
// ```text
// case 0; in a, a; end
// ```
export class DuplicateVariableName {
constructor(
);
}
// Emitted for code like
//
// ```text
// case 0; in a: 1, a: 2; end
// ```
export class DuplicateKeyName {
constructor(
);
}
// Emitted for code like
//
// ```text
// def (1).foo; end
// ```
export class SingletonLiteral {
constructor(
);
}
// Emitted for code like (only in $VERBOSE mode)
//
// ```text
// $100
// ```
export class NthRefIsTooBig {
// Source of the nth_ref that is techincally a regular global variable
nth_ref: string;
constructor(
nth_ref: string,
);
}
// Emitted for code like
//
// ```text
// def foo(aa, aa); end
// ```
export class DuplicatedArgumentName {
constructor(
);
}
// Emitted for code like
//
// ```text
// /[/
// ```
export class RegexError {
// Error from Onigurama engine
error: string;
constructor(
error: string,
);
}
// Emitted for code like
//
// ```text
// %I"x .\xc3."
// ```
export class InvalidSymbol {
// Source of the symbol
symbol: string;
constructor(
symbol: string,
);
}
// Emitted for code like
//
// ```text
// a = return
// ```
export class VoidValueExpression {
constructor(
);
}
}
export namespace tokens {
export const id_to_name: { [K in number]: string };
export const name_to_id: { [K in string]: number };
}