From 0e7fb6b868c1082b89d0c2c3788ed7568fbcb809 Mon Sep 17 00:00:00 2001 From: Kevin Newton Date: Fri, 6 Mar 2026 20:41:27 -0500 Subject: [PATCH 1/2] Copy and embed for serialization format --- docs/serialization.md | 15 ++---- javascript/src/parsePrism.js | 2 +- .../java/org/ruby_lang/prism/Loader.java.erb | 40 ++++---------- templates/javascript/src/deserialize.js.erb | 31 +++-------- templates/lib/prism/serialize.rb.erb | 38 ++++--------- templates/src/serialize.c.erb | 54 ++++--------------- 6 files changed, 39 insertions(+), 141 deletions(-) diff --git a/docs/serialization.md b/docs/serialization.md index ec395f8847..8c1b47c690 100644 --- a/docs/serialization.md +++ b/docs/serialization.md @@ -126,7 +126,7 @@ Every field on the node is then appended to the serialized string. The fields ca * `node` - A field that is a node. This is structured just as like parent node. * `node?` - A field that is a node that is optionally present. If the node is not present, then a single `0` byte will be written in its place. If it is present, then it will be structured just as like parent node. * `node[]` - A field that is an array of nodes. This is structured as a variable-length integer length, followed by the child nodes themselves. -* `string` - A field that is a string. For example, this is used as the name of the method in a call node, since it cannot directly reference the source string (as in `@-` or `foo=`). This is structured as a variable-length integer byte length, followed by the string itself (_without_ a trailing null byte). +* `string` - A field that is a string. For example, this is used as the name of the method in a call node, since it cannot directly reference the source string (as in `@-` or `foo=`). This is structured as a variable-length integer byte length, followed by the string bytes (_without_ a trailing null byte). * `constant` - A variable-length integer that represents an index in the constant pool. * `constant?` - An optional variable-length integer that represents an index in the constant pool. If it's not present, then a single `0` byte will be written in its place. * `integer` - A field that represents an arbitrary-sized integer. The structure is listed above. @@ -135,23 +135,14 @@ Every field on the node is then appended to the serialized string. The fields ca * `uint8` - A field that is an 8-bit unsigned integer. This is structured as a single byte. * `uint32` - A field that is a 32-bit unsigned integer. This is structured as a variable-length integer. -After the syntax tree, the content pool is serialized. This is a list of constants that were referenced from within the tree. The content pool begins at the offset specified in the header. Constants can be either "owned" (in which case their contents are embedded in the serialization) or "shared" (in which case their contents represent a slice of the source string). The most significant bit of the constant indicates whether it is owned or shared. - -In the case that it is owned, the constant is structured as follows: +After the syntax tree, the content pool is serialized. This is a list of constants that were referenced from within the tree. The content pool begins at the offset specified in the header. Every constant is embedded in the serialization. Each constant is structured as follows: | # bytes | field | | --- | --- | | `4` | the byte offset in the serialization for the contents of the constant | | `4` | the byte length in the serialization | -Note that you will need to mask off the most significant bit for the byte offset in the serialization. In the case that it is shared, the constant is structured as follows: - -| # bytes | field | -| --- | --- | -| `4` | the byte offset in the source string for the contents of the constant | -| `4` | the byte length in the source string | - -After the constant pool, the contents of the owned constants are serialized. This is just a sequence of bytes that represent the contents of the constants. At the end of the serialization, the buffer is null terminated. +After the constant pool, the contents of the constants are serialized. This is just a sequence of bytes that represent the contents of the constants. At the end of the serialization, the buffer is null terminated. ## APIs diff --git a/javascript/src/parsePrism.js b/javascript/src/parsePrism.js index 38084da3f1..269f84c825 100644 --- a/javascript/src/parsePrism.js +++ b/javascript/src/parsePrism.js @@ -43,7 +43,7 @@ export function parsePrism(prism, source, options = {}) { prism.pm_serialize_parse(bufferPointer, sourcePointer, sourceArray.length, optionsPointer); const serializedView = new Uint8Array(prism.memory.buffer, prism.pm_buffer_value(bufferPointer), prism.pm_buffer_length(bufferPointer)); - const result = deserialize(sourceArray, serializedView); + const result = deserialize(serializedView); prism.pm_buffer_free(bufferPointer); prism.free(sourcePointer); diff --git a/templates/java/org/ruby_lang/prism/Loader.java.erb b/templates/java/org/ruby_lang/prism/Loader.java.erb index af47aeed73..b48dd4c1cb 100644 --- a/templates/java/org/ruby_lang/prism/Loader.java.erb +++ b/templates/java/org/ruby_lang/prism/Loader.java.erb @@ -40,13 +40,11 @@ public class Loader { private static final class ConstantPool { private final Loader loader; - private final byte[] source; private final int bufferOffset; private final <%= string_type %>[] cache; - ConstantPool(Loader loader, byte[] source, int bufferOffset, int length) { + ConstantPool(Loader loader, int bufferOffset, int length) { this.loader = loader; - this.source = source; this.bufferOffset = bufferOffset; cache = new <%= string_type %>[length]; } @@ -61,15 +59,10 @@ public class Loader { int length = buffer.getInt(offset + 4); byte[] bytes = new byte[length]; - - if (Integer.compareUnsigned(start, 0x7FFFFFFF) <= 0) { - System.arraycopy(source, start, bytes, 0, length); - } else { - int position = buffer.position(); - buffer.position(start & 0x7FFFFFFF); - buffer.get(bytes, 0, length); - buffer.position(position); - } + int position = buffer.position(); + buffer.position(start); + buffer.get(bytes, 0, length); + buffer.position(position); constant = loader.bytesToName(bytes); cache[index] = constant; @@ -125,7 +118,7 @@ public class Loader { int constantPoolBufferOffset = buffer.getInt(); int constantPoolLength = loadVarUInt(); - this.constantPool = new ConstantPool(this, source.bytes, constantPoolBufferOffset, constantPoolLength); + this.constantPool = new ConstantPool(this, constantPoolBufferOffset, constantPoolLength); Nodes.Node node; if (errors.length == 0) { @@ -146,28 +139,13 @@ public class Loader { return new ParseResult(node, magicComments, dataLocation, errors, warnings, source); } - private byte[] loadEmbeddedString() { + private byte[] loadString() { int length = loadVarUInt(); byte[] bytes = new byte[length]; buffer.get(bytes); return bytes; } - private byte[] loadString() { - switch (buffer.get()) { - case 1: - int start = loadVarUInt(); - int length = loadVarUInt(); - byte[] bytes = new byte[length]; - System.arraycopy(source.bytes, start, bytes, 0, length); - return bytes; - case 2: - return loadEmbeddedString(); - default: - throw new Error("Expected 0 or 1 but was " + buffer.get()); - } - } - private int[] loadLineOffsets() { int count = loadVarUInt(); int[] lineOffsets = new int[count]; @@ -199,7 +177,7 @@ public class Loader { // error messages only contain ASCII characters for (int i = 0; i < count; i++) { Nodes.ErrorType type = Nodes.ERROR_TYPES[loadVarUInt()]; - byte[] bytes = loadEmbeddedString(); + byte[] bytes = loadString(); String message = new String(bytes, StandardCharsets.US_ASCII); Nodes.Location location = loadLocation(); ParseResult.ErrorLevel level = ParseResult.ERROR_LEVELS[buffer.get()]; @@ -218,7 +196,7 @@ public class Loader { // warning messages only contain ASCII characters for (int i = 0; i < count; i++) { Nodes.WarningType type = Nodes.WARNING_TYPES[loadVarUInt() - <%= errors.length %>]; - byte[] bytes = loadEmbeddedString(); + byte[] bytes = loadString(); String message = new String(bytes, StandardCharsets.US_ASCII); Nodes.Location location = loadLocation(); ParseResult.WarningLevel level = ParseResult.WARNING_LEVELS[buffer.get()]; diff --git a/templates/javascript/src/deserialize.js.erb b/templates/javascript/src/deserialize.js.erb index 7aebee750c..2aeb142f8d 100644 --- a/templates/javascript/src/deserialize.js.erb +++ b/templates/javascript/src/deserialize.js.erb @@ -29,8 +29,7 @@ class SerializationBuffer { ["ascii-8bit", "ascii"] ]); - constructor(source, array) { - this.source = source; + constructor(array) { this.array = array; this.index = 0; this.fileEncoding = "utf-8"; @@ -96,32 +95,15 @@ class SerializationBuffer { readStringField(flags) { if (flags === undefined) flags = 0; - const type = this.readByte(); - - switch (type) { - case 1: { - const startOffset = this.readVarInt(); - const length = this.readVarInt(); - return this.decodeString(this.source.slice(startOffset, startOffset + length), flags); - } - case 2: - return this.decodeString(this.readBytes(this.readVarInt()), flags); - default: - throw new Error(`Unknown serialized string type: ${type}`); - } + return this.decodeString(this.readBytes(this.readVarInt()), flags); } scanConstant(constantPoolOffset, constantIndex) { const offset = constantPoolOffset + constantIndex * 8; - let startOffset = this.scanUint32(offset); + const startOffset = this.scanUint32(offset); const length = this.scanUint32(offset + 4); - if (startOffset & (1 << 31)) { - startOffset &= (1 << 31) - 1; - return new TextDecoder().decode(this.array.slice(startOffset, startOffset + length)); - } else { - return new TextDecoder().decode(this.source.slice(startOffset, startOffset + length)); - } + return this.getDecoder(this.fileEncoding).decode(this.array.slice(startOffset, startOffset + length)); } readDouble() { @@ -293,13 +275,12 @@ const warningTypes = [ * Accept two Uint8Arrays, one for the source and one for the serialized format. * Return the AST corresponding to the serialized form. * - * @param {Uint8Array} source * @param {Uint8Array} array * @returns {ParseResult} * @throws {Error} */ -export function deserialize(source, array) { - const buffer = new SerializationBuffer(source, array); +export function deserialize(array) { + const buffer = new SerializationBuffer(array); if (buffer.readString(5) !== "PRISM") { throw new Error("Invalid serialization"); diff --git a/templates/lib/prism/serialize.rb.erb b/templates/lib/prism/serialize.rb.erb index c336662f2c..4e61c89a89 100644 --- a/templates/lib/prism/serialize.rb.erb +++ b/templates/lib/prism/serialize.rb.erb @@ -46,7 +46,7 @@ module Prism cpool_base = loader.load_uint32 cpool_size = loader.load_varuint - constant_pool = ConstantPool.new(input, serialized, cpool_base, cpool_size) + constant_pool = ConstantPool.new(serialized, cpool_base, cpool_size) node = loader.load_node(constant_pool, encoding, freeze) #: ProgramNode loader.load_constant_pool(constant_pool) @@ -171,7 +171,7 @@ module Prism cpool_base = loader.load_uint32 cpool_size = loader.load_varuint - constant_pool = ConstantPool.new(input, serialized, cpool_base, cpool_size) + constant_pool = ConstantPool.new(serialized, cpool_base, cpool_size) node = loader.load_node(constant_pool, encoding, freeze) #: ProgramNode loader.load_constant_pool(constant_pool) @@ -202,14 +202,12 @@ module Prism class ConstantPool # :nodoc: attr_reader :size #: Integer - # @rbs @input: String # @rbs @serialized: String # @rbs @base: Integer # @rbs @pool: Array[Symbol?] - #: (String input, String serialized, Integer base, Integer size) -> void - def initialize(input, serialized, base, size) - @input = input + #: (String serialized, Integer base, Integer size) -> void + def initialize(serialized, base, size) @serialized = serialized @base = base @size = size @@ -224,11 +222,7 @@ module Prism start = @serialized.unpack1("L", offset: offset) #: Integer length = @serialized.unpack1("L", offset: offset + 4) #: Integer - if start.nobits?(1 << 31) - (@input.byteslice(start, length) or raise).force_encoding(encoding).to_sym - else - (@serialized.byteslice(start & ((1 << 31) - 1), length) or raise).force_encoding(encoding).to_sym - end + (@serialized.byteslice(start, length) or raise).force_encoding(encoding).to_sym end end end @@ -289,8 +283,8 @@ module Prism trailer = 0 constant_pool.size.times do |index| - start, length = (io.read(8) or raise).unpack("L2") #: [Integer, Integer] - trailer += length if start.anybits?(1 << 31) + length = (io.read(8) or raise).unpack1("L", offset: 4) #: Integer + trailer += length end io.read(trailer) @@ -388,7 +382,7 @@ module Prism error = ParseError.new( DIAGNOSTIC_TYPES.fetch(load_varuint), - load_embedded_string(encoding), + load_string(encoding), load_location_object(freeze), load_error_level ) @@ -422,7 +416,7 @@ module Prism warning = ParseWarning.new( DIAGNOSTIC_TYPES.fetch(load_varuint), - load_embedded_string(encoding), + load_string(encoding), load_location_object(freeze), load_warning_level ) @@ -507,21 +501,9 @@ module Prism end end - #: (Encoding encoding) -> String - def load_embedded_string(encoding) - (io.read(load_varuint) or raise).force_encoding(encoding).freeze - end - #: (Encoding encoding) -> String def load_string(encoding) - case (type = io.getbyte) - when 1 - (input.byteslice(load_varuint, load_varuint) or raise).force_encoding(encoding).freeze - when 2 - load_embedded_string(encoding) - else - raise "Unknown serialized string type: #{type}" - end + (io.read(load_varuint) or raise).force_encoding(encoding).freeze end #: (bool freeze) -> Location diff --git a/templates/src/serialize.c.erb b/templates/src/serialize.c.erb index e58bb81f0a..4fe0cb88c1 100644 --- a/templates/src/serialize.c.erb +++ b/templates/src/serialize.c.erb @@ -26,28 +26,10 @@ pm_serialize_location(const pm_location_t *location, pm_buffer_t *buffer) { } static void -pm_serialize_string(const pm_parser_t *parser, const pm_string_t *string, pm_buffer_t *buffer) { - switch (string->type) { - case PM_STRING_SHARED: { - pm_buffer_append_byte(buffer, 1); - pm_buffer_append_varuint(buffer, pm_ptrdifft_to_u32(pm_string_source(string) - parser->start)); - pm_buffer_append_varuint(buffer, pm_sizet_to_u32(pm_string_length(string))); - break; - } - case PM_STRING_OWNED: - case PM_STRING_CONSTANT: { - uint32_t length = pm_sizet_to_u32(pm_string_length(string)); - pm_buffer_append_byte(buffer, 2); - pm_buffer_append_varuint(buffer, length); - pm_buffer_append_bytes(buffer, pm_string_source(string), length); - break; - } -#ifdef PRISM_HAS_MMAP - case PM_STRING_MAPPED: - assert(false && "Cannot serialize mapped strings."); - break; -#endif - } +pm_serialize_string(const pm_string_t *string, pm_buffer_t *buffer) { + uint32_t length = pm_sizet_to_u32(pm_string_length(string)); + pm_buffer_append_varuint(buffer, length); + pm_buffer_append_bytes(buffer, pm_string_source(string), length); } static void @@ -102,7 +84,7 @@ pm_serialize_node(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) { pm_serialize_node(parser, (pm_node_t *)((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); } <%- when Prism::Template::StringField -%> - pm_serialize_string(parser, &((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); + pm_serialize_string(&((pm_<%= node.human %>_t *)node)-><%= field.name %>, buffer); <%- when Prism::Template::NodeListField -%> uint32_t <%= field.name %>_size = pm_sizet_to_u32(((pm_<%= node.human %>_t *)node)-><%= field.name %>.size); pm_buffer_append_varuint(buffer, <%= field.name %>_size); @@ -304,28 +286,12 @@ pm_serialize_content(pm_parser_t *parser, pm_node_t *node, pm_buffer_t *buffer) pm_constant_t *constant = &parser->constant_pool.constants[bucket->id - 1]; size_t buffer_offset = offset + ((((size_t)bucket->id) - 1) * 8); - if (bucket->type == PM_CONSTANT_POOL_BUCKET_OWNED || bucket->type == PM_CONSTANT_POOL_BUCKET_CONSTANT) { - // Since this is an owned or constant constant, we are going to - // write its contents into the buffer after the constant pool. - // So effectively in place of the source offset, we have a - // buffer offset. We will add a leading 1 to indicate that this - // is a buffer offset. - uint32_t content_offset = pm_sizet_to_u32(buffer->length); - uint32_t owned_mask = 1U << 31; - - assert(content_offset < owned_mask); - content_offset |= owned_mask; - - memcpy(buffer->value + buffer_offset, &content_offset, 4); - pm_buffer_append_bytes(buffer, constant->start, constant->length); - } else { - // Since this is a shared constant, we are going to write its - // source offset directly into the buffer. - uint32_t source_offset = pm_ptrdifft_to_u32(constant->start - parser->start); - memcpy(buffer->value + buffer_offset, &source_offset, 4); - } + // Write the constant contents into the buffer after the constant + // pool. In place of the source offset, we store a buffer offset. + uint32_t content_offset = pm_sizet_to_u32(buffer->length); + memcpy(buffer->value + buffer_offset, &content_offset, 4); + pm_buffer_append_bytes(buffer, constant->start, constant->length); - // Now we can write the length of the constant into the buffer. uint32_t constant_length = pm_sizet_to_u32(constant->length); memcpy(buffer->value + buffer_offset + 4, &constant_length, 4); } From 1b492aa3c8f1b40815a0d575887dc30094aa7ef2 Mon Sep 17 00:00:00 2001 From: Kevin Newton Date: Sun, 8 Mar 2026 10:52:26 -0400 Subject: [PATCH 2/2] Update types --- rakelib/typecheck.rake | 3 + rbi/generated/prism.rbi | 36 +- rbi/generated/prism/compiler.rbi | 310 +- rbi/generated/prism/desugar_compiler.rbi | 24 +- rbi/generated/prism/dispatcher.rbi | 14 +- rbi/generated/prism/dot_visitor.rbi | 20 +- rbi/generated/prism/dsl.rbi | 148 +- rbi/generated/prism/inspect_visitor.rbi | 4 +- rbi/generated/prism/lex_compat.rbi | 38 +- rbi/generated/prism/mutation_compiler.rbi | 304 +- rbi/generated/prism/node.rbi | 3504 ++++++++--------- rbi/generated/prism/node_ext.rbi | 30 +- rbi/generated/prism/parse_result.rbi | 50 +- rbi/generated/prism/parse_result/comments.rbi | 2 +- rbi/generated/prism/pattern.rbi | 6 +- rbi/generated/prism/reflection.rbi | 2 +- rbi/generated/prism/relocation.rbi | 66 +- rbi/generated/prism/serialize.rbi | 19 +- rbi/generated/prism/visitor.rbi | 4 +- sig/generated/prism/parse_result.rbs | 2 + sig/generated/prism/serialize.rbs | 9 +- 21 files changed, 2296 insertions(+), 2299 deletions(-) diff --git a/rakelib/typecheck.rake b/rakelib/typecheck.rake index be18cc3b25..69bd4a0078 100644 --- a/rakelib/typecheck.rake +++ b/rakelib/typecheck.rake @@ -345,11 +345,14 @@ namespace :typecheck do desc "Typecheck with Sorbet" task sorbet: :templates do + require "fileutils" + locals = { polyfills: Dir["lib/prism/polyfill/**/*.rb"], gem_rbis: Dir["sorbet/rbi/**/*.rbi"] } + FileUtils.mkdir_p("sorbet") File.write("sorbet/typed_overrides.yml", ERB.new(<<~YAML, trim_mode: "-").result_with_hash(locals)) false: - ./lib/prism/lex_compat.rb diff --git a/rbi/generated/prism.rbi b/rbi/generated/prism.rbi index 355ebd2073..037c50382c 100644 --- a/rbi/generated/prism.rbi +++ b/rbi/generated/prism.rbi @@ -16,7 +16,7 @@ module Prism # resembles the return value of Ripper.lex. # # For supported options, see Prism.parse. - sig { params(source: String, options: T.untyped).returns(LexCompat::Result) } + sig { params(source: String, options: ::T.untyped).returns(LexCompat::Result) } def self.lex_compat(source, **options); end # Load the serialized AST using the source as a reference into a tree. @@ -26,54 +26,54 @@ module Prism VERSION = T.let(nil, String) BACKEND = T.let(nil, Symbol) - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } def self.parse(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).void } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).void } def self.profile(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } def self.lex(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } def self.parse_lex(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } def self.dump(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } def self.parse_comments(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } def self.parse_success?(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(source: String, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(source: String, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } def self.parse_failure?(source, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(stream: T.untyped, filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } + sig { params(stream: ::T.untyped, filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } def self.parse_stream(stream, filepath: T.unsafe(nil), command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseResult) } def self.parse_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).void } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).void } def self.profile_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(LexResult) } def self.lex_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(ParseLexResult) } def self.parse_lex_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(String) } def self.dump_file(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Array[Comment]) } def self.parse_file_comments(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } def self.parse_file_success?(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end - sig { params(filepath: String, command_line: String, encoding: T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } + sig { params(filepath: String, command_line: String, encoding: ::T.any(Encoding, FalseClass), freeze: T::Boolean, frozen_string_literal: T::Boolean, line: Integer, main_script: T::Boolean, partial_script: T::Boolean, scopes: T::Array[T::Array[Symbol]], version: String).returns(T::Boolean) } def self.parse_file_failure?(filepath, command_line: T.unsafe(nil), encoding: T.unsafe(nil), freeze: T.unsafe(nil), frozen_string_literal: T.unsafe(nil), line: T.unsafe(nil), main_script: T.unsafe(nil), partial_script: T.unsafe(nil), scopes: T.unsafe(nil), version: T.unsafe(nil)); end end diff --git a/rbi/generated/prism/compiler.rbi b/rbi/generated/prism/compiler.rbi index 4a47221123..af86919953 100644 --- a/rbi/generated/prism/compiler.rbi +++ b/rbi/generated/prism/compiler.rbi @@ -19,471 +19,471 @@ module Prism # # => [:program, [[[:call, [[:integer], [:arguments, [[:integer]]]]]]]] class Compiler < Visitor # Visit an individual node. - sig { params(arg0: T.nilable(Node)).returns(T.untyped) } + sig { params(arg0: ::T.nilable(Node)).returns(::T.untyped) } def visit(arg0); end # Visit a list of nodes. - sig { params(arg0: T::Array[T.nilable(Node)]).returns(T.untyped) } + sig { params(arg0: T::Array[::T.nilable(Node)]).returns(::T.untyped) } def visit_all(arg0); end # Visit the child nodes of the given node. - sig { params(arg0: Node).returns(T::Array[T.untyped]) } + sig { params(arg0: Node).returns(T::Array[::T.untyped]) } def visit_child_nodes(arg0); end - sig { params(arg0: AliasGlobalVariableNode).returns(T::Array[T.untyped]) } + sig { params(arg0: AliasGlobalVariableNode).returns(T::Array[::T.untyped]) } def visit_alias_global_variable_node(arg0); end - sig { params(arg0: AliasMethodNode).returns(T::Array[T.untyped]) } + sig { params(arg0: AliasMethodNode).returns(T::Array[::T.untyped]) } def visit_alias_method_node(arg0); end - sig { params(arg0: AlternationPatternNode).returns(T::Array[T.untyped]) } + sig { params(arg0: AlternationPatternNode).returns(T::Array[::T.untyped]) } def visit_alternation_pattern_node(arg0); end - sig { params(arg0: AndNode).returns(T::Array[T.untyped]) } + sig { params(arg0: AndNode).returns(T::Array[::T.untyped]) } def visit_and_node(arg0); end - sig { params(arg0: ArgumentsNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ArgumentsNode).returns(T::Array[::T.untyped]) } def visit_arguments_node(arg0); end - sig { params(arg0: ArrayNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ArrayNode).returns(T::Array[::T.untyped]) } def visit_array_node(arg0); end - sig { params(arg0: ArrayPatternNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ArrayPatternNode).returns(T::Array[::T.untyped]) } def visit_array_pattern_node(arg0); end - sig { params(arg0: AssocNode).returns(T::Array[T.untyped]) } + sig { params(arg0: AssocNode).returns(T::Array[::T.untyped]) } def visit_assoc_node(arg0); end - sig { params(arg0: AssocSplatNode).returns(T::Array[T.untyped]) } + sig { params(arg0: AssocSplatNode).returns(T::Array[::T.untyped]) } def visit_assoc_splat_node(arg0); end - sig { params(arg0: BackReferenceReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BackReferenceReadNode).returns(T::Array[::T.untyped]) } def visit_back_reference_read_node(arg0); end - sig { params(arg0: BeginNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BeginNode).returns(T::Array[::T.untyped]) } def visit_begin_node(arg0); end - sig { params(arg0: BlockArgumentNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BlockArgumentNode).returns(T::Array[::T.untyped]) } def visit_block_argument_node(arg0); end - sig { params(arg0: BlockLocalVariableNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BlockLocalVariableNode).returns(T::Array[::T.untyped]) } def visit_block_local_variable_node(arg0); end - sig { params(arg0: BlockNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BlockNode).returns(T::Array[::T.untyped]) } def visit_block_node(arg0); end - sig { params(arg0: BlockParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BlockParameterNode).returns(T::Array[::T.untyped]) } def visit_block_parameter_node(arg0); end - sig { params(arg0: BlockParametersNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BlockParametersNode).returns(T::Array[::T.untyped]) } def visit_block_parameters_node(arg0); end - sig { params(arg0: BreakNode).returns(T::Array[T.untyped]) } + sig { params(arg0: BreakNode).returns(T::Array[::T.untyped]) } def visit_break_node(arg0); end - sig { params(arg0: CallAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CallAndWriteNode).returns(T::Array[::T.untyped]) } def visit_call_and_write_node(arg0); end - sig { params(arg0: CallNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CallNode).returns(T::Array[::T.untyped]) } def visit_call_node(arg0); end - sig { params(arg0: CallOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CallOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_call_operator_write_node(arg0); end - sig { params(arg0: CallOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CallOrWriteNode).returns(T::Array[::T.untyped]) } def visit_call_or_write_node(arg0); end - sig { params(arg0: CallTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CallTargetNode).returns(T::Array[::T.untyped]) } def visit_call_target_node(arg0); end - sig { params(arg0: CapturePatternNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CapturePatternNode).returns(T::Array[::T.untyped]) } def visit_capture_pattern_node(arg0); end - sig { params(arg0: CaseMatchNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CaseMatchNode).returns(T::Array[::T.untyped]) } def visit_case_match_node(arg0); end - sig { params(arg0: CaseNode).returns(T::Array[T.untyped]) } + sig { params(arg0: CaseNode).returns(T::Array[::T.untyped]) } def visit_case_node(arg0); end - sig { params(arg0: ClassNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ClassNode).returns(T::Array[::T.untyped]) } def visit_class_node(arg0); end - sig { params(arg0: ClassVariableAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ClassVariableAndWriteNode).returns(T::Array[::T.untyped]) } def visit_class_variable_and_write_node(arg0); end - sig { params(arg0: ClassVariableOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ClassVariableOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_class_variable_operator_write_node(arg0); end - sig { params(arg0: ClassVariableOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ClassVariableOrWriteNode).returns(T::Array[::T.untyped]) } def visit_class_variable_or_write_node(arg0); end - sig { params(arg0: ClassVariableReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ClassVariableReadNode).returns(T::Array[::T.untyped]) } def visit_class_variable_read_node(arg0); end - sig { params(arg0: ClassVariableTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ClassVariableTargetNode).returns(T::Array[::T.untyped]) } def visit_class_variable_target_node(arg0); end - sig { params(arg0: ClassVariableWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ClassVariableWriteNode).returns(T::Array[::T.untyped]) } def visit_class_variable_write_node(arg0); end - sig { params(arg0: ConstantAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantAndWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_and_write_node(arg0); end - sig { params(arg0: ConstantOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_operator_write_node(arg0); end - sig { params(arg0: ConstantOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantOrWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_or_write_node(arg0); end - sig { params(arg0: ConstantPathAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantPathAndWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_path_and_write_node(arg0); end - sig { params(arg0: ConstantPathNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantPathNode).returns(T::Array[::T.untyped]) } def visit_constant_path_node(arg0); end - sig { params(arg0: ConstantPathOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantPathOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_path_operator_write_node(arg0); end - sig { params(arg0: ConstantPathOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantPathOrWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_path_or_write_node(arg0); end - sig { params(arg0: ConstantPathTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantPathTargetNode).returns(T::Array[::T.untyped]) } def visit_constant_path_target_node(arg0); end - sig { params(arg0: ConstantPathWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantPathWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_path_write_node(arg0); end - sig { params(arg0: ConstantReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantReadNode).returns(T::Array[::T.untyped]) } def visit_constant_read_node(arg0); end - sig { params(arg0: ConstantTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantTargetNode).returns(T::Array[::T.untyped]) } def visit_constant_target_node(arg0); end - sig { params(arg0: ConstantWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ConstantWriteNode).returns(T::Array[::T.untyped]) } def visit_constant_write_node(arg0); end - sig { params(arg0: DefNode).returns(T::Array[T.untyped]) } + sig { params(arg0: DefNode).returns(T::Array[::T.untyped]) } def visit_def_node(arg0); end - sig { params(arg0: DefinedNode).returns(T::Array[T.untyped]) } + sig { params(arg0: DefinedNode).returns(T::Array[::T.untyped]) } def visit_defined_node(arg0); end - sig { params(arg0: ElseNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ElseNode).returns(T::Array[::T.untyped]) } def visit_else_node(arg0); end - sig { params(arg0: EmbeddedStatementsNode).returns(T::Array[T.untyped]) } + sig { params(arg0: EmbeddedStatementsNode).returns(T::Array[::T.untyped]) } def visit_embedded_statements_node(arg0); end - sig { params(arg0: EmbeddedVariableNode).returns(T::Array[T.untyped]) } + sig { params(arg0: EmbeddedVariableNode).returns(T::Array[::T.untyped]) } def visit_embedded_variable_node(arg0); end - sig { params(arg0: EnsureNode).returns(T::Array[T.untyped]) } + sig { params(arg0: EnsureNode).returns(T::Array[::T.untyped]) } def visit_ensure_node(arg0); end - sig { params(arg0: FalseNode).returns(T::Array[T.untyped]) } + sig { params(arg0: FalseNode).returns(T::Array[::T.untyped]) } def visit_false_node(arg0); end - sig { params(arg0: FindPatternNode).returns(T::Array[T.untyped]) } + sig { params(arg0: FindPatternNode).returns(T::Array[::T.untyped]) } def visit_find_pattern_node(arg0); end - sig { params(arg0: FlipFlopNode).returns(T::Array[T.untyped]) } + sig { params(arg0: FlipFlopNode).returns(T::Array[::T.untyped]) } def visit_flip_flop_node(arg0); end - sig { params(arg0: FloatNode).returns(T::Array[T.untyped]) } + sig { params(arg0: FloatNode).returns(T::Array[::T.untyped]) } def visit_float_node(arg0); end - sig { params(arg0: ForNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ForNode).returns(T::Array[::T.untyped]) } def visit_for_node(arg0); end - sig { params(arg0: ForwardingArgumentsNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ForwardingArgumentsNode).returns(T::Array[::T.untyped]) } def visit_forwarding_arguments_node(arg0); end - sig { params(arg0: ForwardingParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ForwardingParameterNode).returns(T::Array[::T.untyped]) } def visit_forwarding_parameter_node(arg0); end - sig { params(arg0: ForwardingSuperNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ForwardingSuperNode).returns(T::Array[::T.untyped]) } def visit_forwarding_super_node(arg0); end - sig { params(arg0: GlobalVariableAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: GlobalVariableAndWriteNode).returns(T::Array[::T.untyped]) } def visit_global_variable_and_write_node(arg0); end - sig { params(arg0: GlobalVariableOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: GlobalVariableOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_global_variable_operator_write_node(arg0); end - sig { params(arg0: GlobalVariableOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: GlobalVariableOrWriteNode).returns(T::Array[::T.untyped]) } def visit_global_variable_or_write_node(arg0); end - sig { params(arg0: GlobalVariableReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: GlobalVariableReadNode).returns(T::Array[::T.untyped]) } def visit_global_variable_read_node(arg0); end - sig { params(arg0: GlobalVariableTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: GlobalVariableTargetNode).returns(T::Array[::T.untyped]) } def visit_global_variable_target_node(arg0); end - sig { params(arg0: GlobalVariableWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: GlobalVariableWriteNode).returns(T::Array[::T.untyped]) } def visit_global_variable_write_node(arg0); end - sig { params(arg0: HashNode).returns(T::Array[T.untyped]) } + sig { params(arg0: HashNode).returns(T::Array[::T.untyped]) } def visit_hash_node(arg0); end - sig { params(arg0: HashPatternNode).returns(T::Array[T.untyped]) } + sig { params(arg0: HashPatternNode).returns(T::Array[::T.untyped]) } def visit_hash_pattern_node(arg0); end - sig { params(arg0: IfNode).returns(T::Array[T.untyped]) } + sig { params(arg0: IfNode).returns(T::Array[::T.untyped]) } def visit_if_node(arg0); end - sig { params(arg0: ImaginaryNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ImaginaryNode).returns(T::Array[::T.untyped]) } def visit_imaginary_node(arg0); end - sig { params(arg0: ImplicitNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ImplicitNode).returns(T::Array[::T.untyped]) } def visit_implicit_node(arg0); end - sig { params(arg0: ImplicitRestNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ImplicitRestNode).returns(T::Array[::T.untyped]) } def visit_implicit_rest_node(arg0); end - sig { params(arg0: InNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InNode).returns(T::Array[::T.untyped]) } def visit_in_node(arg0); end - sig { params(arg0: IndexAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: IndexAndWriteNode).returns(T::Array[::T.untyped]) } def visit_index_and_write_node(arg0); end - sig { params(arg0: IndexOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: IndexOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_index_operator_write_node(arg0); end - sig { params(arg0: IndexOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: IndexOrWriteNode).returns(T::Array[::T.untyped]) } def visit_index_or_write_node(arg0); end - sig { params(arg0: IndexTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: IndexTargetNode).returns(T::Array[::T.untyped]) } def visit_index_target_node(arg0); end - sig { params(arg0: InstanceVariableAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InstanceVariableAndWriteNode).returns(T::Array[::T.untyped]) } def visit_instance_variable_and_write_node(arg0); end - sig { params(arg0: InstanceVariableOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InstanceVariableOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_instance_variable_operator_write_node(arg0); end - sig { params(arg0: InstanceVariableOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InstanceVariableOrWriteNode).returns(T::Array[::T.untyped]) } def visit_instance_variable_or_write_node(arg0); end - sig { params(arg0: InstanceVariableReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InstanceVariableReadNode).returns(T::Array[::T.untyped]) } def visit_instance_variable_read_node(arg0); end - sig { params(arg0: InstanceVariableTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InstanceVariableTargetNode).returns(T::Array[::T.untyped]) } def visit_instance_variable_target_node(arg0); end - sig { params(arg0: InstanceVariableWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InstanceVariableWriteNode).returns(T::Array[::T.untyped]) } def visit_instance_variable_write_node(arg0); end - sig { params(arg0: IntegerNode).returns(T::Array[T.untyped]) } + sig { params(arg0: IntegerNode).returns(T::Array[::T.untyped]) } def visit_integer_node(arg0); end - sig { params(arg0: InterpolatedMatchLastLineNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InterpolatedMatchLastLineNode).returns(T::Array[::T.untyped]) } def visit_interpolated_match_last_line_node(arg0); end - sig { params(arg0: InterpolatedRegularExpressionNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InterpolatedRegularExpressionNode).returns(T::Array[::T.untyped]) } def visit_interpolated_regular_expression_node(arg0); end - sig { params(arg0: InterpolatedStringNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InterpolatedStringNode).returns(T::Array[::T.untyped]) } def visit_interpolated_string_node(arg0); end - sig { params(arg0: InterpolatedSymbolNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InterpolatedSymbolNode).returns(T::Array[::T.untyped]) } def visit_interpolated_symbol_node(arg0); end - sig { params(arg0: InterpolatedXStringNode).returns(T::Array[T.untyped]) } + sig { params(arg0: InterpolatedXStringNode).returns(T::Array[::T.untyped]) } def visit_interpolated_x_string_node(arg0); end - sig { params(arg0: ItLocalVariableReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ItLocalVariableReadNode).returns(T::Array[::T.untyped]) } def visit_it_local_variable_read_node(arg0); end - sig { params(arg0: ItParametersNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ItParametersNode).returns(T::Array[::T.untyped]) } def visit_it_parameters_node(arg0); end - sig { params(arg0: KeywordHashNode).returns(T::Array[T.untyped]) } + sig { params(arg0: KeywordHashNode).returns(T::Array[::T.untyped]) } def visit_keyword_hash_node(arg0); end - sig { params(arg0: KeywordRestParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: KeywordRestParameterNode).returns(T::Array[::T.untyped]) } def visit_keyword_rest_parameter_node(arg0); end - sig { params(arg0: LambdaNode).returns(T::Array[T.untyped]) } + sig { params(arg0: LambdaNode).returns(T::Array[::T.untyped]) } def visit_lambda_node(arg0); end - sig { params(arg0: LocalVariableAndWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: LocalVariableAndWriteNode).returns(T::Array[::T.untyped]) } def visit_local_variable_and_write_node(arg0); end - sig { params(arg0: LocalVariableOperatorWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: LocalVariableOperatorWriteNode).returns(T::Array[::T.untyped]) } def visit_local_variable_operator_write_node(arg0); end - sig { params(arg0: LocalVariableOrWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: LocalVariableOrWriteNode).returns(T::Array[::T.untyped]) } def visit_local_variable_or_write_node(arg0); end - sig { params(arg0: LocalVariableReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: LocalVariableReadNode).returns(T::Array[::T.untyped]) } def visit_local_variable_read_node(arg0); end - sig { params(arg0: LocalVariableTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: LocalVariableTargetNode).returns(T::Array[::T.untyped]) } def visit_local_variable_target_node(arg0); end - sig { params(arg0: LocalVariableWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: LocalVariableWriteNode).returns(T::Array[::T.untyped]) } def visit_local_variable_write_node(arg0); end - sig { params(arg0: MatchLastLineNode).returns(T::Array[T.untyped]) } + sig { params(arg0: MatchLastLineNode).returns(T::Array[::T.untyped]) } def visit_match_last_line_node(arg0); end - sig { params(arg0: MatchPredicateNode).returns(T::Array[T.untyped]) } + sig { params(arg0: MatchPredicateNode).returns(T::Array[::T.untyped]) } def visit_match_predicate_node(arg0); end - sig { params(arg0: MatchRequiredNode).returns(T::Array[T.untyped]) } + sig { params(arg0: MatchRequiredNode).returns(T::Array[::T.untyped]) } def visit_match_required_node(arg0); end - sig { params(arg0: MatchWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: MatchWriteNode).returns(T::Array[::T.untyped]) } def visit_match_write_node(arg0); end - sig { params(arg0: MissingNode).returns(T::Array[T.untyped]) } + sig { params(arg0: MissingNode).returns(T::Array[::T.untyped]) } def visit_missing_node(arg0); end - sig { params(arg0: ModuleNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ModuleNode).returns(T::Array[::T.untyped]) } def visit_module_node(arg0); end - sig { params(arg0: MultiTargetNode).returns(T::Array[T.untyped]) } + sig { params(arg0: MultiTargetNode).returns(T::Array[::T.untyped]) } def visit_multi_target_node(arg0); end - sig { params(arg0: MultiWriteNode).returns(T::Array[T.untyped]) } + sig { params(arg0: MultiWriteNode).returns(T::Array[::T.untyped]) } def visit_multi_write_node(arg0); end - sig { params(arg0: NextNode).returns(T::Array[T.untyped]) } + sig { params(arg0: NextNode).returns(T::Array[::T.untyped]) } def visit_next_node(arg0); end - sig { params(arg0: NilNode).returns(T::Array[T.untyped]) } + sig { params(arg0: NilNode).returns(T::Array[::T.untyped]) } def visit_nil_node(arg0); end - sig { params(arg0: NoBlockParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: NoBlockParameterNode).returns(T::Array[::T.untyped]) } def visit_no_block_parameter_node(arg0); end - sig { params(arg0: NoKeywordsParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: NoKeywordsParameterNode).returns(T::Array[::T.untyped]) } def visit_no_keywords_parameter_node(arg0); end - sig { params(arg0: NumberedParametersNode).returns(T::Array[T.untyped]) } + sig { params(arg0: NumberedParametersNode).returns(T::Array[::T.untyped]) } def visit_numbered_parameters_node(arg0); end - sig { params(arg0: NumberedReferenceReadNode).returns(T::Array[T.untyped]) } + sig { params(arg0: NumberedReferenceReadNode).returns(T::Array[::T.untyped]) } def visit_numbered_reference_read_node(arg0); end - sig { params(arg0: OptionalKeywordParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: OptionalKeywordParameterNode).returns(T::Array[::T.untyped]) } def visit_optional_keyword_parameter_node(arg0); end - sig { params(arg0: OptionalParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: OptionalParameterNode).returns(T::Array[::T.untyped]) } def visit_optional_parameter_node(arg0); end - sig { params(arg0: OrNode).returns(T::Array[T.untyped]) } + sig { params(arg0: OrNode).returns(T::Array[::T.untyped]) } def visit_or_node(arg0); end - sig { params(arg0: ParametersNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ParametersNode).returns(T::Array[::T.untyped]) } def visit_parameters_node(arg0); end - sig { params(arg0: ParenthesesNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ParenthesesNode).returns(T::Array[::T.untyped]) } def visit_parentheses_node(arg0); end - sig { params(arg0: PinnedExpressionNode).returns(T::Array[T.untyped]) } + sig { params(arg0: PinnedExpressionNode).returns(T::Array[::T.untyped]) } def visit_pinned_expression_node(arg0); end - sig { params(arg0: PinnedVariableNode).returns(T::Array[T.untyped]) } + sig { params(arg0: PinnedVariableNode).returns(T::Array[::T.untyped]) } def visit_pinned_variable_node(arg0); end - sig { params(arg0: PostExecutionNode).returns(T::Array[T.untyped]) } + sig { params(arg0: PostExecutionNode).returns(T::Array[::T.untyped]) } def visit_post_execution_node(arg0); end - sig { params(arg0: PreExecutionNode).returns(T::Array[T.untyped]) } + sig { params(arg0: PreExecutionNode).returns(T::Array[::T.untyped]) } def visit_pre_execution_node(arg0); end - sig { params(arg0: ProgramNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ProgramNode).returns(T::Array[::T.untyped]) } def visit_program_node(arg0); end - sig { params(arg0: RangeNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RangeNode).returns(T::Array[::T.untyped]) } def visit_range_node(arg0); end - sig { params(arg0: RationalNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RationalNode).returns(T::Array[::T.untyped]) } def visit_rational_node(arg0); end - sig { params(arg0: RedoNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RedoNode).returns(T::Array[::T.untyped]) } def visit_redo_node(arg0); end - sig { params(arg0: RegularExpressionNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RegularExpressionNode).returns(T::Array[::T.untyped]) } def visit_regular_expression_node(arg0); end - sig { params(arg0: RequiredKeywordParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RequiredKeywordParameterNode).returns(T::Array[::T.untyped]) } def visit_required_keyword_parameter_node(arg0); end - sig { params(arg0: RequiredParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RequiredParameterNode).returns(T::Array[::T.untyped]) } def visit_required_parameter_node(arg0); end - sig { params(arg0: RescueModifierNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RescueModifierNode).returns(T::Array[::T.untyped]) } def visit_rescue_modifier_node(arg0); end - sig { params(arg0: RescueNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RescueNode).returns(T::Array[::T.untyped]) } def visit_rescue_node(arg0); end - sig { params(arg0: RestParameterNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RestParameterNode).returns(T::Array[::T.untyped]) } def visit_rest_parameter_node(arg0); end - sig { params(arg0: RetryNode).returns(T::Array[T.untyped]) } + sig { params(arg0: RetryNode).returns(T::Array[::T.untyped]) } def visit_retry_node(arg0); end - sig { params(arg0: ReturnNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ReturnNode).returns(T::Array[::T.untyped]) } def visit_return_node(arg0); end - sig { params(arg0: SelfNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SelfNode).returns(T::Array[::T.untyped]) } def visit_self_node(arg0); end - sig { params(arg0: ShareableConstantNode).returns(T::Array[T.untyped]) } + sig { params(arg0: ShareableConstantNode).returns(T::Array[::T.untyped]) } def visit_shareable_constant_node(arg0); end - sig { params(arg0: SingletonClassNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SingletonClassNode).returns(T::Array[::T.untyped]) } def visit_singleton_class_node(arg0); end - sig { params(arg0: SourceEncodingNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SourceEncodingNode).returns(T::Array[::T.untyped]) } def visit_source_encoding_node(arg0); end - sig { params(arg0: SourceFileNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SourceFileNode).returns(T::Array[::T.untyped]) } def visit_source_file_node(arg0); end - sig { params(arg0: SourceLineNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SourceLineNode).returns(T::Array[::T.untyped]) } def visit_source_line_node(arg0); end - sig { params(arg0: SplatNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SplatNode).returns(T::Array[::T.untyped]) } def visit_splat_node(arg0); end - sig { params(arg0: StatementsNode).returns(T::Array[T.untyped]) } + sig { params(arg0: StatementsNode).returns(T::Array[::T.untyped]) } def visit_statements_node(arg0); end - sig { params(arg0: StringNode).returns(T::Array[T.untyped]) } + sig { params(arg0: StringNode).returns(T::Array[::T.untyped]) } def visit_string_node(arg0); end - sig { params(arg0: SuperNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SuperNode).returns(T::Array[::T.untyped]) } def visit_super_node(arg0); end - sig { params(arg0: SymbolNode).returns(T::Array[T.untyped]) } + sig { params(arg0: SymbolNode).returns(T::Array[::T.untyped]) } def visit_symbol_node(arg0); end - sig { params(arg0: TrueNode).returns(T::Array[T.untyped]) } + sig { params(arg0: TrueNode).returns(T::Array[::T.untyped]) } def visit_true_node(arg0); end - sig { params(arg0: UndefNode).returns(T::Array[T.untyped]) } + sig { params(arg0: UndefNode).returns(T::Array[::T.untyped]) } def visit_undef_node(arg0); end - sig { params(arg0: UnlessNode).returns(T::Array[T.untyped]) } + sig { params(arg0: UnlessNode).returns(T::Array[::T.untyped]) } def visit_unless_node(arg0); end - sig { params(arg0: UntilNode).returns(T::Array[T.untyped]) } + sig { params(arg0: UntilNode).returns(T::Array[::T.untyped]) } def visit_until_node(arg0); end - sig { params(arg0: WhenNode).returns(T::Array[T.untyped]) } + sig { params(arg0: WhenNode).returns(T::Array[::T.untyped]) } def visit_when_node(arg0); end - sig { params(arg0: WhileNode).returns(T::Array[T.untyped]) } + sig { params(arg0: WhileNode).returns(T::Array[::T.untyped]) } def visit_while_node(arg0); end - sig { params(arg0: XStringNode).returns(T::Array[T.untyped]) } + sig { params(arg0: XStringNode).returns(T::Array[::T.untyped]) } def visit_x_string_node(arg0); end - sig { params(arg0: YieldNode).returns(T::Array[T.untyped]) } + sig { params(arg0: YieldNode).returns(T::Array[::T.untyped]) } def visit_yield_node(arg0); end end end diff --git a/rbi/generated/prism/desugar_compiler.rbi b/rbi/generated/prism/desugar_compiler.rbi index 3e7c745cc9..167624b9b6 100644 --- a/rbi/generated/prism/desugar_compiler.rbi +++ b/rbi/generated/prism/desugar_compiler.rbi @@ -4,7 +4,7 @@ module Prism class DesugarAndWriteNode include DSL - sig { returns(T.any(ClassVariableAndWriteNode, ConstantAndWriteNode, GlobalVariableAndWriteNode, InstanceVariableAndWriteNode, LocalVariableAndWriteNode)) } + sig { returns(::T.any(ClassVariableAndWriteNode, ConstantAndWriteNode, GlobalVariableAndWriteNode, InstanceVariableAndWriteNode, LocalVariableAndWriteNode)) } attr_reader :node sig { returns(Source) } @@ -16,10 +16,10 @@ module Prism sig { returns(Symbol) } attr_reader :write_class - sig { returns(T::Hash[Symbol, T.untyped]) } + sig { returns(T::Hash[Symbol, ::T.untyped]) } attr_reader :arguments - sig { params(node: T.any(ClassVariableAndWriteNode, ConstantAndWriteNode, GlobalVariableAndWriteNode, InstanceVariableAndWriteNode, LocalVariableAndWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: T.untyped).void } + sig { params(node: ::T.any(ClassVariableAndWriteNode, ConstantAndWriteNode, GlobalVariableAndWriteNode, InstanceVariableAndWriteNode, LocalVariableAndWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: ::T.untyped).void } def initialize(node, default_source, read_class, write_class, **arguments); end # Desugar `x &&= y` to `x && x = y` @@ -30,7 +30,7 @@ module Prism class DesugarOrWriteDefinedNode include DSL - sig { returns(T.any(ClassVariableOrWriteNode, ConstantOrWriteNode, GlobalVariableOrWriteNode)) } + sig { returns(::T.any(ClassVariableOrWriteNode, ConstantOrWriteNode, GlobalVariableOrWriteNode)) } attr_reader :node sig { returns(Source) } @@ -42,10 +42,10 @@ module Prism sig { returns(Symbol) } attr_reader :write_class - sig { returns(T::Hash[Symbol, T.untyped]) } + sig { returns(T::Hash[Symbol, ::T.untyped]) } attr_reader :arguments - sig { params(node: T.any(ClassVariableOrWriteNode, ConstantOrWriteNode, GlobalVariableOrWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: T.untyped).void } + sig { params(node: ::T.any(ClassVariableOrWriteNode, ConstantOrWriteNode, GlobalVariableOrWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: ::T.untyped).void } def initialize(node, default_source, read_class, write_class, **arguments); end # Desugar `x ||= y` to `defined?(x) ? x : x = y` @@ -56,7 +56,7 @@ module Prism class DesugarOperatorWriteNode include DSL - sig { returns(T.any(ClassVariableOperatorWriteNode, ConstantOperatorWriteNode, GlobalVariableOperatorWriteNode, InstanceVariableOperatorWriteNode, LocalVariableOperatorWriteNode)) } + sig { returns(::T.any(ClassVariableOperatorWriteNode, ConstantOperatorWriteNode, GlobalVariableOperatorWriteNode, InstanceVariableOperatorWriteNode, LocalVariableOperatorWriteNode)) } attr_reader :node sig { returns(Source) } @@ -68,10 +68,10 @@ module Prism sig { returns(Symbol) } attr_reader :write_class - sig { returns(T::Hash[Symbol, T.untyped]) } + sig { returns(T::Hash[Symbol, ::T.untyped]) } attr_reader :arguments - sig { params(node: T.any(ClassVariableOperatorWriteNode, ConstantOperatorWriteNode, GlobalVariableOperatorWriteNode, InstanceVariableOperatorWriteNode, LocalVariableOperatorWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: T.untyped).void } + sig { params(node: ::T.any(ClassVariableOperatorWriteNode, ConstantOperatorWriteNode, GlobalVariableOperatorWriteNode, InstanceVariableOperatorWriteNode, LocalVariableOperatorWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: ::T.untyped).void } def initialize(node, default_source, read_class, write_class, **arguments); end # Desugar `x += y` to `x = x + y` @@ -82,7 +82,7 @@ module Prism class DesugarOrWriteNode include DSL - sig { returns(T.any(InstanceVariableOrWriteNode, LocalVariableOrWriteNode)) } + sig { returns(::T.any(InstanceVariableOrWriteNode, LocalVariableOrWriteNode)) } attr_reader :node sig { returns(Source) } @@ -94,10 +94,10 @@ module Prism sig { returns(Symbol) } attr_reader :write_class - sig { returns(T::Hash[Symbol, T.untyped]) } + sig { returns(T::Hash[Symbol, ::T.untyped]) } attr_reader :arguments - sig { params(node: T.any(InstanceVariableOrWriteNode, LocalVariableOrWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: T.untyped).void } + sig { params(node: ::T.any(InstanceVariableOrWriteNode, LocalVariableOrWriteNode), default_source: Source, read_class: Symbol, write_class: Symbol, arguments: ::T.untyped).void } def initialize(node, default_source, read_class, write_class, **arguments); end # Desugar `x ||= y` to `x || x = y` diff --git a/rbi/generated/prism/dispatcher.rbi b/rbi/generated/prism/dispatcher.rbi index 14ef40c9c1..2dfeedf26f 100644 --- a/rbi/generated/prism/dispatcher.rbi +++ b/rbi/generated/prism/dispatcher.rbi @@ -35,7 +35,7 @@ module Prism class Dispatcher < Visitor # A hash mapping event names to arrays of listeners that should be notified # when that event is fired. - sig { returns(T::Hash[Symbol, T::Array[T.untyped]]) } + sig { returns(T::Hash[Symbol, T::Array[::T.untyped]]) } attr_reader :listeners # Initialize a new dispatcher. @@ -43,20 +43,20 @@ module Prism def initialize; end # Register a listener for one or more events. - sig { params(arg0: T.untyped, args: Symbol).void } + sig { params(arg0: ::T.untyped, args: Symbol).void } def register(arg0, *args); end # Register all public methods of a listener that match the pattern # `on__(enter|leave)`. - sig { params(arg0: T.untyped).void } + sig { params(arg0: ::T.untyped).void } def register_public_methods(arg0); end # Register a listener for the given events. - sig { params(arg0: T.untyped, arg1: T::Array[Symbol]).void } + sig { params(arg0: ::T.untyped, arg1: T::Array[Symbol]).void } def register_events(arg0, arg1); end # Walks `root` dispatching events to all registered listeners. - sig { params(node: T.nilable(Node)).returns(T.untyped) } + sig { params(node: ::T.nilable(Node)).returns(::T.untyped) } def dispatch(node); end # Dispatches a single event for `node` to all registered listeners. @@ -520,10 +520,10 @@ module Prism def visit_yield_node(node); end class DispatchOnce < Visitor - sig { returns(T::Hash[Symbol, T::Array[T.untyped]]) } + sig { returns(T::Hash[Symbol, T::Array[::T.untyped]]) } attr_reader :listeners - sig { params(listeners: T::Hash[Symbol, T::Array[T.untyped]]).void } + sig { params(listeners: T::Hash[Symbol, T::Array[::T.untyped]]).void } def initialize(listeners); end # Dispatch enter and leave events for AliasGlobalVariableNode nodes. diff --git a/rbi/generated/prism/dot_visitor.rbi b/rbi/generated/prism/dot_visitor.rbi index 835dd112b6..d707be5a1a 100644 --- a/rbi/generated/prism/dot_visitor.rbi +++ b/rbi/generated/prism/dot_visitor.rbi @@ -8,13 +8,13 @@ module Prism sig { returns(String) } attr_reader :name - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } attr_reader :value sig { returns(T::Boolean) } attr_reader :port - sig { params(name: String, value: T.nilable(String), port: T::Boolean).void } + sig { params(name: String, value: ::T.nilable(String), port: T::Boolean).void } def initialize(name, value, port); end sig { returns(String) } @@ -31,7 +31,7 @@ module Prism sig { params(name: String).void } def initialize(name); end - sig { params(name: String, value: T.nilable(String), port: T::Boolean).void } + sig { params(name: String, value: ::T.nilable(String), port: T::Boolean).void } def field(name, value = T.unsafe(nil), port: T.unsafe(nil)); end sig { returns(String) } @@ -552,7 +552,7 @@ module Prism # Inspect a node that has call_node_flags flags to display the flags as a # comma-separated list. - sig { params(node: T.any(CallAndWriteNode, CallNode, CallOperatorWriteNode, CallOrWriteNode, CallTargetNode, IndexAndWriteNode, IndexOperatorWriteNode, IndexOrWriteNode, IndexTargetNode)).returns(String) } + sig { params(node: ::T.any(CallAndWriteNode, CallNode, CallOperatorWriteNode, CallOrWriteNode, CallTargetNode, IndexAndWriteNode, IndexOperatorWriteNode, IndexOrWriteNode, IndexTargetNode)).returns(String) } private def call_node_flags_inspect(node); end # Inspect a node that has encoding_flags flags to display the flags as a @@ -562,7 +562,7 @@ module Prism # Inspect a node that has integer_base_flags flags to display the flags as a # comma-separated list. - sig { params(node: T.any(IntegerNode, RationalNode)).returns(String) } + sig { params(node: ::T.any(IntegerNode, RationalNode)).returns(String) } private def integer_base_flags_inspect(node); end # Inspect a node that has interpolated_string_node_flags flags to display the flags as a @@ -577,12 +577,12 @@ module Prism # Inspect a node that has loop_flags flags to display the flags as a # comma-separated list. - sig { params(node: T.any(UntilNode, WhileNode)).returns(String) } + sig { params(node: ::T.any(UntilNode, WhileNode)).returns(String) } private def loop_flags_inspect(node); end # Inspect a node that has parameter_flags flags to display the flags as a # comma-separated list. - sig { params(node: T.any(BlockLocalVariableNode, BlockParameterNode, KeywordRestParameterNode, OptionalKeywordParameterNode, OptionalParameterNode, RequiredKeywordParameterNode, RequiredParameterNode, RestParameterNode)).returns(String) } + sig { params(node: ::T.any(BlockLocalVariableNode, BlockParameterNode, KeywordRestParameterNode, OptionalKeywordParameterNode, OptionalParameterNode, RequiredKeywordParameterNode, RequiredParameterNode, RestParameterNode)).returns(String) } private def parameter_flags_inspect(node); end # Inspect a node that has parentheses_node_flags flags to display the flags as a @@ -592,12 +592,12 @@ module Prism # Inspect a node that has range_flags flags to display the flags as a # comma-separated list. - sig { params(node: T.any(FlipFlopNode, RangeNode)).returns(String) } + sig { params(node: ::T.any(FlipFlopNode, RangeNode)).returns(String) } private def range_flags_inspect(node); end # Inspect a node that has regular_expression_flags flags to display the flags as a # comma-separated list. - sig { params(node: T.any(InterpolatedMatchLastLineNode, InterpolatedRegularExpressionNode, MatchLastLineNode, RegularExpressionNode)).returns(String) } + sig { params(node: ::T.any(InterpolatedMatchLastLineNode, InterpolatedRegularExpressionNode, MatchLastLineNode, RegularExpressionNode)).returns(String) } private def regular_expression_flags_inspect(node); end # Inspect a node that has shareable_constant_node_flags flags to display the flags as a @@ -607,7 +607,7 @@ module Prism # Inspect a node that has string_flags flags to display the flags as a # comma-separated list. - sig { params(node: T.any(SourceFileNode, StringNode)).returns(String) } + sig { params(node: ::T.any(SourceFileNode, StringNode)).returns(String) } private def string_flags_inspect(node); end # Inspect a node that has symbol_flags flags to display the flags as a diff --git a/rbi/generated/prism/dsl.rbi b/rbi/generated/prism/dsl.rbi index d03b4f5a47..ac4e68bfa7 100644 --- a/rbi/generated/prism/dsl.rbi +++ b/rbi/generated/prism/dsl.rbi @@ -62,11 +62,11 @@ module Prism def location(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end # Create a new AliasGlobalVariableNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode), old_name: T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode), keyword_loc: Location).returns(AliasGlobalVariableNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: ::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode), old_name: ::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode), keyword_loc: Location).returns(AliasGlobalVariableNode) } def alias_global_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new AliasMethodNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: T.any(SymbolNode, InterpolatedSymbolNode), old_name: T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode), keyword_loc: Location).returns(AliasMethodNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: ::T.any(SymbolNode, InterpolatedSymbolNode), old_name: ::T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode), keyword_loc: Location).returns(AliasMethodNode) } def alias_method_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new AlternationPatternNode node. @@ -82,19 +82,19 @@ module Prism def arguments_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil)); end # Create a new ArrayNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(ArrayNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[Node], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(ArrayNode) } def array_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new ArrayPatternNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), requireds: T::Array[Node], rest: T.nilable(Node), posts: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(ArrayPatternNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), requireds: T::Array[Node], rest: ::T.nilable(Node), posts: T::Array[Node], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(ArrayPatternNode) } def array_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new AssocNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, key: Node, value: Node, operator_loc: T.nilable(Location)).returns(AssocNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, key: Node, value: Node, operator_loc: ::T.nilable(Location)).returns(AssocNode) } def assoc_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new AssocSplatNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: T.nilable(Node), operator_loc: Location).returns(AssocSplatNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: ::T.nilable(Node), operator_loc: Location).returns(AssocSplatNode) } def assoc_splat_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new BackReferenceReadNode node. @@ -102,11 +102,11 @@ module Prism def back_reference_read_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end # Create a new BeginNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, begin_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), rescue_clause: T.nilable(RescueNode), else_clause: T.nilable(ElseNode), ensure_clause: T.nilable(EnsureNode), end_keyword_loc: T.nilable(Location)).returns(BeginNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, begin_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), rescue_clause: ::T.nilable(RescueNode), else_clause: ::T.nilable(ElseNode), ensure_clause: ::T.nilable(EnsureNode), end_keyword_loc: ::T.nilable(Location)).returns(BeginNode) } def begin_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new BlockArgumentNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, expression: T.nilable(Node), operator_loc: Location).returns(BlockArgumentNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, expression: ::T.nilable(Node), operator_loc: Location).returns(BlockArgumentNode) } def block_argument_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new BlockLocalVariableNode node. @@ -114,35 +114,35 @@ module Prism def block_local_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end # Create a new BlockNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], parameters: T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: T.nilable(T.any(StatementsNode, BeginNode)), opening_loc: Location, closing_loc: Location).returns(BlockNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], parameters: ::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), opening_loc: Location, closing_loc: Location).returns(BlockNode) } def block_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new BlockParameterNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).returns(BlockParameterNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).returns(BlockParameterNode) } def block_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new BlockParametersNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parameters: T.nilable(ParametersNode), locals: T::Array[BlockLocalVariableNode], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(BlockParametersNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parameters: ::T.nilable(ParametersNode), locals: T::Array[BlockLocalVariableNode], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(BlockParametersNode) } def block_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new BreakNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: T.nilable(ArgumentsNode), keyword_loc: Location).returns(BreakNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: ::T.nilable(ArgumentsNode), keyword_loc: Location).returns(BreakNode) } def break_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new CallAndWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallAndWriteNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallAndWriteNode) } def call_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new CallNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), name: Symbol, message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), equal_loc: T.nilable(Location), block: T.nilable(T.any(BlockNode, BlockArgumentNode))).returns(CallNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), name: Symbol, message_loc: ::T.nilable(Location), opening_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), closing_loc: ::T.nilable(Location), equal_loc: ::T.nilable(Location), block: ::T.nilable(::T.any(BlockNode, BlockArgumentNode))).returns(CallNode) } def call_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), block: T.unsafe(nil)); end # Create a new CallOperatorWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(CallOperatorWriteNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(CallOperatorWriteNode) } def call_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new CallOrWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallOrWriteNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallOrWriteNode) } def call_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new CallTargetNode node. @@ -154,15 +154,15 @@ module Prism def capture_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new CaseMatchNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: T.nilable(Node), conditions: T::Array[InNode], else_clause: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseMatchNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: ::T.nilable(Node), conditions: T::Array[InNode], else_clause: ::T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseMatchNode) } def case_match_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new CaseNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: T.nilable(Node), conditions: T::Array[WhenNode], else_clause: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: ::T.nilable(Node), conditions: T::Array[WhenNode], else_clause: ::T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseNode) } def case_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new ClassNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: T.any(ConstantReadNode, ConstantPathNode, CallNode), inheritance_operator_loc: T.nilable(Location), superclass: T.nilable(Node), body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ClassNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: ::T.any(ConstantReadNode, ConstantPathNode, CallNode), inheritance_operator_loc: ::T.nilable(Location), superclass: ::T.nilable(Node), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ClassNode) } def class_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end # Create a new ClassVariableAndWriteNode node. @@ -206,7 +206,7 @@ module Prism def constant_path_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new ConstantPathNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: T.nilable(Node), name: T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: ::T.nilable(Node), name: ::T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathNode) } def constant_path_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end # Create a new ConstantPathOperatorWriteNode node. @@ -218,7 +218,7 @@ module Prism def constant_path_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new ConstantPathTargetNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: T.nilable(Node), name: T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathTargetNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: ::T.nilable(Node), name: ::T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathTargetNode) } def constant_path_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end # Create a new ConstantPathWriteNode node. @@ -238,27 +238,27 @@ module Prism def constant_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new DefNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, receiver: T.nilable(Node), parameters: T.nilable(ParametersNode), body: T.nilable(T.any(StatementsNode, BeginNode)), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: T.nilable(Location), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), equal_loc: T.nilable(Location), end_keyword_loc: T.nilable(Location)).returns(DefNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, receiver: ::T.nilable(Node), parameters: ::T.nilable(ParametersNode), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: ::T.nilable(Location), lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location), equal_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location)).returns(DefNode) } def def_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new DefinedNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lparen_loc: T.nilable(Location), value: Node, rparen_loc: T.nilable(Location), keyword_loc: Location).returns(DefinedNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lparen_loc: ::T.nilable(Location), value: Node, rparen_loc: ::T.nilable(Location), keyword_loc: Location).returns(DefinedNode) } def defined_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new ElseNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, else_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: T.nilable(Location)).returns(ElseNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, else_keyword_loc: Location, statements: ::T.nilable(StatementsNode), end_keyword_loc: ::T.nilable(Location)).returns(ElseNode) } def else_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new EmbeddedStatementsNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, statements: T.nilable(StatementsNode), closing_loc: Location).returns(EmbeddedStatementsNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, statements: ::T.nilable(StatementsNode), closing_loc: Location).returns(EmbeddedStatementsNode) } def embedded_statements_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new EmbeddedVariableNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, variable: T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)).returns(EmbeddedVariableNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, variable: ::T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)).returns(EmbeddedVariableNode) } def embedded_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), variable: T.unsafe(nil)); end # Create a new EnsureNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, ensure_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: Location).returns(EnsureNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, ensure_keyword_loc: Location, statements: ::T.nilable(StatementsNode), end_keyword_loc: Location).returns(EnsureNode) } def ensure_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new FalseNode node. @@ -266,11 +266,11 @@ module Prism def false_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new FindPatternNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), left: SplatNode, requireds: T::Array[Node], right: T.any(SplatNode, MissingNode), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(FindPatternNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), left: SplatNode, requireds: T::Array[Node], right: ::T.any(SplatNode, MissingNode), opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(FindPatternNode) } def find_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new FlipFlopNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location).returns(FlipFlopNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: ::T.nilable(Node), right: ::T.nilable(Node), operator_loc: Location).returns(FlipFlopNode) } def flip_flop_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new FloatNode node. @@ -278,7 +278,7 @@ module Prism def float_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new ForNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, index: T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode), collection: Node, statements: T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: T.nilable(Location), end_keyword_loc: Location).returns(ForNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, index: ::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode), collection: Node, statements: ::T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: Location).returns(ForNode) } def for_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new ForwardingArgumentsNode node. @@ -290,7 +290,7 @@ module Prism def forwarding_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new ForwardingSuperNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, block: T.nilable(BlockNode)).returns(ForwardingSuperNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, block: ::T.nilable(BlockNode)).returns(ForwardingSuperNode) } def forwarding_super_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), block: T.unsafe(nil)); end # Create a new GlobalVariableAndWriteNode node. @@ -318,23 +318,23 @@ module Prism def global_variable_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new HashNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, elements: T::Array[T.any(AssocNode, AssocSplatNode)], closing_loc: Location).returns(HashNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, elements: T::Array[::T.any(AssocNode, AssocSplatNode)], closing_loc: Location).returns(HashNode) } def hash_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new HashPatternNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), elements: T::Array[AssocNode], rest: T.nilable(T.any(AssocSplatNode, NoKeywordsParameterNode)), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(HashPatternNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), elements: T::Array[AssocNode], rest: ::T.nilable(::T.any(AssocSplatNode, NoKeywordsParameterNode)), opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(HashPatternNode) } def hash_pattern_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new IfNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, if_keyword_loc: T.nilable(Location), predicate: Node, then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), subsequent: T.nilable(T.any(ElseNode, IfNode)), end_keyword_loc: T.nilable(Location)).returns(IfNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, if_keyword_loc: ::T.nilable(Location), predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), subsequent: ::T.nilable(::T.any(ElseNode, IfNode)), end_keyword_loc: ::T.nilable(Location)).returns(IfNode) } def if_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new ImaginaryNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, numeric: T.any(FloatNode, IntegerNode, RationalNode)).returns(ImaginaryNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, numeric: ::T.any(FloatNode, IntegerNode, RationalNode)).returns(ImaginaryNode) } def imaginary_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numeric: T.unsafe(nil)); end # Create a new ImplicitNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)).returns(ImplicitNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: ::T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)).returns(ImplicitNode) } def implicit_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new ImplicitRestNode node. @@ -342,23 +342,23 @@ module Prism def implicit_rest_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new InNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: T.nilable(StatementsNode), in_loc: Location, then_loc: T.nilable(Location)).returns(InNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_loc: Location, then_loc: ::T.nilable(Location)).returns(InNode) } def in_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end # Create a new IndexAndWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexAndWriteNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexAndWriteNode) } def index_and_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new IndexOperatorWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(IndexOperatorWriteNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(IndexOperatorWriteNode) } def index_operator_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new IndexOrWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexOrWriteNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexOrWriteNode) } def index_or_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new IndexTargetNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: Node, opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode)).returns(IndexTargetNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: Node, opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode)).returns(IndexTargetNode) } def index_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end # Create a new InstanceVariableAndWriteNode node. @@ -390,23 +390,23 @@ module Prism def integer_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new InterpolatedMatchLastLineNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedMatchLastLineNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedMatchLastLineNode) } def interpolated_match_last_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new InterpolatedRegularExpressionNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedRegularExpressionNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedRegularExpressionNode) } def interpolated_regular_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new InterpolatedStringNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)], closing_loc: T.nilable(Location)).returns(InterpolatedStringNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)], closing_loc: ::T.nilable(Location)).returns(InterpolatedStringNode) } def interpolated_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new InterpolatedSymbolNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: T.nilable(Location)).returns(InterpolatedSymbolNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: ::T.nilable(Location)).returns(InterpolatedSymbolNode) } def interpolated_symbol_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new InterpolatedXStringNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedXStringNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedXStringNode) } def interpolated_x_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new ItLocalVariableReadNode node. @@ -418,15 +418,15 @@ module Prism def it_parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new KeywordHashNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[T.any(AssocNode, AssocSplatNode)]).returns(KeywordHashNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[::T.any(AssocNode, AssocSplatNode)]).returns(KeywordHashNode) } def keyword_hash_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil)); end # Create a new KeywordRestParameterNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).returns(KeywordRestParameterNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).returns(KeywordRestParameterNode) } def keyword_rest_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new LambdaNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: T.nilable(T.any(StatementsNode, BeginNode))).returns(LambdaNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: ::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: ::T.nilable(::T.any(StatementsNode, BeginNode))).returns(LambdaNode) } def lambda_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil)); end # Create a new LocalVariableAndWriteNode node. @@ -474,19 +474,19 @@ module Prism def missing_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new ModuleNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: T.any(ConstantReadNode, ConstantPathNode, MissingNode), body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ModuleNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: ::T.any(ConstantReadNode, ConstantPathNode, MissingNode), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ModuleNode) } def module_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end # Create a new MultiTargetNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: T.nilable(T.any(ImplicitRestNode, SplatNode)), rights: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location)).returns(MultiTargetNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: ::T.nilable(::T.any(ImplicitRestNode, SplatNode)), rights: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location)).returns(MultiTargetNode) } def multi_target_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end # Create a new MultiWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: T.nilable(T.any(ImplicitRestNode, SplatNode)), rights: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), operator_loc: Location, value: Node).returns(MultiWriteNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: ::T.nilable(::T.any(ImplicitRestNode, SplatNode)), rights: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location), operator_loc: Location, value: Node).returns(MultiWriteNode) } def multi_write_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end # Create a new NextNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: T.nilable(ArgumentsNode), keyword_loc: Location).returns(NextNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: ::T.nilable(ArgumentsNode), keyword_loc: Location).returns(NextNode) } def next_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new NilNode node. @@ -522,11 +522,11 @@ module Prism def or_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new ParametersNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, requireds: T::Array[T.any(RequiredParameterNode, MultiTargetNode)], optionals: T::Array[OptionalParameterNode], rest: T.nilable(T.any(RestParameterNode, ImplicitRestNode)), posts: T::Array[T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)], keywords: T::Array[T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)], keyword_rest: T.nilable(T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode)), block: T.nilable(T.any(BlockParameterNode, NoBlockParameterNode))).returns(ParametersNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, requireds: T::Array[::T.any(RequiredParameterNode, MultiTargetNode)], optionals: T::Array[OptionalParameterNode], rest: ::T.nilable(::T.any(RestParameterNode, ImplicitRestNode)), posts: T::Array[::T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)], keywords: T::Array[::T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)], keyword_rest: ::T.nilable(::T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode)), block: ::T.nilable(::T.any(BlockParameterNode, NoBlockParameterNode))).returns(ParametersNode) } def parameters_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil)); end # Create a new ParenthesesNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, body: T.nilable(Node), opening_loc: Location, closing_loc: Location).returns(ParenthesesNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, body: ::T.nilable(Node), opening_loc: Location, closing_loc: Location).returns(ParenthesesNode) } def parentheses_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new PinnedExpressionNode node. @@ -534,15 +534,15 @@ module Prism def pinned_expression_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end # Create a new PinnedVariableNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, variable: T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode), operator_loc: Location).returns(PinnedVariableNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, variable: ::T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode), operator_loc: Location).returns(PinnedVariableNode) } def pinned_variable_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), variable: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new PostExecutionNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PostExecutionNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: ::T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PostExecutionNode) } def post_execution_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new PreExecutionNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PreExecutionNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: ::T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PreExecutionNode) } def pre_execution_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end # Create a new ProgramNode node. @@ -550,7 +550,7 @@ module Prism def program_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), statements: T.unsafe(nil)); end # Create a new RangeNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location).returns(RangeNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: ::T.nilable(Node), right: ::T.nilable(Node), operator_loc: Location).returns(RangeNode) } def range_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new RationalNode node. @@ -578,11 +578,11 @@ module Prism def rescue_modifier_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil)); end # Create a new RescueNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, exceptions: T::Array[Node], operator_loc: T.nilable(Location), reference: T.nilable(T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)), then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), subsequent: T.nilable(RescueNode)).returns(RescueNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, exceptions: T::Array[Node], operator_loc: ::T.nilable(Location), reference: ::T.nilable(::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)), then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), subsequent: ::T.nilable(RescueNode)).returns(RescueNode) } def rescue_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil)); end # Create a new RestParameterNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).returns(RestParameterNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).returns(RestParameterNode) } def rest_parameter_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end # Create a new RetryNode node. @@ -590,7 +590,7 @@ module Prism def retry_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new ReturnNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, arguments: T.nilable(ArgumentsNode)).returns(ReturnNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, arguments: ::T.nilable(ArgumentsNode)).returns(ReturnNode) } def return_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil)); end # Create a new SelfNode node. @@ -598,11 +598,11 @@ module Prism def self_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new ShareableConstantNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, write: T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)).returns(ShareableConstantNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, write: ::T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)).returns(ShareableConstantNode) } def shareable_constant_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), write: T.unsafe(nil)); end # Create a new SingletonClassNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location).returns(SingletonClassNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location).returns(SingletonClassNode) } def singleton_class_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new SourceEncodingNode node. @@ -618,7 +618,7 @@ module Prism def source_line_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new SplatNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, expression: T.nilable(Node)).returns(SplatNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, expression: ::T.nilable(Node)).returns(SplatNode) } def splat_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil)); end # Create a new StatementsNode node. @@ -626,15 +626,15 @@ module Prism def statements_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil)); end # Create a new StringNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), content_loc: Location, closing_loc: T.nilable(Location), unescaped: String).returns(StringNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), content_loc: Location, closing_loc: ::T.nilable(Location), unescaped: String).returns(StringNode) } def string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end # Create a new SuperNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), block: T.nilable(T.any(BlockNode, BlockArgumentNode))).returns(SuperNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), rparen_loc: ::T.nilable(Location), block: ::T.nilable(::T.any(BlockNode, BlockArgumentNode))).returns(SuperNode) } def super_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil)); end # Create a new SymbolNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), value_loc: T.nilable(Location), closing_loc: T.nilable(Location), unescaped: String).returns(SymbolNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), value_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), unescaped: String).returns(SymbolNode) } def symbol_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end # Create a new TrueNode node. @@ -642,23 +642,23 @@ module Prism def true_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # Create a new UndefNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, names: T::Array[T.any(SymbolNode, InterpolatedSymbolNode)], keyword_loc: Location).returns(UndefNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, names: T::Array[::T.any(SymbolNode, InterpolatedSymbolNode)], keyword_loc: Location).returns(UndefNode) } def undef_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), names: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end # Create a new UnlessNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), else_clause: T.nilable(ElseNode), end_keyword_loc: T.nilable(Location)).returns(UnlessNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).returns(UnlessNode) } def unless_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end # Create a new UntilNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: T.nilable(Location), closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode)).returns(UntilNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(UntilNode) } def until_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end # Create a new WhenNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode)).returns(WhenNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).returns(WhenNode) } def when_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end # Create a new WhileNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: T.nilable(Location), closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode)).returns(WhileNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(WhileNode) } def while_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end # Create a new XStringNode node. @@ -666,7 +666,7 @@ module Prism def x_string_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end # Create a new YieldNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location)).returns(YieldNode) } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), rparen_loc: ::T.nilable(Location)).returns(YieldNode) } def yield_node(source: T.unsafe(nil), node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end # Retrieve the value of one of the ArgumentsNodeFlags flags. diff --git a/rbi/generated/prism/inspect_visitor.rbi b/rbi/generated/prism/inspect_visitor.rbi index 85442ef768..449a531c38 100644 --- a/rbi/generated/prism/inspect_visitor.rbi +++ b/rbi/generated/prism/inspect_visitor.rbi @@ -22,7 +22,7 @@ module Prism # The list of commands that we need to execute in order to compose the # final string. - sig { returns(T::Array[[T.any(String, Node, Replace), String]]) } + sig { returns(T::Array[[::T.any(String, Node, Replace), String]]) } attr_reader :commands sig { params(indent: String).void } @@ -497,7 +497,7 @@ module Prism private def inspect_node(name, node); end # Compose a string representing the given inner location field. - sig { params(location: T.nilable(Location)).returns(String) } + sig { params(location: ::T.nilable(Location)).returns(String) } private def inspect_location(location); end end end diff --git a/rbi/generated/prism/lex_compat.rbi b/rbi/generated/prism/lex_compat.rbi index df47383acf..5ce03767c8 100644 --- a/rbi/generated/prism/lex_compat.rbi +++ b/rbi/generated/prism/lex_compat.rbi @@ -32,22 +32,22 @@ module Prism # A result class specialized for holding tokens produced by the lexer. class Result < Prism::Result # The list of tokens that were produced by the lexer. - sig { returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } attr_reader :value # Create a new lex compat result object with the given values. - sig { params(value: T::Array[[[Integer, Integer], Symbol, String, T.untyped]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } + sig { params(value: T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end # Implement the hash pattern matching interface for Result. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end end # This is a mapping of prism token types to Ripper token types. This is a # many-to-one mapping because we split up our token types, whereas Ripper # tends to group them. - RIPPER = T.let(nil, T.untyped) + RIPPER = T.let(nil, ::T.untyped) # A heredoc in this case is a list of tokens that belong to the body of the # heredoc that should be appended onto the list of tokens when the heredoc @@ -58,16 +58,16 @@ module Prism # order back into the token stream and set the state of the last token to # the state that the heredoc was opened in. class PlainHeredoc - sig { returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } attr_reader :tokens sig { void } def initialize; end - sig { params(token: [[Integer, Integer], Symbol, String, T.untyped]).void } + sig { params(token: [[Integer, Integer], Symbol, String, ::T.untyped]).void } def <<(token); end - sig { returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } def to_a; end end @@ -78,16 +78,16 @@ module Prism sig { returns(T::Boolean) } attr_reader :split - sig { returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } attr_reader :tokens sig { params(split: T::Boolean).void } def initialize(split); end - sig { params(token: [[Integer, Integer], Symbol, String, T.untyped]).void } + sig { params(token: [[Integer, Integer], Symbol, String, ::T.untyped]).void } def <<(token); end - sig { returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } def to_a; end end @@ -104,13 +104,13 @@ module Prism class DedentingHeredoc TAB_WIDTH = T.let(nil, Integer) - sig { returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } attr_reader :tokens sig { returns(T::Boolean) } attr_reader :dedent_next - sig { returns(T.nilable(Integer)) } + sig { returns(::T.nilable(Integer)) } attr_reader :dedent sig { returns(Integer) } @@ -123,33 +123,33 @@ module Prism # whitespace on plain string content tokens. This allows us to later # remove that amount of whitespace from the beginning of each line. # - sig { params(token: [[Integer, Integer], Symbol, String, T.untyped]).void } + sig { params(token: [[Integer, Integer], Symbol, String, ::T.untyped]).void } def <<(token); end - sig { returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } def to_a; end end # Here we will split between the two types of heredocs and return the # object that will store their tokens. - sig { params(opening: [[Integer, Integer], Symbol, String, T.untyped]).returns(T.any(PlainHeredoc, DashHeredoc, DedentingHeredoc)) } + sig { params(opening: [[Integer, Integer], Symbol, String, ::T.untyped]).returns(::T.any(PlainHeredoc, DashHeredoc, DedentingHeredoc)) } def self.build(opening); end end # In previous versions of Ruby, Ripper wouldn't flush the bom before the # first token, so we had to have a hack in place to account for that. - BOM_FLUSHED = T.let(nil, T.untyped) + BOM_FLUSHED = T.let(nil, ::T.untyped) - sig { returns(T::Hash[Symbol, T.untyped]) } + sig { returns(T::Hash[Symbol, ::T.untyped]) } attr_reader :options - sig { params(source: String, options: T.untyped).void } + sig { params(source: String, options: ::T.untyped).void } def initialize(source, **options); end sig { returns(Result) } def result; end - sig { params(tokens: T::Array[[[Integer, Integer], Symbol, String, T.untyped]], source: Source, data_loc: T.nilable(Location), bom: T::Boolean, eof_token: T.nilable(Token)).returns(T::Array[[[Integer, Integer], Symbol, String, T.untyped]]) } + sig { params(tokens: T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]], source: Source, data_loc: ::T.nilable(Location), bom: T::Boolean, eof_token: ::T.nilable(Token)).returns(T::Array[[[Integer, Integer], Symbol, String, ::T.untyped]]) } private def post_process_tokens(tokens, source, data_loc, bom, eof_token); end end end diff --git a/rbi/generated/prism/mutation_compiler.rbi b/rbi/generated/prism/mutation_compiler.rbi index f62613fa1b..21be124fed 100644 --- a/rbi/generated/prism/mutation_compiler.rbi +++ b/rbi/generated/prism/mutation_compiler.rbi @@ -5,460 +5,460 @@ module Prism # visited. This is useful for consumers that want to mutate the tree, as you # can change subtrees in place without effecting the rest of the tree. class MutationCompiler < Compiler - sig { params(arg0: AliasGlobalVariableNode).returns(T.nilable(Node)) } + sig { params(arg0: AliasGlobalVariableNode).returns(::T.nilable(Node)) } def visit_alias_global_variable_node(arg0); end - sig { params(arg0: AliasMethodNode).returns(T.nilable(Node)) } + sig { params(arg0: AliasMethodNode).returns(::T.nilable(Node)) } def visit_alias_method_node(arg0); end - sig { params(arg0: AlternationPatternNode).returns(T.nilable(Node)) } + sig { params(arg0: AlternationPatternNode).returns(::T.nilable(Node)) } def visit_alternation_pattern_node(arg0); end - sig { params(arg0: AndNode).returns(T.nilable(Node)) } + sig { params(arg0: AndNode).returns(::T.nilable(Node)) } def visit_and_node(arg0); end - sig { params(arg0: ArgumentsNode).returns(T.nilable(Node)) } + sig { params(arg0: ArgumentsNode).returns(::T.nilable(Node)) } def visit_arguments_node(arg0); end - sig { params(arg0: ArrayNode).returns(T.nilable(Node)) } + sig { params(arg0: ArrayNode).returns(::T.nilable(Node)) } def visit_array_node(arg0); end - sig { params(arg0: ArrayPatternNode).returns(T.nilable(Node)) } + sig { params(arg0: ArrayPatternNode).returns(::T.nilable(Node)) } def visit_array_pattern_node(arg0); end - sig { params(arg0: AssocNode).returns(T.nilable(Node)) } + sig { params(arg0: AssocNode).returns(::T.nilable(Node)) } def visit_assoc_node(arg0); end - sig { params(arg0: AssocSplatNode).returns(T.nilable(Node)) } + sig { params(arg0: AssocSplatNode).returns(::T.nilable(Node)) } def visit_assoc_splat_node(arg0); end - sig { params(arg0: BackReferenceReadNode).returns(T.nilable(Node)) } + sig { params(arg0: BackReferenceReadNode).returns(::T.nilable(Node)) } def visit_back_reference_read_node(arg0); end - sig { params(arg0: BeginNode).returns(T.nilable(Node)) } + sig { params(arg0: BeginNode).returns(::T.nilable(Node)) } def visit_begin_node(arg0); end - sig { params(arg0: BlockArgumentNode).returns(T.nilable(Node)) } + sig { params(arg0: BlockArgumentNode).returns(::T.nilable(Node)) } def visit_block_argument_node(arg0); end - sig { params(arg0: BlockLocalVariableNode).returns(T.nilable(Node)) } + sig { params(arg0: BlockLocalVariableNode).returns(::T.nilable(Node)) } def visit_block_local_variable_node(arg0); end - sig { params(arg0: BlockNode).returns(T.nilable(Node)) } + sig { params(arg0: BlockNode).returns(::T.nilable(Node)) } def visit_block_node(arg0); end - sig { params(arg0: BlockParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: BlockParameterNode).returns(::T.nilable(Node)) } def visit_block_parameter_node(arg0); end - sig { params(arg0: BlockParametersNode).returns(T.nilable(Node)) } + sig { params(arg0: BlockParametersNode).returns(::T.nilable(Node)) } def visit_block_parameters_node(arg0); end - sig { params(arg0: BreakNode).returns(T.nilable(Node)) } + sig { params(arg0: BreakNode).returns(::T.nilable(Node)) } def visit_break_node(arg0); end - sig { params(arg0: CallAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: CallAndWriteNode).returns(::T.nilable(Node)) } def visit_call_and_write_node(arg0); end - sig { params(arg0: CallNode).returns(T.nilable(Node)) } + sig { params(arg0: CallNode).returns(::T.nilable(Node)) } def visit_call_node(arg0); end - sig { params(arg0: CallOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: CallOperatorWriteNode).returns(::T.nilable(Node)) } def visit_call_operator_write_node(arg0); end - sig { params(arg0: CallOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: CallOrWriteNode).returns(::T.nilable(Node)) } def visit_call_or_write_node(arg0); end - sig { params(arg0: CallTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: CallTargetNode).returns(::T.nilable(Node)) } def visit_call_target_node(arg0); end - sig { params(arg0: CapturePatternNode).returns(T.nilable(Node)) } + sig { params(arg0: CapturePatternNode).returns(::T.nilable(Node)) } def visit_capture_pattern_node(arg0); end - sig { params(arg0: CaseMatchNode).returns(T.nilable(Node)) } + sig { params(arg0: CaseMatchNode).returns(::T.nilable(Node)) } def visit_case_match_node(arg0); end - sig { params(arg0: CaseNode).returns(T.nilable(Node)) } + sig { params(arg0: CaseNode).returns(::T.nilable(Node)) } def visit_case_node(arg0); end - sig { params(arg0: ClassNode).returns(T.nilable(Node)) } + sig { params(arg0: ClassNode).returns(::T.nilable(Node)) } def visit_class_node(arg0); end - sig { params(arg0: ClassVariableAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ClassVariableAndWriteNode).returns(::T.nilable(Node)) } def visit_class_variable_and_write_node(arg0); end - sig { params(arg0: ClassVariableOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ClassVariableOperatorWriteNode).returns(::T.nilable(Node)) } def visit_class_variable_operator_write_node(arg0); end - sig { params(arg0: ClassVariableOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ClassVariableOrWriteNode).returns(::T.nilable(Node)) } def visit_class_variable_or_write_node(arg0); end - sig { params(arg0: ClassVariableReadNode).returns(T.nilable(Node)) } + sig { params(arg0: ClassVariableReadNode).returns(::T.nilable(Node)) } def visit_class_variable_read_node(arg0); end - sig { params(arg0: ClassVariableTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: ClassVariableTargetNode).returns(::T.nilable(Node)) } def visit_class_variable_target_node(arg0); end - sig { params(arg0: ClassVariableWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ClassVariableWriteNode).returns(::T.nilable(Node)) } def visit_class_variable_write_node(arg0); end - sig { params(arg0: ConstantAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantAndWriteNode).returns(::T.nilable(Node)) } def visit_constant_and_write_node(arg0); end - sig { params(arg0: ConstantOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantOperatorWriteNode).returns(::T.nilable(Node)) } def visit_constant_operator_write_node(arg0); end - sig { params(arg0: ConstantOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantOrWriteNode).returns(::T.nilable(Node)) } def visit_constant_or_write_node(arg0); end - sig { params(arg0: ConstantPathAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantPathAndWriteNode).returns(::T.nilable(Node)) } def visit_constant_path_and_write_node(arg0); end - sig { params(arg0: ConstantPathNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantPathNode).returns(::T.nilable(Node)) } def visit_constant_path_node(arg0); end - sig { params(arg0: ConstantPathOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantPathOperatorWriteNode).returns(::T.nilable(Node)) } def visit_constant_path_operator_write_node(arg0); end - sig { params(arg0: ConstantPathOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantPathOrWriteNode).returns(::T.nilable(Node)) } def visit_constant_path_or_write_node(arg0); end - sig { params(arg0: ConstantPathTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantPathTargetNode).returns(::T.nilable(Node)) } def visit_constant_path_target_node(arg0); end - sig { params(arg0: ConstantPathWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantPathWriteNode).returns(::T.nilable(Node)) } def visit_constant_path_write_node(arg0); end - sig { params(arg0: ConstantReadNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantReadNode).returns(::T.nilable(Node)) } def visit_constant_read_node(arg0); end - sig { params(arg0: ConstantTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantTargetNode).returns(::T.nilable(Node)) } def visit_constant_target_node(arg0); end - sig { params(arg0: ConstantWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: ConstantWriteNode).returns(::T.nilable(Node)) } def visit_constant_write_node(arg0); end - sig { params(arg0: DefNode).returns(T.nilable(Node)) } + sig { params(arg0: DefNode).returns(::T.nilable(Node)) } def visit_def_node(arg0); end - sig { params(arg0: DefinedNode).returns(T.nilable(Node)) } + sig { params(arg0: DefinedNode).returns(::T.nilable(Node)) } def visit_defined_node(arg0); end - sig { params(arg0: ElseNode).returns(T.nilable(Node)) } + sig { params(arg0: ElseNode).returns(::T.nilable(Node)) } def visit_else_node(arg0); end - sig { params(arg0: EmbeddedStatementsNode).returns(T.nilable(Node)) } + sig { params(arg0: EmbeddedStatementsNode).returns(::T.nilable(Node)) } def visit_embedded_statements_node(arg0); end - sig { params(arg0: EmbeddedVariableNode).returns(T.nilable(Node)) } + sig { params(arg0: EmbeddedVariableNode).returns(::T.nilable(Node)) } def visit_embedded_variable_node(arg0); end - sig { params(arg0: EnsureNode).returns(T.nilable(Node)) } + sig { params(arg0: EnsureNode).returns(::T.nilable(Node)) } def visit_ensure_node(arg0); end - sig { params(arg0: FalseNode).returns(T.nilable(Node)) } + sig { params(arg0: FalseNode).returns(::T.nilable(Node)) } def visit_false_node(arg0); end - sig { params(arg0: FindPatternNode).returns(T.nilable(Node)) } + sig { params(arg0: FindPatternNode).returns(::T.nilable(Node)) } def visit_find_pattern_node(arg0); end - sig { params(arg0: FlipFlopNode).returns(T.nilable(Node)) } + sig { params(arg0: FlipFlopNode).returns(::T.nilable(Node)) } def visit_flip_flop_node(arg0); end - sig { params(arg0: FloatNode).returns(T.nilable(Node)) } + sig { params(arg0: FloatNode).returns(::T.nilable(Node)) } def visit_float_node(arg0); end - sig { params(arg0: ForNode).returns(T.nilable(Node)) } + sig { params(arg0: ForNode).returns(::T.nilable(Node)) } def visit_for_node(arg0); end - sig { params(arg0: ForwardingArgumentsNode).returns(T.nilable(Node)) } + sig { params(arg0: ForwardingArgumentsNode).returns(::T.nilable(Node)) } def visit_forwarding_arguments_node(arg0); end - sig { params(arg0: ForwardingParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: ForwardingParameterNode).returns(::T.nilable(Node)) } def visit_forwarding_parameter_node(arg0); end - sig { params(arg0: ForwardingSuperNode).returns(T.nilable(Node)) } + sig { params(arg0: ForwardingSuperNode).returns(::T.nilable(Node)) } def visit_forwarding_super_node(arg0); end - sig { params(arg0: GlobalVariableAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: GlobalVariableAndWriteNode).returns(::T.nilable(Node)) } def visit_global_variable_and_write_node(arg0); end - sig { params(arg0: GlobalVariableOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: GlobalVariableOperatorWriteNode).returns(::T.nilable(Node)) } def visit_global_variable_operator_write_node(arg0); end - sig { params(arg0: GlobalVariableOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: GlobalVariableOrWriteNode).returns(::T.nilable(Node)) } def visit_global_variable_or_write_node(arg0); end - sig { params(arg0: GlobalVariableReadNode).returns(T.nilable(Node)) } + sig { params(arg0: GlobalVariableReadNode).returns(::T.nilable(Node)) } def visit_global_variable_read_node(arg0); end - sig { params(arg0: GlobalVariableTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: GlobalVariableTargetNode).returns(::T.nilable(Node)) } def visit_global_variable_target_node(arg0); end - sig { params(arg0: GlobalVariableWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: GlobalVariableWriteNode).returns(::T.nilable(Node)) } def visit_global_variable_write_node(arg0); end - sig { params(arg0: HashNode).returns(T.nilable(Node)) } + sig { params(arg0: HashNode).returns(::T.nilable(Node)) } def visit_hash_node(arg0); end - sig { params(arg0: HashPatternNode).returns(T.nilable(Node)) } + sig { params(arg0: HashPatternNode).returns(::T.nilable(Node)) } def visit_hash_pattern_node(arg0); end - sig { params(arg0: IfNode).returns(T.nilable(Node)) } + sig { params(arg0: IfNode).returns(::T.nilable(Node)) } def visit_if_node(arg0); end - sig { params(arg0: ImaginaryNode).returns(T.nilable(Node)) } + sig { params(arg0: ImaginaryNode).returns(::T.nilable(Node)) } def visit_imaginary_node(arg0); end - sig { params(arg0: ImplicitNode).returns(T.nilable(Node)) } + sig { params(arg0: ImplicitNode).returns(::T.nilable(Node)) } def visit_implicit_node(arg0); end - sig { params(arg0: ImplicitRestNode).returns(T.nilable(Node)) } + sig { params(arg0: ImplicitRestNode).returns(::T.nilable(Node)) } def visit_implicit_rest_node(arg0); end - sig { params(arg0: InNode).returns(T.nilable(Node)) } + sig { params(arg0: InNode).returns(::T.nilable(Node)) } def visit_in_node(arg0); end - sig { params(arg0: IndexAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: IndexAndWriteNode).returns(::T.nilable(Node)) } def visit_index_and_write_node(arg0); end - sig { params(arg0: IndexOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: IndexOperatorWriteNode).returns(::T.nilable(Node)) } def visit_index_operator_write_node(arg0); end - sig { params(arg0: IndexOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: IndexOrWriteNode).returns(::T.nilable(Node)) } def visit_index_or_write_node(arg0); end - sig { params(arg0: IndexTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: IndexTargetNode).returns(::T.nilable(Node)) } def visit_index_target_node(arg0); end - sig { params(arg0: InstanceVariableAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: InstanceVariableAndWriteNode).returns(::T.nilable(Node)) } def visit_instance_variable_and_write_node(arg0); end - sig { params(arg0: InstanceVariableOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: InstanceVariableOperatorWriteNode).returns(::T.nilable(Node)) } def visit_instance_variable_operator_write_node(arg0); end - sig { params(arg0: InstanceVariableOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: InstanceVariableOrWriteNode).returns(::T.nilable(Node)) } def visit_instance_variable_or_write_node(arg0); end - sig { params(arg0: InstanceVariableReadNode).returns(T.nilable(Node)) } + sig { params(arg0: InstanceVariableReadNode).returns(::T.nilable(Node)) } def visit_instance_variable_read_node(arg0); end - sig { params(arg0: InstanceVariableTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: InstanceVariableTargetNode).returns(::T.nilable(Node)) } def visit_instance_variable_target_node(arg0); end - sig { params(arg0: InstanceVariableWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: InstanceVariableWriteNode).returns(::T.nilable(Node)) } def visit_instance_variable_write_node(arg0); end - sig { params(arg0: IntegerNode).returns(T.nilable(Node)) } + sig { params(arg0: IntegerNode).returns(::T.nilable(Node)) } def visit_integer_node(arg0); end - sig { params(arg0: InterpolatedMatchLastLineNode).returns(T.nilable(Node)) } + sig { params(arg0: InterpolatedMatchLastLineNode).returns(::T.nilable(Node)) } def visit_interpolated_match_last_line_node(arg0); end - sig { params(arg0: InterpolatedRegularExpressionNode).returns(T.nilable(Node)) } + sig { params(arg0: InterpolatedRegularExpressionNode).returns(::T.nilable(Node)) } def visit_interpolated_regular_expression_node(arg0); end - sig { params(arg0: InterpolatedStringNode).returns(T.nilable(Node)) } + sig { params(arg0: InterpolatedStringNode).returns(::T.nilable(Node)) } def visit_interpolated_string_node(arg0); end - sig { params(arg0: InterpolatedSymbolNode).returns(T.nilable(Node)) } + sig { params(arg0: InterpolatedSymbolNode).returns(::T.nilable(Node)) } def visit_interpolated_symbol_node(arg0); end - sig { params(arg0: InterpolatedXStringNode).returns(T.nilable(Node)) } + sig { params(arg0: InterpolatedXStringNode).returns(::T.nilable(Node)) } def visit_interpolated_x_string_node(arg0); end - sig { params(arg0: ItLocalVariableReadNode).returns(T.nilable(Node)) } + sig { params(arg0: ItLocalVariableReadNode).returns(::T.nilable(Node)) } def visit_it_local_variable_read_node(arg0); end - sig { params(arg0: ItParametersNode).returns(T.nilable(Node)) } + sig { params(arg0: ItParametersNode).returns(::T.nilable(Node)) } def visit_it_parameters_node(arg0); end - sig { params(arg0: KeywordHashNode).returns(T.nilable(Node)) } + sig { params(arg0: KeywordHashNode).returns(::T.nilable(Node)) } def visit_keyword_hash_node(arg0); end - sig { params(arg0: KeywordRestParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: KeywordRestParameterNode).returns(::T.nilable(Node)) } def visit_keyword_rest_parameter_node(arg0); end - sig { params(arg0: LambdaNode).returns(T.nilable(Node)) } + sig { params(arg0: LambdaNode).returns(::T.nilable(Node)) } def visit_lambda_node(arg0); end - sig { params(arg0: LocalVariableAndWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: LocalVariableAndWriteNode).returns(::T.nilable(Node)) } def visit_local_variable_and_write_node(arg0); end - sig { params(arg0: LocalVariableOperatorWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: LocalVariableOperatorWriteNode).returns(::T.nilable(Node)) } def visit_local_variable_operator_write_node(arg0); end - sig { params(arg0: LocalVariableOrWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: LocalVariableOrWriteNode).returns(::T.nilable(Node)) } def visit_local_variable_or_write_node(arg0); end - sig { params(arg0: LocalVariableReadNode).returns(T.nilable(Node)) } + sig { params(arg0: LocalVariableReadNode).returns(::T.nilable(Node)) } def visit_local_variable_read_node(arg0); end - sig { params(arg0: LocalVariableTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: LocalVariableTargetNode).returns(::T.nilable(Node)) } def visit_local_variable_target_node(arg0); end - sig { params(arg0: LocalVariableWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: LocalVariableWriteNode).returns(::T.nilable(Node)) } def visit_local_variable_write_node(arg0); end - sig { params(arg0: MatchLastLineNode).returns(T.nilable(Node)) } + sig { params(arg0: MatchLastLineNode).returns(::T.nilable(Node)) } def visit_match_last_line_node(arg0); end - sig { params(arg0: MatchPredicateNode).returns(T.nilable(Node)) } + sig { params(arg0: MatchPredicateNode).returns(::T.nilable(Node)) } def visit_match_predicate_node(arg0); end - sig { params(arg0: MatchRequiredNode).returns(T.nilable(Node)) } + sig { params(arg0: MatchRequiredNode).returns(::T.nilable(Node)) } def visit_match_required_node(arg0); end - sig { params(arg0: MatchWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: MatchWriteNode).returns(::T.nilable(Node)) } def visit_match_write_node(arg0); end - sig { params(arg0: MissingNode).returns(T.nilable(Node)) } + sig { params(arg0: MissingNode).returns(::T.nilable(Node)) } def visit_missing_node(arg0); end - sig { params(arg0: ModuleNode).returns(T.nilable(Node)) } + sig { params(arg0: ModuleNode).returns(::T.nilable(Node)) } def visit_module_node(arg0); end - sig { params(arg0: MultiTargetNode).returns(T.nilable(Node)) } + sig { params(arg0: MultiTargetNode).returns(::T.nilable(Node)) } def visit_multi_target_node(arg0); end - sig { params(arg0: MultiWriteNode).returns(T.nilable(Node)) } + sig { params(arg0: MultiWriteNode).returns(::T.nilable(Node)) } def visit_multi_write_node(arg0); end - sig { params(arg0: NextNode).returns(T.nilable(Node)) } + sig { params(arg0: NextNode).returns(::T.nilable(Node)) } def visit_next_node(arg0); end - sig { params(arg0: NilNode).returns(T.nilable(Node)) } + sig { params(arg0: NilNode).returns(::T.nilable(Node)) } def visit_nil_node(arg0); end - sig { params(arg0: NoBlockParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: NoBlockParameterNode).returns(::T.nilable(Node)) } def visit_no_block_parameter_node(arg0); end - sig { params(arg0: NoKeywordsParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: NoKeywordsParameterNode).returns(::T.nilable(Node)) } def visit_no_keywords_parameter_node(arg0); end - sig { params(arg0: NumberedParametersNode).returns(T.nilable(Node)) } + sig { params(arg0: NumberedParametersNode).returns(::T.nilable(Node)) } def visit_numbered_parameters_node(arg0); end - sig { params(arg0: NumberedReferenceReadNode).returns(T.nilable(Node)) } + sig { params(arg0: NumberedReferenceReadNode).returns(::T.nilable(Node)) } def visit_numbered_reference_read_node(arg0); end - sig { params(arg0: OptionalKeywordParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: OptionalKeywordParameterNode).returns(::T.nilable(Node)) } def visit_optional_keyword_parameter_node(arg0); end - sig { params(arg0: OptionalParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: OptionalParameterNode).returns(::T.nilable(Node)) } def visit_optional_parameter_node(arg0); end - sig { params(arg0: OrNode).returns(T.nilable(Node)) } + sig { params(arg0: OrNode).returns(::T.nilable(Node)) } def visit_or_node(arg0); end - sig { params(arg0: ParametersNode).returns(T.nilable(Node)) } + sig { params(arg0: ParametersNode).returns(::T.nilable(Node)) } def visit_parameters_node(arg0); end - sig { params(arg0: ParenthesesNode).returns(T.nilable(Node)) } + sig { params(arg0: ParenthesesNode).returns(::T.nilable(Node)) } def visit_parentheses_node(arg0); end - sig { params(arg0: PinnedExpressionNode).returns(T.nilable(Node)) } + sig { params(arg0: PinnedExpressionNode).returns(::T.nilable(Node)) } def visit_pinned_expression_node(arg0); end - sig { params(arg0: PinnedVariableNode).returns(T.nilable(Node)) } + sig { params(arg0: PinnedVariableNode).returns(::T.nilable(Node)) } def visit_pinned_variable_node(arg0); end - sig { params(arg0: PostExecutionNode).returns(T.nilable(Node)) } + sig { params(arg0: PostExecutionNode).returns(::T.nilable(Node)) } def visit_post_execution_node(arg0); end - sig { params(arg0: PreExecutionNode).returns(T.nilable(Node)) } + sig { params(arg0: PreExecutionNode).returns(::T.nilable(Node)) } def visit_pre_execution_node(arg0); end - sig { params(arg0: ProgramNode).returns(T.nilable(Node)) } + sig { params(arg0: ProgramNode).returns(::T.nilable(Node)) } def visit_program_node(arg0); end - sig { params(arg0: RangeNode).returns(T.nilable(Node)) } + sig { params(arg0: RangeNode).returns(::T.nilable(Node)) } def visit_range_node(arg0); end - sig { params(arg0: RationalNode).returns(T.nilable(Node)) } + sig { params(arg0: RationalNode).returns(::T.nilable(Node)) } def visit_rational_node(arg0); end - sig { params(arg0: RedoNode).returns(T.nilable(Node)) } + sig { params(arg0: RedoNode).returns(::T.nilable(Node)) } def visit_redo_node(arg0); end - sig { params(arg0: RegularExpressionNode).returns(T.nilable(Node)) } + sig { params(arg0: RegularExpressionNode).returns(::T.nilable(Node)) } def visit_regular_expression_node(arg0); end - sig { params(arg0: RequiredKeywordParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: RequiredKeywordParameterNode).returns(::T.nilable(Node)) } def visit_required_keyword_parameter_node(arg0); end - sig { params(arg0: RequiredParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: RequiredParameterNode).returns(::T.nilable(Node)) } def visit_required_parameter_node(arg0); end - sig { params(arg0: RescueModifierNode).returns(T.nilable(Node)) } + sig { params(arg0: RescueModifierNode).returns(::T.nilable(Node)) } def visit_rescue_modifier_node(arg0); end - sig { params(arg0: RescueNode).returns(T.nilable(Node)) } + sig { params(arg0: RescueNode).returns(::T.nilable(Node)) } def visit_rescue_node(arg0); end - sig { params(arg0: RestParameterNode).returns(T.nilable(Node)) } + sig { params(arg0: RestParameterNode).returns(::T.nilable(Node)) } def visit_rest_parameter_node(arg0); end - sig { params(arg0: RetryNode).returns(T.nilable(Node)) } + sig { params(arg0: RetryNode).returns(::T.nilable(Node)) } def visit_retry_node(arg0); end - sig { params(arg0: ReturnNode).returns(T.nilable(Node)) } + sig { params(arg0: ReturnNode).returns(::T.nilable(Node)) } def visit_return_node(arg0); end - sig { params(arg0: SelfNode).returns(T.nilable(Node)) } + sig { params(arg0: SelfNode).returns(::T.nilable(Node)) } def visit_self_node(arg0); end - sig { params(arg0: ShareableConstantNode).returns(T.nilable(Node)) } + sig { params(arg0: ShareableConstantNode).returns(::T.nilable(Node)) } def visit_shareable_constant_node(arg0); end - sig { params(arg0: SingletonClassNode).returns(T.nilable(Node)) } + sig { params(arg0: SingletonClassNode).returns(::T.nilable(Node)) } def visit_singleton_class_node(arg0); end - sig { params(arg0: SourceEncodingNode).returns(T.nilable(Node)) } + sig { params(arg0: SourceEncodingNode).returns(::T.nilable(Node)) } def visit_source_encoding_node(arg0); end - sig { params(arg0: SourceFileNode).returns(T.nilable(Node)) } + sig { params(arg0: SourceFileNode).returns(::T.nilable(Node)) } def visit_source_file_node(arg0); end - sig { params(arg0: SourceLineNode).returns(T.nilable(Node)) } + sig { params(arg0: SourceLineNode).returns(::T.nilable(Node)) } def visit_source_line_node(arg0); end - sig { params(arg0: SplatNode).returns(T.nilable(Node)) } + sig { params(arg0: SplatNode).returns(::T.nilable(Node)) } def visit_splat_node(arg0); end - sig { params(arg0: StatementsNode).returns(T.nilable(Node)) } + sig { params(arg0: StatementsNode).returns(::T.nilable(Node)) } def visit_statements_node(arg0); end - sig { params(arg0: StringNode).returns(T.nilable(Node)) } + sig { params(arg0: StringNode).returns(::T.nilable(Node)) } def visit_string_node(arg0); end - sig { params(arg0: SuperNode).returns(T.nilable(Node)) } + sig { params(arg0: SuperNode).returns(::T.nilable(Node)) } def visit_super_node(arg0); end - sig { params(arg0: SymbolNode).returns(T.nilable(Node)) } + sig { params(arg0: SymbolNode).returns(::T.nilable(Node)) } def visit_symbol_node(arg0); end - sig { params(arg0: TrueNode).returns(T.nilable(Node)) } + sig { params(arg0: TrueNode).returns(::T.nilable(Node)) } def visit_true_node(arg0); end - sig { params(arg0: UndefNode).returns(T.nilable(Node)) } + sig { params(arg0: UndefNode).returns(::T.nilable(Node)) } def visit_undef_node(arg0); end - sig { params(arg0: UnlessNode).returns(T.nilable(Node)) } + sig { params(arg0: UnlessNode).returns(::T.nilable(Node)) } def visit_unless_node(arg0); end - sig { params(arg0: UntilNode).returns(T.nilable(Node)) } + sig { params(arg0: UntilNode).returns(::T.nilable(Node)) } def visit_until_node(arg0); end - sig { params(arg0: WhenNode).returns(T.nilable(Node)) } + sig { params(arg0: WhenNode).returns(::T.nilable(Node)) } def visit_when_node(arg0); end - sig { params(arg0: WhileNode).returns(T.nilable(Node)) } + sig { params(arg0: WhileNode).returns(::T.nilable(Node)) } def visit_while_node(arg0); end - sig { params(arg0: XStringNode).returns(T.nilable(Node)) } + sig { params(arg0: XStringNode).returns(::T.nilable(Node)) } def visit_x_string_node(arg0); end - sig { params(arg0: YieldNode).returns(T.nilable(Node)) } + sig { params(arg0: YieldNode).returns(::T.nilable(Node)) } def visit_yield_node(arg0); end end end diff --git a/rbi/generated/prism/node.rbi b/rbi/generated/prism/node.rbi index 324250b8c0..3b62926afb 100644 --- a/rbi/generated/prism/node.rbi +++ b/rbi/generated/prism/node.rbi @@ -18,7 +18,7 @@ module Prism attr_reader :node_id # Save this node using a saved source so that it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save(repository); end # A Location instance that represents the location of this node in the @@ -27,7 +27,7 @@ module Prism def location; end # Save the location using a saved source so that it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_location(repository); end # Delegates to [`start_line`](rdoc-ref:Location#start_line) of the associated location object. @@ -58,12 +58,12 @@ module Prism # Delegates to [`cached_start_code_units_offset`](rdoc-ref:Location#cached_start_code_units_offset) # of the associated location object. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_start_code_units_offset(cache); end # Delegates to [`cached_end_code_units_offset`](rdoc-ref:Location#cached_end_code_units_offset) # of the associated location object. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_end_code_units_offset(cache); end # Delegates to [`start_column`](rdoc-ref:Location#start_column) of the associated location object. @@ -86,12 +86,12 @@ module Prism # Delegates to [`cached_start_code_units_column`](rdoc-ref:Location#cached_start_code_units_column) # of the associated location object. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_start_code_units_column(cache); end # Delegates to [`cached_end_code_units_column`](rdoc-ref:Location#cached_end_code_units_column) # of the associated location object. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_end_code_units_column(cache); end # Delegates to [`leading_comments`](rdoc-ref:Location#leading_comments) of the associated location object. @@ -161,10 +161,10 @@ module Prism # particular condition. # # node.breadth_first_search { |node| node.node_id == node_id } - sig { params(blk: T.proc.params(arg0: Node).returns(T::Boolean)).returns(T.nilable(Node)) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(::T.nilable(Node)) } def breadth_first_search(&blk); end - sig { params(blk: T.proc.params(arg0: Node).returns(T::Boolean)).returns(T.nilable(Node)) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(::T.nilable(Node)) } def find(&blk); end # Returns all of the nodes that match the given block when visited in a @@ -172,10 +172,10 @@ module Prism # particular condition. # # node.breadth_first_search_all { |node| node.is_a?(Prism::CallNode) } - sig { params(blk: T.proc.params(arg0: Node).returns(T::Boolean)).returns(T::Array[Node]) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(T::Array[Node]) } def breadth_first_search_all(&blk); end - sig { params(blk: T.proc.params(arg0: Node).returns(T::Boolean)).returns(T::Array[Node]) } + sig { params(blk: ::T.proc.params(arg0: Node).returns(T::Boolean)).returns(T::Array[Node]) } def find_all(&blk); end # Returns a list of the fields that exist for this node class. Fields @@ -185,22 +185,22 @@ module Prism def self.fields; end # Accepts a visitor and calls back into the specialized visit function. - sig { abstract.params(visitor: Visitor).returns(T.untyped) } + sig { abstract.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # Returns an array of child nodes, including `nil`s in the place of optional # nodes that were not present. - sig { abstract.returns(T::Array[T.nilable(Node)]) } + sig { abstract.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end - sig { abstract.returns(T::Array[T.nilable(Node)]) } + sig { abstract.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end # With a block given, yields each child node. Without a block, returns # an enumerator that contains each child node. Excludes any `nil`s in # the place of optional nodes that were not present. sig { abstract.returns(T::Enumerator[Node]) } - sig { abstract.params(blk: T.proc.params(arg0: Node).void).void } + sig { abstract.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # Returns an array of child nodes, excluding any `nil`s in the place of @@ -210,7 +210,7 @@ module Prism # Returns an array of child nodes and locations that could potentially have # comments attached to them. - sig { abstract.returns(T::Array[T.any(Node, Location)]) } + sig { abstract.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Returns a string representation of the node. @@ -246,20 +246,20 @@ module Prism # ^^^^^^^^^^^^^^^ class AliasGlobalVariableNode < Node # Initialize a new AliasGlobalVariableNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode), old_name: T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode), keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: ::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode), old_name: ::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode), keyword_loc: Location).void } def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -267,17 +267,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, new_name: T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode), old_name: T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode), keyword_loc: Location).returns(AliasGlobalVariableNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, new_name: ::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode), old_name: ::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode), keyword_loc: Location).returns(AliasGlobalVariableNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -295,14 +295,14 @@ module Prism # # alias $foo $bar # ^^^^ - sig { returns(T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)) } + sig { returns(::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)) } def new_name; end # Represents the old name of the global variable that can be used before aliasing. # # alias $foo $bar # ^^^^ - sig { returns(T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode)) } + sig { returns(::T.any(GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, SymbolNode, MissingNode)) } def old_name; end # The Location of the `alias` keyword. @@ -314,14 +314,14 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of keyword_loc from the source. sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -331,20 +331,20 @@ module Prism # ^^^^^^^^^^^^^ class AliasMethodNode < Node # Initialize a new AliasMethodNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: T.any(SymbolNode, InterpolatedSymbolNode), old_name: T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode), keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, new_name: ::T.any(SymbolNode, InterpolatedSymbolNode), old_name: ::T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode), keyword_loc: Location).void } def initialize(source, node_id, location, flags, new_name, old_name, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -352,17 +352,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, new_name: T.any(SymbolNode, InterpolatedSymbolNode), old_name: T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode), keyword_loc: Location).returns(AliasMethodNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, new_name: ::T.any(SymbolNode, InterpolatedSymbolNode), old_name: ::T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode), keyword_loc: Location).returns(AliasMethodNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), new_name: T.unsafe(nil), old_name: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -386,7 +386,7 @@ module Prism # # alias :"#{foo}" :"#{bar}" # ^^^^^^^^^ - sig { returns(T.any(SymbolNode, InterpolatedSymbolNode)) } + sig { returns(::T.any(SymbolNode, InterpolatedSymbolNode)) } def new_name; end # Represents the old name of the method that will be aliased. @@ -399,7 +399,7 @@ module Prism # # alias :"#{foo}" :"#{bar}" # ^^^^^^^^^ - sig { returns(T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode)) } + sig { returns(::T.any(SymbolNode, InterpolatedSymbolNode, GlobalVariableReadNode, MissingNode)) } def old_name; end # Represents the Location of the `alias` keyword. @@ -411,14 +411,14 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of keyword_loc from the source. sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -432,16 +432,16 @@ module Prism def initialize(source, node_id, location, flags, left, right, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -449,17 +449,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, left: Node, right: Node, operator_loc: Location).returns(AlternationPatternNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -496,14 +496,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -517,16 +517,16 @@ module Prism def initialize(source, node_id, location, flags, left, right, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -534,17 +534,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, left: Node, right: Node, operator_loc: Location).returns(AndNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -587,14 +587,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -608,16 +608,16 @@ module Prism def initialize(source, node_id, location, flags, arguments); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -625,17 +625,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, arguments: T::Array[Node]).returns(ArgumentsNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -676,7 +676,7 @@ module Prism sig { returns(T::Array[Node]) } def arguments; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -686,20 +686,20 @@ module Prism # ^^^^^^^^^ class ArrayNode < Node # Initialize a new ArrayNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[Node], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, elements, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -707,17 +707,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, elements: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(ArrayNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, elements: T::Array[Node], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(ArrayNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -745,12 +745,12 @@ module Prism # %w[foo bar baz] # "%w[" # %I(apple orange banana) # "%I(" # foo = 1, 2, 3 # nil - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Represents the optional source Location for the closing token. @@ -759,23 +759,23 @@ module Prism # %w[foo bar baz] # "]" # %I(apple orange banana) # ")" # foo = 1, 2, 3 # nil - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -797,20 +797,20 @@ module Prism # ^^^^^^^^^^^^ class ArrayPatternNode < Node # Initialize a new ArrayPatternNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), requireds: T::Array[Node], rest: T.nilable(Node), posts: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), requireds: T::Array[Node], rest: ::T.nilable(Node), posts: T::Array[Node], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -818,17 +818,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), requireds: T::Array[Node], rest: T.nilable(Node), posts: T::Array[Node], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(ArrayPatternNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), requireds: T::Array[Node], rest: ::T.nilable(Node), posts: T::Array[Node], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(ArrayPatternNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), requireds: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -852,7 +852,7 @@ module Prism # # foo in Bar::Baz[1, 2, 3] # ^^^^^^^^ - sig { returns(T.nilable(T.any(ConstantPathNode, ConstantReadNode))) } + sig { returns(::T.nilable(::T.any(ConstantPathNode, ConstantReadNode))) } def constant; end # Represents the required elements of the array pattern. @@ -866,7 +866,7 @@ module Prism # # foo in *bar # ^^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def rest; end # Represents the elements after the rest element of the array pattern. @@ -880,35 +880,35 @@ module Prism # # foo in [1, 2] # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Represents the closing Location of the array pattern. # # foo in [1, 2] # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -918,20 +918,20 @@ module Prism # ^^^^^^ class AssocNode < Node # Initialize a new AssocNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, key: Node, value: Node, operator_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, key: Node, value: Node, operator_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, key, value, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -939,17 +939,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, key: Node, value: Node, operator_loc: T.nilable(Location)).returns(AssocNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, key: Node, value: Node, operator_loc: ::T.nilable(Location)).returns(AssocNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), key: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -990,19 +990,19 @@ module Prism # # { foo => bar } # ^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1012,20 +1012,20 @@ module Prism # ^^^^^ class AssocSplatNode < Node # Initialize a new AssocSplatNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: T.nilable(Node), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: ::T.nilable(Node), operator_loc: Location).void } def initialize(source, node_id, location, flags, value, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1033,17 +1033,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, value: T.nilable(Node), operator_loc: Location).returns(AssocSplatNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, value: ::T.nilable(Node), operator_loc: Location).returns(AssocSplatNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1061,7 +1061,7 @@ module Prism # # { **foo } # ^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def value; end # The Location of the `**` operator. @@ -1073,14 +1073,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1094,16 +1094,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1111,17 +1111,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(BackReferenceReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1143,7 +1143,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1155,20 +1155,20 @@ module Prism # ^^^^^ class BeginNode < Node # Initialize a new BeginNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, begin_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), rescue_clause: T.nilable(RescueNode), else_clause: T.nilable(ElseNode), ensure_clause: T.nilable(EnsureNode), end_keyword_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, begin_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), rescue_clause: ::T.nilable(RescueNode), else_clause: ::T.nilable(ElseNode), ensure_clause: ::T.nilable(EnsureNode), end_keyword_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1176,17 +1176,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, begin_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), rescue_clause: T.nilable(RescueNode), else_clause: T.nilable(ElseNode), ensure_clause: T.nilable(EnsureNode), end_keyword_loc: T.nilable(Location)).returns(BeginNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, begin_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), rescue_clause: ::T.nilable(RescueNode), else_clause: ::T.nilable(ElseNode), ensure_clause: ::T.nilable(EnsureNode), end_keyword_loc: ::T.nilable(Location)).returns(BeginNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), begin_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), rescue_clause: T.unsafe(nil), else_clause: T.unsafe(nil), ensure_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1204,63 +1204,63 @@ module Prism # # begin x end # ^^^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def begin_keyword_loc; end # Save the begin_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_begin_keyword_loc(repository); end # Represents the statements within the begin block. # # begin x end # ^ - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Represents the rescue clause within the begin block. # # begin x; rescue y; end # ^^^^^^^^ - sig { returns(T.nilable(RescueNode)) } + sig { returns(::T.nilable(RescueNode)) } def rescue_clause; end # Represents the else clause within the begin block. # # begin x; rescue y; else z; end # ^^^^^^^^^^^ - sig { returns(T.nilable(ElseNode)) } + sig { returns(::T.nilable(ElseNode)) } def else_clause; end # Represents the ensure clause within the begin block. # # begin x; ensure y; end # ^^^^^^^^ - sig { returns(T.nilable(EnsureNode)) } + sig { returns(::T.nilable(EnsureNode)) } def ensure_clause; end # Represents the Location of the `end` keyword. # # begin x end # ^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def end_keyword_loc; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_end_keyword_loc(repository); end # Slice the location of begin_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def begin_keyword; end # Slice the location of end_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1270,20 +1270,20 @@ module Prism # ^^^^^ class BlockArgumentNode < Node # Initialize a new BlockArgumentNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, expression: T.nilable(Node), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, expression: ::T.nilable(Node), operator_loc: Location).void } def initialize(source, node_id, location, flags, expression, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1291,17 +1291,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, expression: T.nilable(Node), operator_loc: Location).returns(BlockArgumentNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, expression: ::T.nilable(Node), operator_loc: Location).returns(BlockArgumentNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1319,7 +1319,7 @@ module Prism # # foo(&args) # ^^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def expression; end # Represents the Location of the `&` operator. @@ -1331,14 +1331,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1352,16 +1352,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1369,17 +1369,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(BlockLocalVariableNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1404,7 +1404,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1414,20 +1414,20 @@ module Prism # ^^^^^^^^^^^^^^ class BlockNode < Node # Initialize a new BlockNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], parameters: T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: T.nilable(T.any(StatementsNode, BeginNode)), opening_loc: Location, closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], parameters: ::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), opening_loc: Location, closing_loc: Location).void } def initialize(source, node_id, location, flags, locals, parameters, body, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1435,17 +1435,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], parameters: T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: T.nilable(T.any(StatementsNode, BeginNode)), opening_loc: Location, closing_loc: Location).returns(BlockNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], parameters: ::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), opening_loc: Location, closing_loc: Location).returns(BlockNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1474,14 +1474,14 @@ module Prism # ^^^^^^^^^^^ # [1, 2, 3].each { puts it } # ^^^^^^^^^^^ - sig { returns(T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode))) } + sig { returns(::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode))) } def parameters; end # The body of the block. # # [1, 2, 3].each { |i| puts x } # ^^^^^^ - sig { returns(T.nilable(T.any(StatementsNode, BeginNode))) } + sig { returns(::T.nilable(::T.any(StatementsNode, BeginNode))) } def body; end # Represents the Location of the opening `{` or `do`. @@ -1493,7 +1493,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Represents the Location of the closing `}` or `end`. @@ -1505,7 +1505,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. @@ -1516,7 +1516,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1527,20 +1527,20 @@ module Prism # end class BlockParameterNode < Node # Initialize a new BlockParameterNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).void } def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1548,17 +1548,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).returns(BlockParameterNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).returns(BlockParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1581,19 +1581,19 @@ module Prism # def a(&b) # name `:b` # ^ # end - sig { returns(T.nilable(Symbol)) } + sig { returns(::T.nilable(Symbol)) } def name; end # Represents the Location of the block parameter name. # # def a(&b) # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def name_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_name_loc(repository); end # Represents the Location of the `&` operator. @@ -1606,14 +1606,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1627,20 +1627,20 @@ module Prism # end class BlockParametersNode < Node # Initialize a new BlockParametersNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parameters: T.nilable(ParametersNode), locals: T::Array[BlockLocalVariableNode], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parameters: ::T.nilable(ParametersNode), locals: T::Array[BlockLocalVariableNode], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, parameters, locals, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1648,17 +1648,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, parameters: T.nilable(ParametersNode), locals: T::Array[BlockLocalVariableNode], opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(BlockParametersNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, parameters: ::T.nilable(ParametersNode), locals: T::Array[BlockLocalVariableNode], opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(BlockParametersNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parameters: T.unsafe(nil), locals: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1680,7 +1680,7 @@ module Prism # foo do |a, b = 1; local| # ^^^^^^^^ # end - sig { returns(T.nilable(ParametersNode)) } + sig { returns(::T.nilable(ParametersNode)) } def parameters; end # Represents the local variables of the block. @@ -1702,12 +1702,12 @@ module Prism # foo do |a, b = 1; local| # ^ # end - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Represents the closing Location of the block parameters. @@ -1718,23 +1718,23 @@ module Prism # foo do |a, b = 1; local| # ^ # end - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1744,20 +1744,20 @@ module Prism # ^^^^^^^^^ class BreakNode < Node # Initialize a new BreakNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: T.nilable(ArgumentsNode), keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: ::T.nilable(ArgumentsNode), keyword_loc: Location).void } def initialize(source, node_id, location, flags, arguments, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1765,17 +1765,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, arguments: T.nilable(ArgumentsNode), keyword_loc: Location).returns(BreakNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, arguments: ::T.nilable(ArgumentsNode), keyword_loc: Location).returns(BreakNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1793,7 +1793,7 @@ module Prism # # break foo # ^^^ - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # The Location of the `break` keyword. @@ -1805,14 +1805,14 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of keyword_loc from the source. sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1822,20 +1822,20 @@ module Prism # ^^^^^^^^^^^^^^^^^ class CallAndWriteNode < Node # Initialize a new CallAndWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).void } def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -1843,17 +1843,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallAndWriteNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -1887,31 +1887,31 @@ module Prism # # foo.bar &&= value # ^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Represents the Location of the call operator. # # foo.bar &&= value # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def call_operator_loc; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_call_operator_loc(repository); end # Represents the Location of the message. # # foo.bar &&= value # ^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def message_loc; end # Save the message_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_message_loc(repository); end # Represents the name of the method being called. @@ -1937,7 +1937,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Represents the value being assigned. @@ -1948,18 +1948,18 @@ module Prism def value; end # Slice the location of call_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def call_operator; end # Slice the location of message_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def message; end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -1984,20 +1984,20 @@ module Prism # ^^^^^^^^ class CallNode < Node # Initialize a new CallNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), name: Symbol, message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), equal_loc: T.nilable(Location), block: T.nilable(T.any(BlockNode, BlockArgumentNode))).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), name: Symbol, message_loc: ::T.nilable(Location), opening_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), closing_loc: ::T.nilable(Location), equal_loc: ::T.nilable(Location), block: ::T.nilable(::T.any(BlockNode, BlockArgumentNode))).void } def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, equal_loc, block); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2005,17 +2005,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), name: Symbol, message_loc: T.nilable(Location), opening_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), closing_loc: T.nilable(Location), equal_loc: T.nilable(Location), block: T.nilable(T.any(BlockNode, BlockArgumentNode))).returns(CallNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), name: Symbol, message_loc: ::T.nilable(Location), opening_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), closing_loc: ::T.nilable(Location), equal_loc: ::T.nilable(Location), block: ::T.nilable(::T.any(BlockNode, BlockArgumentNode))).returns(CallNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), block: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2055,7 +2055,7 @@ module Prism # # foo + bar # ^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Represents the Location of the call operator. @@ -2065,12 +2065,12 @@ module Prism # # foo&.bar # ^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def call_operator_loc; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_call_operator_loc(repository); end # Represents the name of the method being called. @@ -2084,43 +2084,43 @@ module Prism # # foo.bar # ^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def message_loc; end # Save the message_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_message_loc(repository); end # Represents the Location of the left parenthesis. # # foo(bar) # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Represents the arguments to the method call. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). # # foo(bar) # ^^^ - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Represents the Location of the right parenthesis. # # foo(bar) # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Represents the Location of the equal sign, in the case that this is an attribute write. @@ -2130,42 +2130,42 @@ module Prism # # foo[bar] = value # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def equal_loc; end # Save the equal_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_equal_loc(repository); end # Represents the block that is being passed to the method. # # foo { |a| a } # ^^^^^^^^^ - sig { returns(T.nilable(T.any(BlockNode, BlockArgumentNode))) } + sig { returns(::T.nilable(::T.any(BlockNode, BlockArgumentNode))) } def block; end # Slice the location of call_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def call_operator; end # Slice the location of message_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def message; end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end # Slice the location of equal_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def equal; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -2175,20 +2175,20 @@ module Prism # ^^^^^^^^^^^^^^ class CallOperatorWriteNode < Node # Initialize a new CallOperatorWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Node).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Node).void } def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2196,17 +2196,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(CallOperatorWriteNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(CallOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2240,31 +2240,31 @@ module Prism # # foo.bar += value # ^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Represents the Location of the call operator. # # foo.bar += value # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def call_operator_loc; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_call_operator_loc(repository); end # Represents the Location of the message. # # foo.bar += value # ^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def message_loc; end # Save the message_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_message_loc(repository); end # Represents the name of the method being called. @@ -2297,7 +2297,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Represents the value being assigned. @@ -2308,14 +2308,14 @@ module Prism def value; end # Slice the location of call_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def call_operator; end # Slice the location of message_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def message; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -2325,20 +2325,20 @@ module Prism # ^^^^^^^^^^^^^^^^^ class CallOrWriteNode < Node # Initialize a new CallOrWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).void } def initialize(source, node_id, location, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2346,17 +2346,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), message_loc: T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallOrWriteNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), message_loc: ::T.nilable(Location), read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node).returns(CallOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), message_loc: T.unsafe(nil), read_name: T.unsafe(nil), write_name: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2390,31 +2390,31 @@ module Prism # # foo.bar ||= value # ^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Represents the Location of the call operator. # # foo.bar ||= value # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def call_operator_loc; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_call_operator_loc(repository); end # Represents the Location of the message. # # foo.bar ||= value # ^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def message_loc; end # Save the message_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_message_loc(repository); end # Represents the name of the method being called. @@ -2440,7 +2440,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Represents the value being assigned. @@ -2451,18 +2451,18 @@ module Prism def value; end # Slice the location of call_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def call_operator; end # Slice the location of message_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def message; end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -2484,16 +2484,16 @@ module Prism def initialize(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2501,17 +2501,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, receiver: Node, call_operator_loc: Location, name: Symbol, message_loc: Location).returns(CallTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), name: T.unsafe(nil), message_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2557,7 +2557,7 @@ module Prism # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_call_operator_loc(repository); end # Represents the name of the method being called. @@ -2576,7 +2576,7 @@ module Prism # Save the message_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_message_loc(repository); end # Slice the location of call_operator_loc from the source. @@ -2587,7 +2587,7 @@ module Prism sig { returns(String) } def message; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -2601,16 +2601,16 @@ module Prism def initialize(source, node_id, location, flags, value, target, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2618,17 +2618,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, value: Node, target: LocalVariableTargetNode, operator_loc: Location).returns(CapturePatternNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2665,14 +2665,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -2684,20 +2684,20 @@ module Prism # ^^^^^^^^^ class CaseMatchNode < Node # Initialize a new CaseMatchNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: T.nilable(Node), conditions: T::Array[InNode], else_clause: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: ::T.nilable(Node), conditions: T::Array[InNode], else_clause: ::T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).void } def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2705,17 +2705,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, predicate: T.nilable(Node), conditions: T::Array[InNode], else_clause: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseMatchNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, predicate: ::T.nilable(Node), conditions: T::Array[InNode], else_clause: ::T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseMatchNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2733,7 +2733,7 @@ module Prism # # case true; in false; end # ^^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def predicate; end # Represents the conditions of the case match. @@ -2747,7 +2747,7 @@ module Prism # # case true; in false; else; end # ^^^^^^^^^ - sig { returns(T.nilable(ElseNode)) } + sig { returns(::T.nilable(ElseNode)) } def else_clause; end # Represents the Location of the `case` keyword. @@ -2759,7 +2759,7 @@ module Prism # Save the case_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_case_keyword_loc(repository); end # Represents the Location of the `end` keyword. @@ -2771,7 +2771,7 @@ module Prism # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_end_keyword_loc(repository); end # Slice the location of case_keyword_loc from the source. @@ -2782,7 +2782,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -2794,20 +2794,20 @@ module Prism # ^^^^^^^^^^ class CaseNode < Node # Initialize a new CaseNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: T.nilable(Node), conditions: T::Array[WhenNode], else_clause: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, predicate: ::T.nilable(Node), conditions: T::Array[WhenNode], else_clause: ::T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).void } def initialize(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2815,17 +2815,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, predicate: T.nilable(Node), conditions: T::Array[WhenNode], else_clause: T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, predicate: ::T.nilable(Node), conditions: T::Array[WhenNode], else_clause: ::T.nilable(ElseNode), case_keyword_loc: Location, end_keyword_loc: Location).returns(CaseNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), predicate: T.unsafe(nil), conditions: T.unsafe(nil), else_clause: T.unsafe(nil), case_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2843,7 +2843,7 @@ module Prism # # case true; when false; end # ^^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def predicate; end # Represents the conditions of the case statement. @@ -2857,7 +2857,7 @@ module Prism # # case true; when false; else; end # ^^^^^^^^^ - sig { returns(T.nilable(ElseNode)) } + sig { returns(::T.nilable(ElseNode)) } def else_clause; end # Represents the Location of the `case` keyword. @@ -2869,7 +2869,7 @@ module Prism # Save the case_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_case_keyword_loc(repository); end # Represents the Location of the `end` keyword. @@ -2881,7 +2881,7 @@ module Prism # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_end_keyword_loc(repository); end # Slice the location of case_keyword_loc from the source. @@ -2892,7 +2892,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -2902,20 +2902,20 @@ module Prism # ^^^^^^^^^^^^^ class ClassNode < Node # Initialize a new ClassNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: T.any(ConstantReadNode, ConstantPathNode, CallNode), inheritance_operator_loc: T.nilable(Location), superclass: T.nilable(Node), body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: ::T.any(ConstantReadNode, ConstantPathNode, CallNode), inheritance_operator_loc: ::T.nilable(Location), superclass: ::T.nilable(Node), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).void } def initialize(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -2923,17 +2923,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: T.any(ConstantReadNode, ConstantPathNode, CallNode), inheritance_operator_loc: T.nilable(Location), superclass: T.nilable(Node), body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ClassNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, constant_path: ::T.any(ConstantReadNode, ConstantPathNode, CallNode), inheritance_operator_loc: ::T.nilable(Location), superclass: ::T.nilable(Node), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ClassNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), inheritance_operator_loc: T.unsafe(nil), superclass: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -2960,37 +2960,37 @@ module Prism # Save the class_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_class_keyword_loc(repository); end # Returns the `constant_path` attribute. - sig { returns(T.any(ConstantReadNode, ConstantPathNode, CallNode)) } + sig { returns(::T.any(ConstantReadNode, ConstantPathNode, CallNode)) } def constant_path; end # Represents the Location of the `<` operator. # # class Foo < Bar # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def inheritance_operator_loc; end # Save the inheritance_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_inheritance_operator_loc(repository); end # Represents the superclass of the class. # # class Foo < Bar # ^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def superclass; end # Represents the body of the class. # # class Foo; bar; end # ^^^ - sig { returns(T.nilable(T.any(StatementsNode, BeginNode))) } + sig { returns(::T.nilable(::T.any(StatementsNode, BeginNode))) } def body; end # Represents the Location of the `end` keyword. @@ -3002,7 +3002,7 @@ module Prism # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_end_keyword_loc(repository); end # The name of the class. @@ -3016,14 +3016,14 @@ module Prism def class_keyword; end # Slice the location of inheritance_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def inheritance_operator; end # Slice the location of end_keyword_loc from the source. sig { returns(String) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3037,16 +3037,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3054,17 +3054,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(ClassVariableAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3094,7 +3094,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Represents the Location of the `&&=` operator. @@ -3106,7 +3106,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Represents the value being assigned. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -3120,7 +3120,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3134,16 +3134,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3151,17 +3151,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Node, binary_operator: Symbol).returns(ClassVariableOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3185,7 +3185,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `binary_operator_loc`. @@ -3194,7 +3194,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Returns the `value` attribute. @@ -3205,7 +3205,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3219,16 +3219,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3236,17 +3236,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(ClassVariableOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3270,7 +3270,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -3279,7 +3279,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -3290,7 +3290,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3304,16 +3304,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3321,17 +3321,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(ClassVariableReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3353,7 +3353,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3367,16 +3367,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3384,17 +3384,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(ClassVariableTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3412,7 +3412,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3426,16 +3426,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3443,17 +3443,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, value: Node, operator_loc: Location).returns(ClassVariableWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3484,7 +3484,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -3506,14 +3506,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3527,16 +3527,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3544,17 +3544,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(ConstantAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3578,7 +3578,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -3587,7 +3587,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -3598,7 +3598,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3612,16 +3612,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3629,17 +3629,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Node, binary_operator: Symbol).returns(ConstantOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3663,7 +3663,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `binary_operator_loc`. @@ -3672,7 +3672,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Returns the `value` attribute. @@ -3683,7 +3683,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3697,16 +3697,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3714,17 +3714,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(ConstantOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3748,7 +3748,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -3757,7 +3757,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -3768,7 +3768,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3782,16 +3782,16 @@ module Prism def initialize(source, node_id, location, flags, target, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3799,17 +3799,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, target: ConstantPathNode, operator_loc: Location, value: Node).returns(ConstantPathAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3833,7 +3833,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -3844,7 +3844,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3854,20 +3854,20 @@ module Prism # ^^^^^^^^ class ConstantPathNode < Node # Initialize a new ConstantPathNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: T.nilable(Node), name: T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: ::T.nilable(Node), name: ::T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).void } def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3875,17 +3875,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, parent: T.nilable(Node), name: T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, parent: ::T.nilable(Node), name: ::T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -3909,11 +3909,11 @@ module Prism # # a.b::C # ^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def parent; end # The name of the constant being accessed. This could be `nil` in the event of a syntax error. - sig { returns(T.nilable(Symbol)) } + sig { returns(::T.nilable(Symbol)) } def name; end # The Location of the `::` delimiter. @@ -3928,7 +3928,7 @@ module Prism # Save the delimiter_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_delimiter_loc(repository); end # The Location of the name of the constant. @@ -3943,14 +3943,14 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Slice the location of delimiter_loc from the source. sig { returns(String) } def delimiter; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -3964,16 +3964,16 @@ module Prism def initialize(source, node_id, location, flags, target, binary_operator_loc, value, binary_operator); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -3981,17 +3981,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, target: ConstantPathNode, binary_operator_loc: Location, value: Node, binary_operator: Symbol).returns(ConstantPathOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4015,7 +4015,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Returns the `value` attribute. @@ -4026,7 +4026,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4040,16 +4040,16 @@ module Prism def initialize(source, node_id, location, flags, target, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4057,17 +4057,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, target: ConstantPathNode, operator_loc: Location, value: Node).returns(ConstantPathOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4091,7 +4091,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -4102,7 +4102,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4112,20 +4112,20 @@ module Prism # ^^^^^^^^ ^^^^^^^^ class ConstantPathTargetNode < Node # Initialize a new ConstantPathTargetNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: T.nilable(Node), name: T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, parent: ::T.nilable(Node), name: ::T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).void } def initialize(source, node_id, location, flags, parent, name, delimiter_loc, name_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4133,17 +4133,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, parent: T.nilable(Node), name: T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathTargetNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, parent: ::T.nilable(Node), name: ::T.nilable(Symbol), delimiter_loc: Location, name_loc: Location).returns(ConstantPathTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), parent: T.unsafe(nil), name: T.unsafe(nil), delimiter_loc: T.unsafe(nil), name_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4158,11 +4158,11 @@ module Prism def inspect; end # Returns the `parent` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def parent; end # Returns the `name` attribute. - sig { returns(T.nilable(Symbol)) } + sig { returns(::T.nilable(Symbol)) } def name; end # Returns the Location represented by `delimiter_loc`. @@ -4171,7 +4171,7 @@ module Prism # Save the delimiter_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_delimiter_loc(repository); end # Returns the Location represented by `name_loc`. @@ -4180,14 +4180,14 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Slice the location of delimiter_loc from the source. sig { returns(String) } def delimiter; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4207,16 +4207,16 @@ module Prism def initialize(source, node_id, location, flags, target, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4224,17 +4224,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, target: ConstantPathNode, operator_loc: Location, value: Node).returns(ConstantPathWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), target: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4267,7 +4267,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -4281,7 +4281,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4295,16 +4295,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4312,17 +4312,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(ConstantReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4344,7 +4344,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4358,16 +4358,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4375,17 +4375,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(ConstantTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4403,7 +4403,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4417,16 +4417,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4434,17 +4434,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, value: Node, operator_loc: Location).returns(ConstantWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4475,7 +4475,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -4497,14 +4497,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4515,20 +4515,20 @@ module Prism # ^^^^^^^^^^ class DefNode < Node # Initialize a new DefNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, receiver: T.nilable(Node), parameters: T.nilable(ParametersNode), body: T.nilable(T.any(StatementsNode, BeginNode)), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: T.nilable(Location), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), equal_loc: T.nilable(Location), end_keyword_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, receiver: ::T.nilable(Node), parameters: ::T.nilable(ParametersNode), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: ::T.nilable(Location), lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location), equal_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4536,17 +4536,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, receiver: T.nilable(Node), parameters: T.nilable(ParametersNode), body: T.nilable(T.any(StatementsNode, BeginNode)), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: T.nilable(Location), lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), equal_loc: T.nilable(Location), end_keyword_loc: T.nilable(Location)).returns(DefNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, receiver: ::T.nilable(Node), parameters: ::T.nilable(ParametersNode), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), locals: T::Array[Symbol], def_keyword_loc: Location, operator_loc: ::T.nilable(Location), lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location), equal_loc: ::T.nilable(Location), end_keyword_loc: ::T.nilable(Location)).returns(DefNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), receiver: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil), locals: T.unsafe(nil), def_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), equal_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4570,19 +4570,19 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the `receiver` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Returns the `parameters` attribute. - sig { returns(T.nilable(ParametersNode)) } + sig { returns(::T.nilable(ParametersNode)) } def parameters; end # Returns the `body` attribute. - sig { returns(T.nilable(T.any(StatementsNode, BeginNode))) } + sig { returns(::T.nilable(::T.any(StatementsNode, BeginNode))) } def body; end # Returns the `locals` attribute. @@ -4595,52 +4595,52 @@ module Prism # Save the def_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_def_keyword_loc(repository); end # Returns the Location represented by `operator_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_operator_loc(repository); end # Returns the Location represented by `lparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def lparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_lparen_loc(repository); end # Returns the Location represented by `rparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def rparen_loc; end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_rparen_loc(repository); end # Returns the Location represented by `equal_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def equal_loc; end # Save the equal_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_equal_loc(repository); end # Returns the Location represented by `end_keyword_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def end_keyword_loc; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_end_keyword_loc(repository); end # Slice the location of def_keyword_loc from the source. @@ -4648,26 +4648,26 @@ module Prism def def_keyword; end # Slice the location of operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def operator; end # Slice the location of lparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def lparen; end # Slice the location of rparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def rparen; end # Slice the location of equal_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def equal; end # Slice the location of end_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4677,20 +4677,20 @@ module Prism # ^^^^^^^^^^^ class DefinedNode < Node # Initialize a new DefinedNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lparen_loc: T.nilable(Location), value: Node, rparen_loc: T.nilable(Location), keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lparen_loc: ::T.nilable(Location), value: Node, rparen_loc: ::T.nilable(Location), keyword_loc: Location).void } def initialize(source, node_id, location, flags, lparen_loc, value, rparen_loc, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4698,17 +4698,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, lparen_loc: T.nilable(Location), value: Node, rparen_loc: T.nilable(Location), keyword_loc: Location).returns(DefinedNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, lparen_loc: ::T.nilable(Location), value: Node, rparen_loc: ::T.nilable(Location), keyword_loc: Location).returns(DefinedNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lparen_loc: T.unsafe(nil), value: T.unsafe(nil), rparen_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4723,12 +4723,12 @@ module Prism def inspect; end # Returns the Location represented by `lparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def lparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_lparen_loc(repository); end # Returns the `value` attribute. @@ -4736,12 +4736,12 @@ module Prism def value; end # Returns the Location represented by `rparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def rparen_loc; end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_rparen_loc(repository); end # Returns the Location represented by `keyword_loc`. @@ -4750,22 +4750,22 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of lparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def lparen; end # Slice the location of rparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def rparen; end # Slice the location of keyword_loc from the source. sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4775,20 +4775,20 @@ module Prism # ^^^^^^^^^^ class ElseNode < Node # Initialize a new ElseNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, else_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, else_keyword_loc: Location, statements: ::T.nilable(StatementsNode), end_keyword_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, else_keyword_loc, statements, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4796,17 +4796,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, else_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: T.nilable(Location)).returns(ElseNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, else_keyword_loc: Location, statements: ::T.nilable(StatementsNode), end_keyword_loc: ::T.nilable(Location)).returns(ElseNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), else_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4826,20 +4826,20 @@ module Prism # Save the else_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_else_keyword_loc(repository); end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Returns the Location represented by `end_keyword_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def end_keyword_loc; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_end_keyword_loc(repository); end # Slice the location of else_keyword_loc from the source. @@ -4847,10 +4847,10 @@ module Prism def else_keyword; end # Slice the location of end_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4860,20 +4860,20 @@ module Prism # ^^^^^^ class EmbeddedStatementsNode < Node # Initialize a new EmbeddedStatementsNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, statements: T.nilable(StatementsNode), closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, statements: ::T.nilable(StatementsNode), closing_loc: Location).void } def initialize(source, node_id, location, flags, opening_loc, statements, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4881,17 +4881,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, statements: T.nilable(StatementsNode), closing_loc: Location).returns(EmbeddedStatementsNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, statements: ::T.nilable(StatementsNode), closing_loc: Location).returns(EmbeddedStatementsNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), statements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4911,11 +4911,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Returns the Location represented by `closing_loc`. @@ -4924,7 +4924,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. @@ -4935,7 +4935,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -4945,20 +4945,20 @@ module Prism # ^^^^^ class EmbeddedVariableNode < Node # Initialize a new EmbeddedVariableNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, variable: T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, variable: ::T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)).void } def initialize(source, node_id, location, flags, operator_loc, variable); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -4966,17 +4966,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, operator_loc: Location, variable: T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)).returns(EmbeddedVariableNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, operator_loc: Location, variable: ::T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)).returns(EmbeddedVariableNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), variable: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -4996,18 +4996,18 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `variable` attribute. - sig { returns(T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)) } + sig { returns(::T.any(InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode)) } def variable; end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5021,20 +5021,20 @@ module Prism # end class EnsureNode < Node # Initialize a new EnsureNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, ensure_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, ensure_keyword_loc: Location, statements: ::T.nilable(StatementsNode), end_keyword_loc: Location).void } def initialize(source, node_id, location, flags, ensure_keyword_loc, statements, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5042,17 +5042,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, ensure_keyword_loc: Location, statements: T.nilable(StatementsNode), end_keyword_loc: Location).returns(EnsureNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, ensure_keyword_loc: Location, statements: ::T.nilable(StatementsNode), end_keyword_loc: Location).returns(EnsureNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), ensure_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5072,11 +5072,11 @@ module Prism # Save the ensure_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_ensure_keyword_loc(repository); end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Returns the Location represented by `end_keyword_loc`. @@ -5085,7 +5085,7 @@ module Prism # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_end_keyword_loc(repository); end # Slice the location of ensure_keyword_loc from the source. @@ -5096,7 +5096,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5110,16 +5110,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5127,17 +5127,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(FalseNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5151,7 +5151,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5170,20 +5170,20 @@ module Prism # ^^^^^^^^^^^^^^^ class FindPatternNode < Node # Initialize a new FindPatternNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), left: SplatNode, requireds: T::Array[Node], right: T.any(SplatNode, MissingNode), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), left: SplatNode, requireds: T::Array[Node], right: ::T.any(SplatNode, MissingNode), opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5191,17 +5191,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), left: SplatNode, requireds: T::Array[Node], right: T.any(SplatNode, MissingNode), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(FindPatternNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), left: SplatNode, requireds: T::Array[Node], right: ::T.any(SplatNode, MissingNode), opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(FindPatternNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), left: T.unsafe(nil), requireds: T.unsafe(nil), right: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5219,7 +5219,7 @@ module Prism # # foo in Foo(*bar, baz, *qux) # ^^^ - sig { returns(T.nilable(T.any(ConstantPathNode, ConstantReadNode))) } + sig { returns(::T.nilable(::T.any(ConstantPathNode, ConstantReadNode))) } def constant; end # Represents the first wildcard node in the pattern. @@ -5249,7 +5249,7 @@ module Prism # # foo in Foo(*bar, baz, *qux) # ^^^^ - sig { returns(T.any(SplatNode, MissingNode)) } + sig { returns(::T.any(SplatNode, MissingNode)) } def right; end # The Location of the opening brace. @@ -5259,12 +5259,12 @@ module Prism # # foo in Foo(*bar, baz, *qux) # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # The Location of the closing brace. @@ -5274,23 +5274,23 @@ module Prism # # foo in Foo(*bar, baz, *qux) # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5300,20 +5300,20 @@ module Prism # ^^^^^^^^^^ class FlipFlopNode < Node # Initialize a new FlipFlopNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: ::T.nilable(Node), right: ::T.nilable(Node), operator_loc: Location).void } def initialize(source, node_id, location, flags, left, right, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5321,17 +5321,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location).returns(FlipFlopNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, left: ::T.nilable(Node), right: ::T.nilable(Node), operator_loc: Location).returns(FlipFlopNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5350,11 +5350,11 @@ module Prism def exclude_end?; end # Returns the `left` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def left; end # Returns the `right` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def right; end # Returns the Location represented by `operator_loc`. @@ -5363,14 +5363,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5384,16 +5384,16 @@ module Prism def initialize(source, node_id, location, flags, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5401,17 +5401,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, value: Float).returns(FloatNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5429,7 +5429,7 @@ module Prism sig { returns(Float) } def value; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5439,20 +5439,20 @@ module Prism # ^^^^^^^^^^^^^^ class ForNode < Node # Initialize a new ForNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, index: T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode), collection: Node, statements: T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: T.nilable(Location), end_keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, index: ::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode), collection: Node, statements: ::T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: Location).void } def initialize(source, node_id, location, flags, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5460,17 +5460,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, index: T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode), collection: Node, statements: T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: T.nilable(Location), end_keyword_loc: Location).returns(ForNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, index: ::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode), collection: Node, statements: ::T.nilable(StatementsNode), for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), end_keyword_loc: Location).returns(ForNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), index: T.unsafe(nil), collection: T.unsafe(nil), statements: T.unsafe(nil), for_keyword_loc: T.unsafe(nil), in_keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5488,7 +5488,7 @@ module Prism # # for i in a end # ^ - sig { returns(T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)) } + sig { returns(::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)) } def index; end # The collection to iterate over. @@ -5504,7 +5504,7 @@ module Prism # foo(i) # ^^^^^^ # end - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # The Location of the `for` keyword. @@ -5516,7 +5516,7 @@ module Prism # Save the for_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_for_keyword_loc(repository); end # The Location of the `in` keyword. @@ -5528,19 +5528,19 @@ module Prism # Save the in_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_in_keyword_loc(repository); end # The Location of the `do` keyword, if present. # # for i in a do end # ^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def do_keyword_loc; end # Save the do_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_do_keyword_loc(repository); end # The Location of the `end` keyword. @@ -5552,7 +5552,7 @@ module Prism # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_end_keyword_loc(repository); end # Slice the location of for_keyword_loc from the source. @@ -5564,14 +5564,14 @@ module Prism def in_keyword; end # Slice the location of do_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def do_keyword; end # Slice the location of end_keyword_loc from the source. sig { returns(String) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5587,16 +5587,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5604,17 +5604,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(ForwardingArgumentsNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5628,7 +5628,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5643,16 +5643,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5660,17 +5660,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(ForwardingParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5684,7 +5684,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5699,20 +5699,20 @@ module Prism # If it has any other arguments, it would be a `SuperNode` instead. class ForwardingSuperNode < Node # Initialize a new ForwardingSuperNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, block: T.nilable(BlockNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, block: ::T.nilable(BlockNode)).void } def initialize(source, node_id, location, flags, block); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5720,17 +5720,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, block: T.nilable(BlockNode)).returns(ForwardingSuperNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, block: ::T.nilable(BlockNode)).returns(ForwardingSuperNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), block: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5745,10 +5745,10 @@ module Prism def inspect; end # All other arguments are forwarded as normal, except the original block is replaced with the new block. - sig { returns(T.nilable(BlockNode)) } + sig { returns(::T.nilable(BlockNode)) } def block; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5762,16 +5762,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5779,17 +5779,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(GlobalVariableAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5813,7 +5813,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -5822,7 +5822,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -5833,7 +5833,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5847,16 +5847,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5864,17 +5864,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Node, binary_operator: Symbol).returns(GlobalVariableOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5898,7 +5898,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `binary_operator_loc`. @@ -5907,7 +5907,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Returns the `value` attribute. @@ -5918,7 +5918,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -5932,16 +5932,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -5949,17 +5949,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(GlobalVariableOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -5983,7 +5983,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -5992,7 +5992,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -6003,7 +6003,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6017,16 +6017,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6034,17 +6034,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(GlobalVariableReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6066,7 +6066,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6080,16 +6080,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6097,17 +6097,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(GlobalVariableTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6125,7 +6125,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6139,16 +6139,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6156,17 +6156,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, value: Node, operator_loc: Location).returns(GlobalVariableWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6197,7 +6197,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -6219,14 +6219,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6236,20 +6236,20 @@ module Prism # ^^^^^^^^^^ class HashNode < Node # Initialize a new HashNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, elements: T::Array[T.any(AssocNode, AssocSplatNode)], closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, elements: T::Array[::T.any(AssocNode, AssocSplatNode)], closing_loc: Location).void } def initialize(source, node_id, location, flags, opening_loc, elements, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6257,17 +6257,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, elements: T::Array[T.any(AssocNode, AssocSplatNode)], closing_loc: Location).returns(HashNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, elements: T::Array[::T.any(AssocNode, AssocSplatNode)], closing_loc: Location).returns(HashNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), elements: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6290,7 +6290,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s. @@ -6300,7 +6300,7 @@ module Prism # # { **foo } # ^^^^^ - sig { returns(T::Array[T.any(AssocNode, AssocSplatNode)]) } + sig { returns(T::Array[::T.any(AssocNode, AssocSplatNode)]) } def elements; end # The Location of the closing brace. @@ -6312,7 +6312,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. @@ -6323,7 +6323,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6342,20 +6342,20 @@ module Prism # ^^^^^^^^^^^^^^ class HashPatternNode < Node # Initialize a new HashPatternNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), elements: T::Array[AssocNode], rest: T.nilable(T.any(AssocSplatNode, NoKeywordsParameterNode)), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), elements: T::Array[AssocNode], rest: ::T.nilable(::T.any(AssocSplatNode, NoKeywordsParameterNode)), opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6363,17 +6363,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, constant: T.nilable(T.any(ConstantPathNode, ConstantReadNode)), elements: T::Array[AssocNode], rest: T.nilable(T.any(AssocSplatNode, NoKeywordsParameterNode)), opening_loc: T.nilable(Location), closing_loc: T.nilable(Location)).returns(HashPatternNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, constant: ::T.nilable(::T.any(ConstantPathNode, ConstantReadNode)), elements: T::Array[AssocNode], rest: ::T.nilable(::T.any(AssocSplatNode, NoKeywordsParameterNode)), opening_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location)).returns(HashPatternNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), constant: T.unsafe(nil), elements: T.unsafe(nil), rest: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6394,7 +6394,7 @@ module Prism # # foo => Bar::Baz[a: 1, b: 2] # ^^^^^^^^ - sig { returns(T.nilable(T.any(ConstantPathNode, ConstantReadNode))) } + sig { returns(::T.nilable(::T.any(ConstantPathNode, ConstantReadNode))) } def constant; end # Represents the explicit named hash keys and values. @@ -6414,7 +6414,7 @@ module Prism # # foo => { a: 1, b:, **nil } # ^^^^^ - sig { returns(T.nilable(T.any(AssocSplatNode, NoKeywordsParameterNode))) } + sig { returns(::T.nilable(::T.any(AssocSplatNode, NoKeywordsParameterNode))) } def rest; end # The Location of the opening brace. @@ -6424,12 +6424,12 @@ module Prism # # foo => Bar[a: 1] # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # The Location of the closing brace. @@ -6439,23 +6439,23 @@ module Prism # # foo => Bar[a: 1] # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6471,20 +6471,20 @@ module Prism # ^^^^^^^^^^^^^^^ class IfNode < Node # Initialize a new IfNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, if_keyword_loc: T.nilable(Location), predicate: Node, then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), subsequent: T.nilable(T.any(ElseNode, IfNode)), end_keyword_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, if_keyword_loc: ::T.nilable(Location), predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), subsequent: ::T.nilable(::T.any(ElseNode, IfNode)), end_keyword_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, if_keyword_loc, predicate, then_keyword_loc, statements, subsequent, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6492,17 +6492,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, if_keyword_loc: T.nilable(Location), predicate: Node, then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), subsequent: T.nilable(T.any(ElseNode, IfNode)), end_keyword_loc: T.nilable(Location)).returns(IfNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, if_keyword_loc: ::T.nilable(Location), predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), subsequent: ::T.nilable(::T.any(ElseNode, IfNode)), end_keyword_loc: ::T.nilable(Location)).returns(IfNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), if_keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6522,12 +6522,12 @@ module Prism # ^^ # # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def if_keyword_loc; end # Save the if_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_if_keyword_loc(repository); end # The node for the condition the `IfNode` is testing. @@ -6552,12 +6552,12 @@ module Prism # # a ? b : c # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def then_keyword_loc; end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_then_keyword_loc(repository); end # Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided. @@ -6568,7 +6568,7 @@ module Prism # baz # ^^^ # end - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement. @@ -6584,7 +6584,7 @@ module Prism # # if foo then bar else baz end # ^^^^^^^^^^^^ - sig { returns(T.nilable(T.any(ElseNode, IfNode))) } + sig { returns(::T.nilable(::T.any(ElseNode, IfNode))) } def subsequent; end # The Location of the `end` keyword if present, `nil` otherwise. @@ -6593,27 +6593,27 @@ module Prism # bar # end # ^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def end_keyword_loc; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_end_keyword_loc(repository); end # Slice the location of if_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def if_keyword; end # Slice the location of then_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def then_keyword; end # Slice the location of end_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6623,20 +6623,20 @@ module Prism # ^^^^ class ImaginaryNode < Node # Initialize a new ImaginaryNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, numeric: T.any(FloatNode, IntegerNode, RationalNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, numeric: ::T.any(FloatNode, IntegerNode, RationalNode)).void } def initialize(source, node_id, location, flags, numeric); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6644,17 +6644,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, numeric: T.any(FloatNode, IntegerNode, RationalNode)).returns(ImaginaryNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, numeric: ::T.any(FloatNode, IntegerNode, RationalNode)).returns(ImaginaryNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numeric: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6669,10 +6669,10 @@ module Prism def inspect; end # Returns the `numeric` attribute. - sig { returns(T.any(FloatNode, IntegerNode, RationalNode)) } + sig { returns(::T.any(FloatNode, IntegerNode, RationalNode)) } def numeric; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6688,20 +6688,20 @@ module Prism # ^^^^ class ImplicitNode < Node # Initialize a new ImplicitNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, value: ::T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)).void } def initialize(source, node_id, location, flags, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6709,17 +6709,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, value: T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)).returns(ImplicitNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, value: ::T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)).returns(ImplicitNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6734,10 +6734,10 @@ module Prism def inspect; end # Returns the `value` attribute. - sig { returns(T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)) } + sig { returns(::T.any(LocalVariableReadNode, CallNode, ConstantReadNode, LocalVariableTargetNode)) } def value; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6760,16 +6760,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6777,17 +6777,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(ImplicitRestNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6801,7 +6801,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6811,20 +6811,20 @@ module Prism # ^^^^^^^^^^^ class InNode < Node # Initialize a new InNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: T.nilable(StatementsNode), in_loc: Location, then_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_loc: Location, then_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, pattern, statements, in_loc, then_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6832,17 +6832,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: T.nilable(StatementsNode), in_loc: Location, then_loc: T.nilable(Location)).returns(InNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, pattern: Node, statements: ::T.nilable(StatementsNode), in_loc: Location, then_loc: ::T.nilable(Location)).returns(InNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), pattern: T.unsafe(nil), statements: T.unsafe(nil), in_loc: T.unsafe(nil), then_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6861,7 +6861,7 @@ module Prism def pattern; end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Returns the Location represented by `in_loc`. @@ -6870,16 +6870,16 @@ module Prism # Save the in_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_in_loc(repository); end # Returns the Location represented by `then_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def then_loc; end # Save the then_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_then_loc(repository); end # Slice the location of in_loc from the source. @@ -6887,10 +6887,10 @@ module Prism def in; end # Slice the location of then_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def then; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -6900,20 +6900,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^^ class IndexAndWriteNode < Node # Initialize a new IndexAndWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).void } def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -6921,17 +6921,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexAndWriteNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -6962,16 +6962,16 @@ module Prism def ignore_visibility?; end # Returns the `receiver` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Returns the Location represented by `call_operator_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def call_operator_loc; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_call_operator_loc(repository); end # Returns the Location represented by `opening_loc`. @@ -6980,11 +6980,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `arguments` attribute. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Returns the Location represented by `closing_loc`. @@ -6993,11 +6993,11 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `block` attribute. - sig { returns(T.nilable(BlockArgumentNode)) } + sig { returns(::T.nilable(BlockArgumentNode)) } def block; end # Returns the Location represented by `operator_loc`. @@ -7006,7 +7006,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -7014,7 +7014,7 @@ module Prism def value; end # Slice the location of call_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def call_operator; end # Slice the location of opening_loc from the source. @@ -7029,7 +7029,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7039,20 +7039,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^ class IndexOperatorWriteNode < Node # Initialize a new IndexOperatorWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Location, value: Node).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Location, value: Node).void } def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7060,17 +7060,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(IndexOperatorWriteNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), binary_operator: Symbol, binary_operator_loc: Location, value: Node).returns(IndexOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), binary_operator: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7101,16 +7101,16 @@ module Prism def ignore_visibility?; end # Returns the `receiver` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Returns the Location represented by `call_operator_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def call_operator_loc; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_call_operator_loc(repository); end # Returns the Location represented by `opening_loc`. @@ -7119,11 +7119,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `arguments` attribute. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Returns the Location represented by `closing_loc`. @@ -7132,11 +7132,11 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `block` attribute. - sig { returns(T.nilable(BlockArgumentNode)) } + sig { returns(::T.nilable(BlockArgumentNode)) } def block; end # Returns the `binary_operator` attribute. @@ -7149,7 +7149,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Returns the `value` attribute. @@ -7157,7 +7157,7 @@ module Prism def value; end # Slice the location of call_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def call_operator; end # Slice the location of opening_loc from the source. @@ -7168,7 +7168,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7178,20 +7178,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^^ class IndexOrWriteNode < Node # Initialize a new IndexOrWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).void } def initialize(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7199,17 +7199,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: T.nilable(Node), call_operator_loc: T.nilable(Location), opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexOrWriteNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: ::T.nilable(Node), call_operator_loc: ::T.nilable(Location), opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode), operator_loc: Location, value: Node).returns(IndexOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), call_operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7240,16 +7240,16 @@ module Prism def ignore_visibility?; end # Returns the `receiver` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def receiver; end # Returns the Location represented by `call_operator_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def call_operator_loc; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_call_operator_loc(repository); end # Returns the Location represented by `opening_loc`. @@ -7258,11 +7258,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `arguments` attribute. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Returns the Location represented by `closing_loc`. @@ -7271,11 +7271,11 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `block` attribute. - sig { returns(T.nilable(BlockArgumentNode)) } + sig { returns(::T.nilable(BlockArgumentNode)) } def block; end # Returns the Location represented by `operator_loc`. @@ -7284,7 +7284,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -7292,7 +7292,7 @@ module Prism def value; end # Slice the location of call_operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def call_operator; end # Slice the location of opening_loc from the source. @@ -7307,7 +7307,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7325,20 +7325,20 @@ module Prism # ^^^^^^^^ class IndexTargetNode < Node # Initialize a new IndexTargetNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: Node, opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, receiver: Node, opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode)).void } def initialize(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7346,17 +7346,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, receiver: Node, opening_loc: Location, arguments: T.nilable(ArgumentsNode), closing_loc: Location, block: T.nilable(BlockArgumentNode)).returns(IndexTargetNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, receiver: Node, opening_loc: Location, arguments: ::T.nilable(ArgumentsNode), closing_loc: Location, block: ::T.nilable(BlockArgumentNode)).returns(IndexTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), receiver: T.unsafe(nil), opening_loc: T.unsafe(nil), arguments: T.unsafe(nil), closing_loc: T.unsafe(nil), block: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7396,11 +7396,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `arguments` attribute. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Returns the Location represented by `closing_loc`. @@ -7409,11 +7409,11 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `block` attribute. - sig { returns(T.nilable(BlockArgumentNode)) } + sig { returns(::T.nilable(BlockArgumentNode)) } def block; end # Slice the location of opening_loc from the source. @@ -7424,7 +7424,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7438,16 +7438,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7455,17 +7455,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(InstanceVariableAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7489,7 +7489,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -7498,7 +7498,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -7509,7 +7509,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7523,16 +7523,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, binary_operator_loc, value, binary_operator); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7540,17 +7540,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Node, binary_operator: Symbol).returns(InstanceVariableOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), binary_operator: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7574,7 +7574,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `binary_operator_loc`. @@ -7583,7 +7583,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Returns the `value` attribute. @@ -7594,7 +7594,7 @@ module Prism sig { returns(Symbol) } def binary_operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7608,16 +7608,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7625,17 +7625,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(InstanceVariableOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7659,7 +7659,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -7668,7 +7668,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -7679,7 +7679,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7693,16 +7693,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7710,17 +7710,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(InstanceVariableReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7742,7 +7742,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7756,16 +7756,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7773,17 +7773,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(InstanceVariableTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7801,7 +7801,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7815,16 +7815,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, value, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7832,17 +7832,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, value: Node, operator_loc: Location).returns(InstanceVariableWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7873,7 +7873,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -7895,14 +7895,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7916,16 +7916,16 @@ module Prism def initialize(source, node_id, location, flags, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -7933,17 +7933,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, value: Integer).returns(IntegerNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -7977,7 +7977,7 @@ module Prism sig { returns(Integer) } def value; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -7987,20 +7987,20 @@ module Prism # ^^^^^^^^^^^^^^^^ class InterpolatedMatchLastLineNode < Node # Initialize a new InterpolatedMatchLastLineNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).void } def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8008,17 +8008,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedMatchLastLineNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedMatchLastLineNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8082,11 +8082,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `parts` attribute. - sig { returns(T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } + sig { returns(T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } def parts; end # Returns the Location represented by `closing_loc`. @@ -8095,7 +8095,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. @@ -8106,7 +8106,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8116,20 +8116,20 @@ module Prism # ^^^^^^^^^^^^^^^^ class InterpolatedRegularExpressionNode < Node # Initialize a new InterpolatedRegularExpressionNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).void } def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8137,17 +8137,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedRegularExpressionNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedRegularExpressionNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8211,11 +8211,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `parts` attribute. - sig { returns(T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } + sig { returns(T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } def parts; end # Returns the Location represented by `closing_loc`. @@ -8224,7 +8224,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. @@ -8235,7 +8235,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8245,20 +8245,20 @@ module Prism # ^^^^^^^^^^^^^^^^ class InterpolatedStringNode < Node # Initialize a new InterpolatedStringNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)], closing_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)], closing_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8266,17 +8266,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)], closing_loc: T.nilable(Location)).returns(InterpolatedStringNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)], closing_loc: ::T.nilable(Location)).returns(InterpolatedStringNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8299,36 +8299,36 @@ module Prism def mutable?; end # Returns the Location represented by `opening_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Returns the `parts` attribute. - sig { returns(T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)]) } + sig { returns(T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode, InterpolatedStringNode, XStringNode, InterpolatedXStringNode, SymbolNode, InterpolatedSymbolNode)]) } def parts; end # Returns the Location represented by `closing_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8338,20 +8338,20 @@ module Prism # ^^^^^^^^^^^^^^^^^ class InterpolatedSymbolNode < Node # Initialize a new InterpolatedSymbolNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8359,17 +8359,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: T.nilable(Location)).returns(InterpolatedSymbolNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: ::T.nilable(Location)).returns(InterpolatedSymbolNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8384,36 +8384,36 @@ module Prism def inspect; end # Returns the Location represented by `opening_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Returns the `parts` attribute. - sig { returns(T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } + sig { returns(T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } def parts; end # Returns the Location represented by `closing_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8423,20 +8423,20 @@ module Prism # ^^^^^^^^^^^^^^^^ class InterpolatedXStringNode < Node # Initialize a new InterpolatedXStringNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).void } def initialize(source, node_id, location, flags, opening_loc, parts, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8444,17 +8444,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedXStringNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, parts: T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)], closing_loc: Location).returns(InterpolatedXStringNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), parts: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8474,11 +8474,11 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the `parts` attribute. - sig { returns(T::Array[T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } + sig { returns(T::Array[::T.any(StringNode, EmbeddedStatementsNode, EmbeddedVariableNode)]) } def parts; end # Returns the Location represented by `closing_loc`. @@ -8487,7 +8487,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. @@ -8498,7 +8498,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8512,16 +8512,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8529,17 +8529,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(ItLocalVariableReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8553,7 +8553,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8567,16 +8567,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8584,17 +8584,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(ItParametersNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8608,7 +8608,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8618,20 +8618,20 @@ module Prism # ^^^^ class KeywordHashNode < Node # Initialize a new KeywordHashNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[T.any(AssocNode, AssocSplatNode)]).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, elements: T::Array[::T.any(AssocNode, AssocSplatNode)]).void } def initialize(source, node_id, location, flags, elements); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8639,17 +8639,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, elements: T::Array[T.any(AssocNode, AssocSplatNode)]).returns(KeywordHashNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, elements: T::Array[::T.any(AssocNode, AssocSplatNode)]).returns(KeywordHashNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), elements: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8668,10 +8668,10 @@ module Prism def symbol_keys?; end # Returns the `elements` attribute. - sig { returns(T::Array[T.any(AssocNode, AssocSplatNode)]) } + sig { returns(T::Array[::T.any(AssocNode, AssocSplatNode)]) } def elements; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8682,20 +8682,20 @@ module Prism # end class KeywordRestParameterNode < Node # Initialize a new KeywordRestParameterNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).void } def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8703,17 +8703,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).returns(KeywordRestParameterNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).returns(KeywordRestParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8732,16 +8732,16 @@ module Prism def repeated_parameter?; end # Returns the `name` attribute. - sig { returns(T.nilable(Symbol)) } + sig { returns(::T.nilable(Symbol)) } def name; end # Returns the Location represented by `name_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def name_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -8750,14 +8750,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8767,20 +8767,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^^^ class LambdaNode < Node # Initialize a new LambdaNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: T.nilable(T.any(StatementsNode, BeginNode))).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: ::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: ::T.nilable(::T.any(StatementsNode, BeginNode))).void } def initialize(source, node_id, location, flags, locals, operator_loc, opening_loc, closing_loc, parameters, body); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8788,17 +8788,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: T.nilable(T.any(StatementsNode, BeginNode))).returns(LambdaNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: ::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode)), body: ::T.nilable(::T.any(StatementsNode, BeginNode))).returns(LambdaNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), operator_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), parameters: T.unsafe(nil), body: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8822,7 +8822,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the Location represented by `opening_loc`. @@ -8831,7 +8831,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the Location represented by `closing_loc`. @@ -8840,15 +8840,15 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `parameters` attribute. - sig { returns(T.nilable(T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode))) } + sig { returns(::T.nilable(::T.any(BlockParametersNode, NumberedParametersNode, ItParametersNode))) } def parameters; end # Returns the `body` attribute. - sig { returns(T.nilable(T.any(StatementsNode, BeginNode))) } + sig { returns(::T.nilable(::T.any(StatementsNode, BeginNode))) } def body; end # Slice the location of operator_loc from the source. @@ -8863,7 +8863,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8877,16 +8877,16 @@ module Prism def initialize(source, node_id, location, flags, name_loc, operator_loc, value, name, depth); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8894,17 +8894,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer).returns(LocalVariableAndWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -8924,7 +8924,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -8933,7 +8933,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -8952,7 +8952,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -8966,16 +8966,16 @@ module Prism def initialize(source, node_id, location, flags, name_loc, binary_operator_loc, value, name, binary_operator, depth); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -8983,17 +8983,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name_loc: Location, binary_operator_loc: Location, value: Node, name: Symbol, binary_operator: Symbol, depth: Integer).returns(LocalVariableOperatorWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), binary_operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), binary_operator: T.unsafe(nil), depth: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9013,7 +9013,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `binary_operator_loc`. @@ -9022,7 +9022,7 @@ module Prism # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_binary_operator_loc(repository); end # Returns the `value` attribute. @@ -9041,7 +9041,7 @@ module Prism sig { returns(Integer) } def depth; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9055,16 +9055,16 @@ module Prism def initialize(source, node_id, location, flags, name_loc, operator_loc, value, name, depth); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9072,17 +9072,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer).returns(LocalVariableOrWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9102,7 +9102,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -9111,7 +9111,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -9130,7 +9130,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9144,16 +9144,16 @@ module Prism def initialize(source, node_id, location, flags, name, depth); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9161,17 +9161,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, depth: Integer).returns(LocalVariableReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9207,7 +9207,7 @@ module Prism sig { returns(Integer) } def depth; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9224,16 +9224,16 @@ module Prism def initialize(source, node_id, location, flags, name, depth); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9241,17 +9241,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, depth: Integer).returns(LocalVariableTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9273,7 +9273,7 @@ module Prism sig { returns(Integer) } def depth; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9287,16 +9287,16 @@ module Prism def initialize(source, node_id, location, flags, name, depth, name_loc, value, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9304,17 +9304,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location).returns(LocalVariableWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), depth: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9355,7 +9355,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -9381,14 +9381,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9402,16 +9402,16 @@ module Prism def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9419,17 +9419,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String).returns(MatchLastLineNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9493,7 +9493,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the Location represented by `content_loc`. @@ -9502,7 +9502,7 @@ module Prism # Save the content_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_content_loc(repository); end # Returns the Location represented by `closing_loc`. @@ -9511,7 +9511,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `unescaped` attribute. @@ -9530,7 +9530,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9544,16 +9544,16 @@ module Prism def initialize(source, node_id, location, flags, value, pattern, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9561,17 +9561,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, operator_loc: Location).returns(MatchPredicateNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9599,14 +9599,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9620,16 +9620,16 @@ module Prism def initialize(source, node_id, location, flags, value, pattern, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9637,17 +9637,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, value: Node, pattern: Node, operator_loc: Location).returns(MatchRequiredNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil), pattern: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9723,14 +9723,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9744,16 +9744,16 @@ module Prism def initialize(source, node_id, location, flags, call, targets); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9761,17 +9761,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, call: CallNode, targets: T::Array[LocalVariableTargetNode]).returns(MatchWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), call: T.unsafe(nil), targets: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9793,7 +9793,7 @@ module Prism sig { returns(T::Array[LocalVariableTargetNode]) } def targets; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9804,16 +9804,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9821,17 +9821,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(MissingNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9845,7 +9845,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9855,20 +9855,20 @@ module Prism # ^^^^^^^^^^^^^^ class ModuleNode < Node # Initialize a new ModuleNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: T.any(ConstantReadNode, ConstantPathNode, MissingNode), body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: ::T.any(ConstantReadNode, ConstantPathNode, MissingNode), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).void } def initialize(source, node_id, location, flags, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9876,17 +9876,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: T.any(ConstantReadNode, ConstantPathNode, MissingNode), body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ModuleNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], module_keyword_loc: Location, constant_path: ::T.any(ConstantReadNode, ConstantPathNode, MissingNode), body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location, name: Symbol).returns(ModuleNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), module_keyword_loc: T.unsafe(nil), constant_path: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -9910,15 +9910,15 @@ module Prism # Save the module_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_module_keyword_loc(repository); end # Returns the `constant_path` attribute. - sig { returns(T.any(ConstantReadNode, ConstantPathNode, MissingNode)) } + sig { returns(::T.any(ConstantReadNode, ConstantPathNode, MissingNode)) } def constant_path; end # Returns the `body` attribute. - sig { returns(T.nilable(T.any(StatementsNode, BeginNode))) } + sig { returns(::T.nilable(::T.any(StatementsNode, BeginNode))) } def body; end # Returns the Location represented by `end_keyword_loc`. @@ -9927,7 +9927,7 @@ module Prism # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_end_keyword_loc(repository); end # Returns the `name` attribute. @@ -9942,7 +9942,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -9957,20 +9957,20 @@ module Prism # ^^^^ class MultiTargetNode < Node # Initialize a new MultiTargetNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: T.nilable(T.any(ImplicitRestNode, SplatNode)), rights: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: ::T.nilable(::T.any(ImplicitRestNode, SplatNode)), rights: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -9978,17 +9978,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, lefts: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: T.nilable(T.any(ImplicitRestNode, SplatNode)), rights: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location)).returns(MultiTargetNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, lefts: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: ::T.nilable(::T.any(ImplicitRestNode, SplatNode)), rights: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location)).returns(MultiTargetNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10011,7 +10011,7 @@ module Prism # # a, (b, c) = 1, 2, 3, 4, 5 # ^^^^ - sig { returns(T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } + sig { returns(T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } def lefts; end # Represents a splat node in the target expression. @@ -10028,49 +10028,49 @@ module Prism # # a, (b,) = 1, 2, 3, 4 # ^ - sig { returns(T.nilable(T.any(ImplicitRestNode, SplatNode))) } + sig { returns(::T.nilable(::T.any(ImplicitRestNode, SplatNode))) } def rest; end # Represents the targets expressions after a splat node. # # a, (*, b, c) = 1, 2, 3, 4, 5 # ^^^^ - sig { returns(T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } + sig { returns(T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, RequiredParameterNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } def rights; end # The Location of the opening parenthesis. # # a, (b, c) = 1, 2, 3 # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def lparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_lparen_loc(repository); end # The Location of the closing parenthesis. # # a, (b, c) = 1, 2, 3 # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def rparen_loc; end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_rparen_loc(repository); end # Slice the location of lparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def lparen; end # Slice the location of rparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def rparen; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10080,20 +10080,20 @@ module Prism # ^^^^^^^^^^^^^^^^^ class MultiWriteNode < Node # Initialize a new MultiWriteNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: T.nilable(T.any(ImplicitRestNode, SplatNode)), rights: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), operator_loc: Location, value: Node).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, lefts: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: ::T.nilable(::T.any(ImplicitRestNode, SplatNode)), rights: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location), operator_loc: Location, value: Node).void } def initialize(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10101,17 +10101,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, lefts: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: T.nilable(T.any(ImplicitRestNode, SplatNode)), rights: T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: T.nilable(Location), rparen_loc: T.nilable(Location), operator_loc: Location, value: Node).returns(MultiWriteNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, lefts: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], rest: ::T.nilable(::T.any(ImplicitRestNode, SplatNode)), rights: T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)], lparen_loc: ::T.nilable(Location), rparen_loc: ::T.nilable(Location), operator_loc: Location, value: Node).returns(MultiWriteNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), lefts: T.unsafe(nil), rest: T.unsafe(nil), rights: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10134,7 +10134,7 @@ module Prism # # a, b, c = 1, 2, 3, 4, 5 # ^^^^^^^ - sig { returns(T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } + sig { returns(T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } def lefts; end # Represents a splat node in the target expression. @@ -10151,38 +10151,38 @@ module Prism # # a, b, = 1, 2, 3, 4 # ^ - sig { returns(T.nilable(T.any(ImplicitRestNode, SplatNode))) } + sig { returns(::T.nilable(::T.any(ImplicitRestNode, SplatNode))) } def rest; end # Represents the targets expressions after a splat node. # # a, *, b, c = 1, 2, 3, 4, 5 # ^^^^ - sig { returns(T::Array[T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } + sig { returns(T::Array[::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, MultiTargetNode, BackReferenceReadNode, NumberedReferenceReadNode)]) } def rights; end # The Location of the opening parenthesis. # # (a, b, c) = 1, 2, 3 # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def lparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_lparen_loc(repository); end # The Location of the closing parenthesis. # # (a, b, c) = 1, 2, 3 # ^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def rparen_loc; end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_rparen_loc(repository); end # The Location of the operator. @@ -10194,7 +10194,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # The value to write to the targets. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -10205,18 +10205,18 @@ module Prism def value; end # Slice the location of lparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def lparen; end # Slice the location of rparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def rparen; end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10226,20 +10226,20 @@ module Prism # ^^^^^^ class NextNode < Node # Initialize a new NextNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: T.nilable(ArgumentsNode), keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, arguments: ::T.nilable(ArgumentsNode), keyword_loc: Location).void } def initialize(source, node_id, location, flags, arguments, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10247,17 +10247,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, arguments: T.nilable(ArgumentsNode), keyword_loc: Location).returns(NextNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, arguments: ::T.nilable(ArgumentsNode), keyword_loc: Location).returns(NextNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), arguments: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10272,7 +10272,7 @@ module Prism def inspect; end # Returns the `arguments` attribute. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Returns the Location represented by `keyword_loc`. @@ -10281,14 +10281,14 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of keyword_loc from the source. sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10302,16 +10302,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10319,17 +10319,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(NilNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10343,7 +10343,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10358,16 +10358,16 @@ module Prism def initialize(source, node_id, location, flags, operator_loc, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10375,17 +10375,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, operator_loc: Location, keyword_loc: Location).returns(NoBlockParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10405,7 +10405,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the Location represented by `keyword_loc`. @@ -10414,7 +10414,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of operator_loc from the source. @@ -10425,7 +10425,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10440,16 +10440,16 @@ module Prism def initialize(source, node_id, location, flags, operator_loc, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10457,17 +10457,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, operator_loc: Location, keyword_loc: Location).returns(NoKeywordsParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10487,7 +10487,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the Location represented by `keyword_loc`. @@ -10496,7 +10496,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of operator_loc from the source. @@ -10507,7 +10507,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10521,16 +10521,16 @@ module Prism def initialize(source, node_id, location, flags, maximum); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10538,17 +10538,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, maximum: Integer).returns(NumberedParametersNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), maximum: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10566,7 +10566,7 @@ module Prism sig { returns(Integer) } def maximum; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10580,16 +10580,16 @@ module Prism def initialize(source, node_id, location, flags, number); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10597,17 +10597,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, number: Integer).returns(NumberedReferenceReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), number: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10631,7 +10631,7 @@ module Prism sig { returns(Integer) } def number; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10646,16 +10646,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10663,17 +10663,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, value: Node).returns(OptionalKeywordParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10701,14 +10701,14 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the `value` attribute. sig { returns(Node) } def value; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10723,16 +10723,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc, operator_loc, value); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10740,17 +10740,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location, operator_loc: Location, value: Node).returns(OptionalParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), value: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10778,7 +10778,7 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -10787,7 +10787,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `value` attribute. @@ -10798,7 +10798,7 @@ module Prism sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10812,16 +10812,16 @@ module Prism def initialize(source, node_id, location, flags, left, right, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10829,17 +10829,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, left: Node, right: Node, operator_loc: Location).returns(OrNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10882,14 +10882,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10900,20 +10900,20 @@ module Prism # end class ParametersNode < Node # Initialize a new ParametersNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, requireds: T::Array[T.any(RequiredParameterNode, MultiTargetNode)], optionals: T::Array[OptionalParameterNode], rest: T.nilable(T.any(RestParameterNode, ImplicitRestNode)), posts: T::Array[T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)], keywords: T::Array[T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)], keyword_rest: T.nilable(T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode)), block: T.nilable(T.any(BlockParameterNode, NoBlockParameterNode))).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, requireds: T::Array[::T.any(RequiredParameterNode, MultiTargetNode)], optionals: T::Array[OptionalParameterNode], rest: ::T.nilable(::T.any(RestParameterNode, ImplicitRestNode)), posts: T::Array[::T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)], keywords: T::Array[::T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)], keyword_rest: ::T.nilable(::T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode)), block: ::T.nilable(::T.any(BlockParameterNode, NoBlockParameterNode))).void } def initialize(source, node_id, location, flags, requireds, optionals, rest, posts, keywords, keyword_rest, block); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -10921,17 +10921,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, requireds: T::Array[T.any(RequiredParameterNode, MultiTargetNode)], optionals: T::Array[OptionalParameterNode], rest: T.nilable(T.any(RestParameterNode, ImplicitRestNode)), posts: T::Array[T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)], keywords: T::Array[T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)], keyword_rest: T.nilable(T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode)), block: T.nilable(T.any(BlockParameterNode, NoBlockParameterNode))).returns(ParametersNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, requireds: T::Array[::T.any(RequiredParameterNode, MultiTargetNode)], optionals: T::Array[OptionalParameterNode], rest: ::T.nilable(::T.any(RestParameterNode, ImplicitRestNode)), posts: T::Array[::T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)], keywords: T::Array[::T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)], keyword_rest: ::T.nilable(::T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode)), block: ::T.nilable(::T.any(BlockParameterNode, NoBlockParameterNode))).returns(ParametersNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), requireds: T.unsafe(nil), optionals: T.unsafe(nil), rest: T.unsafe(nil), posts: T.unsafe(nil), keywords: T.unsafe(nil), keyword_rest: T.unsafe(nil), block: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -10946,7 +10946,7 @@ module Prism def inspect; end # Returns the `requireds` attribute. - sig { returns(T::Array[T.any(RequiredParameterNode, MultiTargetNode)]) } + sig { returns(T::Array[::T.any(RequiredParameterNode, MultiTargetNode)]) } def requireds; end # Returns the `optionals` attribute. @@ -10954,26 +10954,26 @@ module Prism def optionals; end # Returns the `rest` attribute. - sig { returns(T.nilable(T.any(RestParameterNode, ImplicitRestNode))) } + sig { returns(::T.nilable(::T.any(RestParameterNode, ImplicitRestNode))) } def rest; end # Returns the `posts` attribute. - sig { returns(T::Array[T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)]) } + sig { returns(T::Array[::T.any(RequiredParameterNode, MultiTargetNode, KeywordRestParameterNode, NoKeywordsParameterNode, ForwardingParameterNode, BlockParameterNode, NoBlockParameterNode)]) } def posts; end # Returns the `keywords` attribute. - sig { returns(T::Array[T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)]) } + sig { returns(T::Array[::T.any(RequiredKeywordParameterNode, OptionalKeywordParameterNode)]) } def keywords; end # Returns the `keyword_rest` attribute. - sig { returns(T.nilable(T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode))) } + sig { returns(::T.nilable(::T.any(KeywordRestParameterNode, ForwardingParameterNode, NoKeywordsParameterNode))) } def keyword_rest; end # Returns the `block` attribute. - sig { returns(T.nilable(T.any(BlockParameterNode, NoBlockParameterNode))) } + sig { returns(::T.nilable(::T.any(BlockParameterNode, NoBlockParameterNode))) } def block; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -10983,20 +10983,20 @@ module Prism # ^^^^^^^^^ class ParenthesesNode < Node # Initialize a new ParenthesesNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, body: T.nilable(Node), opening_loc: Location, closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, body: ::T.nilable(Node), opening_loc: Location, closing_loc: Location).void } def initialize(source, node_id, location, flags, body, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11004,17 +11004,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, body: T.nilable(Node), opening_loc: Location, closing_loc: Location).returns(ParenthesesNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, body: ::T.nilable(Node), opening_loc: Location, closing_loc: Location).returns(ParenthesesNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11033,7 +11033,7 @@ module Prism def multiple_statements?; end # Returns the `body` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def body; end # Returns the Location represented by `opening_loc`. @@ -11042,7 +11042,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the Location represented by `closing_loc`. @@ -11051,7 +11051,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of opening_loc from the source. @@ -11062,7 +11062,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11076,16 +11076,16 @@ module Prism def initialize(source, node_id, location, flags, expression, operator_loc, lparen_loc, rparen_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11093,17 +11093,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, expression: Node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location).returns(PinnedExpressionNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), operator_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11133,7 +11133,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # The Location of the opening parenthesis. @@ -11145,7 +11145,7 @@ module Prism # Save the lparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_lparen_loc(repository); end # The Location of the closing parenthesis. @@ -11157,7 +11157,7 @@ module Prism # Save the rparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_rparen_loc(repository); end # Slice the location of operator_loc from the source. @@ -11172,7 +11172,7 @@ module Prism sig { returns(String) } def rparen; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11182,20 +11182,20 @@ module Prism # ^^^^ class PinnedVariableNode < Node # Initialize a new PinnedVariableNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, variable: T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, variable: ::T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode), operator_loc: Location).void } def initialize(source, node_id, location, flags, variable, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11203,17 +11203,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, variable: T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode), operator_loc: Location).returns(PinnedVariableNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, variable: ::T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode), operator_loc: Location).returns(PinnedVariableNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), variable: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11231,7 +11231,7 @@ module Prism # # foo in ^bar # ^^^ - sig { returns(T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode)) } + sig { returns(::T.any(LocalVariableReadNode, InstanceVariableReadNode, ClassVariableReadNode, GlobalVariableReadNode, BackReferenceReadNode, NumberedReferenceReadNode, ItLocalVariableReadNode, MissingNode)) } def variable; end # The Location of the `^` operator @@ -11243,14 +11243,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11260,20 +11260,20 @@ module Prism # ^^^^^^^^^^^ class PostExecutionNode < Node # Initialize a new PostExecutionNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: ::T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).void } def initialize(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11281,17 +11281,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PostExecutionNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, statements: ::T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PostExecutionNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11306,7 +11306,7 @@ module Prism def inspect; end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Returns the Location represented by `keyword_loc`. @@ -11315,7 +11315,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the Location represented by `opening_loc`. @@ -11324,7 +11324,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the Location represented by `closing_loc`. @@ -11333,7 +11333,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of keyword_loc from the source. @@ -11348,7 +11348,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11358,20 +11358,20 @@ module Prism # ^^^^^^^^^^^^^ class PreExecutionNode < Node # Initialize a new PreExecutionNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, statements: ::T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).void } def initialize(source, node_id, location, flags, statements, keyword_loc, opening_loc, closing_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11379,17 +11379,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, statements: T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PreExecutionNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, statements: ::T.nilable(StatementsNode), keyword_loc: Location, opening_loc: Location, closing_loc: Location).returns(PreExecutionNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), statements: T.unsafe(nil), keyword_loc: T.unsafe(nil), opening_loc: T.unsafe(nil), closing_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11404,7 +11404,7 @@ module Prism def inspect; end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Returns the Location represented by `keyword_loc`. @@ -11413,7 +11413,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the Location represented by `opening_loc`. @@ -11422,7 +11422,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the Location represented by `closing_loc`. @@ -11431,7 +11431,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Slice the location of keyword_loc from the source. @@ -11446,7 +11446,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11457,16 +11457,16 @@ module Prism def initialize(source, node_id, location, flags, locals, statements); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11474,17 +11474,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], statements: StatementsNode).returns(ProgramNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), statements: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11506,7 +11506,7 @@ module Prism sig { returns(StatementsNode) } def statements; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11519,20 +11519,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ class RangeNode < Node # Initialize a new RangeNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, left: ::T.nilable(Node), right: ::T.nilable(Node), operator_loc: Location).void } def initialize(source, node_id, location, flags, left, right, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11540,17 +11540,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, left: T.nilable(Node), right: T.nilable(Node), operator_loc: Location).returns(RangeNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, left: ::T.nilable(Node), right: ::T.nilable(Node), operator_loc: Location).returns(RangeNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), left: T.unsafe(nil), right: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11575,7 +11575,7 @@ module Prism # # hello...goodbye # ^^^^^ - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def left; end # The right-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -11586,7 +11586,7 @@ module Prism # 1...foo # ^^^ # If neither right-hand or left-hand side was included, this will be a MissingNode. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def right; end # The Location of the `..` or `...` operator. @@ -11595,14 +11595,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11616,16 +11616,16 @@ module Prism def initialize(source, node_id, location, flags, numerator, denominator); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11633,17 +11633,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, numerator: Integer, denominator: Integer).returns(RationalNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), numerator: T.unsafe(nil), denominator: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11685,7 +11685,7 @@ module Prism sig { returns(Integer) } def denominator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11699,16 +11699,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11716,17 +11716,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(RedoNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11740,7 +11740,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11754,16 +11754,16 @@ module Prism def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11771,17 +11771,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String).returns(RegularExpressionNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11845,7 +11845,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the Location represented by `content_loc`. @@ -11854,7 +11854,7 @@ module Prism # Save the content_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_content_loc(repository); end # Returns the Location represented by `closing_loc`. @@ -11863,7 +11863,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `unescaped` attribute. @@ -11882,7 +11882,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11897,16 +11897,16 @@ module Prism def initialize(source, node_id, location, flags, name, name_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11914,17 +11914,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol, name_loc: Location).returns(RequiredKeywordParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -11952,10 +11952,10 @@ module Prism # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_name_loc(repository); end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -11970,16 +11970,16 @@ module Prism def initialize(source, node_id, location, flags, name); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -11987,17 +11987,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, name: Symbol).returns(RequiredParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12019,7 +12019,7 @@ module Prism sig { returns(Symbol) } def name; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12033,16 +12033,16 @@ module Prism def initialize(source, node_id, location, flags, expression, keyword_loc, rescue_expression); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12050,17 +12050,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, expression: Node, keyword_loc: Location, rescue_expression: Node).returns(RescueModifierNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), expression: T.unsafe(nil), keyword_loc: T.unsafe(nil), rescue_expression: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12084,7 +12084,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the `rescue_expression` attribute. @@ -12095,7 +12095,7 @@ module Prism sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12110,20 +12110,20 @@ module Prism # `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field. class RescueNode < Node # Initialize a new RescueNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, exceptions: T::Array[Node], operator_loc: T.nilable(Location), reference: T.nilable(T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)), then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), subsequent: T.nilable(RescueNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, exceptions: T::Array[Node], operator_loc: ::T.nilable(Location), reference: ::T.nilable(::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)), then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), subsequent: ::T.nilable(RescueNode)).void } def initialize(source, node_id, location, flags, keyword_loc, exceptions, operator_loc, reference, then_keyword_loc, statements, subsequent); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12131,17 +12131,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, exceptions: T::Array[Node], operator_loc: T.nilable(Location), reference: T.nilable(T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)), then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), subsequent: T.nilable(RescueNode)).returns(RescueNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, exceptions: T::Array[Node], operator_loc: ::T.nilable(Location), reference: ::T.nilable(::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode)), then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), subsequent: ::T.nilable(RescueNode)).returns(RescueNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), exceptions: T.unsafe(nil), operator_loc: T.unsafe(nil), reference: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), subsequent: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12161,7 +12161,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the `exceptions` attribute. @@ -12169,33 +12169,33 @@ module Prism def exceptions; end # Returns the Location represented by `operator_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_operator_loc(repository); end # Returns the `reference` attribute. - sig { returns(T.nilable(T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode))) } + sig { returns(::T.nilable(::T.any(LocalVariableTargetNode, InstanceVariableTargetNode, ClassVariableTargetNode, GlobalVariableTargetNode, ConstantTargetNode, ConstantPathTargetNode, CallTargetNode, IndexTargetNode, BackReferenceReadNode, NumberedReferenceReadNode, MissingNode))) } def reference; end # Returns the Location represented by `then_keyword_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def then_keyword_loc; end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_then_keyword_loc(repository); end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Returns the `subsequent` attribute. - sig { returns(T.nilable(RescueNode)) } + sig { returns(::T.nilable(RescueNode)) } def subsequent; end # Slice the location of keyword_loc from the source. @@ -12203,14 +12203,14 @@ module Prism def keyword; end # Slice the location of operator_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def operator; end # Slice the location of then_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def then_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12221,20 +12221,20 @@ module Prism # end class RestParameterNode < Node # Initialize a new RestParameterNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).void } def initialize(source, node_id, location, flags, name, name_loc, operator_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12242,17 +12242,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, name: T.nilable(Symbol), name_loc: T.nilable(Location), operator_loc: Location).returns(RestParameterNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, name: ::T.nilable(Symbol), name_loc: ::T.nilable(Location), operator_loc: Location).returns(RestParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), name: T.unsafe(nil), name_loc: T.unsafe(nil), operator_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12271,16 +12271,16 @@ module Prism def repeated_parameter?; end # Returns the `name` attribute. - sig { returns(T.nilable(Symbol)) } + sig { returns(::T.nilable(Symbol)) } def name; end # Returns the Location represented by `name_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def name_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_name_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -12289,14 +12289,14 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12310,16 +12310,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12327,17 +12327,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(RetryNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12351,7 +12351,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12361,20 +12361,20 @@ module Prism # ^^^^^^^^ class ReturnNode < Node # Initialize a new ReturnNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, arguments: T.nilable(ArgumentsNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, arguments: ::T.nilable(ArgumentsNode)).void } def initialize(source, node_id, location, flags, keyword_loc, arguments); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12382,17 +12382,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, arguments: T.nilable(ArgumentsNode)).returns(ReturnNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, arguments: ::T.nilable(ArgumentsNode)).returns(ReturnNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), arguments: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12412,18 +12412,18 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the `arguments` attribute. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Slice the location of keyword_loc from the source. sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12437,16 +12437,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12454,17 +12454,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(SelfNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12478,7 +12478,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12489,20 +12489,20 @@ module Prism # ^^^^^^^^^^^^ class ShareableConstantNode < Node # Initialize a new ShareableConstantNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, write: T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, write: ::T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)).void } def initialize(source, node_id, location, flags, write); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12510,17 +12510,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, write: T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)).returns(ShareableConstantNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, write: ::T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)).returns(ShareableConstantNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), write: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12547,10 +12547,10 @@ module Prism def experimental_copy?; end # The constant write that should be modified with the shareability state. - sig { returns(T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)) } + sig { returns(::T.any(ConstantWriteNode, ConstantAndWriteNode, ConstantOrWriteNode, ConstantOperatorWriteNode, ConstantPathWriteNode, ConstantPathAndWriteNode, ConstantPathOrWriteNode, ConstantPathOperatorWriteNode)) } def write; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12560,20 +12560,20 @@ module Prism # ^^^^^^^^^^^^^^^^^ class SingletonClassNode < Node # Initialize a new SingletonClassNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location).void } def initialize(source, node_id, location, flags, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12581,17 +12581,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: T.nilable(T.any(StatementsNode, BeginNode)), end_keyword_loc: Location).returns(SingletonClassNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, locals: T::Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: ::T.nilable(::T.any(StatementsNode, BeginNode)), end_keyword_loc: Location).returns(SingletonClassNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), locals: T.unsafe(nil), class_keyword_loc: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil), body: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12615,7 +12615,7 @@ module Prism # Save the class_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_class_keyword_loc(repository); end # Returns the Location represented by `operator_loc`. @@ -12624,7 +12624,7 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `expression` attribute. @@ -12632,7 +12632,7 @@ module Prism def expression; end # Returns the `body` attribute. - sig { returns(T.nilable(T.any(StatementsNode, BeginNode))) } + sig { returns(::T.nilable(::T.any(StatementsNode, BeginNode))) } def body; end # Returns the Location represented by `end_keyword_loc`. @@ -12641,7 +12641,7 @@ module Prism # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_end_keyword_loc(repository); end # Slice the location of class_keyword_loc from the source. @@ -12656,7 +12656,7 @@ module Prism sig { returns(String) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12670,16 +12670,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12687,17 +12687,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(SourceEncodingNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12711,7 +12711,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12725,16 +12725,16 @@ module Prism def initialize(source, node_id, location, flags, filepath); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12742,17 +12742,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, filepath: String).returns(SourceFileNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), filepath: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12786,7 +12786,7 @@ module Prism sig { returns(String) } def filepath; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12800,16 +12800,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12817,17 +12817,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(SourceLineNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12841,7 +12841,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12851,20 +12851,20 @@ module Prism # ^^ class SplatNode < Node # Initialize a new SplatNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, expression: T.nilable(Node)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, operator_loc: Location, expression: ::T.nilable(Node)).void } def initialize(source, node_id, location, flags, operator_loc, expression); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12872,17 +12872,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, operator_loc: Location, expression: T.nilable(Node)).returns(SplatNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, operator_loc: Location, expression: ::T.nilable(Node)).returns(SplatNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), operator_loc: T.unsafe(nil), expression: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12902,18 +12902,18 @@ module Prism # Save the operator_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_operator_loc(repository); end # Returns the `expression` attribute. - sig { returns(T.nilable(Node)) } + sig { returns(::T.nilable(Node)) } def expression; end # Slice the location of operator_loc from the source. sig { returns(String) } def operator; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12927,16 +12927,16 @@ module Prism def initialize(source, node_id, location, flags, body); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -12944,17 +12944,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, body: T::Array[Node]).returns(StatementsNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), body: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -12972,7 +12972,7 @@ module Prism sig { returns(T::Array[Node]) } def body; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -12988,20 +12988,20 @@ module Prism # ^^^^ ^^^^ class StringNode < Node # Initialize a new StringNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), content_loc: Location, closing_loc: T.nilable(Location), unescaped: String).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), content_loc: Location, closing_loc: ::T.nilable(Location), unescaped: String).void } def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13009,17 +13009,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), content_loc: Location, closing_loc: T.nilable(Location), unescaped: String).returns(StringNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), content_loc: Location, closing_loc: ::T.nilable(Location), unescaped: String).returns(StringNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13050,12 +13050,12 @@ module Prism def mutable?; end # Returns the Location represented by `opening_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Returns the Location represented by `content_loc`. @@ -13064,16 +13064,16 @@ module Prism # Save the content_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_content_loc(repository); end # Returns the Location represented by `closing_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Returns the `unescaped` attribute. @@ -13081,7 +13081,7 @@ module Prism def unescaped; end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of content_loc from the source. @@ -13089,10 +13089,10 @@ module Prism def content; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13107,20 +13107,20 @@ module Prism # If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead. class SuperNode < Node # Initialize a new SuperNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), block: T.nilable(T.any(BlockNode, BlockArgumentNode))).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), rparen_loc: ::T.nilable(Location), block: ::T.nilable(::T.any(BlockNode, BlockArgumentNode))).void } def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc, block); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13128,17 +13128,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location), block: T.nilable(T.any(BlockNode, BlockArgumentNode))).returns(SuperNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), rparen_loc: ::T.nilable(Location), block: ::T.nilable(::T.any(BlockNode, BlockArgumentNode))).returns(SuperNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil), block: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13158,33 +13158,33 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the Location represented by `lparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def lparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_lparen_loc(repository); end # Can be only `nil` when there are empty parentheses, like `super()`. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Returns the Location represented by `rparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def rparen_loc; end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_rparen_loc(repository); end # Returns the `block` attribute. - sig { returns(T.nilable(T.any(BlockNode, BlockArgumentNode))) } + sig { returns(::T.nilable(::T.any(BlockNode, BlockArgumentNode))) } def block; end # Slice the location of keyword_loc from the source. @@ -13192,14 +13192,14 @@ module Prism def keyword; end # Slice the location of lparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def lparen; end # Slice the location of rparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def rparen; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13212,20 +13212,20 @@ module Prism # ^^^ class SymbolNode < Node # Initialize a new SymbolNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), value_loc: T.nilable(Location), closing_loc: T.nilable(Location), unescaped: String).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), value_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), unescaped: String).void } def initialize(source, node_id, location, flags, opening_loc, value_loc, closing_loc, unescaped); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13233,17 +13233,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: T.nilable(Location), value_loc: T.nilable(Location), closing_loc: T.nilable(Location), unescaped: String).returns(SymbolNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: ::T.nilable(Location), value_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), unescaped: String).returns(SymbolNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), value_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13270,30 +13270,30 @@ module Prism def forced_us_ascii_encoding?; end # Returns the Location represented by `opening_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def opening_loc; end # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_opening_loc(repository); end # Returns the Location represented by `value_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def value_loc; end # Save the value_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_value_loc(repository); end # Returns the Location represented by `closing_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Returns the `unescaped` attribute. @@ -13301,18 +13301,18 @@ module Prism def unescaped; end # Slice the location of opening_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def opening; end # Slice the location of value_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def value; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13326,16 +13326,16 @@ module Prism def initialize(source, node_id, location, flags); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13343,17 +13343,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer).returns(TrueNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13367,7 +13367,7 @@ module Prism sig { override.returns(String) } def inspect; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13377,20 +13377,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^^ class UndefNode < Node # Initialize a new UndefNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, names: T::Array[T.any(SymbolNode, InterpolatedSymbolNode)], keyword_loc: Location).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, names: T::Array[::T.any(SymbolNode, InterpolatedSymbolNode)], keyword_loc: Location).void } def initialize(source, node_id, location, flags, names, keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13398,17 +13398,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, names: T::Array[T.any(SymbolNode, InterpolatedSymbolNode)], keyword_loc: Location).returns(UndefNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, names: T::Array[::T.any(SymbolNode, InterpolatedSymbolNode)], keyword_loc: Location).returns(UndefNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), names: T.unsafe(nil), keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13423,7 +13423,7 @@ module Prism def inspect; end # Returns the `names` attribute. - sig { returns(T::Array[T.any(SymbolNode, InterpolatedSymbolNode)]) } + sig { returns(T::Array[::T.any(SymbolNode, InterpolatedSymbolNode)]) } def names; end # Returns the Location represented by `keyword_loc`. @@ -13432,14 +13432,14 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Slice the location of keyword_loc from the source. sig { returns(String) } def keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13452,20 +13452,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^^^^ class UnlessNode < Node # Initialize a new UnlessNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), else_clause: T.nilable(ElseNode), end_keyword_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, keyword_loc, predicate, then_keyword_loc, statements, else_clause, end_keyword_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13473,17 +13473,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode), else_clause: T.nilable(ElseNode), end_keyword_loc: T.nilable(Location)).returns(UnlessNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, predicate: Node, then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode), else_clause: ::T.nilable(ElseNode), end_keyword_loc: ::T.nilable(Location)).returns(UnlessNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), predicate: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil), else_clause: T.unsafe(nil), end_keyword_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13509,7 +13509,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -13526,12 +13526,12 @@ module Prism # # unless cond then bar end # ^^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def then_keyword_loc; end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_then_keyword_loc(repository); end # The body of statements that will executed if the unless condition is @@ -13539,26 +13539,26 @@ module Prism # # unless cond then bar end # ^^^ - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # The else clause of the unless expression, if present. # # unless cond then bar else baz end # ^^^^^^^^^^^^ - sig { returns(T.nilable(ElseNode)) } + sig { returns(::T.nilable(ElseNode)) } def else_clause; end # The Location of the `end` keyword, if present. # # unless cond then bar end # ^^^ - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def end_keyword_loc; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_end_keyword_loc(repository); end # Slice the location of keyword_loc from the source. @@ -13566,14 +13566,14 @@ module Prism def keyword; end # Slice the location of then_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def then_keyword; end # Slice the location of end_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def end_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13586,20 +13586,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^ class UntilNode < Node # Initialize a new UntilNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: T.nilable(Location), closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).void } def initialize(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13607,17 +13607,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: T.nilable(Location), closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode)).returns(UntilNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(UntilNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13641,25 +13641,25 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the Location represented by `do_keyword_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def do_keyword_loc; end # Save the do_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_do_keyword_loc(repository); end # Returns the Location represented by `closing_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Returns the `predicate` attribute. @@ -13667,7 +13667,7 @@ module Prism def predicate; end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Slice the location of keyword_loc from the source. @@ -13675,14 +13675,14 @@ module Prism def keyword; end # Slice the location of do_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def do_keyword; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13694,20 +13694,20 @@ module Prism # end class WhenNode < Node # Initialize a new WhenNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).void } def initialize(source, node_id, location, flags, keyword_loc, conditions, then_keyword_loc, statements); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13715,17 +13715,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: T.nilable(Location), statements: T.nilable(StatementsNode)).returns(WhenNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, conditions: T::Array[Node], then_keyword_loc: ::T.nilable(Location), statements: ::T.nilable(StatementsNode)).returns(WhenNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), conditions: T.unsafe(nil), then_keyword_loc: T.unsafe(nil), statements: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13745,7 +13745,7 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the `conditions` attribute. @@ -13753,16 +13753,16 @@ module Prism def conditions; end # Returns the Location represented by `then_keyword_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def then_keyword_loc; end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_then_keyword_loc(repository); end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Slice the location of keyword_loc from the source. @@ -13770,10 +13770,10 @@ module Prism def keyword; end # Slice the location of then_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def then_keyword; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13786,20 +13786,20 @@ module Prism # ^^^^^^^^^^^^^^^^^^^^ class WhileNode < Node # Initialize a new WhileNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: T.nilable(Location), closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).void } def initialize(source, node_id, location, flags, keyword_loc, do_keyword_loc, closing_loc, predicate, statements); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13807,17 +13807,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: T.nilable(Location), closing_loc: T.nilable(Location), predicate: Node, statements: T.nilable(StatementsNode)).returns(WhileNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, do_keyword_loc: ::T.nilable(Location), closing_loc: ::T.nilable(Location), predicate: Node, statements: ::T.nilable(StatementsNode)).returns(WhileNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), do_keyword_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), predicate: T.unsafe(nil), statements: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13841,25 +13841,25 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the Location represented by `do_keyword_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def do_keyword_loc; end # Save the do_keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_do_keyword_loc(repository); end # Returns the Location represented by `closing_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def closing_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_closing_loc(repository); end # Returns the `predicate` attribute. @@ -13867,7 +13867,7 @@ module Prism def predicate; end # Returns the `statements` attribute. - sig { returns(T.nilable(StatementsNode)) } + sig { returns(::T.nilable(StatementsNode)) } def statements; end # Slice the location of keyword_loc from the source. @@ -13875,14 +13875,14 @@ module Prism def keyword; end # Slice the location of do_keyword_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def do_keyword; end # Slice the location of closing_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13896,16 +13896,16 @@ module Prism def initialize(source, node_id, location, flags, opening_loc, content_loc, closing_loc, unescaped); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -13913,17 +13913,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. sig { params(node_id: Integer, location: Location, flags: Integer, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String).returns(XStringNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), opening_loc: T.unsafe(nil), content_loc: T.unsafe(nil), closing_loc: T.unsafe(nil), unescaped: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -13951,7 +13951,7 @@ module Prism # Save the opening_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_opening_loc(repository); end # Returns the Location represented by `content_loc`. @@ -13960,7 +13960,7 @@ module Prism # Save the content_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_content_loc(repository); end # Returns the Location represented by `closing_loc`. @@ -13969,7 +13969,7 @@ module Prism # Save the closing_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_closing_loc(repository); end # Returns the `unescaped` attribute. @@ -13988,7 +13988,7 @@ module Prism sig { returns(String) } def closing; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end @@ -13998,20 +13998,20 @@ module Prism # ^^^^^^^ class YieldNode < Node # Initialize a new YieldNode node. - sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location)).void } + sig { params(source: Source, node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), rparen_loc: ::T.nilable(Location)).void } def initialize(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc); end # See Node.accept. - sig { override.params(visitor: Visitor).returns(T.untyped) } + sig { override.params(visitor: Visitor).returns(::T.untyped) } def accept(visitor); end # See Node.child_nodes. - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def child_nodes; end # See Node.each_child_node. sig { override.returns(T::Enumerator[Node]) } - sig { override.params(blk: T.proc.params(arg0: Node).void).void } + sig { override.params(blk: ::T.proc.params(arg0: Node).void).void } def each_child_node(&blk); end # See Node.compact_child_nodes. @@ -14019,17 +14019,17 @@ module Prism def compact_child_nodes; end # See Node.comment_targets. - sig { override.returns(T::Array[T.any(Node, Location)]) } + sig { override.returns(T::Array[::T.any(Node, Location)]) } def comment_targets; end # Creates a copy of self with the given fields, using self as the template. - sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: T.nilable(Location), arguments: T.nilable(ArgumentsNode), rparen_loc: T.nilable(Location)).returns(YieldNode) } + sig { params(node_id: Integer, location: Location, flags: Integer, keyword_loc: Location, lparen_loc: ::T.nilable(Location), arguments: ::T.nilable(ArgumentsNode), rparen_loc: ::T.nilable(Location)).returns(YieldNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), keyword_loc: T.unsafe(nil), lparen_loc: T.unsafe(nil), arguments: T.unsafe(nil), rparen_loc: T.unsafe(nil)); end - sig { override.returns(T::Array[T.nilable(Node)]) } + sig { override.returns(T::Array[::T.nilable(Node)]) } def deconstruct; end - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # See `Node#type`. @@ -14049,29 +14049,29 @@ module Prism # Save the keyword_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(Relocation::Entry) } + sig { params(repository: ::T.untyped).returns(Relocation::Entry) } def save_keyword_loc(repository); end # Returns the Location represented by `lparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def lparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_lparen_loc(repository); end # Returns the `arguments` attribute. - sig { returns(T.nilable(ArgumentsNode)) } + sig { returns(::T.nilable(ArgumentsNode)) } def arguments; end # Returns the Location represented by `rparen_loc`. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def rparen_loc; end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. - sig { params(repository: T.untyped).returns(T.nilable(Relocation::Entry)) } + sig { params(repository: ::T.untyped).returns(::T.nilable(Relocation::Entry)) } def save_rparen_loc(repository); end # Slice the location of keyword_loc from the source. @@ -14079,192 +14079,192 @@ module Prism def keyword; end # Slice the location of lparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def lparen; end # Slice the location of rparen_loc from the source. - sig { returns(T.nilable(String)) } + sig { returns(::T.nilable(String)) } def rparen; end - sig { params(other: T.untyped).returns(T.nilable(T::Boolean)) } + sig { params(other: ::T.untyped).returns(::T.nilable(T::Boolean)) } def ===(other); end end # Flags for arguments nodes. module ArgumentsNodeFlags # if the arguments contain forwarding - CONTAINS_FORWARDING = T.let(nil, T.untyped) + CONTAINS_FORWARDING = T.let(nil, ::T.untyped) # if the arguments contain keywords - CONTAINS_KEYWORDS = T.let(nil, T.untyped) + CONTAINS_KEYWORDS = T.let(nil, ::T.untyped) # if the arguments contain a keyword splat - CONTAINS_KEYWORD_SPLAT = T.let(nil, T.untyped) + CONTAINS_KEYWORD_SPLAT = T.let(nil, ::T.untyped) # if the arguments contain a splat - CONTAINS_SPLAT = T.let(nil, T.untyped) + CONTAINS_SPLAT = T.let(nil, ::T.untyped) # if the arguments contain multiple splats - CONTAINS_MULTIPLE_SPLATS = T.let(nil, T.untyped) + CONTAINS_MULTIPLE_SPLATS = T.let(nil, ::T.untyped) end # Flags for array nodes. module ArrayNodeFlags # if array contains splat nodes - CONTAINS_SPLAT = T.let(nil, T.untyped) + CONTAINS_SPLAT = T.let(nil, ::T.untyped) end # Flags for call nodes. module CallNodeFlags # &. operator - SAFE_NAVIGATION = T.let(nil, T.untyped) + SAFE_NAVIGATION = T.let(nil, ::T.untyped) # a call that could have been a local variable - VARIABLE_CALL = T.let(nil, T.untyped) + VARIABLE_CALL = T.let(nil, ::T.untyped) # a call that is an attribute write, so the value being written should be returned - ATTRIBUTE_WRITE = T.let(nil, T.untyped) + ATTRIBUTE_WRITE = T.let(nil, ::T.untyped) # a call that ignores method visibility - IGNORE_VISIBILITY = T.let(nil, T.untyped) + IGNORE_VISIBILITY = T.let(nil, ::T.untyped) end # Flags for nodes that have unescaped content. module EncodingFlags # internal bytes forced the encoding to UTF-8 - FORCED_UTF8_ENCODING = T.let(nil, T.untyped) + FORCED_UTF8_ENCODING = T.let(nil, ::T.untyped) # internal bytes forced the encoding to binary - FORCED_BINARY_ENCODING = T.let(nil, T.untyped) + FORCED_BINARY_ENCODING = T.let(nil, ::T.untyped) end # Flags for integer nodes that correspond to the base of the integer. module IntegerBaseFlags # 0b prefix - BINARY = T.let(nil, T.untyped) + BINARY = T.let(nil, ::T.untyped) # 0d or no prefix - DECIMAL = T.let(nil, T.untyped) + DECIMAL = T.let(nil, ::T.untyped) # 0o or 0 prefix - OCTAL = T.let(nil, T.untyped) + OCTAL = T.let(nil, ::T.untyped) # 0x prefix - HEXADECIMAL = T.let(nil, T.untyped) + HEXADECIMAL = T.let(nil, ::T.untyped) end # Flags for interpolated string nodes that indicated mutability if they are also marked as literals. module InterpolatedStringNodeFlags # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - FROZEN = T.let(nil, T.untyped) + FROZEN = T.let(nil, ::T.untyped) # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal`; only for adjacent string literals like `'a' 'b'` - MUTABLE = T.let(nil, T.untyped) + MUTABLE = T.let(nil, ::T.untyped) end # Flags for keyword hash nodes. module KeywordHashNodeFlags # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments - SYMBOL_KEYS = T.let(nil, T.untyped) + SYMBOL_KEYS = T.let(nil, ::T.untyped) end # Flags for while and until loop nodes. module LoopFlags # a loop after a begin statement, so the body is executed first before the condition - BEGIN_MODIFIER = T.let(nil, T.untyped) + BEGIN_MODIFIER = T.let(nil, ::T.untyped) end # Flags for parameter nodes. module ParameterFlags # a parameter name that has been repeated in the method signature - REPEATED_PARAMETER = T.let(nil, T.untyped) + REPEATED_PARAMETER = T.let(nil, ::T.untyped) end # Flags for parentheses nodes. module ParenthesesNodeFlags # parentheses that contain multiple potentially void statements - MULTIPLE_STATEMENTS = T.let(nil, T.untyped) + MULTIPLE_STATEMENTS = T.let(nil, ::T.untyped) end # Flags for range and flip-flop nodes. module RangeFlags # ... operator - EXCLUDE_END = T.let(nil, T.untyped) + EXCLUDE_END = T.let(nil, ::T.untyped) end # Flags for regular expression and match last line nodes. module RegularExpressionFlags # i - ignores the case of characters when matching - IGNORE_CASE = T.let(nil, T.untyped) + IGNORE_CASE = T.let(nil, ::T.untyped) # x - ignores whitespace and allows comments in regular expressions - EXTENDED = T.let(nil, T.untyped) + EXTENDED = T.let(nil, ::T.untyped) # m - allows $ to match the end of lines within strings - MULTI_LINE = T.let(nil, T.untyped) + MULTI_LINE = T.let(nil, ::T.untyped) # o - only interpolates values into the regular expression once - ONCE = T.let(nil, T.untyped) + ONCE = T.let(nil, ::T.untyped) # e - forces the EUC-JP encoding - EUC_JP = T.let(nil, T.untyped) + EUC_JP = T.let(nil, ::T.untyped) # n - forces the ASCII-8BIT encoding - ASCII_8BIT = T.let(nil, T.untyped) + ASCII_8BIT = T.let(nil, ::T.untyped) # s - forces the Windows-31J encoding - WINDOWS_31J = T.let(nil, T.untyped) + WINDOWS_31J = T.let(nil, ::T.untyped) # u - forces the UTF-8 encoding - UTF_8 = T.let(nil, T.untyped) + UTF_8 = T.let(nil, ::T.untyped) # internal bytes forced the encoding to UTF-8 - FORCED_UTF8_ENCODING = T.let(nil, T.untyped) + FORCED_UTF8_ENCODING = T.let(nil, ::T.untyped) # internal bytes forced the encoding to binary - FORCED_BINARY_ENCODING = T.let(nil, T.untyped) + FORCED_BINARY_ENCODING = T.let(nil, ::T.untyped) # internal bytes forced the encoding to US-ASCII - FORCED_US_ASCII_ENCODING = T.let(nil, T.untyped) + FORCED_US_ASCII_ENCODING = T.let(nil, ::T.untyped) end # Flags for shareable constant nodes. module ShareableConstantNodeFlags # constant writes that should be modified with shareable constant value literal - LITERAL = T.let(nil, T.untyped) + LITERAL = T.let(nil, ::T.untyped) # constant writes that should be modified with shareable constant value experimental everything - EXPERIMENTAL_EVERYTHING = T.let(nil, T.untyped) + EXPERIMENTAL_EVERYTHING = T.let(nil, ::T.untyped) # constant writes that should be modified with shareable constant value experimental copy - EXPERIMENTAL_COPY = T.let(nil, T.untyped) + EXPERIMENTAL_COPY = T.let(nil, ::T.untyped) end # Flags for string nodes. module StringFlags # internal bytes forced the encoding to UTF-8 - FORCED_UTF8_ENCODING = T.let(nil, T.untyped) + FORCED_UTF8_ENCODING = T.let(nil, ::T.untyped) # internal bytes forced the encoding to binary - FORCED_BINARY_ENCODING = T.let(nil, T.untyped) + FORCED_BINARY_ENCODING = T.let(nil, ::T.untyped) # frozen by virtue of a `frozen_string_literal: true` comment or `--enable-frozen-string-literal` - FROZEN = T.let(nil, T.untyped) + FROZEN = T.let(nil, ::T.untyped) # mutable by virtue of a `frozen_string_literal: false` comment or `--disable-frozen-string-literal` - MUTABLE = T.let(nil, T.untyped) + MUTABLE = T.let(nil, ::T.untyped) end # Flags for symbol nodes. module SymbolFlags # internal bytes forced the encoding to UTF-8 - FORCED_UTF8_ENCODING = T.let(nil, T.untyped) + FORCED_UTF8_ENCODING = T.let(nil, ::T.untyped) # internal bytes forced the encoding to binary - FORCED_BINARY_ENCODING = T.let(nil, T.untyped) + FORCED_BINARY_ENCODING = T.let(nil, ::T.untyped) # internal bytes forced the encoding to US-ASCII - FORCED_US_ASCII_ENCODING = T.let(nil, T.untyped) + FORCED_US_ASCII_ENCODING = T.let(nil, ::T.untyped) end # The flags that are common to all nodes. diff --git a/rbi/generated/prism/node_ext.rbi b/rbi/generated/prism/node_ext.rbi index 925fd8dd7a..25255d073b 100644 --- a/rbi/generated/prism/node_ext.rbi +++ b/rbi/generated/prism/node_ext.rbi @@ -45,25 +45,25 @@ module Prism module HeredocQuery # Returns true if this node was represented as a heredoc in the source code. - sig { params(opening: T.nilable(String)).returns(T.nilable(T::Boolean)) } + sig { params(opening: ::T.nilable(String)).returns(::T.nilable(T::Boolean)) } def self.heredoc?(opening); end end class InterpolatedStringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(T.nilable(T::Boolean)) } + sig { returns(::T.nilable(T::Boolean)) } def heredoc?; end end class InterpolatedXStringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(T.nilable(T::Boolean)) } + sig { returns(::T.nilable(T::Boolean)) } def heredoc?; end end class StringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(T.nilable(T::Boolean)) } + sig { returns(::T.nilable(T::Boolean)) } def heredoc?; end # Occasionally it's helpful to treat a string as if it were interpolated so @@ -74,7 +74,7 @@ module Prism class XStringNode < Node # Returns true if this node was represented as a heredoc in the source code. - sig { returns(T.nilable(T::Boolean)) } + sig { returns(::T.nilable(T::Boolean)) } def heredoc?; end # Occasionally it's helpful to treat a string as if it were interpolated so @@ -96,7 +96,7 @@ module Prism # Returns the value of the node as an IntegerNode or a FloatNode. This # method is deprecated in favor of #value or #numerator/#denominator. - sig { returns(T.any(IntegerNode, FloatNode)) } + sig { returns(::T.any(IntegerNode, FloatNode)) } def numeric; end end @@ -148,7 +148,7 @@ module Prism # Previously, we had a child node on this class that contained either a # constant read or a missing node. To not cause a breaking change, we # continue to supply that API. - sig { returns(T.any(ConstantReadNode, MissingNode)) } + sig { returns(::T.any(ConstantReadNode, MissingNode)) } def child; end end @@ -165,7 +165,7 @@ module Prism # Previously, we had a child node on this class that contained either a # constant read or a missing node. To not cause a breaking change, we # continue to supply that API. - sig { returns(T.any(ConstantReadNode, MissingNode)) } + sig { returns(::T.any(ConstantReadNode, MissingNode)) } def child; end end @@ -182,7 +182,7 @@ module Prism class ParametersNode < Node # Mirrors the Method#parameters method. - sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) } + sig { returns(T::Array[::T.any([Symbol, Symbol], [Symbol])]) } def signature; end end @@ -196,7 +196,7 @@ module Prism # can be any amount of space between the message and the = sign. However, # sometimes you want the location of the full message including the inner # space and the = sign. This method provides that. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } def full_message_loc; end end @@ -299,35 +299,35 @@ module Prism class CaseMatchNode < Node # Returns the else clause of the case match node. This method is deprecated # in favor of #else_clause. - sig { returns(T.nilable(ElseNode)) } + sig { returns(::T.nilable(ElseNode)) } def consequent; end end class CaseNode < Node # Returns the else clause of the case node. This method is deprecated in # favor of #else_clause. - sig { returns(T.nilable(ElseNode)) } + sig { returns(::T.nilable(ElseNode)) } def consequent; end end class IfNode < Node # Returns the subsequent if/elsif/else clause of the if node. This method is # deprecated in favor of #subsequent. - sig { returns(T.nilable(T.any(IfNode, ElseNode))) } + sig { returns(::T.nilable(::T.any(IfNode, ElseNode))) } def consequent; end end class RescueNode < Node # Returns the subsequent rescue clause of the rescue node. This method is # deprecated in favor of #subsequent. - sig { returns(T.nilable(RescueNode)) } + sig { returns(::T.nilable(RescueNode)) } def consequent; end end class UnlessNode < Node # Returns the else clause of the unless node. This method is deprecated in # favor of #else_clause. - sig { returns(T.nilable(ElseNode)) } + sig { returns(::T.nilable(ElseNode)) } def consequent; end end end diff --git a/rbi/generated/prism/parse_result.rbi b/rbi/generated/prism/parse_result.rbi index 51297530c3..4a904e85e1 100644 --- a/rbi/generated/prism/parse_result.rbi +++ b/rbi/generated/prism/parse_result.rbi @@ -192,7 +192,7 @@ module Prism # Returns a cache that is the identity function in order to maintain the # same interface. We can do this because code units are always equivalent to # byte offsets for ASCII-only sources. - sig { params(encoding: Encoding).returns(T.untyped) } + sig { params(encoding: Encoding).returns(::T.untyped) } def code_units_cache(encoding); end # Specialized version of `code_units_column` that does not depend on @@ -283,7 +283,7 @@ module Prism # The start offset from the start of the file in code units using the given # cache to fetch or calculate the value. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_start_code_units_offset(cache); end # The byte offset from the beginning of the source where this location ends. @@ -301,7 +301,7 @@ module Prism # The end offset from the start of the file in code units using the given # cache to fetch or calculate the value. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_end_code_units_offset(cache); end # The line number where this location starts. @@ -333,7 +333,7 @@ module Prism # The start column in code units using the given cache to fetch or calculate # the value. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_start_code_units_column(cache); end # The column in bytes where this location ends from the start of the @@ -353,11 +353,11 @@ module Prism # The end column in code units using the given cache to fetch or calculate # the value. - sig { params(cache: T.untyped).returns(Integer) } + sig { params(cache: ::T.untyped).returns(Integer) } def cached_end_code_units_column(cache); end # Implement the hash pattern matching interface for Location. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # Implement the pretty print interface for Location. @@ -365,7 +365,7 @@ module Prism def pretty_print(q); end # Returns true if the given other location is equal to this location. - sig { params(other: T.untyped).returns(T::Boolean) } + sig { params(other: ::T.untyped).returns(T::Boolean) } def ==(other); end # Returns a new location that stretches from this location to the given @@ -393,7 +393,7 @@ module Prism def initialize(location); end # Implement the hash pattern matching interface for Comment. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # Returns the content of the comment by slicing it from the source code. @@ -455,7 +455,7 @@ module Prism def value; end # Implement the hash pattern matching interface for MagicComment. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # Returns a string representation of this magic comment. @@ -487,7 +487,7 @@ module Prism def initialize(type, message, location, level); end # Implement the hash pattern matching interface for ParseError. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # Returns a string representation of this error. @@ -519,7 +519,7 @@ module Prism def initialize(type, message, location, level); end # Implement the hash pattern matching interface for ParseWarning. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # Returns a string representation of this warning. @@ -542,7 +542,7 @@ module Prism # An optional location that represents the location of the __END__ marker # and the rest of the content of the file. This content is loaded into the # DATA constant when the file being parsed is the main file being executed. - sig { returns(T.nilable(Location)) } + sig { returns(::T.nilable(Location)) } attr_reader :data_loc # The list of errors that were generated during parsing. @@ -558,11 +558,11 @@ module Prism attr_reader :source # Create a new result object with the given values. - sig { params(comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } + sig { params(comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } def initialize(comments, magic_comments, data_loc, errors, warnings, source); end # Implement the hash pattern matching interface for Result. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # Returns the encoding of the source code that was parsed. @@ -606,10 +606,10 @@ module Prism # token of an unclosed construct rather than at the end of the source. These # errors always indicate incomplete input regardless of their byte position, # so they are checked by type rather than by location. - CONTINUABLE = T.let(nil, T.untyped) + CONTINUABLE = T.let(nil, ::T.untyped) # Create a code units cache for the given encoding. - sig { params(encoding: Encoding).returns(T.untyped) } + sig { params(encoding: Encoding).returns(::T.untyped) } def code_units_cache(encoding); end end @@ -620,11 +620,11 @@ module Prism attr_reader :value # Create a new parse result object with the given values. - sig { params(value: ProgramNode, comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } + sig { params(value: ProgramNode, comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end # Implement the hash pattern matching interface for ParseResult. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # Attach the list of comments to their respective locations in the tree. @@ -649,11 +649,11 @@ module Prism attr_reader :value # Create a new lex result object with the given values. - sig { params(value: T::Array[[Token, Integer]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } + sig { params(value: T::Array[[Token, Integer]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end # Implement the hash pattern matching interface for LexResult. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end end @@ -665,11 +665,11 @@ module Prism attr_reader :value # Create a new parse lex result object with the given values. - sig { params(value: [ProgramNode, T::Array[[Token, Integer]]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } + sig { params(value: [ProgramNode, T::Array[[Token, Integer]]], comments: T::Array[Comment], magic_comments: T::Array[MagicComment], data_loc: ::T.nilable(Location), errors: T::Array[ParseError], warnings: T::Array[ParseWarning], source: Source).void } def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end # Implement the hash pattern matching interface for ParseLexResult. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end end @@ -688,11 +688,11 @@ module Prism attr_reader :value # Create a new token object with the given type, value, and location. - sig { params(source: Source, type: Symbol, value: String, location: T.any(Location, Integer)).void } + sig { params(source: Source, type: Symbol, value: String, location: ::T.any(Location, Integer)).void } def initialize(source, type, value, location); end # Implement the hash pattern matching interface for Token. - sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } + sig { params(keys: ::T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, ::T.untyped]) } def deconstruct_keys(keys); end # A Location object representing the location of this token in the source. @@ -704,7 +704,7 @@ module Prism def pretty_print(q); end # Returns true if the given other token is equal to this token. - sig { params(other: T.untyped).returns(T::Boolean) } + sig { params(other: ::T.untyped).returns(T::Boolean) } def ==(other); end # Returns a string representation of this token. diff --git a/rbi/generated/prism/parse_result/comments.rbi b/rbi/generated/prism/parse_result/comments.rbi index 4220d23d9d..f386d03f34 100644 --- a/rbi/generated/prism/parse_result/comments.rbi +++ b/rbi/generated/prism/parse_result/comments.rbi @@ -83,7 +83,7 @@ module Prism # Responsible for finding the nearest targets to the given comment within # the context of the given encapsulating node. - sig { params(node: Node, comment: Comment).returns([T.untyped, T.untyped, T.untyped]) } + sig { params(node: Node, comment: Comment).returns([::T.untyped, ::T.untyped, ::T.untyped]) } private def nearest_targets(node, comment); end end end diff --git a/rbi/generated/prism/pattern.rbi b/rbi/generated/prism/pattern.rbi index cc74c54d5e..375518b8f7 100644 --- a/rbi/generated/prism/pattern.rbi +++ b/rbi/generated/prism/pattern.rbi @@ -63,7 +63,7 @@ module Prism # matches the pattern. If no block is given, an enumerator will be returned # that will yield each node that matches the pattern. sig { params(root: Node).returns(T::Enumerator[Node]) } - sig { params(root: Node, blk: T.proc.params(arg0: Node).void).void } + sig { params(root: Node, blk: ::T.proc.params(arg0: Node).void).void } def scan(root, &blk); end # Shortcut for combining two procs into one that returns true if both return @@ -79,7 +79,7 @@ module Prism # Raise an error because the given node is not supported. Note purposefully # not typing this method since it is a no return method that Steep does not # understand. - sig { params(node: Node).returns(T.noreturn) } + sig { params(node: Node).returns(::T.noreturn) } private def compile_error(node); end # in [foo, bar, baz] @@ -100,7 +100,7 @@ module Prism private def compile_constant_read_node(node); end # Compile a name associated with a constant. - sig { params(node: T.any(ConstantPathNode, ConstantReadNode), name: Symbol).returns(Proc) } + sig { params(node: ::T.any(ConstantPathNode, ConstantReadNode), name: Symbol).returns(Proc) } private def compile_constant_name(node, name); end # in InstanceVariableReadNode[name: Symbol] diff --git a/rbi/generated/prism/reflection.rbi b/rbi/generated/prism/reflection.rbi index 7a4cd1bb43..1094c461f4 100644 --- a/rbi/generated/prism/reflection.rbi +++ b/rbi/generated/prism/reflection.rbi @@ -83,7 +83,7 @@ module Prism end # Returns the fields for the given node. - sig { params(node: T.class_of(Node)).returns(T::Array[Field]) } + sig { params(node: ::T.class_of(Node)).returns(T::Array[Field]) } def self.fields_for(node); end end end diff --git a/rbi/generated/prism/relocation.rbi b/rbi/generated/prism/relocation.rbi index e1c0a5bd40..7868d065b0 100644 --- a/rbi/generated/prism/relocation.rbi +++ b/rbi/generated/prism/relocation.rbi @@ -102,26 +102,26 @@ module Prism # Reify the values on this entry with the given values. This is an # internal-only API that is called from the repository when it is time to # reify the values. - sig { params(values: T::Hash[Symbol, T.untyped]).void } + sig { params(values: T::Hash[Symbol, ::T.untyped]).void } def reify!(values); end # Fetch a value from the entry, raising an error if it is missing. - sig { params(name: Symbol).returns(T.untyped) } + sig { params(name: Symbol).returns(::T.untyped) } private def fetch_value(name); end # Return the values from the repository, reifying them if necessary. - sig { returns(T::Hash[Symbol, T.untyped]) } + sig { returns(T::Hash[Symbol, ::T.untyped]) } private def values; end end # Represents the source of a repository that will be reparsed. class Source # The value that will need to be reparsed. - sig { returns(T.untyped) } + sig { returns(::T.untyped) } attr_reader :value # Initialize the source with the given value. - sig { params(value: T.untyped).void } + sig { params(value: ::T.untyped).void } def initialize(value); end # Reparse the value and return the parse result. @@ -129,7 +129,7 @@ module Prism def result; end # Create a code units cache for the given encoding. - sig { params(encoding: Encoding).returns(T.untyped) } + sig { params(encoding: Encoding).returns(::T.untyped) } def code_units_cache(encoding); end end @@ -158,28 +158,28 @@ module Prism def initialize(value); end # Fetch the file path. - sig { params(_value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(_value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(_value); end end # A field representing the start and end lines. class LinesField # Fetches the start and end line of a value. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end end # A field representing the start and end byte offsets. class OffsetsField # Fetches the start and end byte offset of a value. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end end # A field representing the start and end character offsets. class CharacterOffsetsField # Fetches the start and end character offset of a value. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end end @@ -200,25 +200,25 @@ module Prism # Fetches the start and end code units offset of a value for a particular # encoding. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end # Lazily create a code units cache for the associated encoding. - sig { returns(T.untyped) } + sig { returns(::T.untyped) } private def cache; end end # A field representing the start and end byte columns. class ColumnsField # Fetches the start and end byte column of a value. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end end # A field representing the start and end character columns. class CharacterColumnsField # Fetches the start and end character column of a value. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end end @@ -240,11 +240,11 @@ module Prism # Fetches the start and end code units column of a value for a particular # encoding. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end # Lazily create a code units cache for the associated encoding. - sig { returns(T.untyped) } + sig { returns(::T.untyped) } private def cache; end end @@ -263,21 +263,21 @@ module Prism end # Create comment objects from the given values. - sig { params(values: T.untyped).returns(T::Array[Comment]) } + sig { params(values: ::T.untyped).returns(T::Array[Comment]) } private def comments(values); end end # A field representing the leading comments. class LeadingCommentsField < CommentsField # Fetches the leading comments of a value. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end end # A field representing the trailing comments. class TrailingCommentsField < CommentsField # Fetches the trailing comments of a value. - sig { params(value: T.untyped).returns(T::Hash[Symbol, T.untyped]) } + sig { params(value: ::T.untyped).returns(T::Hash[Symbol, ::T.untyped]) } def fields(value); end end @@ -294,7 +294,7 @@ module Prism attr_reader :source # The fields that have been configured on this repository. - sig { returns(T::Hash[Symbol, T.untyped]) } + sig { returns(T::Hash[Symbol, ::T.untyped]) } attr_reader :fields # The entries that have been saved on this repository. @@ -306,58 +306,58 @@ module Prism def initialize(source); end # Create a code units cache for the given encoding from the source. - sig { params(encoding: Encoding).returns(T.untyped) } + sig { params(encoding: Encoding).returns(::T.untyped) } def code_units_cache(encoding); end # Configure the filepath field for this repository and return self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def filepath; end # Configure the lines field for this repository and return self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def lines; end # Configure the offsets field for this repository and return self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def offsets; end # Configure the character offsets field for this repository and return # self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def character_offsets; end # Configure the code unit offsets field for this repository for a specific # encoding and return self. - sig { params(encoding: Encoding).returns(T.self_type) } + sig { params(encoding: Encoding).returns(::T.self_type) } def code_unit_offsets(encoding); end # Configure the columns field for this repository and return self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def columns; end # Configure the character columns field for this repository and return # self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def character_columns; end # Configure the code unit columns field for this repository for a specific # encoding and return self. - sig { params(encoding: Encoding).returns(T.self_type) } + sig { params(encoding: Encoding).returns(::T.self_type) } def code_unit_columns(encoding); end # Configure the leading comments field for this repository and return # self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def leading_comments; end # Configure the trailing comments field for this repository and return # self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def trailing_comments; end # Configure both the leading and trailing comment fields for this # repository and return self. - sig { returns(T.self_type) } + sig { returns(::T.self_type) } def comments; end # This method is called from nodes and locations when they want to enter @@ -374,7 +374,7 @@ module Prism # Append the given field to the repository and return the repository so # that these calls can be chained. - sig { params(name: Symbol, arg0: T.untyped).returns(T.self_type) } + sig { params(name: Symbol, arg0: ::T.untyped).returns(::T.self_type) } private def field(name, arg0); end end diff --git a/rbi/generated/prism/serialize.rbi b/rbi/generated/prism/serialize.rbi index 9957fc9858..80bf9be1da 100644 --- a/rbi/generated/prism/serialize.rbi +++ b/rbi/generated/prism/serialize.rbi @@ -49,14 +49,14 @@ module Prism sig { returns(Integer) } attr_reader :size - sig { params(input: String, serialized: String, base: Integer, size: Integer).void } - def initialize(input, serialized, base, size); end + sig { params(serialized: String, base: Integer, size: Integer).void } + def initialize(serialized, base, size); end sig { params(index: Integer, encoding: Encoding).returns(Symbol) } def get(index, encoding); end end - FastStringIO = T.let(nil, T.untyped) + FastStringIO = T.let(nil, ::T.untyped) class Loader sig { returns(String) } @@ -126,12 +126,9 @@ module Prism sig { returns(Integer) } def load_uint32; end - sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean).returns(T.nilable(Node)) } + sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean).returns(::T.nilable(Node)) } def load_optional_node(constant_pool, encoding, freeze); end - sig { params(encoding: Encoding).returns(String) } - def load_embedded_string(encoding); end - sig { params(encoding: Encoding).returns(String) } def load_string(encoding); end @@ -147,16 +144,16 @@ module Prism # Load an optional location object from the serialized data if it is # present. Note that we are lying about the signature a bit here, because # we sometimes load it as a packed integer instead of an object. - sig { params(freeze: T::Boolean).returns(T.nilable(Location)) } + sig { params(freeze: T::Boolean).returns(::T.nilable(Location)) } def load_optional_location(freeze); end - sig { params(freeze: T::Boolean).returns(T.nilable(Location)) } + sig { params(freeze: T::Boolean).returns(::T.nilable(Location)) } def load_optional_location_object(freeze); end sig { params(constant_pool: ConstantPool, encoding: Encoding).returns(Symbol) } def load_constant(constant_pool, encoding); end - sig { params(constant_pool: ConstantPool, encoding: Encoding).returns(T.nilable(Symbol)) } + sig { params(constant_pool: ConstantPool, encoding: Encoding).returns(::T.nilable(Symbol)) } def load_optional_constant(constant_pool, encoding); end sig { params(constant_pool: ConstantPool, encoding: Encoding, freeze: T::Boolean).returns(Node) } @@ -167,6 +164,6 @@ module Prism end # The token types that can be indexed by their enum values. - TOKEN_TYPES = T.let(nil, T::Array[T.nilable(Symbol)]) + TOKEN_TYPES = T.let(nil, T::Array[::T.nilable(Symbol)]) end end diff --git a/rbi/generated/prism/visitor.rbi b/rbi/generated/prism/visitor.rbi index 5025dd4c10..53534f1dc6 100644 --- a/rbi/generated/prism/visitor.rbi +++ b/rbi/generated/prism/visitor.rbi @@ -8,11 +8,11 @@ module Prism class BasicVisitor # Calls `accept` on the given node if it is not `nil`, which in turn should # call back into this visitor by calling the appropriate `visit_*` method. - sig { params(node: T.nilable(Node)).void } + sig { params(node: ::T.nilable(Node)).void } def visit(node); end # Visits each node in `nodes` by calling `accept` on each one. - sig { params(nodes: T::Array[T.nilable(Node)]).void } + sig { params(nodes: T::Array[::T.nilable(Node)]).void } def visit_all(nodes); end # Visits the child nodes of `node` by calling `accept` on each one. diff --git a/sig/generated/prism/parse_result.rbs b/sig/generated/prism/parse_result.rbs index af25241fdb..dc56214867 100644 --- a/sig/generated/prism/parse_result.rbs +++ b/sig/generated/prism/parse_result.rbs @@ -697,6 +697,8 @@ module Prism # token of an unclosed construct rather than at the end of the source. These # errors always indicate incomplete input regardless of their byte position, # so they are checked by type rather than by location. + # -- + # : Array[Symbol] CONTINUABLE: untyped # Create a code units cache for the given encoding. diff --git a/sig/generated/prism/serialize.rbs b/sig/generated/prism/serialize.rbs index 468f18dd56..e0b944856b 100644 --- a/sig/generated/prism/serialize.rbs +++ b/sig/generated/prism/serialize.rbs @@ -53,16 +53,14 @@ module Prism # :nodoc: attr_reader size: Integer - @input: String - @serialized: String @base: Integer @pool: Array[Symbol?] - # : (String input, String serialized, Integer base, Integer size) -> void - def initialize: (String input, String serialized, Integer base, Integer size) -> void + # : (String serialized, Integer base, Integer size) -> void + def initialize: (String serialized, Integer base, Integer size) -> void # : (Integer index, Encoding encoding) -> Symbol def get: (Integer index, Encoding encoding) -> Symbol @@ -140,9 +138,6 @@ module Prism # : (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node? def load_optional_node: (ConstantPool constant_pool, Encoding encoding, bool freeze) -> node? - # : (Encoding encoding) -> String - def load_embedded_string: (Encoding encoding) -> String - # : (Encoding encoding) -> String def load_string: (Encoding encoding) -> String