diff --git a/Gemfile b/Gemfile index 28e3941f0..090f17bef 100644 --- a/Gemfile +++ b/Gemfile @@ -63,8 +63,7 @@ group :development, :test do gem "bcrypt" gem "xpath" gem "kredis" - # TODO: Unlock when segfault in sorbet-static is fixed - gem "sorbet-static", "< 0.6.12889" + gem "sorbet-static" end group :test do diff --git a/Gemfile.lock b/Gemfile.lock index e32b30a1c..e5fcc0b10 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -159,28 +159,28 @@ GEM activemodel globalid (1.3.0) activesupport (>= 6.1) - google-protobuf (4.33.4) + google-protobuf (4.33.5) bigdecimal rake (>= 13) - google-protobuf (4.33.4-aarch64-linux-gnu) + google-protobuf (4.33.5-aarch64-linux-gnu) bigdecimal rake (>= 13) - google-protobuf (4.33.4-aarch64-linux-musl) + google-protobuf (4.33.5-aarch64-linux-musl) bigdecimal rake (>= 13) - google-protobuf (4.33.4-arm64-darwin) + google-protobuf (4.33.5-arm64-darwin) bigdecimal rake (>= 13) - google-protobuf (4.33.4-x86_64-darwin) + google-protobuf (4.33.5-x86_64-darwin) bigdecimal rake (>= 13) - google-protobuf (4.33.4-x86_64-linux-gnu) + google-protobuf (4.33.5-x86_64-linux-gnu) bigdecimal rake (>= 13) - google-protobuf (4.33.4-x86_64-linux-musl) + google-protobuf (4.33.5-x86_64-linux-musl) bigdecimal rake (>= 13) - graphql (2.5.16) + graphql (2.5.19) base64 fiber-storage logger @@ -191,11 +191,12 @@ GEM activerecord (>= 7.0) ar_transaction_changes (~> 1.1) io-console (0.8.2) - irb (1.16.0) + irb (1.17.0) pp (>= 0.6.0) + prism (>= 1.3.0) rdoc (>= 4.0.0) reline (>= 0.4.2) - json (2.18.0) + json (2.18.1) kramdown (2.5.2) rexml (>= 3.4.4) kredis (1.8.0) @@ -254,13 +255,13 @@ GEM racc (~> 1.4) ostruct (0.6.2) parallel (1.27.0) - parser (3.3.10.0) + parser (3.3.10.1) ast (~> 2.4.1) racc pp (0.6.3) prettyprint prettyprint (0.2.0) - prism (1.8.0) + prism (1.9.0) psych (5.3.1) date stringio @@ -309,10 +310,11 @@ GEM rbi (0.3.9) prism (~> 1.0) rbs (>= 3.4.4) - rbs (4.0.0.dev.4) + rbs (4.0.0.dev.5) logger prism (>= 1.3.0) - rdoc (7.0.3) + tsort + rdoc (7.2.0) erb psych (>= 4.0.0) tsort @@ -325,7 +327,7 @@ GEM io-console (~> 0.5) require-hooks (0.2.3) rexml (3.4.4) - rubocop (1.82.1) + rubocop (1.84.1) json (~> 2.3) language_server-protocol (~> 3.17.0.2) lint_roller (~> 1.1.0) @@ -333,7 +335,7 @@ GEM parser (>= 3.3.0.2) rainbow (>= 2.2.2, < 4.0) regexp_parser (>= 2.9.3, < 3.0) - rubocop-ast (>= 1.48.0, < 2.0) + rubocop-ast (>= 1.49.0, < 2.0) ruby-progressbar (~> 1.7) unicode-display_width (>= 2.4.0, < 4.0) rubocop-ast (1.49.0) @@ -344,10 +346,10 @@ GEM rubocop (~> 1.81) rubocop-shopify (2.18.0) rubocop (~> 1.62) - rubocop-sorbet (0.11.0) + rubocop-sorbet (0.12.0) lint_roller rubocop (>= 1.75.2) - ruby-lsp (0.26.4) + ruby-lsp (0.26.6) language_server-protocol (~> 3.17.0) prism (>= 1.2, < 2.0) rbs (>= 3, < 5) @@ -355,7 +357,7 @@ GEM ruby-lsp (>= 0.26.0, < 0.27.0) ruby-progressbar (1.13.0) securerandom (0.4.1) - shopify-money (3.2.5) + shopify-money (3.2.7) bigdecimal (>= 3.0) sidekiq (8.1.0) connection_pool (>= 3.0.0) @@ -364,15 +366,15 @@ GEM rack (>= 3.2.0) redis-client (>= 0.26.0) smart_properties (1.17.0) - sorbet (0.6.12887) - sorbet-static (= 0.6.12887) - sorbet-runtime (0.6.12887) - sorbet-static (0.6.12887-aarch64-linux) - sorbet-static (0.6.12887-universal-darwin) - sorbet-static (0.6.12887-x86_64-linux) - sorbet-static-and-runtime (0.6.12887) - sorbet (= 0.6.12887) - sorbet-runtime (= 0.6.12887) + sorbet (0.6.12929) + sorbet-static (= 0.6.12929) + sorbet-runtime (0.6.12929) + sorbet-static (0.6.12929-aarch64-linux) + sorbet-static (0.6.12929-universal-darwin) + sorbet-static (0.6.12929-x86_64-linux) + sorbet-static-and-runtime (0.6.12929) + sorbet (= 0.6.12929) + sorbet-runtime (= 0.6.12929) spoom (1.7.11) erubi (>= 1.10.0) prism (>= 0.28.0) @@ -464,7 +466,7 @@ DEPENDENCIES shopify-money sidekiq smart_properties - sorbet-static (< 0.6.12889) + sorbet-static sprockets sqlite3 state_machines diff --git a/sorbet/rbi/gems/google-protobuf@4.33.4.rbi b/sorbet/rbi/gems/google-protobuf@4.33.5.rbi similarity index 100% rename from sorbet/rbi/gems/google-protobuf@4.33.4.rbi rename to sorbet/rbi/gems/google-protobuf@4.33.5.rbi diff --git a/sorbet/rbi/gems/graphql@2.5.16.rbi b/sorbet/rbi/gems/graphql@2.5.19.rbi similarity index 97% rename from sorbet/rbi/gems/graphql@2.5.16.rbi rename to sorbet/rbi/gems/graphql@2.5.19.rbi index b6c239fc9..f83ea3fd2 100644 --- a/sorbet/rbi/gems/graphql@2.5.16.rbi +++ b/sorbet/rbi/gems/graphql@2.5.19.rbi @@ -854,7 +854,7 @@ end # but `GraphQL::Dashboard` is consistent with this gem's naming. # So define both constants to refer to the same class. # -# pkg:gem/graphql#lib/graphql/dashboard.rb:156 +# pkg:gem/graphql#lib/graphql/dashboard.rb:159 GraphQL::Dashboard = Graphql::Dashboard # This plugin supports Fiber-based concurrency, along with {GraphQL::Dataloader::Source}. @@ -2888,7 +2888,7 @@ end # pkg:gem/graphql#lib/graphql/language/block_string.rb:3 module GraphQL::Language class << self - # pkg:gem/graphql#lib/graphql/language.rb:89 + # pkg:gem/graphql#lib/graphql/language.rb:99 def add_space_between_numbers_and_names(query_str); end # Returns a new string if any single-quoted newlines were escaped. @@ -3168,6 +3168,17 @@ class GraphQL::Language::DocumentFromSchemaDefinition def schema_respects_root_name_conventions?(schema); end end +# pkg:gem/graphql#lib/graphql/language.rb:87 +GraphQL::Language::EFFICIENT_IGNORE_REGEXP = T.let(T.unsafe(nil), Regexp) + +# Optimized pattern using: +# - Possessive quantifiers (*+, ++) to prevent backtracking in number patterns +# - Atomic group (?>...) for IGNORE to prevent backtracking +# - Single unified number pattern instead of three alternatives +# +# pkg:gem/graphql#lib/graphql/language.rb:86 +GraphQL::Language::EFFICIENT_NUMBER_REGEXP = T.let(T.unsafe(nil), Regexp) + # Exposes {.generate}, which turns AST nodes back into query strings. # # pkg:gem/graphql#lib/graphql/language/generation.rb:5 @@ -3189,9 +3200,12 @@ module GraphQL::Language::Generation def generate(node, indent: T.unsafe(nil), printer: T.unsafe(nil)); end end -# pkg:gem/graphql#lib/graphql/language.rb:80 +# pkg:gem/graphql#lib/graphql/language.rb:91 GraphQL::Language::INVALID_NUMBER_FOLLOWED_BY_NAME_REGEXP = T.let(T.unsafe(nil), Regexp) +# pkg:gem/graphql#lib/graphql/language.rb:80 +GraphQL::Language::LEADING_REGEX = T.let(T.unsafe(nil), Regexp) + # pkg:gem/graphql#lib/graphql/language/lexer.rb:5 class GraphQL::Language::Lexer # @return [Lexer] a new instance of Lexer @@ -3419,6 +3433,9 @@ GraphQL::Language::Lexer::UTF_8 = T.let(T.unsafe(nil), Regexp) # pkg:gem/graphql#lib/graphql/language/lexer.rb:143 GraphQL::Language::Lexer::VALID_STRING = T.let(T.unsafe(nil), Regexp) +# pkg:gem/graphql#lib/graphql/language.rb:89 +GraphQL::Language::MAYBE_INVALID_NUMBER = T.let(T.unsafe(nil), Regexp) + # pkg:gem/graphql#lib/graphql/language/nodes.rb:4 module GraphQL::Language::Nodes; end @@ -9196,82 +9213,89 @@ class GraphQL::Schema::Argument # @param arg_name [Symbol] # @param as [Symbol] Override the keyword name when passed to a method + # @param ast_node [GraphQL::Language::Nodes::InputValueDefinition] Private, used by GraphQL-Ruby when parsing schema files # @param camelize [Boolean] if true, the name will be camelized when building the schema + # @param comment [String] Private, used by GraphQL-Ruby when parsing GraphQL schema files # @param default_value [Object] + # @param definition_block [Proc] Called with the newly-created {Argument} # @param deprecation_reason [String] # @param desc [String] # @param description [String] # @param directives [Hash{Class => Hash}] # @param from_resolver [Boolean] if true, a Resolver class defined this argument + # @param loads [Class, Array] A GraphQL type to load for the given ID when one is present + # @param name [Symbol] positional argument also accepted # @param loads [Class, Array] A GraphQL type to load for the given ID when one is present + # @param owner [Class] Private, used by GraphQL-Ruby during schema definition # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value` # @param required [Boolean, :nullable] if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`. + # @param type [Class, Array] Input type; positional argument also accepted # @param type_expr # @param validates [Hash, nil] Options for building validators, if any should be applied # @return [Argument] a new instance of Argument # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:53 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:60 def initialize(arg_name = T.unsafe(nil), type_expr = T.unsafe(nil), desc = T.unsafe(nil), owner:, required: T.unsafe(nil), type: T.unsafe(nil), name: T.unsafe(nil), loads: T.unsafe(nil), description: T.unsafe(nil), comment: T.unsafe(nil), ast_node: T.unsafe(nil), default_value: T.unsafe(nil), as: T.unsafe(nil), from_resolver: T.unsafe(nil), camelize: T.unsafe(nil), prepare: T.unsafe(nil), validates: T.unsafe(nil), directives: T.unsafe(nil), deprecation_reason: T.unsafe(nil), replace_null_with_default: T.unsafe(nil), &definition_block); end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:160 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:167 def authorized?(obj, value, ctx); end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:164 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:171 def authorized_as_type?(obj, value, ctx, as_type:); end # @api private # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:255 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:262 def coerce_into_values(parent_object, values, context, argument_values); end # @return [String] Comment for this argument # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:134 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:141 def comment(text = T.unsafe(nil)); end # Sets the attribute comment # # @param value the value to set the attribute comment to. # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:131 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:138 def comment=(_arg0); end # @param default_value [Object] The value to use when the client doesn't provide one # @return [Object] the value used when the client doesn't provide a value for this argument # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:104 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:111 def default_value(new_default_value = T.unsafe(nil)); end # @return [Boolean] True if this argument has a default value # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:112 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:119 def default_value?; end # @return [String] Deprecation reason for this argument # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:143 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:150 def deprecation_reason(text = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:151 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:158 def deprecation_reason=(new_reason); end # @return [String] Documentation for this argument # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:123 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:130 def description(text = T.unsafe(nil)); end # Sets the attribute description # # @param value the value to set the attribute description to. # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:120 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:127 def description=(_arg0); end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:215 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:222 def freeze; end # @return [Boolean] true if a resolver defined this argument @@ -9284,7 +9308,7 @@ class GraphQL::Schema::Argument # pkg:gem/graphql#lib/graphql/schema/argument.rb:14 def graphql_name; end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:98 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:105 def inspect; end # @return [Symbol] This argument's name in Ruby keyword arguments @@ -9292,7 +9316,7 @@ class GraphQL::Schema::Argument # pkg:gem/graphql#lib/graphql/schema/argument.rb:29 def keyword; end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:316 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:323 def load_and_authorize_value(load_method_owner, coerced_value, context); end # @return [Class, Module, nil] If this argument should load an application object, this is the type of object to load @@ -9321,52 +9345,52 @@ class GraphQL::Schema::Argument # # @api private # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:223 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:230 def prepare_value(obj, value, context: T.unsafe(nil)); end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:116 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:123 def replace_null_with_default?; end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:209 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:216 def statically_coercible?; end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:197 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:204 def type; end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:187 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:194 def type=(new_type); end # @api private # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:369 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:376 def validate_default_value; end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:156 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:163 def visible?(context); end private - # pkg:gem/graphql#lib/graphql/schema/argument.rb:406 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:413 def recursively_prepare_input_object(value, type, context); end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:434 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:441 def validate_deprecated_or_optional(null:, deprecation_reason:); end - # pkg:gem/graphql#lib/graphql/schema/argument.rb:422 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:429 def validate_input_type(input_type); end end -# pkg:gem/graphql#lib/graphql/schema/argument.rb:397 +# pkg:gem/graphql#lib/graphql/schema/argument.rb:404 class GraphQL::Schema::Argument::InvalidDefaultValueError < ::GraphQL::Error # @return [InvalidDefaultValueError] a new instance of InvalidDefaultValueError # - # pkg:gem/graphql#lib/graphql/schema/argument.rb:398 + # pkg:gem/graphql#lib/graphql/schema/argument.rb:405 def initialize(argument); end end @@ -10206,11 +10230,14 @@ class GraphQL::Schema::Field # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added. # @param default_page_size [Integer, nil] For connections, the default number of items to return from this field, or `nil` to return unlimited results. + # @param definition_block [Proc] an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new {Field}. # @param deprecation_reason [String] If present, the field is marked "deprecated" with this message # @param description [String] Field description # @param dig [Array] The nested hash keys to lookup on the underlying hash to resolve this field using dig # @param directives [Hash{Class => Hash}] Directives to apply to this field + # @param dynamic_introspection [Boolean] (Private, used by GraphQL-Ruby) # @param extensions [Array Object>>] Named extensions to apply to this field (see also {#extension}) + # @param extras [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] Extra arguments to be injected into the resolver for this field # @param fallback_value [Object] A fallback value if the method is not defined # @param hash_key [String, Symbol] The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`) # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__` @@ -10220,6 +10247,8 @@ class GraphQL::Schema::Field # @param name [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API) # @param null [Boolean] (defaults to `true`) `true` if this field may return `null`, `false` if it is never `null` # @param owner [Class] The type that this field belongs to + # @param relay_node_field [Boolean] (Private, used by GraphQL-Ruby) + # @param relay_nodes_field [Boolean] (Private, used by GraphQL-Ruby) # @param resolver_class [Class] (Private) A {Schema::Resolver} which this field was derived from. Use `resolver:` to create a field with a resolver. # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`) # @param scope [Boolean] If true, the return type's `.scope_items` method will be called on the return value @@ -10229,12 +10258,12 @@ class GraphQL::Schema::Field # @param validates [Array] Configurations for validating this field # @return [Field] a new instance of Field # - # pkg:gem/graphql#lib/graphql/schema/field.rb:258 + # pkg:gem/graphql#lib/graphql/schema/field.rb:217 def initialize(type: T.unsafe(nil), name: T.unsafe(nil), owner: T.unsafe(nil), null: T.unsafe(nil), description: T.unsafe(nil), comment: T.unsafe(nil), deprecation_reason: T.unsafe(nil), method: T.unsafe(nil), hash_key: T.unsafe(nil), dig: T.unsafe(nil), resolver_method: T.unsafe(nil), connection: T.unsafe(nil), max_page_size: T.unsafe(nil), default_page_size: T.unsafe(nil), scope: T.unsafe(nil), introspection: T.unsafe(nil), camelize: T.unsafe(nil), trace: T.unsafe(nil), complexity: T.unsafe(nil), ast_node: T.unsafe(nil), extras: T.unsafe(nil), extensions: T.unsafe(nil), connection_extension: T.unsafe(nil), resolver_class: T.unsafe(nil), subscription_scope: T.unsafe(nil), relay_node_field: T.unsafe(nil), relay_nodes_field: T.unsafe(nil), method_conflict_warning: T.unsafe(nil), broadcastable: T.unsafe(nil), arguments: T.unsafe(nil), directives: T.unsafe(nil), validates: T.unsafe(nil), fallback_value: T.unsafe(nil), dynamic_introspection: T.unsafe(nil), &definition_block); end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:669 + # pkg:gem/graphql#lib/graphql/schema/field.rb:628 def authorized?(object, args, context); end # If true, subscription updates with this field can be shared between viewers @@ -10242,31 +10271,31 @@ class GraphQL::Schema::Field # @return [Boolean, nil] # @see GraphQL::Subscriptions::BroadcastAnalyzer # - # pkg:gem/graphql#lib/graphql/schema/field.rb:400 + # pkg:gem/graphql#lib/graphql/schema/field.rb:359 def broadcastable?; end - # pkg:gem/graphql#lib/graphql/schema/field.rb:513 + # pkg:gem/graphql#lib/graphql/schema/field.rb:472 def calculate_complexity(query:, nodes:, child_complexity:); end # @param text [String] # @return [String, nil] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:426 + # pkg:gem/graphql#lib/graphql/schema/field.rb:385 def comment(text = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/field.rb:563 + # pkg:gem/graphql#lib/graphql/schema/field.rb:522 def complexity(new_complexity = T.unsafe(nil)); end # Can be set with `connection: true|false` or inferred from a type name ending in `*Connection` # # @return [Boolean] if true, this field will be wrapped with Relay connection behavior # - # pkg:gem/graphql#lib/graphql/schema/field.rb:160 + # pkg:gem/graphql#lib/graphql/schema/field.rb:114 def connection?; end # @return [Integer, nil] Applied to connections if {#has_default_page_size?} # - # pkg:gem/graphql#lib/graphql/schema/field.rb:609 + # pkg:gem/graphql#lib/graphql/schema/field.rb:568 def default_page_size; end # @return [String, nil] @@ -10277,7 +10306,7 @@ class GraphQL::Schema::Field # @param text [String] # @return [String] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:412 + # pkg:gem/graphql#lib/graphql/schema/field.rb:371 def description(text = T.unsafe(nil)); end # Sets the attribute description @@ -10297,14 +10326,14 @@ class GraphQL::Schema::Field # Returns the value of attribute dynamic_introspection. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:395 + # pkg:gem/graphql#lib/graphql/schema/field.rb:354 def dynamic_introspection; end # Sets the attribute dynamic_introspection # # @param value the value to set the attribute dynamic_introspection to. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:395 + # pkg:gem/graphql#lib/graphql/schema/field.rb:354 def dynamic_introspection=(_arg0); end # Calls the definition block, if one was given. @@ -10314,7 +10343,7 @@ class GraphQL::Schema::Field # @api private # @return [self] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:381 + # pkg:gem/graphql#lib/graphql/schema/field.rb:340 def ensure_loaded; end # Add `extension` to this field, initialized with `options` if provided. @@ -10327,7 +10356,7 @@ class GraphQL::Schema::Field # @param options [Hash] if provided, given as `options:` when initializing `extension`. # @return [void] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:478 + # pkg:gem/graphql#lib/graphql/schema/field.rb:437 def extension(extension_class, **options); end # Read extension instances from this field, @@ -10343,7 +10372,7 @@ class GraphQL::Schema::Field # @param extensions [Array Hash>>] Add extensions to this field. For hash elements, only the first key/value is used. # @return [Array] extensions to apply to this field # - # pkg:gem/graphql#lib/graphql/schema/field.rb:453 + # pkg:gem/graphql#lib/graphql/schema/field.rb:412 def extensions(new_extensions = T.unsafe(nil)); end # Read extras (as symbols) from this field, @@ -10352,15 +10381,15 @@ class GraphQL::Schema::Field # @param new_extras [Array] Add extras to this field # @return [Array] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:495 + # pkg:gem/graphql#lib/graphql/schema/field.rb:454 def extras(new_extras = T.unsafe(nil)); end # @param ctx [GraphQL::Query::Context] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:824 + # pkg:gem/graphql#lib/graphql/schema/field.rb:783 def fetch_extra(extra_name, ctx); end - # pkg:gem/graphql#lib/graphql/schema/field.rb:619 + # pkg:gem/graphql#lib/graphql/schema/field.rb:578 def freeze; end # @return [String] the GraphQL name for this field, camelized unless `camelize: false` is provided @@ -10370,12 +10399,12 @@ class GraphQL::Schema::Field # @return [Boolean] True if this field's {#default_page_size} should override the schema default. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:604 + # pkg:gem/graphql#lib/graphql/schema/field.rb:563 def has_default_page_size?; end # @return [Boolean] True if this field's {#max_page_size} should override the schema default. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:588 + # pkg:gem/graphql#lib/graphql/schema/field.rb:547 def has_max_page_size?; end # Returns the value of attribute hash_key. @@ -10393,12 +10422,12 @@ class GraphQL::Schema::Field # @return [Integer, nil] Applied to connections if {#has_max_page_size?} # - # pkg:gem/graphql#lib/graphql/schema/field.rb:593 + # pkg:gem/graphql#lib/graphql/schema/field.rb:552 def max_page_size; end # @return [Boolean] Should we warn if this field's name conflicts with a built-in method? # - # pkg:gem/graphql#lib/graphql/schema/field.rb:224 + # pkg:gem/graphql#lib/graphql/schema/field.rb:178 def method_conflict_warning?; end # @return [String] Method or hash key on the underlying object to look up @@ -10443,12 +10472,12 @@ class GraphQL::Schema::Field # @return Boolean # - # pkg:gem/graphql#lib/graphql/schema/field.rb:219 + # pkg:gem/graphql#lib/graphql/schema/field.rb:173 def relay_node_field; end # @return Boolean # - # pkg:gem/graphql#lib/graphql/schema/field.rb:221 + # pkg:gem/graphql#lib/graphql/schema/field.rb:175 def relay_nodes_field; end # This method is called by the interpreter for each field. @@ -10458,7 +10487,7 @@ class GraphQL::Schema::Field # @param ctx [GraphQL::Query::Context] # @param object [GraphQL::Schema::Object] An instance of some type class, wrapping an application object # - # pkg:gem/graphql#lib/graphql/schema/field.rb:718 + # pkg:gem/graphql#lib/graphql/schema/field.rb:677 def resolve(object, args, query_ctx); end # @return [Class, nil] The {Schema::Resolver} this field was derived from, if there is one @@ -10473,7 +10502,7 @@ class GraphQL::Schema::Field # @return [Boolean] if true, the return type's `.scope_items` method will be applied to this field's return value # - # pkg:gem/graphql#lib/graphql/schema/field.rb:183 + # pkg:gem/graphql#lib/graphql/schema/field.rb:137 def scoped?; end # @return [String, nil] @@ -10500,33 +10529,33 @@ class GraphQL::Schema::Field # @param new_type [Module, GraphQL::Schema::NonNull, GraphQL::Schema::List] A GraphQL return type # @return [Module, GraphQL::Schema::NonNull, GraphQL::Schema::List, nil] the configured type for this field # - # pkg:gem/graphql#lib/graphql/schema/field.rb:635 + # pkg:gem/graphql#lib/graphql/schema/field.rb:594 def type(new_type = T.unsafe(nil)); end # Sets the attribute type # # @param value the value to set the attribute type to. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:628 + # pkg:gem/graphql#lib/graphql/schema/field.rb:587 def type=(_arg0); end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/field.rb:661 + # pkg:gem/graphql#lib/graphql/schema/field.rb:620 def visible?(context); end private - # pkg:gem/graphql#lib/graphql/schema/field.rb:946 + # pkg:gem/graphql#lib/graphql/schema/field.rb:905 def apply_own_complexity_to(child_complexity, query, nodes); end - # pkg:gem/graphql#lib/graphql/schema/field.rb:836 + # pkg:gem/graphql#lib/graphql/schema/field.rb:795 def assert_satisfactory_implementation(receiver, method_name, ruby_kwargs); end - # pkg:gem/graphql#lib/graphql/schema/field.rb:923 + # pkg:gem/graphql#lib/graphql/schema/field.rb:882 def run_extensions_before_resolve(obj, args, ctx, extended, idx: T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/field.rb:964 + # pkg:gem/graphql#lib/graphql/schema/field.rb:923 def set_pagination_extensions(connection_extension:); end # Wrap execution with hooks. @@ -10534,7 +10563,7 @@ class GraphQL::Schema::Field # # @return [Object] Whatever the # - # pkg:gem/graphql#lib/graphql/schema/field.rb:890 + # pkg:gem/graphql#lib/graphql/schema/field.rb:849 def with_extensions(obj, args, ctx); end class << self @@ -10548,24 +10577,8 @@ class GraphQL::Schema::Field # end # @return [Class] A {FieldExtension} subclass for implementing pagination behavior. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:210 + # pkg:gem/graphql#lib/graphql/schema/field.rb:164 def connection_extension(new_extension_class = T.unsafe(nil)); end - - # Create a field instance from a list of arguments, keyword arguments, and a block. - # - # This method implements prioritization between the `resolver` or `mutation` defaults - # and the local overrides via other keywords. - # - # It also normalizes positional arguments into keywords for {Schema::Field#initialize}. - # - # @param mutation [Class] A {GraphQL::Schema::Mutation} class to use for field configuration - # @param resolver [Class] A {GraphQL::Schema::Resolver} class to use for field configuration - # @param subscription [Class] A {GraphQL::Schema::Subscription} class to use for field configuration - # @return [GraphQL::Schema:Field] an instance of `self` - # @see {.initialize} for other options - # - # pkg:gem/graphql#lib/graphql/schema/field.rb:123 - def from_options(name = T.unsafe(nil), type = T.unsafe(nil), desc = T.unsafe(nil), comment: T.unsafe(nil), resolver: T.unsafe(nil), mutation: T.unsafe(nil), subscription: T.unsafe(nil), **kwargs, &block); end end end @@ -10585,66 +10598,66 @@ class GraphQL::Schema::Field::ConnectionExtension < ::GraphQL::Schema::FieldExte def resolve(object:, arguments:, context:); end end -# pkg:gem/graphql#lib/graphql/schema/field.rb:876 +# pkg:gem/graphql#lib/graphql/schema/field.rb:835 class GraphQL::Schema::Field::ExtendedState # @return [ExtendedState] a new instance of ExtendedState # - # pkg:gem/graphql#lib/graphql/schema/field.rb:877 + # pkg:gem/graphql#lib/graphql/schema/field.rb:836 def initialize(args, object); end # Returns the value of attribute added_extras. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def added_extras; end # Sets the attribute added_extras # # @param value the value to set the attribute added_extras to. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def added_extras=(_arg0); end # Returns the value of attribute arguments. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def arguments; end # Sets the attribute arguments # # @param value the value to set the attribute arguments to. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def arguments=(_arg0); end # Returns the value of attribute memos. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def memos; end # Sets the attribute memos # # @param value the value to set the attribute memos to. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def memos=(_arg0); end # Returns the value of attribute object. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def object; end # Sets the attribute object # # @param value the value to set the attribute object to. # - # pkg:gem/graphql#lib/graphql/schema/field.rb:884 + # pkg:gem/graphql#lib/graphql/schema/field.rb:843 def object=(_arg0); end end # pkg:gem/graphql#lib/graphql/schema/field.rb:18 class GraphQL::Schema::Field::FieldImplementationFailed < ::GraphQL::Error; end -# pkg:gem/graphql#lib/graphql/schema/field.rb:627 +# pkg:gem/graphql#lib/graphql/schema/field.rb:586 class GraphQL::Schema::Field::MissingReturnTypeError < ::GraphQL::Error; end # pkg:gem/graphql#lib/graphql/schema/field/scope_extension.rb:6 @@ -11630,36 +11643,56 @@ module GraphQL::Schema::Member::HasArguments # @param arg_defn [GraphQL::Schema::Argument] # @return [GraphQL::Schema::Argument] # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:47 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:70 def add_argument(arg_defn); end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:200 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:223 def all_argument_definitions; end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:92 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:115 def any_arguments?; end - # @return [GraphQL::Schema::Argument] An instance of {argument_class}, created from `*args` - # @see {GraphQL::Schema::Argument#initialize} for parameters - # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:19 - def argument(*args, **kwargs, &block); end + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @param arg_name [Symbol] The underscore-cased name of this argument, `name:` keyword also accepted + # @param definition_block [Proc] Called with the newly-created {Argument} + # @param desc [String] Argument description, `description:` keyword also accepted + # @param kwargs [Hash] Keywords for defining an argument. Any keywords not documented here must be handled by your base Argument class. + # @param type_expr The GraphQL type of this argument; `type:` keyword also accepted + # @return [GraphQL::Schema::Argument] An instance of {argument_class} created from these arguments + # + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:39 + def argument(arg_name = T.unsafe(nil), type_expr = T.unsafe(nil), desc = T.unsafe(nil), **kwargs, &definition_block); end # @param new_arg_class [Class] A class to use for building argument definitions # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:223 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:246 def argument_class(new_arg_class = T.unsafe(nil)); end # @return [Hash GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions] Hash GraphQL::Schema::Argument] Arguments defined on this thing, keyed by name. Includes inherited definitions # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:79 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:102 def arguments(context = T.unsafe(nil), _require_defined_arguments = T.unsafe(nil)); end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:306 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:329 def arguments_statically_coercible?; end # If given a block, it will eventually yield the loaded args to the block. @@ -11672,25 +11705,25 @@ module GraphQL::Schema::Member::HasArguments # @return [Interpreter::Arguments, Execution::Lazy] # @yield [Interpreter::Arguments, Execution::Lazy] # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:236 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:259 def coerce_arguments(parent_object, values, context, &block); end # @return [GraphQL::Schema::Argument, nil] Argument defined on this thing, fetched by name. # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:211 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:234 def get_argument(argument_name, context = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:428 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:451 def own_arguments; end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:63 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:86 def remove_argument(arg_defn); end # Usually, this is validated statically by RequiredArgumentsArePresent, # but not for directives. # TODO apply static validations on schema definitions? # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:293 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:316 def validate_directive_argument(arg_defn, value); end class << self @@ -11706,21 +11739,21 @@ module GraphQL::Schema::Member::HasArguments end end -# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:314 +# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:337 module GraphQL::Schema::Member::HasArguments::ArgumentClassAccessor - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:315 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:338 def argument_class(new_arg_class = T.unsafe(nil)); end end -# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:326 +# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:349 module GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:351 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:374 def authorize_application_object(argument, id, context, loaded_application_object); end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:346 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:369 def load_and_authorize_application_object(argument, id, context); end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:338 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:361 def load_application_object(argument, id, context); end # Called when an argument's `loads:` configuration fails to fetch an application object. @@ -11730,7 +11763,7 @@ module GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader # @param err [GraphQL::LoadApplicationObjectFailedError] The error that occurred # @return [Object, nil] If a value is returned, it will be used instead of the failed load # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:422 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:445 def load_application_object_failed(err); end # Look up the corresponding object for a provided ID. @@ -11741,54 +11774,54 @@ module GraphQL::Schema::Member::HasArguments::ArgumentObjectLoader # @param id [String] A client-provided to look up # @param type [Class, Module] A GraphQL type definition # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:334 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:357 def object_from_id(type, id, context); end end -# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:96 +# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:119 module GraphQL::Schema::Member::HasArguments::ClassConfigured - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:97 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:120 def inherited(child_class); end end -# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:102 +# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:125 module GraphQL::Schema::Member::HasArguments::ClassConfigured::InheritedArguments - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:123 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:146 def all_argument_definitions; end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:119 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:142 def any_arguments?; end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:103 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:126 def arguments(context = T.unsafe(nil), require_defined_arguments = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:136 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:159 def get_argument(argument_name, context = T.unsafe(nil)); end end -# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:151 +# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:174 module GraphQL::Schema::Member::HasArguments::FieldConfigured - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:174 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:197 def all_argument_definitions; end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:170 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:193 def any_arguments?; end - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:152 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:175 def arguments(context = T.unsafe(nil), _require_defined_arguments = T.unsafe(nil)); end end -# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:298 +# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:321 module GraphQL::Schema::Member::HasArguments::HasDirectiveArguments - # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:299 + # pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:322 def validate_directive_argument(arg_defn, value); end end -# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:427 +# pkg:gem/graphql#lib/graphql/schema/member/has_arguments.rb:450 GraphQL::Schema::Member::HasArguments::NO_ARGUMENTS = T.let(T.unsafe(nil), Hash) # pkg:gem/graphql#lib/graphql/schema/member/has_ast_node.rb:5 @@ -11972,6 +12005,7 @@ end # # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:7 module GraphQL::Schema::Member::HasFields + include ::GraphQL::EmptyObjects include ::GraphQL::Schema::Member::HasFields::InterfaceMethods # Register this field with the class, overriding a previous one if needed. @@ -11979,71 +12013,112 @@ module GraphQL::Schema::Member::HasFields # @param field_defn [GraphQL::Schema::Field] # @return [void] # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:36 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:108 def add_field(field_defn, method_conflict_warning: T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:99 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:171 def all_field_definitions; end # Add a field to this object or interface with the given definition # + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @option kwargs + # @param definition_block [Proc] an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new {Field}. + # @param desc_positional [String] Field description; `description:` keyword is also accepted + # @param kwargs [Hash] Keywords for defining the field. Any not documented here will be passed to your base field class where they must be handled. + # @param name_positional [Symbol] The underscore-cased version of this field name (will be camelized for the GraphQL API); `name:` keyword is also accepted + # @param type_positional [Class, GraphQL::BaseType, Array] The return type of this field; `type:` keyword is also accepted # @return [GraphQL::Schema::Field] - # @see {GraphQL::Schema::Field#initialize} for method signature + # @yieldparam field [GraphQL::Schema::Field] The newly-created field instance + # @yieldreturn [void] # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:11 - def field(*args, **kwargs, &block); end + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:53 + def field(name_positional = T.unsafe(nil), type_positional = T.unsafe(nil), desc_positional = T.unsafe(nil), **kwargs, &definition_block); end # @return [Class] The class to initialize when adding fields to this kind of schema member # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:64 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:136 def field_class(new_field_class = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:74 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:146 def global_id_field(field_name, **kwargs); end # @param new_has_no_fields [Boolean] Call with `true` to make this Object type ignore the requirement to have any defined fields. # @return [void] # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:84 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:156 def has_no_fields(new_has_no_fields); end # @return [Boolean] `true` if `has_no_fields(true)` was configued # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:90 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:162 def has_no_fields?; end # @return [Hash GraphQL::Schema::Field, Array>] Fields defined on this class _specifically_, not parent classes # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:95 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:167 def own_fields; end private - # @param [GraphQL::Schema::Field] + # @param field_defn [GraphQL::Schema::Field] # @return [String] A warning to give when this field definition might conflict with a built-in method # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:237 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:309 def conflict_field_name_warning(field_defn); end - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:203 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:275 def inherited(subclass); end # If `type` is an interface, and `self` has a type membership for `type`, then make sure it's visible. # # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:213 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:285 def visible_interface_implementation?(type, context, warden); end class << self # @private # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:196 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:268 def extended(child_class); end # @private # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:190 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:262 def included(child_class); end end end @@ -12053,35 +12128,35 @@ end # # @api private # -# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:31 +# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:103 GraphQL::Schema::Member::HasFields::CONFLICT_FIELD_NAMES = T.let(T.unsafe(nil), Set) # A list of GraphQL-Ruby keywords. # # @api private # -# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:25 +# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:97 GraphQL::Schema::Member::HasFields::GRAPHQL_RUBY_KEYWORDS = T.let(T.unsafe(nil), Array) -# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:111 +# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:183 module GraphQL::Schema::Member::HasFields::InterfaceMethods # @return [Hash GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:126 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:198 def fields(context = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:112 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:184 def get_field(field_name, context = T.unsafe(nil)); end end -# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:145 +# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:217 module GraphQL::Schema::Member::HasFields::ObjectMethods # @return [Hash GraphQL::Schema::Field>] Fields on this object, keyed by name, including inherited fields # - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:165 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:237 def fields(context = T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:146 + # pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:218 def get_field(field_name, context = T.unsafe(nil)); end end @@ -12089,7 +12164,7 @@ end # # @api private # -# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:20 +# pkg:gem/graphql#lib/graphql/schema/member/has_fields.rb:92 GraphQL::Schema::Member::HasFields::RUBY_KEYWORDS = T.let(T.unsafe(nil), Array) # pkg:gem/graphql#lib/graphql/schema/member/has_interfaces.rb:6 @@ -18259,7 +18334,7 @@ class GraphQL::Tracing::DataDogTracing < ::GraphQL::Tracing::PlatformTracing def tracer; end end -# `DetailedTrace` can make detailed profiles for a subset of production traffic. +# `DetailedTrace` can make detailed profiles for a subset of production traffic. Install it in Rails with `rails generate graphql:detailed_trace`. # # When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: ...` will be used for the query, # overriding the one in `context[:trace_mode]`. @@ -18268,8 +18343,14 @@ end # this behavior by extending {DetailedTrace} and overriding {#inspect_object}. You can opt out of debug annotations # entirely with `use ..., debug: false` or for a single query with `context: { detailed_trace_debug: false }`. # -# __Redis__: The sampler stores its results in a provided Redis database. Depending on your needs, -# You can configure this database to retain all data (persistent) or to expire data according to your rules. +# You can store saved traces in two ways: +# +# - __ActiveRecord__: With `rails generate graphql:detailed_trace`, a new migration will be added to your app. +# That table will be used to store trace data. +# +# - __Redis__: Pass `redis: ...` to save trace data to a Redis database. Depending on your needs, +# you can configure this database to retain all data (persistent) or to expire data according to your rules. +# # If you need to save traces indefinitely, you can download them from Perfetto after opening them there. # # @example Adding the sampler to your schema @@ -18294,57 +18375,59 @@ end # end # end # end +# @example Installing with Rails +# rails generate graphql:detailed_trace # optional: --redis # @example disabling debug annotations completely # use DetailedTrace, debug: false, ... # @example disabling debug annotations for one query # MySchema.execute(query_str, context: { detailed_trace_debug: false }) # @see Graphql::Dashboard GraphQL::Dashboard for viewing stored results # -# pkg:gem/graphql#lib/graphql/tracing/detailed_trace/memory_backend.rb:5 +# pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:5 class GraphQL::Tracing::DetailedTrace # @return [DetailedTrace] a new instance of DetailedTrace # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:69 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:84 def initialize(storage:, trace_mode:, debug:); end # @return [Boolean] # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:84 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:99 def debug?; end # @return [void] # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:106 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:121 def delete_all_traces; end # @return [void] # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:101 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:116 def delete_trace(id); end # @return [StoredTrace, nil] # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:96 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:111 def find_trace(id); end - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:110 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:125 def inspect_object(object); end # @return [String] ID of saved trace # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:79 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:94 def save_trace(operation_name, duration_ms, begin_ms, trace_data); end # @return [Symbol] The trace mode to use when {Schema.detailed_trace?} returns `true` # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:76 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:91 def trace_mode; end # @param before [Integer] Timestamp in milliseconds since epoch # @param last [Integer] # @return [Enumerable] # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:91 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:106 def traces(last: T.unsafe(nil), before: T.unsafe(nil)); end class << self @@ -18352,21 +18435,78 @@ class GraphQL::Tracing::DetailedTrace # # @return [true] # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:124 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:139 def debug?; end - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:114 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:129 def inspect_object(object); end # @param debug [Boolean] if `false`, it won't create `debug` annotations in Perfetto traces (reduces overhead) # @param limit [Integer] A maximum number of profiles to store + # @param model_class [Class] Overrides {ActiveRecordBackend::GraphqlDetailedTrace} if present # @param redis [Redis] If provided, profiles will be stored in Redis for later review # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:56 - def use(schema, trace_mode: T.unsafe(nil), memory: T.unsafe(nil), debug: T.unsafe(nil), redis: T.unsafe(nil), limit: T.unsafe(nil)); end + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:69 + def use(schema, trace_mode: T.unsafe(nil), memory: T.unsafe(nil), debug: T.unsafe(nil), redis: T.unsafe(nil), limit: T.unsafe(nil), model_class: T.unsafe(nil)); end end end +# pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:6 +class GraphQL::Tracing::DetailedTrace::ActiveRecordBackend + # @return [ActiveRecordBackend] a new instance of ActiveRecordBackend + # + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:10 + def initialize(limit: T.unsafe(nil), model_class: T.unsafe(nil)); end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:31 + def delete_all_traces; end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:26 + def delete_trace(id); end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:35 + def find_trace(id); end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:44 + def save_trace(operation_name, duration_ms, begin_ms, trace_data); end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:15 + def traces(last:, before:); end + + private + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:61 + def record_to_stored_trace(gdt); end +end + +# pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:7 +class GraphQL::Tracing::DetailedTrace::ActiveRecordBackend::GraphqlDetailedTrace < ::ActiveRecord::Base + include ::GraphQL::Tracing::DetailedTrace::ActiveRecordBackend::GraphqlDetailedTrace::GeneratedAttributeMethods + include ::GraphQL::Tracing::DetailedTrace::ActiveRecordBackend::GraphqlDetailedTrace::GeneratedAssociationMethods + + class << self + private + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:7 + def __class_attr__validators; end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:7 + def __class_attr__validators=(new_value); end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:7 + def __class_attr_defined_enums; end + + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:7 + def __class_attr_defined_enums=(new_value); end + end +end + +# pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:7 +module GraphQL::Tracing::DetailedTrace::ActiveRecordBackend::GraphqlDetailedTrace::GeneratedAssociationMethods; end + +# pkg:gem/graphql#lib/graphql/tracing/detailed_trace/active_record_backend.rb:7 +module GraphQL::Tracing::DetailedTrace::ActiveRecordBackend::GraphqlDetailedTrace::GeneratedAttributeMethods; end + # An in-memory trace storage backend. Suitable for testing and development only. # It won't work for multi-process deployments and everything is erased when the app is restarted. # @@ -18424,36 +18564,36 @@ end # pkg:gem/graphql#lib/graphql/tracing/detailed_trace/redis_backend.rb:7 GraphQL::Tracing::DetailedTrace::RedisBackend::KEY_PREFIX = T.let(T.unsafe(nil), String) -# pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:128 +# pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:143 class GraphQL::Tracing::DetailedTrace::StoredTrace # @return [StoredTrace] a new instance of StoredTrace # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:129 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:144 def initialize(id:, operation_name:, duration_ms:, begin_ms:, trace_data:); end # Returns the value of attribute begin_ms. # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:137 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:152 def begin_ms; end # Returns the value of attribute duration_ms. # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:137 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:152 def duration_ms; end # Returns the value of attribute id. # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:137 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:152 def id; end # Returns the value of attribute operation_name. # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:137 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:152 def operation_name; end # Returns the value of attribute trace_data. # - # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:137 + # pkg:gem/graphql#lib/graphql/tracing/detailed_trace.rb:152 def trace_data; end end @@ -19026,67 +19166,67 @@ module GraphQL::Tracing::PerfettoTrace # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:76 def initialize(active_support_notifications_pattern: T.unsafe(nil), save_profile: T.unsafe(nil), **_rest); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:274 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:289 def begin_analyze_multiplex(m, analyzers); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:496 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:511 def begin_authorized(type, obj, ctx); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:438 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:453 def begin_dataloader(dl); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:458 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:473 def begin_dataloader_source(source); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:237 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:252 def begin_execute_field(field, object, arguments, query); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:526 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:541 def begin_resolve_type(type, value, context); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:321 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:336 def begin_validate(query, validate); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:426 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:441 def dataloader_fiber_exit; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:407 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:422 def dataloader_fiber_resume(source); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:385 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:400 def dataloader_fiber_yield(source); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:359 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:374 def dataloader_spawn_execution_fiber(jobs); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:372 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:387 def dataloader_spawn_source_fiber(pending_sources); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:289 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:304 def end_analyze_multiplex(m, analyzers); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:510 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:525 def end_authorized(type, obj, ctx, is_authorized); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:449 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:464 def end_dataloader(dl); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:483 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:498 def end_dataloader_source(source); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:251 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:266 def end_execute_field(field, object, arguments, query, app_result); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:540 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:555 def end_resolve_type(type, value, context, resolved_type); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:335 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:350 def end_validate(query, validate, validation_errors); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:207 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:222 def execute_multiplex(multiplex:); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:301 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:316 def parse(query_string:); end # Dump protobuf output in the specified file. @@ -19095,54 +19235,54 @@ module GraphQL::Tracing::PerfettoTrace # @param file [String] path to a file in a directory that already exists # @return [nil, String, Hash] If `file` was given, `nil`. If `file` was `nil`, a Hash if `debug_json: true`, else binary data. # - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:560 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:575 def write(file:, debug_json: T.unsafe(nil)); end private - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:679 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:725 def count_allocations; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:683 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:729 def count_fibers(diff); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:687 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:733 def count_fields; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:593 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:624 def debug_annotation(iid, value_key, value); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:691 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:737 def dup_with(message, attrs, delete_counters: T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:701 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:747 def fiber_flow_stack; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:589 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:604 def fid; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:719 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:765 def new_interned_data; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:601 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:632 def payload_to_debug(k, v, iid: T.unsafe(nil), intern_value: T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:775 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:821 def subscribe_to_active_support_notifications(pattern); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:585 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:600 def tid; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:705 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:751 def trace_packet(timestamp: T.unsafe(nil), **event_attrs); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:746 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:792 def track_descriptor_packet(parent_uuid, uuid, name, counter: T.unsafe(nil)); end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:581 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:596 def ts; end - # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:769 + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:815 def unsubscribe_from_active_support_notifications; end class << self @@ -19159,6 +19299,21 @@ GraphQL::Tracing::PerfettoTrace::ACTIVE_SUPPORT_NOTIFICATIONS_CATEGORY_IIDS = T. # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:54 GraphQL::Tracing::PerfettoTrace::AUTHORIZED_CATEGORY_IIDS = T.let(T.unsafe(nil), Array) +# pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:608 +class GraphQL::Tracing::PerfettoTrace::ArgumentsFilter + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:614 + def filter_param(key, value); end +end + +# pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:612 +GraphQL::Tracing::PerfettoTrace::ArgumentsFilter::FILTERED = T.let(T.unsafe(nil), String) + +# From Rails defaults +# https://github.com/rails/rails/blob/main/railties/lib/rails/generators/rails/app/templates/config/initializers/filter_parameter_logging.rb.tt#L6-L8 +# +# pkg:gem/graphql#lib/graphql/tracing/perfetto_trace.rb:611 +GraphQL::Tracing::PerfettoTrace::ArgumentsFilter::SENSITIVE_KEY = T.let(T.unsafe(nil), Regexp) + # pkg:gem/graphql#lib/graphql/tracing/perfetto_trace/trace_pb.rb:23 class GraphQL::Tracing::PerfettoTrace::CounterDescriptor < ::Google::Protobuf::AbstractMessage; end @@ -21122,7 +21277,7 @@ end # pkg:gem/graphql#lib/graphql/version.rb:3 GraphQL::VERSION = T.let(T.unsafe(nil), String) -# pkg:gem/graphql#lib/graphql/dashboard.rb:3 +# pkg:gem/graphql#lib/graphql/dashboard.rb:4 module Graphql; end # `GraphQL::Dashboard` is a `Rails::Engine`-based dashboard for viewing metadata about your GraphQL schema. @@ -21153,55 +21308,56 @@ module Graphql; end # mount GraphQL::Dashboard, at: "graphql_dashboard", schema: "MySchema" # @see GraphQL::Tracing::DetailedTrace DetailedTrace for viewing production traces in the Dashboard # -# pkg:gem/graphql#lib/graphql/dashboard.rb:34 +# pkg:gem/graphql#lib/graphql/dashboard.rb:35 class Graphql::Dashboard < ::Rails::Engine; end -# pkg:gem/graphql#lib/graphql/dashboard.rb:81 +# pkg:gem/graphql#lib/graphql/dashboard.rb:84 class Graphql::Dashboard::ApplicationController < ::ActionController::Base - # pkg:gem/graphql#lib/graphql/dashboard.rb:98 + # pkg:gem/graphql#lib/graphql/dashboard.rb:85 + def _run_process_action_callbacks(&block); end + + # pkg:gem/graphql#lib/graphql/dashboard.rb:101 def schema_class; end private - # pkg:gem/graphql#lib/graphql/dashboard.rb:81 + # pkg:gem/graphql#lib/graphql/dashboard.rb:84 def _layout(lookup_context, formats, keys); end class << self private - # pkg:gem/graphql#lib/graphql/dashboard.rb:82 + # pkg:gem/graphql#lib/graphql/dashboard.rb:85 def __class_attr___callbacks; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:82 + # pkg:gem/graphql#lib/graphql/dashboard.rb:85 def __class_attr___callbacks=(new_value); end - # pkg:gem/graphql#lib/graphql/dashboard.rb:111 + # pkg:gem/graphql#lib/graphql/dashboard.rb:114 def __class_attr__helper_methods; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:111 + # pkg:gem/graphql#lib/graphql/dashboard.rb:114 def __class_attr__helper_methods=(new_value); end - # pkg:gem/graphql#lib/graphql/dashboard.rb:81 + # pkg:gem/graphql#lib/graphql/dashboard.rb:84 def __class_attr_config; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:81 + # pkg:gem/graphql#lib/graphql/dashboard.rb:84 def __class_attr_config=(new_value); end - # pkg:gem/graphql#lib/graphql/dashboard.rb:81 + # pkg:gem/graphql#lib/graphql/dashboard.rb:84 def __class_attr_middleware_stack; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:81 + # pkg:gem/graphql#lib/graphql/dashboard.rb:84 def __class_attr_middleware_stack=(new_value); end end end -# pkg:gem/graphql#lib/graphql/dashboard.rb:111 +# pkg:gem/graphql#lib/graphql/dashboard.rb:114 module Graphql::Dashboard::ApplicationController::HelperMethods - include ::ActionText::ContentHelper - include ::ActionText::TagHelper include ::ActionController::Base::HelperMethods - # pkg:gem/graphql#lib/graphql/dashboard.rb:111 + # pkg:gem/graphql#lib/graphql/dashboard.rb:114 def schema_class(*_arg0, **_arg1, &_arg2); end end @@ -21281,29 +21437,29 @@ module Graphql::Dashboard::Installable end end -# pkg:gem/graphql#lib/graphql/dashboard.rb:114 +# pkg:gem/graphql#lib/graphql/dashboard.rb:117 class Graphql::Dashboard::LandingsController < ::Graphql::Dashboard::ApplicationController - # pkg:gem/graphql#lib/graphql/dashboard.rb:115 + # pkg:gem/graphql#lib/graphql/dashboard.rb:118 def show; end private - # pkg:gem/graphql#lib/graphql/dashboard.rb:114 + # pkg:gem/graphql#lib/graphql/dashboard.rb:117 def _layout(lookup_context, formats, keys); end class << self private - # pkg:gem/graphql#lib/graphql/dashboard.rb:114 + # pkg:gem/graphql#lib/graphql/dashboard.rb:117 def __class_attr_config; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:114 + # pkg:gem/graphql#lib/graphql/dashboard.rb:117 def __class_attr_config=(new_value); end - # pkg:gem/graphql#lib/graphql/dashboard.rb:114 + # pkg:gem/graphql#lib/graphql/dashboard.rb:117 def __class_attr_middleware_stack; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:114 + # pkg:gem/graphql#lib/graphql/dashboard.rb:117 def __class_attr_middleware_stack=(new_value); end end end @@ -21520,42 +21676,42 @@ class Graphql::Dashboard::OperationStore::OperationsController < ::Graphql::Dash end end -# pkg:gem/graphql#lib/graphql/dashboard.rb:119 +# pkg:gem/graphql#lib/graphql/dashboard.rb:122 class Graphql::Dashboard::StaticsController < ::Graphql::Dashboard::ApplicationController - # pkg:gem/graphql#lib/graphql/dashboard.rb:136 + # pkg:gem/graphql#lib/graphql/dashboard.rb:139 def show; end private - # pkg:gem/graphql#lib/graphql/dashboard.rb:119 + # pkg:gem/graphql#lib/graphql/dashboard.rb:122 def _layout(lookup_context, formats, keys); end class << self private - # pkg:gem/graphql#lib/graphql/dashboard.rb:120 + # pkg:gem/graphql#lib/graphql/dashboard.rb:123 def __class_attr___callbacks; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:120 + # pkg:gem/graphql#lib/graphql/dashboard.rb:123 def __class_attr___callbacks=(new_value); end - # pkg:gem/graphql#lib/graphql/dashboard.rb:119 + # pkg:gem/graphql#lib/graphql/dashboard.rb:122 def __class_attr_config; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:119 + # pkg:gem/graphql#lib/graphql/dashboard.rb:122 def __class_attr_config=(new_value); end - # pkg:gem/graphql#lib/graphql/dashboard.rb:119 + # pkg:gem/graphql#lib/graphql/dashboard.rb:122 def __class_attr_middleware_stack; end - # pkg:gem/graphql#lib/graphql/dashboard.rb:119 + # pkg:gem/graphql#lib/graphql/dashboard.rb:122 def __class_attr_middleware_stack=(new_value); end end end # Use an explicit list of files to avoid any chance of reading other files from disk # -# pkg:gem/graphql#lib/graphql/dashboard.rb:122 +# pkg:gem/graphql#lib/graphql/dashboard.rb:125 Graphql::Dashboard::StaticsController::STATICS = T.let(T.unsafe(nil), Hash) # pkg:gem/graphql#lib/graphql/dashboard/subscriptions.rb:4 diff --git a/sorbet/rbi/gems/json@2.18.0.rbi b/sorbet/rbi/gems/json@2.18.1.rbi similarity index 99% rename from sorbet/rbi/gems/json@2.18.0.rbi rename to sorbet/rbi/gems/json@2.18.1.rbi index 13b3a52ec..6267ad95f 100644 --- a/sorbet/rbi/gems/json@2.18.0.rbi +++ b/sorbet/rbi/gems/json@2.18.1.rbi @@ -31,6 +31,15 @@ end # # \JSON is a lightweight data-interchange format. # +# \JSON is easy for us humans to read and write, +# and equally simple for machines to read (parse) and write (generate). +# +# \JSON is language-independent, making it an ideal interchange format +# for applications in differing programming languages +# and on differing operating systems. +# +# == \JSON Values +# # A \JSON value is one of the following: # - Double-quoted text: "foo". # - Number: +1+, +1.0+, +2.0e2+. @@ -198,6 +207,18 @@ end # When enabled: # JSON.parse('[1,]', allow_trailing_comma: true) # => [1] # +# --- +# +# Option +allow_control_characters+ (boolean) specifies whether to allow +# unescaped ASCII control characters, such as newlines, in strings; +# defaults to +false+. +# +# With the default, +false+: +# JSON.parse(%{"Hello\nWorld"}) # invalid ASCII control character in string (JSON::ParserError) +# +# When enabled: +# JSON.parse(%{"Hello\nWorld"}, allow_control_characters: true) # => "Hello\nWorld" +# # ====== Output Options # # Option +freeze+ (boolean) specifies whether the returned objects will be frozen; diff --git a/sorbet/rbi/gems/parser@3.3.10.0.rbi b/sorbet/rbi/gems/parser@3.3.10.1.rbi similarity index 100% rename from sorbet/rbi/gems/parser@3.3.10.0.rbi rename to sorbet/rbi/gems/parser@3.3.10.1.rbi diff --git a/sorbet/rbi/gems/prism@1.8.0.rbi b/sorbet/rbi/gems/prism@1.9.0.rbi similarity index 89% rename from sorbet/rbi/gems/prism@1.8.0.rbi rename to sorbet/rbi/gems/prism@1.9.0.rbi index f8c463b80..0c1073cc9 100644 --- a/sorbet/rbi/gems/prism@1.8.0.rbi +++ b/sorbet/rbi/gems/prism@1.9.0.rbi @@ -42,139 +42,127 @@ module Prism class << self # Mirror the Prism.dump API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def dump(*_arg0); end # Mirror the Prism.dump_file API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def dump_file(*_arg0); end # Mirror the Prism.lex API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def lex(*_arg0); end # :call-seq: # Prism::lex_compat(source, **options) -> LexCompat::Result # # Returns a parse result whose value is an array of tokens that closely - # resembles the return value of Ripper::lex. The main difference is that the - # `:on_sp` token is not emitted. + # resembles the return value of Ripper::lex. # # For supported options, see Prism::parse. # - # pkg:gem/prism#lib/prism.rb:68 + # pkg:gem/prism#lib/prism.rb:65 sig { params(source: String, options: T::Hash[Symbol, T.untyped]).returns(Prism::LexCompat::Result) } def lex_compat(source, **options); end # Mirror the Prism.lex_file API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def lex_file(*_arg0); end - # :call-seq: - # Prism::lex_ripper(source) -> Array - # - # This lexes with the Ripper lex. It drops any space events but otherwise - # returns the same tokens. Raises SyntaxError if the syntax in source is - # invalid. - # - # pkg:gem/prism#lib/prism.rb:78 - sig { params(source: String).returns(T::Array[T.untyped]) } - def lex_ripper(source); end - # :call-seq: # Prism::load(source, serialized, freeze) -> ParseResult # # Load the serialized AST using the source as a reference into a tree. # - # pkg:gem/prism#lib/prism.rb:86 + # pkg:gem/prism#lib/prism.rb:73 sig { params(source: String, serialized: String, freeze: T.nilable(T::Boolean)).returns(Prism::ParseResult) } def load(source, serialized, freeze = T.unsafe(nil)); end # Mirror the Prism.parse API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse(*_arg0); end # Mirror the Prism.parse_comments API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_comments(*_arg0); end # Mirror the Prism.parse_failure? API by using the serialization API. # # @return [Boolean] # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_failure?(*_arg0); end # Mirror the Prism.parse_file API by using the serialization API. This uses # native strings instead of Ruby strings because it allows us to use mmap # when it is available. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_file(*_arg0); end # Mirror the Prism.parse_file_comments API by using the serialization # API. This uses native strings instead of Ruby strings because it allows us # to use mmap when it is available. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_file_comments(*_arg0); end # Mirror the Prism.parse_file_failure? API by using the serialization API. # # @return [Boolean] # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_file_failure?(*_arg0); end # Mirror the Prism.parse_file_success? API by using the serialization API. # # @return [Boolean] # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_file_success?(*_arg0); end # Mirror the Prism.parse_lex API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_lex(*_arg0); end # Mirror the Prism.parse_lex_file API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_lex_file(*_arg0); end # Mirror the Prism.parse_stream API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_stream(*_arg0); end # Mirror the Prism.parse_success? API by using the serialization API. # # @return [Boolean] # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse_success?(*_arg0); end # Mirror the Prism.profile API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def profile(*_arg0); end # Mirror the Prism.profile_file API by using the serialization API. # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def profile_file(*_arg0); end # Create a new scope with the given locals and forwarding options that is # suitable for passing into one of the Prism.* methods that accepts the # `scopes` option. # - # pkg:gem/prism#lib/prism/parse_result.rb:895 + # pkg:gem/prism#lib/prism/parse_result.rb:904 sig { params(locals: T::Array[Symbol], forwarding: T::Array[Symbol]).returns(Prism::Scope) } def scope(locals: T.unsafe(nil), forwarding: T.unsafe(nil)); end end @@ -189,17 +177,17 @@ end # eagerly converted to UTF-8, this class will be used as well. This is because # at that point we will treat everything as single-byte characters. # -# pkg:gem/prism#lib/prism/parse_result.rb:241 +# pkg:gem/prism#lib/prism/parse_result.rb:250 class Prism::ASCIISource < ::Prism::Source # Return the column number in characters for the given byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:248 + # pkg:gem/prism#lib/prism/parse_result.rb:257 sig { params(byte_offset: Integer).returns(Integer) } def character_column(byte_offset); end # Return the character offset for the given byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:243 + # pkg:gem/prism#lib/prism/parse_result.rb:252 sig { params(byte_offset: Integer).returns(Integer) } def character_offset(byte_offset); end @@ -207,7 +195,7 @@ class Prism::ASCIISource < ::Prism::Source # same interface. We can do this because code units are always equivalent to # byte offsets for ASCII-only sources. # - # pkg:gem/prism#lib/prism/parse_result.rb:265 + # pkg:gem/prism#lib/prism/parse_result.rb:274 sig do params( encoding: Encoding @@ -219,7 +207,7 @@ class Prism::ASCIISource < ::Prism::Source # `code_units_offset`, which is a more expensive operation. This is # essentially the same as `Prism::Source#column`. # - # pkg:gem/prism#lib/prism/parse_result.rb:272 + # pkg:gem/prism#lib/prism/parse_result.rb:281 sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } def code_units_column(byte_offset, encoding); end @@ -230,7 +218,7 @@ class Prism::ASCIISource < ::Prism::Source # concept of code units that differs from the number of characters in other # encodings, it is not captured here. # - # pkg:gem/prism#lib/prism/parse_result.rb:258 + # pkg:gem/prism#lib/prism/parse_result.rb:267 sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } def code_units_offset(byte_offset, encoding); end end @@ -240,13 +228,13 @@ end # alias $foo $bar # ^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:326 +# pkg:gem/prism#lib/prism/node.rb:334 class Prism::AliasGlobalVariableNode < ::Prism::Node # Initialize a new AliasGlobalVariableNode node. # # @return [AliasGlobalVariableNode] a new instance of AliasGlobalVariableNode # - # pkg:gem/prism#lib/prism/node.rb:328 + # pkg:gem/prism#lib/prism/node.rb:336 sig do params( source: Prism::Source, @@ -263,36 +251,36 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:429 + # pkg:gem/prism#lib/prism/node.rb:437 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:339 + # pkg:gem/prism#lib/prism/node.rb:347 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:344 + # pkg:gem/prism#lib/prism/node.rb:352 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:362 + # pkg:gem/prism#lib/prism/node.rb:370 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:357 + # pkg:gem/prism#lib/prism/node.rb:365 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, ?old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, ?keyword_loc: Location) -> AliasGlobalVariableNode # - # pkg:gem/prism#lib/prism/node.rb:367 + # pkg:gem/prism#lib/prism/node.rb:375 sig do params( node_id: Integer, @@ -308,13 +296,13 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:372 + # pkg:gem/prism#lib/prism/node.rb:380 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode, old_name: GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | SymbolNode | MissingNode, keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:375 + # pkg:gem/prism#lib/prism/node.rb:383 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -322,7 +310,7 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # # @yield [new_name] # - # pkg:gem/prism#lib/prism/node.rb:349 + # pkg:gem/prism#lib/prism/node.rb:357 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -330,13 +318,13 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:413 + # pkg:gem/prism#lib/prism/node.rb:421 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:408 + # pkg:gem/prism#lib/prism/node.rb:416 sig { returns(String) } def keyword; end @@ -345,7 +333,7 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # alias $foo $bar # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:395 + # pkg:gem/prism#lib/prism/node.rb:403 sig { returns(Prism::Location) } def keyword_loc; end @@ -354,7 +342,7 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # alias $foo $bar # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:383 + # pkg:gem/prism#lib/prism/node.rb:391 sig { returns(T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)) } def new_name; end @@ -363,7 +351,7 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # alias $foo $bar # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:389 + # pkg:gem/prism#lib/prism/node.rb:397 sig do returns(T.any(Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::SymbolNode, Prism::MissingNode)) end @@ -372,19 +360,19 @@ class Prism::AliasGlobalVariableNode < ::Prism::Node # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:403 + # pkg:gem/prism#lib/prism/node.rb:411 def save_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:418 + # pkg:gem/prism#lib/prism/node.rb:426 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:423 + # pkg:gem/prism#lib/prism/node.rb:431 def type; end end end @@ -394,13 +382,13 @@ end # alias foo bar # ^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:441 +# pkg:gem/prism#lib/prism/node.rb:449 class Prism::AliasMethodNode < ::Prism::Node # Initialize a new AliasMethodNode node. # # @return [AliasMethodNode] a new instance of AliasMethodNode # - # pkg:gem/prism#lib/prism/node.rb:443 + # pkg:gem/prism#lib/prism/node.rb:451 sig do params( source: Prism::Source, @@ -417,36 +405,36 @@ class Prism::AliasMethodNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:556 + # pkg:gem/prism#lib/prism/node.rb:564 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:454 + # pkg:gem/prism#lib/prism/node.rb:462 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:459 + # pkg:gem/prism#lib/prism/node.rb:467 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:477 + # pkg:gem/prism#lib/prism/node.rb:485 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:472 + # pkg:gem/prism#lib/prism/node.rb:480 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?new_name: SymbolNode | InterpolatedSymbolNode, ?old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, ?keyword_loc: Location) -> AliasMethodNode # - # pkg:gem/prism#lib/prism/node.rb:482 + # pkg:gem/prism#lib/prism/node.rb:490 sig do params( node_id: Integer, @@ -462,13 +450,13 @@ class Prism::AliasMethodNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:487 + # pkg:gem/prism#lib/prism/node.rb:495 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, new_name: SymbolNode | InterpolatedSymbolNode, old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode, keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:490 + # pkg:gem/prism#lib/prism/node.rb:498 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -476,7 +464,7 @@ class Prism::AliasMethodNode < ::Prism::Node # # @yield [new_name] # - # pkg:gem/prism#lib/prism/node.rb:464 + # pkg:gem/prism#lib/prism/node.rb:472 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -484,13 +472,13 @@ class Prism::AliasMethodNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:540 + # pkg:gem/prism#lib/prism/node.rb:548 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:535 + # pkg:gem/prism#lib/prism/node.rb:543 sig { returns(String) } def keyword; end @@ -499,7 +487,7 @@ class Prism::AliasMethodNode < ::Prism::Node # alias foo bar # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:522 + # pkg:gem/prism#lib/prism/node.rb:530 sig { returns(Prism::Location) } def keyword_loc; end @@ -514,7 +502,7 @@ class Prism::AliasMethodNode < ::Prism::Node # alias :"#{foo}" :"#{bar}" # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:504 + # pkg:gem/prism#lib/prism/node.rb:512 sig { returns(T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)) } def new_name; end @@ -529,7 +517,7 @@ class Prism::AliasMethodNode < ::Prism::Node # alias :"#{foo}" :"#{bar}" # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:516 + # pkg:gem/prism#lib/prism/node.rb:524 sig do returns(T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode, Prism::GlobalVariableReadNode, Prism::MissingNode)) end @@ -538,19 +526,19 @@ class Prism::AliasMethodNode < ::Prism::Node # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:530 + # pkg:gem/prism#lib/prism/node.rb:538 def save_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:545 + # pkg:gem/prism#lib/prism/node.rb:553 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:550 + # pkg:gem/prism#lib/prism/node.rb:558 def type; end end end @@ -560,13 +548,13 @@ end # foo => bar | baz # ^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:568 +# pkg:gem/prism#lib/prism/node.rb:576 class Prism::AlternationPatternNode < ::Prism::Node # Initialize a new AlternationPatternNode node. # # @return [AlternationPatternNode] a new instance of AlternationPatternNode # - # pkg:gem/prism#lib/prism/node.rb:570 + # pkg:gem/prism#lib/prism/node.rb:578 sig do params( source: Prism::Source, @@ -583,36 +571,36 @@ class Prism::AlternationPatternNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:671 + # pkg:gem/prism#lib/prism/node.rb:679 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:581 + # pkg:gem/prism#lib/prism/node.rb:589 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:586 + # pkg:gem/prism#lib/prism/node.rb:594 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:604 + # pkg:gem/prism#lib/prism/node.rb:612 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:599 + # pkg:gem/prism#lib/prism/node.rb:607 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AlternationPatternNode # - # pkg:gem/prism#lib/prism/node.rb:609 + # pkg:gem/prism#lib/prism/node.rb:617 sig do params( node_id: Integer, @@ -628,13 +616,13 @@ class Prism::AlternationPatternNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:614 + # pkg:gem/prism#lib/prism/node.rb:622 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:617 + # pkg:gem/prism#lib/prism/node.rb:625 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -642,7 +630,7 @@ class Prism::AlternationPatternNode < ::Prism::Node # # @yield [left] # - # pkg:gem/prism#lib/prism/node.rb:591 + # pkg:gem/prism#lib/prism/node.rb:599 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -650,7 +638,7 @@ class Prism::AlternationPatternNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:655 + # pkg:gem/prism#lib/prism/node.rb:663 sig { override.returns(String) } def inspect; end @@ -659,13 +647,13 @@ class Prism::AlternationPatternNode < ::Prism::Node # foo => bar | baz # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:625 + # pkg:gem/prism#lib/prism/node.rb:633 sig { returns(Prism::Node) } def left; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:650 + # pkg:gem/prism#lib/prism/node.rb:658 sig { returns(String) } def operator; end @@ -674,7 +662,7 @@ class Prism::AlternationPatternNode < ::Prism::Node # foo => bar | baz # ^ # - # pkg:gem/prism#lib/prism/node.rb:637 + # pkg:gem/prism#lib/prism/node.rb:645 sig { returns(Prism::Location) } def operator_loc; end @@ -683,26 +671,26 @@ class Prism::AlternationPatternNode < ::Prism::Node # foo => bar | baz # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:631 + # pkg:gem/prism#lib/prism/node.rb:639 sig { returns(Prism::Node) } def right; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:645 + # pkg:gem/prism#lib/prism/node.rb:653 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:660 + # pkg:gem/prism#lib/prism/node.rb:668 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:665 + # pkg:gem/prism#lib/prism/node.rb:673 def type; end end end @@ -712,13 +700,13 @@ end # left and right # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:683 +# pkg:gem/prism#lib/prism/node.rb:691 class Prism::AndNode < ::Prism::Node # Initialize a new AndNode node. # # @return [AndNode] a new instance of AndNode # - # pkg:gem/prism#lib/prism/node.rb:685 + # pkg:gem/prism#lib/prism/node.rb:693 sig do params( source: Prism::Source, @@ -735,36 +723,36 @@ class Prism::AndNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:792 + # pkg:gem/prism#lib/prism/node.rb:800 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:696 + # pkg:gem/prism#lib/prism/node.rb:704 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:701 + # pkg:gem/prism#lib/prism/node.rb:709 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:719 + # pkg:gem/prism#lib/prism/node.rb:727 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:714 + # pkg:gem/prism#lib/prism/node.rb:722 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> AndNode # - # pkg:gem/prism#lib/prism/node.rb:724 + # pkg:gem/prism#lib/prism/node.rb:732 sig do params( node_id: Integer, @@ -780,13 +768,13 @@ class Prism::AndNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:729 + # pkg:gem/prism#lib/prism/node.rb:737 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:732 + # pkg:gem/prism#lib/prism/node.rb:740 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -794,7 +782,7 @@ class Prism::AndNode < ::Prism::Node # # @yield [left] # - # pkg:gem/prism#lib/prism/node.rb:706 + # pkg:gem/prism#lib/prism/node.rb:714 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -802,7 +790,7 @@ class Prism::AndNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:776 + # pkg:gem/prism#lib/prism/node.rb:784 sig { override.returns(String) } def inspect; end @@ -814,13 +802,13 @@ class Prism::AndNode < ::Prism::Node # 1 && 2 # ^ # - # pkg:gem/prism#lib/prism/node.rb:743 + # pkg:gem/prism#lib/prism/node.rb:751 sig { returns(Prism::Node) } def left; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:771 + # pkg:gem/prism#lib/prism/node.rb:779 sig { returns(String) } def operator; end @@ -829,7 +817,7 @@ class Prism::AndNode < ::Prism::Node # left and right # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:758 + # pkg:gem/prism#lib/prism/node.rb:766 sig { returns(Prism::Location) } def operator_loc; end @@ -841,26 +829,26 @@ class Prism::AndNode < ::Prism::Node # 1 and 2 # ^ # - # pkg:gem/prism#lib/prism/node.rb:752 + # pkg:gem/prism#lib/prism/node.rb:760 sig { returns(Prism::Node) } def right; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:766 + # pkg:gem/prism#lib/prism/node.rb:774 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:781 + # pkg:gem/prism#lib/prism/node.rb:789 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:786 + # pkg:gem/prism#lib/prism/node.rb:794 def type; end end end @@ -870,13 +858,13 @@ end # return foo, bar, baz # ^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:804 +# pkg:gem/prism#lib/prism/node.rb:812 class Prism::ArgumentsNode < ::Prism::Node # Initialize a new ArgumentsNode node. # # @return [ArgumentsNode] a new instance of ArgumentsNode # - # pkg:gem/prism#lib/prism/node.rb:806 + # pkg:gem/prism#lib/prism/node.rb:814 sig do params( source: Prism::Source, @@ -891,12 +879,12 @@ class Prism::ArgumentsNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:902 + # pkg:gem/prism#lib/prism/node.rb:910 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:815 + # pkg:gem/prism#lib/prism/node.rb:823 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -905,25 +893,25 @@ class Prism::ArgumentsNode < ::Prism::Node # foo(bar, baz) # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:883 + # pkg:gem/prism#lib/prism/node.rb:891 sig { returns(T::Array[Prism::Node]) } def arguments; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:820 + # pkg:gem/prism#lib/prism/node.rb:828 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:837 + # pkg:gem/prism#lib/prism/node.rb:845 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:832 + # pkg:gem/prism#lib/prism/node.rb:840 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -931,7 +919,7 @@ class Prism::ArgumentsNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:855 + # pkg:gem/prism#lib/prism/node.rb:863 sig { returns(T::Boolean) } def contains_forwarding?; end @@ -939,7 +927,7 @@ class Prism::ArgumentsNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:865 + # pkg:gem/prism#lib/prism/node.rb:873 sig { returns(T::Boolean) } def contains_keyword_splat?; end @@ -947,7 +935,7 @@ class Prism::ArgumentsNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:860 + # pkg:gem/prism#lib/prism/node.rb:868 sig { returns(T::Boolean) } def contains_keywords?; end @@ -955,7 +943,7 @@ class Prism::ArgumentsNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:875 + # pkg:gem/prism#lib/prism/node.rb:883 sig { returns(T::Boolean) } def contains_multiple_splats?; end @@ -963,13 +951,13 @@ class Prism::ArgumentsNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:870 + # pkg:gem/prism#lib/prism/node.rb:878 sig { returns(T::Boolean) } def contains_splat?; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: Array[Prism::node]) -> ArgumentsNode # - # pkg:gem/prism#lib/prism/node.rb:842 + # pkg:gem/prism#lib/prism/node.rb:850 sig do params( node_id: Integer, @@ -983,19 +971,19 @@ class Prism::ArgumentsNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:847 + # pkg:gem/prism#lib/prism/node.rb:855 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: Array[Prism::node] } # - # pkg:gem/prism#lib/prism/node.rb:850 + # pkg:gem/prism#lib/prism/node.rb:858 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:825 + # pkg:gem/prism#lib/prism/node.rb:833 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -1003,52 +991,52 @@ class Prism::ArgumentsNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:886 + # pkg:gem/prism#lib/prism/node.rb:894 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:891 + # pkg:gem/prism#lib/prism/node.rb:899 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:896 + # pkg:gem/prism#lib/prism/node.rb:904 def type; end end end # Flags for arguments nodes. # -# pkg:gem/prism#lib/prism/node.rb:19772 +# pkg:gem/prism#lib/prism/node.rb:19780 module Prism::ArgumentsNodeFlags; end # if the arguments contain forwarding # -# pkg:gem/prism#lib/prism/node.rb:19774 +# pkg:gem/prism#lib/prism/node.rb:19782 Prism::ArgumentsNodeFlags::CONTAINS_FORWARDING = T.let(T.unsafe(nil), Integer) # if the arguments contain keywords # -# pkg:gem/prism#lib/prism/node.rb:19777 +# pkg:gem/prism#lib/prism/node.rb:19785 Prism::ArgumentsNodeFlags::CONTAINS_KEYWORDS = T.let(T.unsafe(nil), Integer) # if the arguments contain a keyword splat # -# pkg:gem/prism#lib/prism/node.rb:19780 +# pkg:gem/prism#lib/prism/node.rb:19788 Prism::ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT = T.let(T.unsafe(nil), Integer) # if the arguments contain multiple splats # -# pkg:gem/prism#lib/prism/node.rb:19786 +# pkg:gem/prism#lib/prism/node.rb:19794 Prism::ArgumentsNodeFlags::CONTAINS_MULTIPLE_SPLATS = T.let(T.unsafe(nil), Integer) # if the arguments contain a splat # -# pkg:gem/prism#lib/prism/node.rb:19783 +# pkg:gem/prism#lib/prism/node.rb:19791 Prism::ArgumentsNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer) # Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i. @@ -1056,13 +1044,13 @@ Prism::ArgumentsNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer) # [1, 2, 3] # ^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:914 +# pkg:gem/prism#lib/prism/node.rb:922 class Prism::ArrayNode < ::Prism::Node # Initialize a new ArrayNode node. # # @return [ArrayNode] a new instance of ArrayNode # - # pkg:gem/prism#lib/prism/node.rb:916 + # pkg:gem/prism#lib/prism/node.rb:924 sig do params( source: Prism::Source, @@ -1079,24 +1067,24 @@ class Prism::ArrayNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1049 + # pkg:gem/prism#lib/prism/node.rb:1057 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:927 + # pkg:gem/prism#lib/prism/node.rb:935 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:932 + # pkg:gem/prism#lib/prism/node.rb:940 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:1028 + # pkg:gem/prism#lib/prism/node.rb:1036 sig { returns(T.nilable(String)) } def closing; end @@ -1107,19 +1095,19 @@ class Prism::ArrayNode < ::Prism::Node # %I(apple orange banana) # ")" # foo = 1, 2, 3 # nil # - # pkg:gem/prism#lib/prism/node.rb:1004 + # pkg:gem/prism#lib/prism/node.rb:1012 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:949 + # pkg:gem/prism#lib/prism/node.rb:957 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:944 + # pkg:gem/prism#lib/prism/node.rb:952 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -1127,13 +1115,13 @@ class Prism::ArrayNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:967 + # pkg:gem/prism#lib/prism/node.rb:975 sig { returns(T::Boolean) } def contains_splat?; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayNode # - # pkg:gem/prism#lib/prism/node.rb:954 + # pkg:gem/prism#lib/prism/node.rb:962 sig do params( node_id: Integer, @@ -1149,24 +1137,24 @@ class Prism::ArrayNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:959 + # pkg:gem/prism#lib/prism/node.rb:967 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[Prism::node], opening_loc: Location?, closing_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:962 + # pkg:gem/prism#lib/prism/node.rb:970 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:937 + # pkg:gem/prism#lib/prism/node.rb:945 def each_child_node; end # Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array. # - # pkg:gem/prism#lib/prism/node.rb:972 + # pkg:gem/prism#lib/prism/node.rb:980 sig { returns(T::Array[Prism::Node]) } def elements; end @@ -1175,13 +1163,13 @@ class Prism::ArrayNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1033 + # pkg:gem/prism#lib/prism/node.rb:1041 sig { override.returns(String) } def inspect; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:1023 + # pkg:gem/prism#lib/prism/node.rb:1031 sig { returns(T.nilable(String)) } def opening; end @@ -1192,44 +1180,44 @@ class Prism::ArrayNode < ::Prism::Node # %I(apple orange banana) # "%I(" # foo = 1, 2, 3 # nil # - # pkg:gem/prism#lib/prism/node.rb:980 + # pkg:gem/prism#lib/prism/node.rb:988 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1018 + # pkg:gem/prism#lib/prism/node.rb:1026 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:994 + # pkg:gem/prism#lib/prism/node.rb:1002 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1038 + # pkg:gem/prism#lib/prism/node.rb:1046 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1043 + # pkg:gem/prism#lib/prism/node.rb:1051 def type; end end end # Flags for array nodes. # -# pkg:gem/prism#lib/prism/node.rb:19790 +# pkg:gem/prism#lib/prism/node.rb:19798 module Prism::ArrayNodeFlags; end # if array contains splat nodes # -# pkg:gem/prism#lib/prism/node.rb:19792 +# pkg:gem/prism#lib/prism/node.rb:19800 Prism::ArrayNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer) # Represents an array pattern in pattern matching. @@ -1249,13 +1237,13 @@ Prism::ArrayNodeFlags::CONTAINS_SPLAT = T.let(T.unsafe(nil), Integer) # foo in Bar[1, 2, 3] # ^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:1075 +# pkg:gem/prism#lib/prism/node.rb:1083 class Prism::ArrayPatternNode < ::Prism::Node # Initialize a new ArrayPatternNode node. # # @return [ArrayPatternNode] a new instance of ArrayPatternNode # - # pkg:gem/prism#lib/prism/node.rb:1077 + # pkg:gem/prism#lib/prism/node.rb:1085 sig do params( source: Prism::Source, @@ -1275,24 +1263,24 @@ class Prism::ArrayPatternNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1239 + # pkg:gem/prism#lib/prism/node.rb:1247 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1091 + # pkg:gem/prism#lib/prism/node.rb:1099 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1096 + # pkg:gem/prism#lib/prism/node.rb:1104 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:1218 + # pkg:gem/prism#lib/prism/node.rb:1226 sig { returns(T.nilable(String)) } def closing; end @@ -1301,19 +1289,19 @@ class Prism::ArrayPatternNode < ::Prism::Node # foo in [1, 2] # ^ # - # pkg:gem/prism#lib/prism/node.rb:1194 + # pkg:gem/prism#lib/prism/node.rb:1202 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1121 + # pkg:gem/prism#lib/prism/node.rb:1129 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1111 + # pkg:gem/prism#lib/prism/node.rb:1119 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -1328,13 +1316,13 @@ class Prism::ArrayPatternNode < ::Prism::Node # foo in Bar::Baz[1, 2, 3] # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1148 + # pkg:gem/prism#lib/prism/node.rb:1156 sig { returns(T.nilable(T.any(Prism::ConstantPathNode, Prism::ConstantReadNode))) } def constant; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode # - # pkg:gem/prism#lib/prism/node.rb:1126 + # pkg:gem/prism#lib/prism/node.rb:1134 sig do params( node_id: Integer, @@ -1353,13 +1341,13 @@ class Prism::ArrayPatternNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1131 + # pkg:gem/prism#lib/prism/node.rb:1139 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:1134 + # pkg:gem/prism#lib/prism/node.rb:1142 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -1367,7 +1355,7 @@ class Prism::ArrayPatternNode < ::Prism::Node # # @yield [constant] # - # pkg:gem/prism#lib/prism/node.rb:1101 + # pkg:gem/prism#lib/prism/node.rb:1109 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -1375,13 +1363,13 @@ class Prism::ArrayPatternNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1223 + # pkg:gem/prism#lib/prism/node.rb:1231 sig { override.returns(String) } def inspect; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:1213 + # pkg:gem/prism#lib/prism/node.rb:1221 sig { returns(T.nilable(String)) } def opening; end @@ -1390,7 +1378,7 @@ class Prism::ArrayPatternNode < ::Prism::Node # foo in [1, 2] # ^ # - # pkg:gem/prism#lib/prism/node.rb:1172 + # pkg:gem/prism#lib/prism/node.rb:1180 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end @@ -1399,7 +1387,7 @@ class Prism::ArrayPatternNode < ::Prism::Node # foo in *bar, baz # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:1166 + # pkg:gem/prism#lib/prism/node.rb:1174 sig { returns(T::Array[Prism::Node]) } def posts; end @@ -1408,7 +1396,7 @@ class Prism::ArrayPatternNode < ::Prism::Node # foo in [1, 2] # ^ ^ # - # pkg:gem/prism#lib/prism/node.rb:1154 + # pkg:gem/prism#lib/prism/node.rb:1162 sig { returns(T::Array[Prism::Node]) } def requireds; end @@ -1417,32 +1405,32 @@ class Prism::ArrayPatternNode < ::Prism::Node # foo in *bar # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1160 + # pkg:gem/prism#lib/prism/node.rb:1168 sig { returns(T.nilable(Prism::Node)) } def rest; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1208 + # pkg:gem/prism#lib/prism/node.rb:1216 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1186 + # pkg:gem/prism#lib/prism/node.rb:1194 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1228 + # pkg:gem/prism#lib/prism/node.rb:1236 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1233 + # pkg:gem/prism#lib/prism/node.rb:1241 def type; end end end @@ -1452,13 +1440,13 @@ end # { a => b } # ^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:1256 +# pkg:gem/prism#lib/prism/node.rb:1264 class Prism::AssocNode < ::Prism::Node # Initialize a new AssocNode node. # # @return [AssocNode] a new instance of AssocNode # - # pkg:gem/prism#lib/prism/node.rb:1258 + # pkg:gem/prism#lib/prism/node.rb:1266 sig do params( source: Prism::Source, @@ -1475,36 +1463,36 @@ class Prism::AssocNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1374 + # pkg:gem/prism#lib/prism/node.rb:1382 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1269 + # pkg:gem/prism#lib/prism/node.rb:1277 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1274 + # pkg:gem/prism#lib/prism/node.rb:1282 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1292 + # pkg:gem/prism#lib/prism/node.rb:1300 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1287 + # pkg:gem/prism#lib/prism/node.rb:1295 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?key: Prism::node, ?value: Prism::node, ?operator_loc: Location?) -> AssocNode # - # pkg:gem/prism#lib/prism/node.rb:1297 + # pkg:gem/prism#lib/prism/node.rb:1305 sig do params( node_id: Integer, @@ -1520,13 +1508,13 @@ class Prism::AssocNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1302 + # pkg:gem/prism#lib/prism/node.rb:1310 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, key: Prism::node, value: Prism::node, operator_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:1305 + # pkg:gem/prism#lib/prism/node.rb:1313 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -1534,7 +1522,7 @@ class Prism::AssocNode < ::Prism::Node # # @yield [key] # - # pkg:gem/prism#lib/prism/node.rb:1279 + # pkg:gem/prism#lib/prism/node.rb:1287 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -1542,7 +1530,7 @@ class Prism::AssocNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1358 + # pkg:gem/prism#lib/prism/node.rb:1366 sig { override.returns(String) } def inspect; end @@ -1557,13 +1545,13 @@ class Prism::AssocNode < ::Prism::Node # { def a; end => 1 } # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1319 + # pkg:gem/prism#lib/prism/node.rb:1327 sig { returns(Prism::Node) } def key; end # def operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:1353 + # pkg:gem/prism#lib/prism/node.rb:1361 sig { returns(T.nilable(String)) } def operator; end @@ -1572,19 +1560,19 @@ class Prism::AssocNode < ::Prism::Node # { foo => bar } # ^^ # - # pkg:gem/prism#lib/prism/node.rb:1334 + # pkg:gem/prism#lib/prism/node.rb:1342 sig { returns(T.nilable(Prism::Location)) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1348 + # pkg:gem/prism#lib/prism/node.rb:1356 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1363 + # pkg:gem/prism#lib/prism/node.rb:1371 sig { override.returns(Symbol) } def type; end @@ -1596,14 +1584,14 @@ class Prism::AssocNode < ::Prism::Node # { x: 1 } # ^ # - # pkg:gem/prism#lib/prism/node.rb:1328 + # pkg:gem/prism#lib/prism/node.rb:1336 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1368 + # pkg:gem/prism#lib/prism/node.rb:1376 def type; end end end @@ -1613,13 +1601,13 @@ end # { **foo } # ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:1386 +# pkg:gem/prism#lib/prism/node.rb:1394 class Prism::AssocSplatNode < ::Prism::Node # Initialize a new AssocSplatNode node. # # @return [AssocSplatNode] a new instance of AssocSplatNode # - # pkg:gem/prism#lib/prism/node.rb:1388 + # pkg:gem/prism#lib/prism/node.rb:1396 sig do params( source: Prism::Source, @@ -1635,36 +1623,36 @@ class Prism::AssocSplatNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1483 + # pkg:gem/prism#lib/prism/node.rb:1491 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1398 + # pkg:gem/prism#lib/prism/node.rb:1406 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1403 + # pkg:gem/prism#lib/prism/node.rb:1411 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1422 + # pkg:gem/prism#lib/prism/node.rb:1430 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1415 + # pkg:gem/prism#lib/prism/node.rb:1423 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node?, ?operator_loc: Location) -> AssocSplatNode # - # pkg:gem/prism#lib/prism/node.rb:1427 + # pkg:gem/prism#lib/prism/node.rb:1435 sig do params( node_id: Integer, @@ -1679,13 +1667,13 @@ class Prism::AssocSplatNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1432 + # pkg:gem/prism#lib/prism/node.rb:1440 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node?, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:1435 + # pkg:gem/prism#lib/prism/node.rb:1443 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -1693,7 +1681,7 @@ class Prism::AssocSplatNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:1408 + # pkg:gem/prism#lib/prism/node.rb:1416 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -1701,13 +1689,13 @@ class Prism::AssocSplatNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1467 + # pkg:gem/prism#lib/prism/node.rb:1475 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:1462 + # pkg:gem/prism#lib/prism/node.rb:1470 sig { returns(String) } def operator; end @@ -1716,19 +1704,19 @@ class Prism::AssocSplatNode < ::Prism::Node # { **x } # ^^ # - # pkg:gem/prism#lib/prism/node.rb:1449 + # pkg:gem/prism#lib/prism/node.rb:1457 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1457 + # pkg:gem/prism#lib/prism/node.rb:1465 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1472 + # pkg:gem/prism#lib/prism/node.rb:1480 sig { override.returns(Symbol) } def type; end @@ -1737,21 +1725,21 @@ class Prism::AssocSplatNode < ::Prism::Node # { **foo } # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:1443 + # pkg:gem/prism#lib/prism/node.rb:1451 sig { returns(T.nilable(Prism::Node)) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1477 + # pkg:gem/prism#lib/prism/node.rb:1485 def type; end end end # The FFI backend is used on other Ruby implementations. # -# pkg:gem/prism#lib/prism.rb:103 +# pkg:gem/prism#lib/prism.rb:90 Prism::BACKEND = T.let(T.unsafe(nil), Symbol) # Represents reading a reference to a field in the previous match. @@ -1759,49 +1747,49 @@ Prism::BACKEND = T.let(T.unsafe(nil), Symbol) # $' # ^^ # -# pkg:gem/prism#lib/prism/node.rb:1494 +# pkg:gem/prism#lib/prism/node.rb:1502 class Prism::BackReferenceReadNode < ::Prism::Node # Initialize a new BackReferenceReadNode node. # # @return [BackReferenceReadNode] a new instance of BackReferenceReadNode # - # pkg:gem/prism#lib/prism/node.rb:1496 + # pkg:gem/prism#lib/prism/node.rb:1504 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1567 + # pkg:gem/prism#lib/prism/node.rb:1575 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1505 + # pkg:gem/prism#lib/prism/node.rb:1513 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1510 + # pkg:gem/prism#lib/prism/node.rb:1518 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1526 + # pkg:gem/prism#lib/prism/node.rb:1534 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1521 + # pkg:gem/prism#lib/prism/node.rb:1529 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BackReferenceReadNode # - # pkg:gem/prism#lib/prism/node.rb:1531 + # pkg:gem/prism#lib/prism/node.rb:1539 sig do params( node_id: Integer, @@ -1815,19 +1803,19 @@ class Prism::BackReferenceReadNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1536 + # pkg:gem/prism#lib/prism/node.rb:1544 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:1539 + # pkg:gem/prism#lib/prism/node.rb:1547 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:1515 + # pkg:gem/prism#lib/prism/node.rb:1523 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -1835,7 +1823,7 @@ class Prism::BackReferenceReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1551 + # pkg:gem/prism#lib/prism/node.rb:1559 sig { override.returns(String) } def inspect; end @@ -1845,20 +1833,20 @@ class Prism::BackReferenceReadNode < ::Prism::Node # # $+ # name `:$+` # - # pkg:gem/prism#lib/prism/node.rb:1548 + # pkg:gem/prism#lib/prism/node.rb:1556 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1556 + # pkg:gem/prism#lib/prism/node.rb:1564 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1561 + # pkg:gem/prism#lib/prism/node.rb:1569 def type; end end end @@ -1897,13 +1885,13 @@ end # end # ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:1579 +# pkg:gem/prism#lib/prism/node.rb:1587 class Prism::BeginNode < ::Prism::Node # Initialize a new BeginNode node. # # @return [BeginNode] a new instance of BeginNode # - # pkg:gem/prism#lib/prism/node.rb:1581 + # pkg:gem/prism#lib/prism/node.rb:1589 sig do params( source: Prism::Source, @@ -1923,18 +1911,18 @@ class Prism::BeginNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1737 + # pkg:gem/prism#lib/prism/node.rb:1745 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1595 + # pkg:gem/prism#lib/prism/node.rb:1603 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def begin_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:1711 + # pkg:gem/prism#lib/prism/node.rb:1719 sig { returns(T.nilable(String)) } def begin_keyword; end @@ -1943,31 +1931,31 @@ class Prism::BeginNode < ::Prism::Node # begin x end # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1646 + # pkg:gem/prism#lib/prism/node.rb:1654 sig { returns(T.nilable(Prism::Location)) } def begin_keyword_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1600 + # pkg:gem/prism#lib/prism/node.rb:1608 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1625 + # pkg:gem/prism#lib/prism/node.rb:1633 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1615 + # pkg:gem/prism#lib/prism/node.rb:1623 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?begin_keyword_loc: Location?, ?statements: StatementsNode?, ?rescue_clause: RescueNode?, ?else_clause: ElseNode?, ?ensure_clause: EnsureNode?, ?end_keyword_loc: Location?) -> BeginNode # - # pkg:gem/prism#lib/prism/node.rb:1630 + # pkg:gem/prism#lib/prism/node.rb:1638 sig do params( node_id: Integer, @@ -1986,13 +1974,13 @@ class Prism::BeginNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1635 + # pkg:gem/prism#lib/prism/node.rb:1643 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:1638 + # pkg:gem/prism#lib/prism/node.rb:1646 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -2000,7 +1988,7 @@ class Prism::BeginNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:1605 + # pkg:gem/prism#lib/prism/node.rb:1613 def each_child_node; end # Represents the else clause within the begin block. @@ -2008,13 +1996,13 @@ class Prism::BeginNode < ::Prism::Node # begin x; rescue y; else z; end # ^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1680 + # pkg:gem/prism#lib/prism/node.rb:1688 sig { returns(T.nilable(Prism::ElseNode)) } def else_clause; end # def end_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:1716 + # pkg:gem/prism#lib/prism/node.rb:1724 sig { returns(T.nilable(String)) } def end_keyword; end @@ -2023,7 +2011,7 @@ class Prism::BeginNode < ::Prism::Node # begin x end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:1692 + # pkg:gem/prism#lib/prism/node.rb:1700 sig { returns(T.nilable(Prism::Location)) } def end_keyword_loc; end @@ -2032,7 +2020,7 @@ class Prism::BeginNode < ::Prism::Node # begin x; ensure y; end # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1686 + # pkg:gem/prism#lib/prism/node.rb:1694 sig { returns(T.nilable(Prism::EnsureNode)) } def ensure_clause; end @@ -2041,7 +2029,7 @@ class Prism::BeginNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1721 + # pkg:gem/prism#lib/prism/node.rb:1729 sig { override.returns(String) } def inspect; end @@ -2053,20 +2041,20 @@ class Prism::BeginNode < ::Prism::Node # begin x; rescue y; end # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1674 + # pkg:gem/prism#lib/prism/node.rb:1682 sig { returns(T.nilable(Prism::RescueNode)) } def rescue_clause; end # Save the begin_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1660 + # pkg:gem/prism#lib/prism/node.rb:1668 def save_begin_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1706 + # pkg:gem/prism#lib/prism/node.rb:1714 def save_end_keyword_loc(repository); end # Represents the statements within the begin block. @@ -2074,20 +2062,20 @@ class Prism::BeginNode < ::Prism::Node # begin x end # ^ # - # pkg:gem/prism#lib/prism/node.rb:1668 + # pkg:gem/prism#lib/prism/node.rb:1676 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1726 + # pkg:gem/prism#lib/prism/node.rb:1734 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1731 + # pkg:gem/prism#lib/prism/node.rb:1739 def type; end end end @@ -2097,13 +2085,13 @@ end # bar(&args) # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:1752 +# pkg:gem/prism#lib/prism/node.rb:1760 class Prism::BlockArgumentNode < ::Prism::Node # Initialize a new BlockArgumentNode node. # # @return [BlockArgumentNode] a new instance of BlockArgumentNode # - # pkg:gem/prism#lib/prism/node.rb:1754 + # pkg:gem/prism#lib/prism/node.rb:1762 sig do params( source: Prism::Source, @@ -2119,36 +2107,36 @@ class Prism::BlockArgumentNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1849 + # pkg:gem/prism#lib/prism/node.rb:1857 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1764 + # pkg:gem/prism#lib/prism/node.rb:1772 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1769 + # pkg:gem/prism#lib/prism/node.rb:1777 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1788 + # pkg:gem/prism#lib/prism/node.rb:1796 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1781 + # pkg:gem/prism#lib/prism/node.rb:1789 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node?, ?operator_loc: Location) -> BlockArgumentNode # - # pkg:gem/prism#lib/prism/node.rb:1793 + # pkg:gem/prism#lib/prism/node.rb:1801 sig do params( node_id: Integer, @@ -2163,13 +2151,13 @@ class Prism::BlockArgumentNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1798 + # pkg:gem/prism#lib/prism/node.rb:1806 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node?, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:1801 + # pkg:gem/prism#lib/prism/node.rb:1809 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -2177,7 +2165,7 @@ class Prism::BlockArgumentNode < ::Prism::Node # # @yield [expression] # - # pkg:gem/prism#lib/prism/node.rb:1774 + # pkg:gem/prism#lib/prism/node.rb:1782 def each_child_node; end # The expression that is being passed as a block argument. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). @@ -2185,7 +2173,7 @@ class Prism::BlockArgumentNode < ::Prism::Node # foo(&args) # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:1809 + # pkg:gem/prism#lib/prism/node.rb:1817 sig { returns(T.nilable(Prism::Node)) } def expression; end @@ -2194,13 +2182,13 @@ class Prism::BlockArgumentNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1833 + # pkg:gem/prism#lib/prism/node.rb:1841 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:1828 + # pkg:gem/prism#lib/prism/node.rb:1836 sig { returns(String) } def operator; end @@ -2209,26 +2197,26 @@ class Prism::BlockArgumentNode < ::Prism::Node # foo(&args) # ^ # - # pkg:gem/prism#lib/prism/node.rb:1815 + # pkg:gem/prism#lib/prism/node.rb:1823 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:1823 + # pkg:gem/prism#lib/prism/node.rb:1831 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1838 + # pkg:gem/prism#lib/prism/node.rb:1846 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1843 + # pkg:gem/prism#lib/prism/node.rb:1851 def type; end end end @@ -2238,49 +2226,49 @@ end # a { |; b| } # ^ # -# pkg:gem/prism#lib/prism/node.rb:1860 +# pkg:gem/prism#lib/prism/node.rb:1868 class Prism::BlockLocalVariableNode < ::Prism::Node # Initialize a new BlockLocalVariableNode node. # # @return [BlockLocalVariableNode] a new instance of BlockLocalVariableNode # - # pkg:gem/prism#lib/prism/node.rb:1862 + # pkg:gem/prism#lib/prism/node.rb:1870 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:1937 + # pkg:gem/prism#lib/prism/node.rb:1945 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1871 + # pkg:gem/prism#lib/prism/node.rb:1879 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1876 + # pkg:gem/prism#lib/prism/node.rb:1884 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1892 + # pkg:gem/prism#lib/prism/node.rb:1900 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1887 + # pkg:gem/prism#lib/prism/node.rb:1895 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> BlockLocalVariableNode # - # pkg:gem/prism#lib/prism/node.rb:1897 + # pkg:gem/prism#lib/prism/node.rb:1905 sig do params( node_id: Integer, @@ -2294,19 +2282,19 @@ class Prism::BlockLocalVariableNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1902 + # pkg:gem/prism#lib/prism/node.rb:1910 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:1905 + # pkg:gem/prism#lib/prism/node.rb:1913 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:1881 + # pkg:gem/prism#lib/prism/node.rb:1889 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -2314,7 +2302,7 @@ class Prism::BlockLocalVariableNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:1921 + # pkg:gem/prism#lib/prism/node.rb:1929 sig { override.returns(String) } def inspect; end @@ -2323,7 +2311,7 @@ class Prism::BlockLocalVariableNode < ::Prism::Node # a { |; b| } # name `:b` # ^ # - # pkg:gem/prism#lib/prism/node.rb:1918 + # pkg:gem/prism#lib/prism/node.rb:1926 sig { returns(Symbol) } def name; end @@ -2331,20 +2319,20 @@ class Prism::BlockLocalVariableNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:1910 + # pkg:gem/prism#lib/prism/node.rb:1918 sig { returns(T::Boolean) } def repeated_parameter?; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:1926 + # pkg:gem/prism#lib/prism/node.rb:1934 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:1931 + # pkg:gem/prism#lib/prism/node.rb:1939 def type; end end end @@ -2354,13 +2342,13 @@ end # [1, 2, 3].each { |i| puts x } # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:1948 +# pkg:gem/prism#lib/prism/node.rb:1956 class Prism::BlockNode < ::Prism::Node # Initialize a new BlockNode node. # # @return [BlockNode] a new instance of BlockNode # - # pkg:gem/prism#lib/prism/node.rb:1950 + # pkg:gem/prism#lib/prism/node.rb:1958 sig do params( source: Prism::Source, @@ -2379,12 +2367,12 @@ class Prism::BlockNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:2087 + # pkg:gem/prism#lib/prism/node.rb:2095 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:1963 + # pkg:gem/prism#lib/prism/node.rb:1971 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -2393,46 +2381,46 @@ class Prism::BlockNode < ::Prism::Node # [1, 2, 3].each { |i| puts x } # ^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:2026 + # pkg:gem/prism#lib/prism/node.rb:2034 sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1968 + # pkg:gem/prism#lib/prism/node.rb:1976 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:2066 + # pkg:gem/prism#lib/prism/node.rb:2074 sig { returns(String) } def closing; end - # Represents the location of the closing `|`. + # Represents the location of the closing `}` or `end`. # # [1, 2, 3].each { |i| puts x } - # ^ + # ^ # - # pkg:gem/prism#lib/prism/node.rb:2048 + # pkg:gem/prism#lib/prism/node.rb:2056 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:1989 + # pkg:gem/prism#lib/prism/node.rb:1997 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:1981 + # pkg:gem/prism#lib/prism/node.rb:1989 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil, ?opening_loc: Location, ?closing_loc: Location) -> BlockNode # - # pkg:gem/prism#lib/prism/node.rb:1994 + # pkg:gem/prism#lib/prism/node.rb:2002 sig do params( node_id: Integer, @@ -2450,13 +2438,13 @@ class Prism::BlockNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:1999 + # pkg:gem/prism#lib/prism/node.rb:2007 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil, opening_loc: Location, closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:2002 + # pkg:gem/prism#lib/prism/node.rb:2010 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -2464,7 +2452,7 @@ class Prism::BlockNode < ::Prism::Node # # @yield [parameters] # - # pkg:gem/prism#lib/prism/node.rb:1973 + # pkg:gem/prism#lib/prism/node.rb:1981 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -2472,7 +2460,7 @@ class Prism::BlockNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:2071 + # pkg:gem/prism#lib/prism/node.rb:2079 sig { override.returns(String) } def inspect; end @@ -2481,22 +2469,22 @@ class Prism::BlockNode < ::Prism::Node # [1, 2, 3].each { |i| puts x } # locals: [:i] # ^ # - # pkg:gem/prism#lib/prism/node.rb:2010 + # pkg:gem/prism#lib/prism/node.rb:2018 sig { returns(T::Array[Symbol]) } def locals; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:2061 + # pkg:gem/prism#lib/prism/node.rb:2069 sig { returns(String) } def opening; end - # Represents the location of the opening `|`. + # Represents the location of the opening `{` or `do`. # # [1, 2, 3].each { |i| puts x } - # ^ + # ^ # - # pkg:gem/prism#lib/prism/node.rb:2032 + # pkg:gem/prism#lib/prism/node.rb:2040 sig { returns(Prism::Location) } def opening_loc; end @@ -2509,32 +2497,32 @@ class Prism::BlockNode < ::Prism::Node # [1, 2, 3].each { puts it } # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:2020 + # pkg:gem/prism#lib/prism/node.rb:2028 sig { returns(T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode))) } def parameters; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2056 + # pkg:gem/prism#lib/prism/node.rb:2064 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2040 + # pkg:gem/prism#lib/prism/node.rb:2048 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:2076 + # pkg:gem/prism#lib/prism/node.rb:2084 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:2081 + # pkg:gem/prism#lib/prism/node.rb:2089 def type; end end end @@ -2545,13 +2533,13 @@ end # ^^ # end # -# pkg:gem/prism#lib/prism/node.rb:2103 +# pkg:gem/prism#lib/prism/node.rb:2111 class Prism::BlockParameterNode < ::Prism::Node # Initialize a new BlockParameterNode node. # # @return [BlockParameterNode] a new instance of BlockParameterNode # - # pkg:gem/prism#lib/prism/node.rb:2105 + # pkg:gem/prism#lib/prism/node.rb:2113 sig do params( source: Prism::Source, @@ -2568,36 +2556,36 @@ class Prism::BlockParameterNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:2227 + # pkg:gem/prism#lib/prism/node.rb:2235 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:2116 + # pkg:gem/prism#lib/prism/node.rb:2124 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2121 + # pkg:gem/prism#lib/prism/node.rb:2129 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:2137 + # pkg:gem/prism#lib/prism/node.rb:2145 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:2132 + # pkg:gem/prism#lib/prism/node.rb:2140 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> BlockParameterNode # - # pkg:gem/prism#lib/prism/node.rb:2142 + # pkg:gem/prism#lib/prism/node.rb:2150 sig do params( node_id: Integer, @@ -2613,19 +2601,19 @@ class Prism::BlockParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2147 + # pkg:gem/prism#lib/prism/node.rb:2155 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:2150 + # pkg:gem/prism#lib/prism/node.rb:2158 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:2126 + # pkg:gem/prism#lib/prism/node.rb:2134 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -2633,7 +2621,7 @@ class Prism::BlockParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:2211 + # pkg:gem/prism#lib/prism/node.rb:2219 sig { override.returns(String) } def inspect; end @@ -2643,7 +2631,7 @@ class Prism::BlockParameterNode < ::Prism::Node # ^ # end # - # pkg:gem/prism#lib/prism/node.rb:2164 + # pkg:gem/prism#lib/prism/node.rb:2172 sig { returns(T.nilable(Symbol)) } def name; end @@ -2652,13 +2640,13 @@ class Prism::BlockParameterNode < ::Prism::Node # def a(&b) # ^ # - # pkg:gem/prism#lib/prism/node.rb:2170 + # pkg:gem/prism#lib/prism/node.rb:2178 sig { returns(T.nilable(Prism::Location)) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:2206 + # pkg:gem/prism#lib/prism/node.rb:2214 sig { returns(String) } def operator; end @@ -2668,7 +2656,7 @@ class Prism::BlockParameterNode < ::Prism::Node # ^ # end # - # pkg:gem/prism#lib/prism/node.rb:2193 + # pkg:gem/prism#lib/prism/node.rb:2201 sig { returns(Prism::Location) } def operator_loc; end @@ -2676,32 +2664,32 @@ class Prism::BlockParameterNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2155 + # pkg:gem/prism#lib/prism/node.rb:2163 sig { returns(T::Boolean) } def repeated_parameter?; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2184 + # pkg:gem/prism#lib/prism/node.rb:2192 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2201 + # pkg:gem/prism#lib/prism/node.rb:2209 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:2216 + # pkg:gem/prism#lib/prism/node.rb:2224 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:2221 + # pkg:gem/prism#lib/prism/node.rb:2229 def type; end end end @@ -2715,13 +2703,13 @@ end # ^^^^^^^^^^^^^^^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:2244 +# pkg:gem/prism#lib/prism/node.rb:2252 class Prism::BlockParametersNode < ::Prism::Node # Initialize a new BlockParametersNode node. # # @return [BlockParametersNode] a new instance of BlockParametersNode # - # pkg:gem/prism#lib/prism/node.rb:2246 + # pkg:gem/prism#lib/prism/node.rb:2254 sig do params( source: Prism::Source, @@ -2739,24 +2727,24 @@ class Prism::BlockParametersNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:2400 + # pkg:gem/prism#lib/prism/node.rb:2408 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:2258 + # pkg:gem/prism#lib/prism/node.rb:2266 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2263 + # pkg:gem/prism#lib/prism/node.rb:2271 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2379 + # pkg:gem/prism#lib/prism/node.rb:2387 sig { returns(T.nilable(String)) } def closing; end @@ -2769,25 +2757,25 @@ class Prism::BlockParametersNode < ::Prism::Node # ^ # end # - # pkg:gem/prism#lib/prism/node.rb:2355 + # pkg:gem/prism#lib/prism/node.rb:2363 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:2284 + # pkg:gem/prism#lib/prism/node.rb:2292 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:2276 + # pkg:gem/prism#lib/prism/node.rb:2284 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parameters: ParametersNode?, ?locals: Array[BlockLocalVariableNode], ?opening_loc: Location?, ?closing_loc: Location?) -> BlockParametersNode # - # pkg:gem/prism#lib/prism/node.rb:2289 + # pkg:gem/prism#lib/prism/node.rb:2297 sig do params( node_id: Integer, @@ -2804,13 +2792,13 @@ class Prism::BlockParametersNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2294 + # pkg:gem/prism#lib/prism/node.rb:2302 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parameters: ParametersNode?, locals: Array[BlockLocalVariableNode], opening_loc: Location?, closing_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:2297 + # pkg:gem/prism#lib/prism/node.rb:2305 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -2818,7 +2806,7 @@ class Prism::BlockParametersNode < ::Prism::Node # # @yield [parameters] # - # pkg:gem/prism#lib/prism/node.rb:2268 + # pkg:gem/prism#lib/prism/node.rb:2276 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -2826,7 +2814,7 @@ class Prism::BlockParametersNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:2384 + # pkg:gem/prism#lib/prism/node.rb:2392 sig { override.returns(String) } def inspect; end @@ -2839,13 +2827,13 @@ class Prism::BlockParametersNode < ::Prism::Node # ^^^^^ # end # - # pkg:gem/prism#lib/prism/node.rb:2319 + # pkg:gem/prism#lib/prism/node.rb:2327 sig { returns(T::Array[Prism::BlockLocalVariableNode]) } def locals; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2374 + # pkg:gem/prism#lib/prism/node.rb:2382 sig { returns(T.nilable(String)) } def opening; end @@ -2858,7 +2846,7 @@ class Prism::BlockParametersNode < ::Prism::Node # ^ # end # - # pkg:gem/prism#lib/prism/node.rb:2329 + # pkg:gem/prism#lib/prism/node.rb:2337 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end @@ -2871,32 +2859,32 @@ class Prism::BlockParametersNode < ::Prism::Node # ^^^^^^^^ # end # - # pkg:gem/prism#lib/prism/node.rb:2309 + # pkg:gem/prism#lib/prism/node.rb:2317 sig { returns(T.nilable(Prism::ParametersNode)) } def parameters; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2369 + # pkg:gem/prism#lib/prism/node.rb:2377 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2343 + # pkg:gem/prism#lib/prism/node.rb:2351 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:2389 + # pkg:gem/prism#lib/prism/node.rb:2397 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:2394 + # pkg:gem/prism#lib/prism/node.rb:2402 def type; end end end @@ -2906,13 +2894,13 @@ end # break foo # ^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:2414 +# pkg:gem/prism#lib/prism/node.rb:2422 class Prism::BreakNode < ::Prism::Node # Initialize a new BreakNode node. # # @return [BreakNode] a new instance of BreakNode # - # pkg:gem/prism#lib/prism/node.rb:2416 + # pkg:gem/prism#lib/prism/node.rb:2424 sig do params( source: Prism::Source, @@ -2928,12 +2916,12 @@ class Prism::BreakNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:2511 + # pkg:gem/prism#lib/prism/node.rb:2519 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:2426 + # pkg:gem/prism#lib/prism/node.rb:2434 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -2942,31 +2930,31 @@ class Prism::BreakNode < ::Prism::Node # break foo # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2471 + # pkg:gem/prism#lib/prism/node.rb:2479 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2431 + # pkg:gem/prism#lib/prism/node.rb:2439 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:2450 + # pkg:gem/prism#lib/prism/node.rb:2458 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:2443 + # pkg:gem/prism#lib/prism/node.rb:2451 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> BreakNode # - # pkg:gem/prism#lib/prism/node.rb:2455 + # pkg:gem/prism#lib/prism/node.rb:2463 sig do params( node_id: Integer, @@ -2981,13 +2969,13 @@ class Prism::BreakNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2460 + # pkg:gem/prism#lib/prism/node.rb:2468 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:2463 + # pkg:gem/prism#lib/prism/node.rb:2471 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -2995,7 +2983,7 @@ class Prism::BreakNode < ::Prism::Node # # @yield [arguments] # - # pkg:gem/prism#lib/prism/node.rb:2436 + # pkg:gem/prism#lib/prism/node.rb:2444 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -3003,13 +2991,13 @@ class Prism::BreakNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:2495 + # pkg:gem/prism#lib/prism/node.rb:2503 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:2490 + # pkg:gem/prism#lib/prism/node.rb:2498 sig { returns(String) } def keyword; end @@ -3018,26 +3006,26 @@ class Prism::BreakNode < ::Prism::Node # break foo # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:2477 + # pkg:gem/prism#lib/prism/node.rb:2485 sig { returns(Prism::Location) } def keyword_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2485 + # pkg:gem/prism#lib/prism/node.rb:2493 def save_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:2500 + # pkg:gem/prism#lib/prism/node.rb:2508 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:2505 + # pkg:gem/prism#lib/prism/node.rb:2513 def type; end end end @@ -3047,13 +3035,13 @@ end # foo.bar &&= value # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:2522 +# pkg:gem/prism#lib/prism/node.rb:2530 class Prism::CallAndWriteNode < ::Prism::Node # Initialize a new CallAndWriteNode node. # # @return [CallAndWriteNode] a new instance of CallAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:2524 + # pkg:gem/prism#lib/prism/node.rb:2532 sig do params( source: Prism::Source, @@ -3074,12 +3062,12 @@ class Prism::CallAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:2718 + # pkg:gem/prism#lib/prism/node.rb:2726 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:2539 + # pkg:gem/prism#lib/prism/node.rb:2547 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -3087,13 +3075,13 @@ class Prism::CallAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2593 + # pkg:gem/prism#lib/prism/node.rb:2601 sig { returns(T::Boolean) } def attribute_write?; end # def call_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2687 + # pkg:gem/prism#lib/prism/node.rb:2695 sig { returns(T.nilable(String)) } def call_operator; end @@ -3102,31 +3090,31 @@ class Prism::CallAndWriteNode < ::Prism::Node # foo.bar &&= value # ^ # - # pkg:gem/prism#lib/prism/node.rb:2612 + # pkg:gem/prism#lib/prism/node.rb:2620 sig { returns(T.nilable(Prism::Location)) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2544 + # pkg:gem/prism#lib/prism/node.rb:2552 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:2565 + # pkg:gem/prism#lib/prism/node.rb:2573 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:2557 + # pkg:gem/prism#lib/prism/node.rb:2565 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:2570 + # pkg:gem/prism#lib/prism/node.rb:2578 sig do params( node_id: Integer, @@ -3146,13 +3134,13 @@ class Prism::CallAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2575 + # pkg:gem/prism#lib/prism/node.rb:2583 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:2578 + # pkg:gem/prism#lib/prism/node.rb:2586 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -3160,7 +3148,7 @@ class Prism::CallAndWriteNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:2549 + # pkg:gem/prism#lib/prism/node.rb:2557 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -3170,19 +3158,19 @@ class Prism::CallAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2598 + # pkg:gem/prism#lib/prism/node.rb:2606 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:2702 + # pkg:gem/prism#lib/prism/node.rb:2710 sig { override.returns(String) } def inspect; end # def message: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2692 + # pkg:gem/prism#lib/prism/node.rb:2700 sig { returns(T.nilable(String)) } def message; end @@ -3191,13 +3179,13 @@ class Prism::CallAndWriteNode < ::Prism::Node # foo.bar &&= value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2634 + # pkg:gem/prism#lib/prism/node.rb:2642 sig { returns(T.nilable(Prism::Location)) } def message_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:2697 + # pkg:gem/prism#lib/prism/node.rb:2705 sig { returns(String) } def operator; end @@ -3206,7 +3194,7 @@ class Prism::CallAndWriteNode < ::Prism::Node # foo.bar &&= value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2668 + # pkg:gem/prism#lib/prism/node.rb:2676 sig { returns(Prism::Location) } def operator_loc; end @@ -3215,7 +3203,7 @@ class Prism::CallAndWriteNode < ::Prism::Node # foo.bar &&= value # read_name `:bar` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2656 + # pkg:gem/prism#lib/prism/node.rb:2664 sig { returns(Symbol) } def read_name; end @@ -3224,7 +3212,7 @@ class Prism::CallAndWriteNode < ::Prism::Node # foo.bar &&= value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2606 + # pkg:gem/prism#lib/prism/node.rb:2614 sig { returns(T.nilable(Prism::Node)) } def receiver; end @@ -3232,31 +3220,31 @@ class Prism::CallAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2583 + # pkg:gem/prism#lib/prism/node.rb:2591 sig { returns(T::Boolean) } def safe_navigation?; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2626 + # pkg:gem/prism#lib/prism/node.rb:2634 def save_call_operator_loc(repository); end # Save the message_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2648 + # pkg:gem/prism#lib/prism/node.rb:2656 def save_message_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2676 + # pkg:gem/prism#lib/prism/node.rb:2684 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:2707 + # pkg:gem/prism#lib/prism/node.rb:2715 sig { override.returns(Symbol) } def type; end @@ -3265,7 +3253,7 @@ class Prism::CallAndWriteNode < ::Prism::Node # foo.bar &&= value # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:2684 + # pkg:gem/prism#lib/prism/node.rb:2692 sig { returns(Prism::Node) } def value; end @@ -3273,7 +3261,7 @@ class Prism::CallAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2588 + # pkg:gem/prism#lib/prism/node.rb:2596 sig { returns(T::Boolean) } def variable_call?; end @@ -3282,14 +3270,14 @@ class Prism::CallAndWriteNode < ::Prism::Node # foo.bar &&= value # write_name `:bar=` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2662 + # pkg:gem/prism#lib/prism/node.rb:2670 sig { returns(Symbol) } def write_name; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:2712 + # pkg:gem/prism#lib/prism/node.rb:2720 def type; end end end @@ -3314,13 +3302,13 @@ end # foo&.bar # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:2750 +# pkg:gem/prism#lib/prism/node.rb:2758 class Prism::CallNode < ::Prism::Node # Initialize a new CallNode node. # # @return [CallNode] a new instance of CallNode # - # pkg:gem/prism#lib/prism/node.rb:2752 + # pkg:gem/prism#lib/prism/node.rb:2760 sig do params( source: Prism::Source, @@ -3343,12 +3331,12 @@ class Prism::CallNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:3021 + # pkg:gem/prism#lib/prism/node.rb:3029 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:2769 + # pkg:gem/prism#lib/prism/node.rb:2777 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -3357,7 +3345,7 @@ class Prism::CallNode < ::Prism::Node # foo(bar) # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2924 + # pkg:gem/prism#lib/prism/node.rb:2932 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end @@ -3365,7 +3353,7 @@ class Prism::CallNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2825 + # pkg:gem/prism#lib/prism/node.rb:2833 sig { returns(T::Boolean) } def attribute_write?; end @@ -3374,13 +3362,13 @@ class Prism::CallNode < ::Prism::Node # foo { |a| a } # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:2977 + # pkg:gem/prism#lib/prism/node.rb:2985 sig { returns(T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))) } def block; end # def call_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2980 + # pkg:gem/prism#lib/prism/node.rb:2988 sig { returns(T.nilable(String)) } def call_operator; end @@ -3392,19 +3380,19 @@ class Prism::CallNode < ::Prism::Node # foo&.bar # ^^ # - # pkg:gem/prism#lib/prism/node.rb:2853 + # pkg:gem/prism#lib/prism/node.rb:2861 sig { returns(T.nilable(Prism::Location)) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2774 + # pkg:gem/prism#lib/prism/node.rb:2782 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2995 + # pkg:gem/prism#lib/prism/node.rb:3003 sig { returns(T.nilable(String)) } def closing; end @@ -3413,25 +3401,25 @@ class Prism::CallNode < ::Prism::Node # foo(bar) # ^ # - # pkg:gem/prism#lib/prism/node.rb:2930 + # pkg:gem/prism#lib/prism/node.rb:2938 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:2797 + # pkg:gem/prism#lib/prism/node.rb:2805 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:2788 + # pkg:gem/prism#lib/prism/node.rb:2796 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?equal_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode # - # pkg:gem/prism#lib/prism/node.rb:2802 + # pkg:gem/prism#lib/prism/node.rb:2810 sig do params( node_id: Integer, @@ -3453,13 +3441,13 @@ class Prism::CallNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:2807 + # pkg:gem/prism#lib/prism/node.rb:2815 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, equal_loc: Location?, block: BlockNode | BlockArgumentNode | nil } # - # pkg:gem/prism#lib/prism/node.rb:2810 + # pkg:gem/prism#lib/prism/node.rb:2818 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -3467,12 +3455,12 @@ class Prism::CallNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:2779 + # pkg:gem/prism#lib/prism/node.rb:2787 def each_child_node; end # def equal: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:3000 + # pkg:gem/prism#lib/prism/node.rb:3008 sig { returns(T.nilable(String)) } def equal; end @@ -3484,7 +3472,7 @@ class Prism::CallNode < ::Prism::Node # foo[bar] = value # ^ # - # pkg:gem/prism#lib/prism/node.rb:2955 + # pkg:gem/prism#lib/prism/node.rb:2963 sig { returns(T.nilable(Prism::Location)) } def equal_loc; end @@ -3509,19 +3497,19 @@ class Prism::CallNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2830 + # pkg:gem/prism#lib/prism/node.rb:2838 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:3005 + # pkg:gem/prism#lib/prism/node.rb:3013 sig { override.returns(String) } def inspect; end # def message: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2985 + # pkg:gem/prism#lib/prism/node.rb:2993 sig { returns(T.nilable(String)) } def message; end @@ -3530,7 +3518,7 @@ class Prism::CallNode < ::Prism::Node # foo.bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2881 + # pkg:gem/prism#lib/prism/node.rb:2889 sig { returns(T.nilable(Prism::Location)) } def message_loc; end @@ -3539,13 +3527,13 @@ class Prism::CallNode < ::Prism::Node # foo.bar # name `:foo` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2875 + # pkg:gem/prism#lib/prism/node.rb:2883 sig { returns(Symbol) } def name; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:2990 + # pkg:gem/prism#lib/prism/node.rb:2998 sig { returns(T.nilable(String)) } def opening; end @@ -3553,7 +3541,7 @@ class Prism::CallNode < ::Prism::Node # foo(bar) # ^ # - # pkg:gem/prism#lib/prism/node.rb:2902 + # pkg:gem/prism#lib/prism/node.rb:2910 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end @@ -3568,7 +3556,7 @@ class Prism::CallNode < ::Prism::Node # foo + bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:2844 + # pkg:gem/prism#lib/prism/node.rb:2852 sig { returns(T.nilable(Prism::Node)) } def receiver; end @@ -3576,43 +3564,43 @@ class Prism::CallNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2815 + # pkg:gem/prism#lib/prism/node.rb:2823 sig { returns(T::Boolean) } def safe_navigation?; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2867 + # pkg:gem/prism#lib/prism/node.rb:2875 def save_call_operator_loc(repository); end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2944 + # pkg:gem/prism#lib/prism/node.rb:2952 def save_closing_loc(repository); end # Save the equal_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2969 + # pkg:gem/prism#lib/prism/node.rb:2977 def save_equal_loc(repository); end # Save the message_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2895 + # pkg:gem/prism#lib/prism/node.rb:2903 def save_message_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:2916 + # pkg:gem/prism#lib/prism/node.rb:2924 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:3010 + # pkg:gem/prism#lib/prism/node.rb:3018 sig { override.returns(Symbol) } def type; end @@ -3620,41 +3608,41 @@ class Prism::CallNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:2820 + # pkg:gem/prism#lib/prism/node.rb:2828 sig { returns(T::Boolean) } def variable_call?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:3015 + # pkg:gem/prism#lib/prism/node.rb:3023 def type; end end end # Flags for call nodes. # -# pkg:gem/prism#lib/prism/node.rb:19796 +# pkg:gem/prism#lib/prism/node.rb:19804 module Prism::CallNodeFlags; end # a call that is an attribute write, so the value being written should be returned # -# pkg:gem/prism#lib/prism/node.rb:19804 +# pkg:gem/prism#lib/prism/node.rb:19812 Prism::CallNodeFlags::ATTRIBUTE_WRITE = T.let(T.unsafe(nil), Integer) # a call that ignores method visibility # -# pkg:gem/prism#lib/prism/node.rb:19807 +# pkg:gem/prism#lib/prism/node.rb:19815 Prism::CallNodeFlags::IGNORE_VISIBILITY = T.let(T.unsafe(nil), Integer) # &. operator # -# pkg:gem/prism#lib/prism/node.rb:19798 +# pkg:gem/prism#lib/prism/node.rb:19806 Prism::CallNodeFlags::SAFE_NAVIGATION = T.let(T.unsafe(nil), Integer) # a call that could have been a local variable # -# pkg:gem/prism#lib/prism/node.rb:19801 +# pkg:gem/prism#lib/prism/node.rb:19809 Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer) # Represents the use of an assignment operator on a call. @@ -3662,13 +3650,13 @@ Prism::CallNodeFlags::VARIABLE_CALL = T.let(T.unsafe(nil), Integer) # foo.bar += baz # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:3040 +# pkg:gem/prism#lib/prism/node.rb:3048 class Prism::CallOperatorWriteNode < ::Prism::Node # Initialize a new CallOperatorWriteNode node. # # @return [CallOperatorWriteNode] a new instance of CallOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:3042 + # pkg:gem/prism#lib/prism/node.rb:3050 sig do params( source: Prism::Source, @@ -3690,12 +3678,12 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:3238 + # pkg:gem/prism#lib/prism/node.rb:3246 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:3058 + # pkg:gem/prism#lib/prism/node.rb:3066 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -3703,7 +3691,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3112 + # pkg:gem/prism#lib/prism/node.rb:3120 sig { returns(T::Boolean) } def attribute_write?; end @@ -3712,7 +3700,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # binary_operator `:+` # ^ # - # pkg:gem/prism#lib/prism/node.rb:3187 + # pkg:gem/prism#lib/prism/node.rb:3195 sig { returns(Symbol) } def binary_operator; end @@ -3721,13 +3709,13 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # ^^ # - # pkg:gem/prism#lib/prism/node.rb:3193 + # pkg:gem/prism#lib/prism/node.rb:3201 sig { returns(Prism::Location) } def binary_operator_loc; end # def call_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:3212 + # pkg:gem/prism#lib/prism/node.rb:3220 sig { returns(T.nilable(String)) } def call_operator; end @@ -3736,31 +3724,31 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # ^ # - # pkg:gem/prism#lib/prism/node.rb:3131 + # pkg:gem/prism#lib/prism/node.rb:3139 sig { returns(T.nilable(Prism::Location)) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3063 + # pkg:gem/prism#lib/prism/node.rb:3071 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:3084 + # pkg:gem/prism#lib/prism/node.rb:3092 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:3076 + # pkg:gem/prism#lib/prism/node.rb:3084 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> CallOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:3089 + # pkg:gem/prism#lib/prism/node.rb:3097 sig do params( node_id: Integer, @@ -3781,13 +3769,13 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3094 + # pkg:gem/prism#lib/prism/node.rb:3102 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:3097 + # pkg:gem/prism#lib/prism/node.rb:3105 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -3795,7 +3783,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:3068 + # pkg:gem/prism#lib/prism/node.rb:3076 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -3805,19 +3793,19 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3117 + # pkg:gem/prism#lib/prism/node.rb:3125 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:3222 + # pkg:gem/prism#lib/prism/node.rb:3230 sig { override.returns(String) } def inspect; end # def message: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:3217 + # pkg:gem/prism#lib/prism/node.rb:3225 sig { returns(T.nilable(String)) } def message; end @@ -3826,7 +3814,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3153 + # pkg:gem/prism#lib/prism/node.rb:3161 sig { returns(T.nilable(Prism::Location)) } def message_loc; end @@ -3847,7 +3835,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # read_name `:bar` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3175 + # pkg:gem/prism#lib/prism/node.rb:3183 sig { returns(Symbol) } def read_name; end @@ -3856,7 +3844,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3125 + # pkg:gem/prism#lib/prism/node.rb:3133 sig { returns(T.nilable(Prism::Node)) } def receiver; end @@ -3864,31 +3852,31 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3102 + # pkg:gem/prism#lib/prism/node.rb:3110 sig { returns(T::Boolean) } def safe_navigation?; end # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3201 + # pkg:gem/prism#lib/prism/node.rb:3209 def save_binary_operator_loc(repository); end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3145 + # pkg:gem/prism#lib/prism/node.rb:3153 def save_call_operator_loc(repository); end # Save the message_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3167 + # pkg:gem/prism#lib/prism/node.rb:3175 def save_message_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:3227 + # pkg:gem/prism#lib/prism/node.rb:3235 sig { override.returns(Symbol) } def type; end @@ -3897,7 +3885,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3209 + # pkg:gem/prism#lib/prism/node.rb:3217 sig { returns(Prism::Node) } def value; end @@ -3905,7 +3893,7 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3107 + # pkg:gem/prism#lib/prism/node.rb:3115 sig { returns(T::Boolean) } def variable_call?; end @@ -3914,14 +3902,14 @@ class Prism::CallOperatorWriteNode < ::Prism::Node # foo.bar += value # write_name `:bar=` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3181 + # pkg:gem/prism#lib/prism/node.rb:3189 sig { returns(Symbol) } def write_name; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:3232 + # pkg:gem/prism#lib/prism/node.rb:3240 def type; end end end @@ -3931,13 +3919,13 @@ end # foo.bar ||= value # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:3256 +# pkg:gem/prism#lib/prism/node.rb:3264 class Prism::CallOrWriteNode < ::Prism::Node # Initialize a new CallOrWriteNode node. # # @return [CallOrWriteNode] a new instance of CallOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:3258 + # pkg:gem/prism#lib/prism/node.rb:3266 sig do params( source: Prism::Source, @@ -3958,12 +3946,12 @@ class Prism::CallOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:3452 + # pkg:gem/prism#lib/prism/node.rb:3460 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:3273 + # pkg:gem/prism#lib/prism/node.rb:3281 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -3971,13 +3959,13 @@ class Prism::CallOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3327 + # pkg:gem/prism#lib/prism/node.rb:3335 sig { returns(T::Boolean) } def attribute_write?; end # def call_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:3421 + # pkg:gem/prism#lib/prism/node.rb:3429 sig { returns(T.nilable(String)) } def call_operator; end @@ -3986,31 +3974,31 @@ class Prism::CallOrWriteNode < ::Prism::Node # foo.bar ||= value # ^ # - # pkg:gem/prism#lib/prism/node.rb:3346 + # pkg:gem/prism#lib/prism/node.rb:3354 sig { returns(T.nilable(Prism::Location)) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3278 + # pkg:gem/prism#lib/prism/node.rb:3286 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:3299 + # pkg:gem/prism#lib/prism/node.rb:3307 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:3291 + # pkg:gem/prism#lib/prism/node.rb:3299 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator_loc: Location, ?value: Prism::node) -> CallOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:3304 + # pkg:gem/prism#lib/prism/node.rb:3312 sig do params( node_id: Integer, @@ -4030,13 +4018,13 @@ class Prism::CallOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3309 + # pkg:gem/prism#lib/prism/node.rb:3317 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:3312 + # pkg:gem/prism#lib/prism/node.rb:3320 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -4044,7 +4032,7 @@ class Prism::CallOrWriteNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:3283 + # pkg:gem/prism#lib/prism/node.rb:3291 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -4054,19 +4042,19 @@ class Prism::CallOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3332 + # pkg:gem/prism#lib/prism/node.rb:3340 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:3436 + # pkg:gem/prism#lib/prism/node.rb:3444 sig { override.returns(String) } def inspect; end # def message: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:3426 + # pkg:gem/prism#lib/prism/node.rb:3434 sig { returns(T.nilable(String)) } def message; end @@ -4075,13 +4063,13 @@ class Prism::CallOrWriteNode < ::Prism::Node # foo.bar ||= value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3368 + # pkg:gem/prism#lib/prism/node.rb:3376 sig { returns(T.nilable(Prism::Location)) } def message_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:3431 + # pkg:gem/prism#lib/prism/node.rb:3439 sig { returns(String) } def operator; end @@ -4090,7 +4078,7 @@ class Prism::CallOrWriteNode < ::Prism::Node # foo.bar ||= value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3402 + # pkg:gem/prism#lib/prism/node.rb:3410 sig { returns(Prism::Location) } def operator_loc; end @@ -4099,7 +4087,7 @@ class Prism::CallOrWriteNode < ::Prism::Node # foo.bar ||= value # read_name `:bar` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3390 + # pkg:gem/prism#lib/prism/node.rb:3398 sig { returns(Symbol) } def read_name; end @@ -4108,7 +4096,7 @@ class Prism::CallOrWriteNode < ::Prism::Node # foo.bar ||= value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3340 + # pkg:gem/prism#lib/prism/node.rb:3348 sig { returns(T.nilable(Prism::Node)) } def receiver; end @@ -4116,31 +4104,31 @@ class Prism::CallOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3317 + # pkg:gem/prism#lib/prism/node.rb:3325 sig { returns(T::Boolean) } def safe_navigation?; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3360 + # pkg:gem/prism#lib/prism/node.rb:3368 def save_call_operator_loc(repository); end # Save the message_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3382 + # pkg:gem/prism#lib/prism/node.rb:3390 def save_message_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3410 + # pkg:gem/prism#lib/prism/node.rb:3418 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:3441 + # pkg:gem/prism#lib/prism/node.rb:3449 sig { override.returns(Symbol) } def type; end @@ -4149,7 +4137,7 @@ class Prism::CallOrWriteNode < ::Prism::Node # foo.bar ||= value # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3418 + # pkg:gem/prism#lib/prism/node.rb:3426 sig { returns(Prism::Node) } def value; end @@ -4157,7 +4145,7 @@ class Prism::CallOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3322 + # pkg:gem/prism#lib/prism/node.rb:3330 sig { returns(T::Boolean) } def variable_call?; end @@ -4166,14 +4154,14 @@ class Prism::CallOrWriteNode < ::Prism::Node # foo.bar ||= value # write_name `:bar=` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3396 + # pkg:gem/prism#lib/prism/node.rb:3404 sig { returns(Symbol) } def write_name; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:3446 + # pkg:gem/prism#lib/prism/node.rb:3454 def type; end end end @@ -4191,13 +4179,13 @@ end # for foo.bar in baz do end # ^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:3477 +# pkg:gem/prism#lib/prism/node.rb:3485 class Prism::CallTargetNode < ::Prism::Node # Initialize a new CallTargetNode node. # # @return [CallTargetNode] a new instance of CallTargetNode # - # pkg:gem/prism#lib/prism/node.rb:3479 + # pkg:gem/prism#lib/prism/node.rb:3487 sig do params( source: Prism::Source, @@ -4215,12 +4203,12 @@ class Prism::CallTargetNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:3621 + # pkg:gem/prism#lib/prism/node.rb:3629 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:3491 + # pkg:gem/prism#lib/prism/node.rb:3499 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -4228,13 +4216,13 @@ class Prism::CallTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3541 + # pkg:gem/prism#lib/prism/node.rb:3549 sig { returns(T::Boolean) } def attribute_write?; end # def call_operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:3595 + # pkg:gem/prism#lib/prism/node.rb:3603 sig { returns(String) } def call_operator; end @@ -4243,31 +4231,31 @@ class Prism::CallTargetNode < ::Prism::Node # foo.bar = 1 # ^ # - # pkg:gem/prism#lib/prism/node.rb:3560 + # pkg:gem/prism#lib/prism/node.rb:3568 sig { returns(Prism::Location) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3496 + # pkg:gem/prism#lib/prism/node.rb:3504 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:3513 + # pkg:gem/prism#lib/prism/node.rb:3521 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:3508 + # pkg:gem/prism#lib/prism/node.rb:3516 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?call_operator_loc: Location, ?name: Symbol, ?message_loc: Location) -> CallTargetNode # - # pkg:gem/prism#lib/prism/node.rb:3518 + # pkg:gem/prism#lib/prism/node.rb:3526 sig do params( node_id: Integer, @@ -4284,13 +4272,13 @@ class Prism::CallTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3523 + # pkg:gem/prism#lib/prism/node.rb:3531 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, call_operator_loc: Location, name: Symbol, message_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:3526 + # pkg:gem/prism#lib/prism/node.rb:3534 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -4298,7 +4286,7 @@ class Prism::CallTargetNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:3501 + # pkg:gem/prism#lib/prism/node.rb:3509 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -4308,19 +4296,19 @@ class Prism::CallTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3546 + # pkg:gem/prism#lib/prism/node.rb:3554 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:3605 + # pkg:gem/prism#lib/prism/node.rb:3613 sig { override.returns(String) } def inspect; end # def message: () -> String # - # pkg:gem/prism#lib/prism/node.rb:3600 + # pkg:gem/prism#lib/prism/node.rb:3608 sig { returns(String) } def message; end @@ -4329,7 +4317,7 @@ class Prism::CallTargetNode < ::Prism::Node # foo.bar = 1 # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3582 + # pkg:gem/prism#lib/prism/node.rb:3590 sig { returns(Prism::Location) } def message_loc; end @@ -4338,7 +4326,7 @@ class Prism::CallTargetNode < ::Prism::Node # foo.bar = 1 # name `:foo` # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3576 + # pkg:gem/prism#lib/prism/node.rb:3584 sig { returns(Symbol) } def name; end @@ -4347,7 +4335,7 @@ class Prism::CallTargetNode < ::Prism::Node # foo.bar = 1 # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3554 + # pkg:gem/prism#lib/prism/node.rb:3562 sig { returns(Prism::Node) } def receiver; end @@ -4355,25 +4343,25 @@ class Prism::CallTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3531 + # pkg:gem/prism#lib/prism/node.rb:3539 sig { returns(T::Boolean) } def safe_navigation?; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3568 + # pkg:gem/prism#lib/prism/node.rb:3576 def save_call_operator_loc(repository); end # Save the message_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3590 + # pkg:gem/prism#lib/prism/node.rb:3598 def save_message_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:3610 + # pkg:gem/prism#lib/prism/node.rb:3618 sig { override.returns(Symbol) } def type; end @@ -4381,14 +4369,14 @@ class Prism::CallTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:3536 + # pkg:gem/prism#lib/prism/node.rb:3544 sig { returns(T::Boolean) } def variable_call?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:3615 + # pkg:gem/prism#lib/prism/node.rb:3623 def type; end end end @@ -4398,13 +4386,13 @@ end # foo => [bar => baz] # ^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:3635 +# pkg:gem/prism#lib/prism/node.rb:3643 class Prism::CapturePatternNode < ::Prism::Node # Initialize a new CapturePatternNode node. # # @return [CapturePatternNode] a new instance of CapturePatternNode # - # pkg:gem/prism#lib/prism/node.rb:3637 + # pkg:gem/prism#lib/prism/node.rb:3645 sig do params( source: Prism::Source, @@ -4421,36 +4409,36 @@ class Prism::CapturePatternNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:3738 + # pkg:gem/prism#lib/prism/node.rb:3746 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:3648 + # pkg:gem/prism#lib/prism/node.rb:3656 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3653 + # pkg:gem/prism#lib/prism/node.rb:3661 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:3671 + # pkg:gem/prism#lib/prism/node.rb:3679 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:3666 + # pkg:gem/prism#lib/prism/node.rb:3674 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: LocalVariableTargetNode, ?operator_loc: Location) -> CapturePatternNode # - # pkg:gem/prism#lib/prism/node.rb:3676 + # pkg:gem/prism#lib/prism/node.rb:3684 sig do params( node_id: Integer, @@ -4466,13 +4454,13 @@ class Prism::CapturePatternNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3681 + # pkg:gem/prism#lib/prism/node.rb:3689 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: LocalVariableTargetNode, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:3684 + # pkg:gem/prism#lib/prism/node.rb:3692 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -4480,7 +4468,7 @@ class Prism::CapturePatternNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:3658 + # pkg:gem/prism#lib/prism/node.rb:3666 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -4488,13 +4476,13 @@ class Prism::CapturePatternNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:3722 + # pkg:gem/prism#lib/prism/node.rb:3730 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:3717 + # pkg:gem/prism#lib/prism/node.rb:3725 sig { returns(String) } def operator; end @@ -4503,14 +4491,14 @@ class Prism::CapturePatternNode < ::Prism::Node # foo => bar # ^^ # - # pkg:gem/prism#lib/prism/node.rb:3704 + # pkg:gem/prism#lib/prism/node.rb:3712 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3712 + # pkg:gem/prism#lib/prism/node.rb:3720 def save_operator_loc(repository); end # Represents the target of the capture. @@ -4518,13 +4506,13 @@ class Prism::CapturePatternNode < ::Prism::Node # foo => bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3698 + # pkg:gem/prism#lib/prism/node.rb:3706 sig { returns(Prism::LocalVariableTargetNode) } def target; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:3727 + # pkg:gem/prism#lib/prism/node.rb:3735 sig { override.returns(Symbol) } def type; end @@ -4533,14 +4521,14 @@ class Prism::CapturePatternNode < ::Prism::Node # foo => bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3692 + # pkg:gem/prism#lib/prism/node.rb:3700 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:3732 + # pkg:gem/prism#lib/prism/node.rb:3740 def type; end end end @@ -4552,13 +4540,13 @@ end # end # ^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:3752 +# pkg:gem/prism#lib/prism/node.rb:3760 class Prism::CaseMatchNode < ::Prism::Node # Initialize a new CaseMatchNode node. # # @return [CaseMatchNode] a new instance of CaseMatchNode # - # pkg:gem/prism#lib/prism/node.rb:3754 + # pkg:gem/prism#lib/prism/node.rb:3762 sig do params( source: Prism::Source, @@ -4577,18 +4565,18 @@ class Prism::CaseMatchNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:3889 + # pkg:gem/prism#lib/prism/node.rb:3897 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:3767 + # pkg:gem/prism#lib/prism/node.rb:3775 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def case_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:3863 + # pkg:gem/prism#lib/prism/node.rb:3871 sig { returns(String) } def case_keyword; end @@ -4597,25 +4585,25 @@ class Prism::CaseMatchNode < ::Prism::Node # case true; in false; end # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3834 + # pkg:gem/prism#lib/prism/node.rb:3842 sig { returns(Prism::Location) } def case_keyword_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3772 + # pkg:gem/prism#lib/prism/node.rb:3780 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:3795 + # pkg:gem/prism#lib/prism/node.rb:3803 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:3786 + # pkg:gem/prism#lib/prism/node.rb:3794 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -4624,7 +4612,7 @@ class Prism::CaseMatchNode < ::Prism::Node # case true; in false; end # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3822 + # pkg:gem/prism#lib/prism/node.rb:3830 sig { returns(T::Array[Prism::InNode]) } def conditions; end @@ -4636,7 +4624,7 @@ class Prism::CaseMatchNode < ::Prism::Node # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[InNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode # - # pkg:gem/prism#lib/prism/node.rb:3800 + # pkg:gem/prism#lib/prism/node.rb:3808 sig do params( node_id: Integer, @@ -4654,13 +4642,13 @@ class Prism::CaseMatchNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3805 + # pkg:gem/prism#lib/prism/node.rb:3813 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[InNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:3808 + # pkg:gem/prism#lib/prism/node.rb:3816 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -4668,7 +4656,7 @@ class Prism::CaseMatchNode < ::Prism::Node # # @yield [predicate] # - # pkg:gem/prism#lib/prism/node.rb:3777 + # pkg:gem/prism#lib/prism/node.rb:3785 def each_child_node; end # Represents the else clause of the case match. @@ -4676,13 +4664,13 @@ class Prism::CaseMatchNode < ::Prism::Node # case true; in false; else; end # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3828 + # pkg:gem/prism#lib/prism/node.rb:3836 sig { returns(T.nilable(Prism::ElseNode)) } def else_clause; end # def end_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:3868 + # pkg:gem/prism#lib/prism/node.rb:3876 sig { returns(String) } def end_keyword; end @@ -4691,7 +4679,7 @@ class Prism::CaseMatchNode < ::Prism::Node # case true; in false; end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:3850 + # pkg:gem/prism#lib/prism/node.rb:3858 sig { returns(Prism::Location) } def end_keyword_loc; end @@ -4700,7 +4688,7 @@ class Prism::CaseMatchNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:3873 + # pkg:gem/prism#lib/prism/node.rb:3881 sig { override.returns(String) } def inspect; end @@ -4709,32 +4697,32 @@ class Prism::CaseMatchNode < ::Prism::Node # case true; in false; end # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3816 + # pkg:gem/prism#lib/prism/node.rb:3824 sig { returns(T.nilable(Prism::Node)) } def predicate; end # Save the case_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3842 + # pkg:gem/prism#lib/prism/node.rb:3850 def save_case_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3858 + # pkg:gem/prism#lib/prism/node.rb:3866 def save_end_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:3878 + # pkg:gem/prism#lib/prism/node.rb:3886 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:3883 + # pkg:gem/prism#lib/prism/node.rb:3891 def type; end end end @@ -4746,13 +4734,13 @@ end # end # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:3906 +# pkg:gem/prism#lib/prism/node.rb:3914 class Prism::CaseNode < ::Prism::Node # Initialize a new CaseNode node. # # @return [CaseNode] a new instance of CaseNode # - # pkg:gem/prism#lib/prism/node.rb:3908 + # pkg:gem/prism#lib/prism/node.rb:3916 sig do params( source: Prism::Source, @@ -4771,18 +4759,18 @@ class Prism::CaseNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4043 + # pkg:gem/prism#lib/prism/node.rb:4051 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:3921 + # pkg:gem/prism#lib/prism/node.rb:3929 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def case_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:4017 + # pkg:gem/prism#lib/prism/node.rb:4025 sig { returns(String) } def case_keyword; end @@ -4791,25 +4779,25 @@ class Prism::CaseNode < ::Prism::Node # case true; when false; end # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3988 + # pkg:gem/prism#lib/prism/node.rb:3996 sig { returns(Prism::Location) } def case_keyword_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3926 + # pkg:gem/prism#lib/prism/node.rb:3934 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:3949 + # pkg:gem/prism#lib/prism/node.rb:3957 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:3940 + # pkg:gem/prism#lib/prism/node.rb:3948 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -4818,7 +4806,7 @@ class Prism::CaseNode < ::Prism::Node # case true; when false; end # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3976 + # pkg:gem/prism#lib/prism/node.rb:3984 sig { returns(T::Array[Prism::WhenNode]) } def conditions; end @@ -4830,7 +4818,7 @@ class Prism::CaseNode < ::Prism::Node # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[WhenNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode # - # pkg:gem/prism#lib/prism/node.rb:3954 + # pkg:gem/prism#lib/prism/node.rb:3962 sig do params( node_id: Integer, @@ -4848,13 +4836,13 @@ class Prism::CaseNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:3959 + # pkg:gem/prism#lib/prism/node.rb:3967 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[WhenNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:3962 + # pkg:gem/prism#lib/prism/node.rb:3970 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -4862,7 +4850,7 @@ class Prism::CaseNode < ::Prism::Node # # @yield [predicate] # - # pkg:gem/prism#lib/prism/node.rb:3931 + # pkg:gem/prism#lib/prism/node.rb:3939 def each_child_node; end # Represents the else clause of the case statement. @@ -4870,13 +4858,13 @@ class Prism::CaseNode < ::Prism::Node # case true; when false; else; end # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3982 + # pkg:gem/prism#lib/prism/node.rb:3990 sig { returns(T.nilable(Prism::ElseNode)) } def else_clause; end # def end_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:4022 + # pkg:gem/prism#lib/prism/node.rb:4030 sig { returns(String) } def end_keyword; end @@ -4885,7 +4873,7 @@ class Prism::CaseNode < ::Prism::Node # case true; when false; end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:4004 + # pkg:gem/prism#lib/prism/node.rb:4012 sig { returns(Prism::Location) } def end_keyword_loc; end @@ -4894,7 +4882,7 @@ class Prism::CaseNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4027 + # pkg:gem/prism#lib/prism/node.rb:4035 sig { override.returns(String) } def inspect; end @@ -4903,32 +4891,32 @@ class Prism::CaseNode < ::Prism::Node # case true; when false; end # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:3970 + # pkg:gem/prism#lib/prism/node.rb:3978 sig { returns(T.nilable(Prism::Node)) } def predicate; end # Save the case_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:3996 + # pkg:gem/prism#lib/prism/node.rb:4004 def save_case_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4012 + # pkg:gem/prism#lib/prism/node.rb:4020 def save_end_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4032 + # pkg:gem/prism#lib/prism/node.rb:4040 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4037 + # pkg:gem/prism#lib/prism/node.rb:4045 def type; end end end @@ -4938,13 +4926,13 @@ end # class Foo end # ^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4058 +# pkg:gem/prism#lib/prism/node.rb:4066 class Prism::ClassNode < ::Prism::Node # Initialize a new ClassNode node. # # @return [ClassNode] a new instance of ClassNode # - # pkg:gem/prism#lib/prism/node.rb:4060 + # pkg:gem/prism#lib/prism/node.rb:4068 sig do params( source: Prism::Source, @@ -4966,12 +4954,12 @@ class Prism::ClassNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4231 + # pkg:gem/prism#lib/prism/node.rb:4239 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4076 + # pkg:gem/prism#lib/prism/node.rb:4084 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -4981,19 +4969,19 @@ class Prism::ClassNode < ::Prism::Node # foo # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:4176 + # pkg:gem/prism#lib/prism/node.rb:4184 sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4081 + # pkg:gem/prism#lib/prism/node.rb:4089 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def class_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:4200 + # pkg:gem/prism#lib/prism/node.rb:4208 sig { returns(String) } def class_keyword; end @@ -5002,31 +4990,31 @@ class Prism::ClassNode < ::Prism::Node # class Foo end # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:4128 + # pkg:gem/prism#lib/prism/node.rb:4136 sig { returns(Prism::Location) } def class_keyword_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4104 + # pkg:gem/prism#lib/prism/node.rb:4112 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4095 + # pkg:gem/prism#lib/prism/node.rb:4103 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # attr_reader constant_path: ConstantReadNode | ConstantPathNode | CallNode # - # pkg:gem/prism#lib/prism/node.rb:4141 + # pkg:gem/prism#lib/prism/node.rb:4149 sig { returns(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::CallNode)) } def constant_path; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | CallNode, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode # - # pkg:gem/prism#lib/prism/node.rb:4109 + # pkg:gem/prism#lib/prism/node.rb:4117 sig do params( node_id: Integer, @@ -5047,13 +5035,13 @@ class Prism::ClassNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4114 + # pkg:gem/prism#lib/prism/node.rb:4122 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | CallNode, inheritance_operator_loc: Location?, superclass: Prism::node?, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:4117 + # pkg:gem/prism#lib/prism/node.rb:4125 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -5061,12 +5049,12 @@ class Prism::ClassNode < ::Prism::Node # # @yield [constant_path] # - # pkg:gem/prism#lib/prism/node.rb:4086 + # pkg:gem/prism#lib/prism/node.rb:4094 def each_child_node; end # def end_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:4210 + # pkg:gem/prism#lib/prism/node.rb:4218 sig { returns(String) } def end_keyword; end @@ -5075,7 +5063,7 @@ class Prism::ClassNode < ::Prism::Node # class Foo end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:4182 + # pkg:gem/prism#lib/prism/node.rb:4190 sig { returns(Prism::Location) } def end_keyword_loc; end @@ -5084,7 +5072,7 @@ class Prism::ClassNode < ::Prism::Node # def inheritance_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:4205 + # pkg:gem/prism#lib/prism/node.rb:4213 sig { returns(T.nilable(String)) } def inheritance_operator; end @@ -5093,19 +5081,19 @@ class Prism::ClassNode < ::Prism::Node # class Foo < Bar # ^ # - # pkg:gem/prism#lib/prism/node.rb:4147 + # pkg:gem/prism#lib/prism/node.rb:4155 sig { returns(T.nilable(Prism::Location)) } def inheritance_operator_loc; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4215 + # pkg:gem/prism#lib/prism/node.rb:4223 sig { override.returns(String) } def inspect; end # attr_reader locals: Array[Symbol] # - # pkg:gem/prism#lib/prism/node.rb:4122 + # pkg:gem/prism#lib/prism/node.rb:4130 sig { returns(T::Array[Symbol]) } def locals; end @@ -5113,26 +5101,26 @@ class Prism::ClassNode < ::Prism::Node # # class Foo end # name `:Foo` # - # pkg:gem/prism#lib/prism/node.rb:4197 + # pkg:gem/prism#lib/prism/node.rb:4205 sig { returns(Symbol) } def name; end # Save the class_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4136 + # pkg:gem/prism#lib/prism/node.rb:4144 def save_class_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4190 + # pkg:gem/prism#lib/prism/node.rb:4198 def save_end_keyword_loc(repository); end # Save the inheritance_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4161 + # pkg:gem/prism#lib/prism/node.rb:4169 def save_inheritance_operator_loc(repository); end # Represents the superclass of the class. @@ -5140,20 +5128,20 @@ class Prism::ClassNode < ::Prism::Node # class Foo < Bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:4169 + # pkg:gem/prism#lib/prism/node.rb:4177 sig { returns(T.nilable(Prism::Node)) } def superclass; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4220 + # pkg:gem/prism#lib/prism/node.rb:4228 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4225 + # pkg:gem/prism#lib/prism/node.rb:4233 def type; end end end @@ -5163,13 +5151,13 @@ end # @@target &&= value # ^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4249 +# pkg:gem/prism#lib/prism/node.rb:4257 class Prism::ClassVariableAndWriteNode < ::Prism::Node # Initialize a new ClassVariableAndWriteNode node. # # @return [ClassVariableAndWriteNode] a new instance of ClassVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4251 + # pkg:gem/prism#lib/prism/node.rb:4259 sig do params( source: Prism::Source, @@ -5187,36 +5175,36 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4368 + # pkg:gem/prism#lib/prism/node.rb:4376 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4263 + # pkg:gem/prism#lib/prism/node.rb:4271 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4268 + # pkg:gem/prism#lib/prism/node.rb:4276 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4285 + # pkg:gem/prism#lib/prism/node.rb:4293 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4280 + # pkg:gem/prism#lib/prism/node.rb:4288 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4290 + # pkg:gem/prism#lib/prism/node.rb:4298 sig do params( node_id: Integer, @@ -5233,13 +5221,13 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4295 + # pkg:gem/prism#lib/prism/node.rb:4303 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:4298 + # pkg:gem/prism#lib/prism/node.rb:4306 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -5250,7 +5238,7 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:4273 + # pkg:gem/prism#lib/prism/node.rb:4281 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -5258,7 +5246,7 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4352 + # pkg:gem/prism#lib/prism/node.rb:4360 sig { override.returns(String) } def inspect; end @@ -5267,7 +5255,7 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # @@target &&= value # name `:@@target` # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:4306 + # pkg:gem/prism#lib/prism/node.rb:4314 sig { returns(Symbol) } def name; end @@ -5276,13 +5264,13 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # @@target &&= value # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:4312 + # pkg:gem/prism#lib/prism/node.rb:4320 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:4347 + # pkg:gem/prism#lib/prism/node.rb:4355 sig { returns(String) } def operator; end @@ -5291,25 +5279,25 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # @@target &&= value # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:4328 + # pkg:gem/prism#lib/prism/node.rb:4336 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4320 + # pkg:gem/prism#lib/prism/node.rb:4328 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4336 + # pkg:gem/prism#lib/prism/node.rb:4344 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4357 + # pkg:gem/prism#lib/prism/node.rb:4365 sig { override.returns(Symbol) } def type; end @@ -5318,14 +5306,14 @@ class Prism::ClassVariableAndWriteNode < ::Prism::Node # @@target &&= value # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:4344 + # pkg:gem/prism#lib/prism/node.rb:4352 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4362 + # pkg:gem/prism#lib/prism/node.rb:4370 def type; end end end @@ -5335,13 +5323,13 @@ end # @@target += value # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4381 +# pkg:gem/prism#lib/prism/node.rb:4389 class Prism::ClassVariableOperatorWriteNode < ::Prism::Node # Initialize a new ClassVariableOperatorWriteNode node. # # @return [ClassVariableOperatorWriteNode] a new instance of ClassVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4383 + # pkg:gem/prism#lib/prism/node.rb:4391 sig do params( source: Prism::Source, @@ -5360,48 +5348,48 @@ class Prism::ClassVariableOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4487 + # pkg:gem/prism#lib/prism/node.rb:4495 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4396 + # pkg:gem/prism#lib/prism/node.rb:4404 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader binary_operator: Symbol # - # pkg:gem/prism#lib/prism/node.rb:4468 + # pkg:gem/prism#lib/prism/node.rb:4476 sig { returns(Symbol) } def binary_operator; end # attr_reader binary_operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:4452 + # pkg:gem/prism#lib/prism/node.rb:4460 sig { returns(Prism::Location) } def binary_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4401 + # pkg:gem/prism#lib/prism/node.rb:4409 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4418 + # pkg:gem/prism#lib/prism/node.rb:4426 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4413 + # pkg:gem/prism#lib/prism/node.rb:4421 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ClassVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4423 + # pkg:gem/prism#lib/prism/node.rb:4431 sig do params( node_id: Integer, @@ -5419,13 +5407,13 @@ class Prism::ClassVariableOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4428 + # pkg:gem/prism#lib/prism/node.rb:4436 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:4431 + # pkg:gem/prism#lib/prism/node.rb:4439 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -5436,7 +5424,7 @@ class Prism::ClassVariableOperatorWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:4406 + # pkg:gem/prism#lib/prism/node.rb:4414 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -5444,19 +5432,19 @@ class Prism::ClassVariableOperatorWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4471 + # pkg:gem/prism#lib/prism/node.rb:4479 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:4436 + # pkg:gem/prism#lib/prism/node.rb:4444 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:4439 + # pkg:gem/prism#lib/prism/node.rb:4447 sig { returns(Prism::Location) } def name_loc; end @@ -5475,31 +5463,31 @@ class Prism::ClassVariableOperatorWriteNode < ::Prism::Node # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4460 + # pkg:gem/prism#lib/prism/node.rb:4468 def save_binary_operator_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4447 + # pkg:gem/prism#lib/prism/node.rb:4455 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4476 + # pkg:gem/prism#lib/prism/node.rb:4484 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:4465 + # pkg:gem/prism#lib/prism/node.rb:4473 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4481 + # pkg:gem/prism#lib/prism/node.rb:4489 def type; end end end @@ -5509,13 +5497,13 @@ end # @@target ||= value # ^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4501 +# pkg:gem/prism#lib/prism/node.rb:4509 class Prism::ClassVariableOrWriteNode < ::Prism::Node # Initialize a new ClassVariableOrWriteNode node. # # @return [ClassVariableOrWriteNode] a new instance of ClassVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4503 + # pkg:gem/prism#lib/prism/node.rb:4511 sig do params( source: Prism::Source, @@ -5533,36 +5521,36 @@ class Prism::ClassVariableOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4608 + # pkg:gem/prism#lib/prism/node.rb:4616 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4515 + # pkg:gem/prism#lib/prism/node.rb:4523 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4520 + # pkg:gem/prism#lib/prism/node.rb:4528 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4537 + # pkg:gem/prism#lib/prism/node.rb:4545 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4532 + # pkg:gem/prism#lib/prism/node.rb:4540 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ClassVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4542 + # pkg:gem/prism#lib/prism/node.rb:4550 sig do params( node_id: Integer, @@ -5579,13 +5567,13 @@ class Prism::ClassVariableOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4547 + # pkg:gem/prism#lib/prism/node.rb:4555 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:4550 + # pkg:gem/prism#lib/prism/node.rb:4558 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -5596,7 +5584,7 @@ class Prism::ClassVariableOrWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:4525 + # pkg:gem/prism#lib/prism/node.rb:4533 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -5604,62 +5592,62 @@ class Prism::ClassVariableOrWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4592 + # pkg:gem/prism#lib/prism/node.rb:4600 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:4555 + # pkg:gem/prism#lib/prism/node.rb:4563 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:4558 + # pkg:gem/prism#lib/prism/node.rb:4566 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:4587 + # pkg:gem/prism#lib/prism/node.rb:4595 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:4571 + # pkg:gem/prism#lib/prism/node.rb:4579 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4566 + # pkg:gem/prism#lib/prism/node.rb:4574 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4579 + # pkg:gem/prism#lib/prism/node.rb:4587 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4597 + # pkg:gem/prism#lib/prism/node.rb:4605 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:4584 + # pkg:gem/prism#lib/prism/node.rb:4592 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4602 + # pkg:gem/prism#lib/prism/node.rb:4610 def type; end end end @@ -5669,49 +5657,49 @@ end # @@foo # ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4621 +# pkg:gem/prism#lib/prism/node.rb:4629 class Prism::ClassVariableReadNode < ::Prism::Node # Initialize a new ClassVariableReadNode node. # # @return [ClassVariableReadNode] a new instance of ClassVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:4623 + # pkg:gem/prism#lib/prism/node.rb:4631 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4694 + # pkg:gem/prism#lib/prism/node.rb:4702 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4632 + # pkg:gem/prism#lib/prism/node.rb:4640 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4637 + # pkg:gem/prism#lib/prism/node.rb:4645 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4653 + # pkg:gem/prism#lib/prism/node.rb:4661 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4648 + # pkg:gem/prism#lib/prism/node.rb:4656 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:4658 + # pkg:gem/prism#lib/prism/node.rb:4666 sig do params( node_id: Integer, @@ -5725,19 +5713,19 @@ class Prism::ClassVariableReadNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4663 + # pkg:gem/prism#lib/prism/node.rb:4671 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:4666 + # pkg:gem/prism#lib/prism/node.rb:4674 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:4642 + # pkg:gem/prism#lib/prism/node.rb:4650 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -5745,7 +5733,7 @@ class Prism::ClassVariableReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4678 + # pkg:gem/prism#lib/prism/node.rb:4686 sig { override.returns(String) } def inspect; end @@ -5755,20 +5743,20 @@ class Prism::ClassVariableReadNode < ::Prism::Node # # @@_test # name `:@@_test` # - # pkg:gem/prism#lib/prism/node.rb:4675 + # pkg:gem/prism#lib/prism/node.rb:4683 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4683 + # pkg:gem/prism#lib/prism/node.rb:4691 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4688 + # pkg:gem/prism#lib/prism/node.rb:4696 def type; end end end @@ -5778,49 +5766,49 @@ end # @@foo, @@bar = baz # ^^^^^ ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4704 +# pkg:gem/prism#lib/prism/node.rb:4712 class Prism::ClassVariableTargetNode < ::Prism::Node # Initialize a new ClassVariableTargetNode node. # # @return [ClassVariableTargetNode] a new instance of ClassVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:4706 + # pkg:gem/prism#lib/prism/node.rb:4714 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4773 + # pkg:gem/prism#lib/prism/node.rb:4781 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4715 + # pkg:gem/prism#lib/prism/node.rb:4723 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4720 + # pkg:gem/prism#lib/prism/node.rb:4728 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4736 + # pkg:gem/prism#lib/prism/node.rb:4744 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4731 + # pkg:gem/prism#lib/prism/node.rb:4739 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ClassVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:4741 + # pkg:gem/prism#lib/prism/node.rb:4749 sig do params( node_id: Integer, @@ -5834,19 +5822,19 @@ class Prism::ClassVariableTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4746 + # pkg:gem/prism#lib/prism/node.rb:4754 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:4749 + # pkg:gem/prism#lib/prism/node.rb:4757 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:4725 + # pkg:gem/prism#lib/prism/node.rb:4733 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -5854,26 +5842,26 @@ class Prism::ClassVariableTargetNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4757 + # pkg:gem/prism#lib/prism/node.rb:4765 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:4754 + # pkg:gem/prism#lib/prism/node.rb:4762 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4762 + # pkg:gem/prism#lib/prism/node.rb:4770 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4767 + # pkg:gem/prism#lib/prism/node.rb:4775 def type; end end end @@ -5883,13 +5871,13 @@ end # @@foo = 1 # ^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4783 +# pkg:gem/prism#lib/prism/node.rb:4791 class Prism::ClassVariableWriteNode < ::Prism::Node # Initialize a new ClassVariableWriteNode node. # # @return [ClassVariableWriteNode] a new instance of ClassVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4785 + # pkg:gem/prism#lib/prism/node.rb:4793 sig do params( source: Prism::Source, @@ -5907,36 +5895,36 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:4906 + # pkg:gem/prism#lib/prism/node.rb:4914 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4797 + # pkg:gem/prism#lib/prism/node.rb:4805 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4802 + # pkg:gem/prism#lib/prism/node.rb:4810 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4819 + # pkg:gem/prism#lib/prism/node.rb:4827 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4814 + # pkg:gem/prism#lib/prism/node.rb:4822 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ClassVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4824 + # pkg:gem/prism#lib/prism/node.rb:4832 sig do params( node_id: Integer, @@ -5953,13 +5941,13 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4829 + # pkg:gem/prism#lib/prism/node.rb:4837 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:4832 + # pkg:gem/prism#lib/prism/node.rb:4840 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -5967,7 +5955,7 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:4807 + # pkg:gem/prism#lib/prism/node.rb:4815 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -5975,7 +5963,7 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:4890 + # pkg:gem/prism#lib/prism/node.rb:4898 sig { override.returns(String) } def inspect; end @@ -5985,7 +5973,7 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # # @@_test = :test # name `@@_test` # - # pkg:gem/prism#lib/prism/node.rb:4841 + # pkg:gem/prism#lib/prism/node.rb:4849 sig { returns(Symbol) } def name; end @@ -5994,13 +5982,13 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # @@foo = :bar # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:4847 + # pkg:gem/prism#lib/prism/node.rb:4855 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:4885 + # pkg:gem/prism#lib/prism/node.rb:4893 sig { returns(String) } def operator; end @@ -6009,25 +5997,25 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # @@foo = :bar # ^ # - # pkg:gem/prism#lib/prism/node.rb:4872 + # pkg:gem/prism#lib/prism/node.rb:4880 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4855 + # pkg:gem/prism#lib/prism/node.rb:4863 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4880 + # pkg:gem/prism#lib/prism/node.rb:4888 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:4895 + # pkg:gem/prism#lib/prism/node.rb:4903 sig { override.returns(Symbol) } def type; end @@ -6039,14 +6027,14 @@ class Prism::ClassVariableWriteNode < ::Prism::Node # @@_xyz = 123 # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:4866 + # pkg:gem/prism#lib/prism/node.rb:4874 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:4900 + # pkg:gem/prism#lib/prism/node.rb:4908 def type; end end end @@ -6065,49 +6053,49 @@ end # introduce some kind of LRU cache to limit the number of entries, but this # has not yet been implemented. # -# pkg:gem/prism#lib/prism/parse_result.rb:177 +# pkg:gem/prism#lib/prism/parse_result.rb:186 class Prism::CodeUnitsCache # Initialize a new cache with the given source and encoding. # # @return [CodeUnitsCache] a new instance of CodeUnitsCache # - # pkg:gem/prism#lib/prism/parse_result.rb:203 + # pkg:gem/prism#lib/prism/parse_result.rb:212 sig { params(source: String, encoding: Encoding).void } def initialize(source, encoding); end # Retrieve the code units offset from the given byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:217 + # pkg:gem/prism#lib/prism/parse_result.rb:226 sig { params(byte_offset: Integer).returns(Integer) } def [](byte_offset); end end -# pkg:gem/prism#lib/prism/parse_result.rb:189 +# pkg:gem/prism#lib/prism/parse_result.rb:198 class Prism::CodeUnitsCache::LengthCounter # @return [LengthCounter] a new instance of LengthCounter # - # pkg:gem/prism#lib/prism/parse_result.rb:190 + # pkg:gem/prism#lib/prism/parse_result.rb:199 def initialize(source, encoding); end - # pkg:gem/prism#lib/prism/parse_result.rb:195 + # pkg:gem/prism#lib/prism/parse_result.rb:204 def count(byte_offset, byte_length); end end -# pkg:gem/prism#lib/prism/parse_result.rb:178 +# pkg:gem/prism#lib/prism/parse_result.rb:187 class Prism::CodeUnitsCache::UTF16Counter # @return [UTF16Counter] a new instance of UTF16Counter # - # pkg:gem/prism#lib/prism/parse_result.rb:179 + # pkg:gem/prism#lib/prism/parse_result.rb:188 def initialize(source, encoding); end - # pkg:gem/prism#lib/prism/parse_result.rb:184 + # pkg:gem/prism#lib/prism/parse_result.rb:193 def count(byte_offset, byte_length); end end # This represents a comment that was encountered during parsing. It is the # base class for all comment types. # -# pkg:gem/prism#lib/prism/parse_result.rb:512 +# pkg:gem/prism#lib/prism/parse_result.rb:521 class Prism::Comment abstract! @@ -6115,25 +6103,25 @@ class Prism::Comment # # @return [Comment] a new instance of Comment # - # pkg:gem/prism#lib/prism/parse_result.rb:517 + # pkg:gem/prism#lib/prism/parse_result.rb:526 sig { params(location: Prism::Location).void } def initialize(location); end # Implement the hash pattern matching interface for Comment. # - # pkg:gem/prism#lib/prism/parse_result.rb:522 + # pkg:gem/prism#lib/prism/parse_result.rb:531 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # The location of this comment in the source. # - # pkg:gem/prism#lib/prism/parse_result.rb:514 + # pkg:gem/prism#lib/prism/parse_result.rb:523 sig { returns(Prism::Location) } def location; end # Returns the content of the comment by slicing it from the source code. # - # pkg:gem/prism#lib/prism/parse_result.rb:527 + # pkg:gem/prism#lib/prism/parse_result.rb:536 sig { returns(String) } def slice; end @@ -6939,13 +6927,13 @@ end # Target &&= value # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:4919 +# pkg:gem/prism#lib/prism/node.rb:4927 class Prism::ConstantAndWriteNode < ::Prism::Node # Initialize a new ConstantAndWriteNode node. # # @return [ConstantAndWriteNode] a new instance of ConstantAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4921 + # pkg:gem/prism#lib/prism/node.rb:4929 sig do params( source: Prism::Source, @@ -6963,36 +6951,36 @@ class Prism::ConstantAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5026 + # pkg:gem/prism#lib/prism/node.rb:5034 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:4933 + # pkg:gem/prism#lib/prism/node.rb:4941 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4938 + # pkg:gem/prism#lib/prism/node.rb:4946 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:4955 + # pkg:gem/prism#lib/prism/node.rb:4963 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:4950 + # pkg:gem/prism#lib/prism/node.rb:4958 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:4960 + # pkg:gem/prism#lib/prism/node.rb:4968 sig do params( node_id: Integer, @@ -7009,13 +6997,13 @@ class Prism::ConstantAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:4965 + # pkg:gem/prism#lib/prism/node.rb:4973 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:4968 + # pkg:gem/prism#lib/prism/node.rb:4976 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -7026,7 +7014,7 @@ class Prism::ConstantAndWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:4943 + # pkg:gem/prism#lib/prism/node.rb:4951 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -7034,62 +7022,62 @@ class Prism::ConstantAndWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5010 + # pkg:gem/prism#lib/prism/node.rb:5018 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:4973 + # pkg:gem/prism#lib/prism/node.rb:4981 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:4976 + # pkg:gem/prism#lib/prism/node.rb:4984 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:5005 + # pkg:gem/prism#lib/prism/node.rb:5013 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:4989 + # pkg:gem/prism#lib/prism/node.rb:4997 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4984 + # pkg:gem/prism#lib/prism/node.rb:4992 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:4997 + # pkg:gem/prism#lib/prism/node.rb:5005 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5015 + # pkg:gem/prism#lib/prism/node.rb:5023 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:5002 + # pkg:gem/prism#lib/prism/node.rb:5010 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5020 + # pkg:gem/prism#lib/prism/node.rb:5028 def type; end end end @@ -7099,13 +7087,13 @@ end # Target += value # ^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5039 +# pkg:gem/prism#lib/prism/node.rb:5047 class Prism::ConstantOperatorWriteNode < ::Prism::Node # Initialize a new ConstantOperatorWriteNode node. # # @return [ConstantOperatorWriteNode] a new instance of ConstantOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5041 + # pkg:gem/prism#lib/prism/node.rb:5049 sig do params( source: Prism::Source, @@ -7124,48 +7112,48 @@ class Prism::ConstantOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5145 + # pkg:gem/prism#lib/prism/node.rb:5153 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5054 + # pkg:gem/prism#lib/prism/node.rb:5062 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader binary_operator: Symbol # - # pkg:gem/prism#lib/prism/node.rb:5126 + # pkg:gem/prism#lib/prism/node.rb:5134 sig { returns(Symbol) } def binary_operator; end # attr_reader binary_operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5110 + # pkg:gem/prism#lib/prism/node.rb:5118 sig { returns(Prism::Location) } def binary_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5059 + # pkg:gem/prism#lib/prism/node.rb:5067 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5076 + # pkg:gem/prism#lib/prism/node.rb:5084 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5071 + # pkg:gem/prism#lib/prism/node.rb:5079 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5081 + # pkg:gem/prism#lib/prism/node.rb:5089 sig do params( node_id: Integer, @@ -7183,13 +7171,13 @@ class Prism::ConstantOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5086 + # pkg:gem/prism#lib/prism/node.rb:5094 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:5089 + # pkg:gem/prism#lib/prism/node.rb:5097 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -7200,7 +7188,7 @@ class Prism::ConstantOperatorWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:5064 + # pkg:gem/prism#lib/prism/node.rb:5072 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -7208,19 +7196,19 @@ class Prism::ConstantOperatorWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5129 + # pkg:gem/prism#lib/prism/node.rb:5137 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:5094 + # pkg:gem/prism#lib/prism/node.rb:5102 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5097 + # pkg:gem/prism#lib/prism/node.rb:5105 sig { returns(Prism::Location) } def name_loc; end @@ -7239,31 +7227,31 @@ class Prism::ConstantOperatorWriteNode < ::Prism::Node # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5118 + # pkg:gem/prism#lib/prism/node.rb:5126 def save_binary_operator_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5105 + # pkg:gem/prism#lib/prism/node.rb:5113 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5134 + # pkg:gem/prism#lib/prism/node.rb:5142 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:5123 + # pkg:gem/prism#lib/prism/node.rb:5131 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5139 + # pkg:gem/prism#lib/prism/node.rb:5147 def type; end end end @@ -7273,13 +7261,13 @@ end # Target ||= value # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5159 +# pkg:gem/prism#lib/prism/node.rb:5167 class Prism::ConstantOrWriteNode < ::Prism::Node # Initialize a new ConstantOrWriteNode node. # # @return [ConstantOrWriteNode] a new instance of ConstantOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5161 + # pkg:gem/prism#lib/prism/node.rb:5169 sig do params( source: Prism::Source, @@ -7297,36 +7285,36 @@ class Prism::ConstantOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5266 + # pkg:gem/prism#lib/prism/node.rb:5274 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5173 + # pkg:gem/prism#lib/prism/node.rb:5181 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5178 + # pkg:gem/prism#lib/prism/node.rb:5186 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5195 + # pkg:gem/prism#lib/prism/node.rb:5203 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5190 + # pkg:gem/prism#lib/prism/node.rb:5198 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> ConstantOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5200 + # pkg:gem/prism#lib/prism/node.rb:5208 sig do params( node_id: Integer, @@ -7343,13 +7331,13 @@ class Prism::ConstantOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5205 + # pkg:gem/prism#lib/prism/node.rb:5213 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:5208 + # pkg:gem/prism#lib/prism/node.rb:5216 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -7360,7 +7348,7 @@ class Prism::ConstantOrWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:5183 + # pkg:gem/prism#lib/prism/node.rb:5191 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -7368,62 +7356,62 @@ class Prism::ConstantOrWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5250 + # pkg:gem/prism#lib/prism/node.rb:5258 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:5213 + # pkg:gem/prism#lib/prism/node.rb:5221 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5216 + # pkg:gem/prism#lib/prism/node.rb:5224 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:5245 + # pkg:gem/prism#lib/prism/node.rb:5253 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5229 + # pkg:gem/prism#lib/prism/node.rb:5237 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5224 + # pkg:gem/prism#lib/prism/node.rb:5232 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5237 + # pkg:gem/prism#lib/prism/node.rb:5245 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5255 + # pkg:gem/prism#lib/prism/node.rb:5263 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:5242 + # pkg:gem/prism#lib/prism/node.rb:5250 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5260 + # pkg:gem/prism#lib/prism/node.rb:5268 def type; end end end @@ -7433,13 +7421,13 @@ end # Parent::Child &&= value # ^^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5279 +# pkg:gem/prism#lib/prism/node.rb:5287 class Prism::ConstantPathAndWriteNode < ::Prism::Node # Initialize a new ConstantPathAndWriteNode node. # # @return [ConstantPathAndWriteNode] a new instance of ConstantPathAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5281 + # pkg:gem/prism#lib/prism/node.rb:5289 sig do params( source: Prism::Source, @@ -7456,36 +7444,36 @@ class Prism::ConstantPathAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5373 + # pkg:gem/prism#lib/prism/node.rb:5381 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5292 + # pkg:gem/prism#lib/prism/node.rb:5300 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5297 + # pkg:gem/prism#lib/prism/node.rb:5305 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5315 + # pkg:gem/prism#lib/prism/node.rb:5323 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5310 + # pkg:gem/prism#lib/prism/node.rb:5318 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5320 + # pkg:gem/prism#lib/prism/node.rb:5328 sig do params( node_id: Integer, @@ -7501,13 +7489,13 @@ class Prism::ConstantPathAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5325 + # pkg:gem/prism#lib/prism/node.rb:5333 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:5328 + # pkg:gem/prism#lib/prism/node.rb:5336 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -7515,7 +7503,7 @@ class Prism::ConstantPathAndWriteNode < ::Prism::Node # # @yield [target] # - # pkg:gem/prism#lib/prism/node.rb:5302 + # pkg:gem/prism#lib/prism/node.rb:5310 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -7523,50 +7511,50 @@ class Prism::ConstantPathAndWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5357 + # pkg:gem/prism#lib/prism/node.rb:5365 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:5352 + # pkg:gem/prism#lib/prism/node.rb:5360 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5336 + # pkg:gem/prism#lib/prism/node.rb:5344 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5344 + # pkg:gem/prism#lib/prism/node.rb:5352 def save_operator_loc(repository); end # attr_reader target: ConstantPathNode # - # pkg:gem/prism#lib/prism/node.rb:5333 + # pkg:gem/prism#lib/prism/node.rb:5341 sig { returns(Prism::ConstantPathNode) } def target; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5362 + # pkg:gem/prism#lib/prism/node.rb:5370 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:5349 + # pkg:gem/prism#lib/prism/node.rb:5357 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5367 + # pkg:gem/prism#lib/prism/node.rb:5375 def type; end end end @@ -7576,13 +7564,13 @@ end # Foo::Bar # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5385 +# pkg:gem/prism#lib/prism/node.rb:5393 class Prism::ConstantPathNode < ::Prism::Node # Initialize a new ConstantPathNode node. # # @return [ConstantPathNode] a new instance of ConstantPathNode # - # pkg:gem/prism#lib/prism/node.rb:5387 + # pkg:gem/prism#lib/prism/node.rb:5395 sig do params( source: Prism::Source, @@ -7600,12 +7588,12 @@ class Prism::ConstantPathNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5515 + # pkg:gem/prism#lib/prism/node.rb:5523 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5399 + # pkg:gem/prism#lib/prism/node.rb:5407 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -7618,25 +7606,25 @@ class Prism::ConstantPathNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5404 + # pkg:gem/prism#lib/prism/node.rb:5412 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5423 + # pkg:gem/prism#lib/prism/node.rb:5431 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5416 + # pkg:gem/prism#lib/prism/node.rb:5424 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathNode # - # pkg:gem/prism#lib/prism/node.rb:5428 + # pkg:gem/prism#lib/prism/node.rb:5436 sig do params( node_id: Integer, @@ -7653,19 +7641,19 @@ class Prism::ConstantPathNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5433 + # pkg:gem/prism#lib/prism/node.rb:5441 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:5436 + # pkg:gem/prism#lib/prism/node.rb:5444 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def delimiter: () -> String # - # pkg:gem/prism#lib/prism/node.rb:5494 + # pkg:gem/prism#lib/prism/node.rb:5502 sig { returns(String) } def delimiter; end @@ -7677,7 +7665,7 @@ class Prism::ConstantPathNode < ::Prism::Node # One::Two # ^^ # - # pkg:gem/prism#lib/prism/node.rb:5462 + # pkg:gem/prism#lib/prism/node.rb:5470 sig { returns(Prism::Location) } def delimiter_loc; end @@ -7685,7 +7673,7 @@ class Prism::ConstantPathNode < ::Prism::Node # # @yield [parent] # - # pkg:gem/prism#lib/prism/node.rb:5409 + # pkg:gem/prism#lib/prism/node.rb:5417 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -7706,13 +7694,13 @@ class Prism::ConstantPathNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5499 + # pkg:gem/prism#lib/prism/node.rb:5507 sig { override.returns(String) } def inspect; end # The name of the constant being accessed. This could be `nil` in the event of a syntax error. # - # pkg:gem/prism#lib/prism/node.rb:5453 + # pkg:gem/prism#lib/prism/node.rb:5461 sig { returns(T.nilable(Symbol)) } def name; end @@ -7724,7 +7712,7 @@ class Prism::ConstantPathNode < ::Prism::Node # One::Two # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:5481 + # pkg:gem/prism#lib/prism/node.rb:5489 sig { returns(Prism::Location) } def name_loc; end @@ -7739,32 +7727,32 @@ class Prism::ConstantPathNode < ::Prism::Node # a.b::C # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:5450 + # pkg:gem/prism#lib/prism/node.rb:5458 sig { returns(T.nilable(Prism::Node)) } def parent; end # Save the delimiter_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5470 + # pkg:gem/prism#lib/prism/node.rb:5478 def save_delimiter_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5489 + # pkg:gem/prism#lib/prism/node.rb:5497 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5504 + # pkg:gem/prism#lib/prism/node.rb:5512 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5509 + # pkg:gem/prism#lib/prism/node.rb:5517 def type; end end end @@ -7791,13 +7779,13 @@ class Prism::ConstantPathNode::MissingNodesInConstantPathError < ::StandardError # Parent::Child += value # ^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5528 +# pkg:gem/prism#lib/prism/node.rb:5536 class Prism::ConstantPathOperatorWriteNode < ::Prism::Node # Initialize a new ConstantPathOperatorWriteNode node. # # @return [ConstantPathOperatorWriteNode] a new instance of ConstantPathOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5530 + # pkg:gem/prism#lib/prism/node.rb:5538 sig do params( source: Prism::Source, @@ -7815,48 +7803,48 @@ class Prism::ConstantPathOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5621 + # pkg:gem/prism#lib/prism/node.rb:5629 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5542 + # pkg:gem/prism#lib/prism/node.rb:5550 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader binary_operator: Symbol # - # pkg:gem/prism#lib/prism/node.rb:5602 + # pkg:gem/prism#lib/prism/node.rb:5610 sig { returns(Symbol) } def binary_operator; end # attr_reader binary_operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5586 + # pkg:gem/prism#lib/prism/node.rb:5594 sig { returns(Prism::Location) } def binary_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5547 + # pkg:gem/prism#lib/prism/node.rb:5555 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5565 + # pkg:gem/prism#lib/prism/node.rb:5573 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5560 + # pkg:gem/prism#lib/prism/node.rb:5568 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> ConstantPathOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5570 + # pkg:gem/prism#lib/prism/node.rb:5578 sig do params( node_id: Integer, @@ -7873,13 +7861,13 @@ class Prism::ConstantPathOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5575 + # pkg:gem/prism#lib/prism/node.rb:5583 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:5578 + # pkg:gem/prism#lib/prism/node.rb:5586 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -7887,7 +7875,7 @@ class Prism::ConstantPathOperatorWriteNode < ::Prism::Node # # @yield [target] # - # pkg:gem/prism#lib/prism/node.rb:5552 + # pkg:gem/prism#lib/prism/node.rb:5560 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -7895,7 +7883,7 @@ class Prism::ConstantPathOperatorWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5605 + # pkg:gem/prism#lib/prism/node.rb:5613 sig { override.returns(String) } def inspect; end @@ -7914,31 +7902,31 @@ class Prism::ConstantPathOperatorWriteNode < ::Prism::Node # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5594 + # pkg:gem/prism#lib/prism/node.rb:5602 def save_binary_operator_loc(repository); end # attr_reader target: ConstantPathNode # - # pkg:gem/prism#lib/prism/node.rb:5583 + # pkg:gem/prism#lib/prism/node.rb:5591 sig { returns(Prism::ConstantPathNode) } def target; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5610 + # pkg:gem/prism#lib/prism/node.rb:5618 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:5599 + # pkg:gem/prism#lib/prism/node.rb:5607 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5615 + # pkg:gem/prism#lib/prism/node.rb:5623 def type; end end end @@ -7948,13 +7936,13 @@ end # Parent::Child ||= value # ^^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5634 +# pkg:gem/prism#lib/prism/node.rb:5642 class Prism::ConstantPathOrWriteNode < ::Prism::Node # Initialize a new ConstantPathOrWriteNode node. # # @return [ConstantPathOrWriteNode] a new instance of ConstantPathOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5636 + # pkg:gem/prism#lib/prism/node.rb:5644 sig do params( source: Prism::Source, @@ -7971,36 +7959,36 @@ class Prism::ConstantPathOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5728 + # pkg:gem/prism#lib/prism/node.rb:5736 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5647 + # pkg:gem/prism#lib/prism/node.rb:5655 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5652 + # pkg:gem/prism#lib/prism/node.rb:5660 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5670 + # pkg:gem/prism#lib/prism/node.rb:5678 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5665 + # pkg:gem/prism#lib/prism/node.rb:5673 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5675 + # pkg:gem/prism#lib/prism/node.rb:5683 sig do params( node_id: Integer, @@ -8016,13 +8004,13 @@ class Prism::ConstantPathOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5680 + # pkg:gem/prism#lib/prism/node.rb:5688 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:5683 + # pkg:gem/prism#lib/prism/node.rb:5691 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -8030,7 +8018,7 @@ class Prism::ConstantPathOrWriteNode < ::Prism::Node # # @yield [target] # - # pkg:gem/prism#lib/prism/node.rb:5657 + # pkg:gem/prism#lib/prism/node.rb:5665 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -8038,50 +8026,50 @@ class Prism::ConstantPathOrWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5712 + # pkg:gem/prism#lib/prism/node.rb:5720 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:5707 + # pkg:gem/prism#lib/prism/node.rb:5715 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5691 + # pkg:gem/prism#lib/prism/node.rb:5699 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5699 + # pkg:gem/prism#lib/prism/node.rb:5707 def save_operator_loc(repository); end # attr_reader target: ConstantPathNode # - # pkg:gem/prism#lib/prism/node.rb:5688 + # pkg:gem/prism#lib/prism/node.rb:5696 sig { returns(Prism::ConstantPathNode) } def target; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5717 + # pkg:gem/prism#lib/prism/node.rb:5725 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:5704 + # pkg:gem/prism#lib/prism/node.rb:5712 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5722 + # pkg:gem/prism#lib/prism/node.rb:5730 def type; end end end @@ -8091,13 +8079,13 @@ end # Foo::Foo, Bar::Bar = baz # ^^^^^^^^ ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5740 +# pkg:gem/prism#lib/prism/node.rb:5748 class Prism::ConstantPathTargetNode < ::Prism::Node # Initialize a new ConstantPathTargetNode node. # # @return [ConstantPathTargetNode] a new instance of ConstantPathTargetNode # - # pkg:gem/prism#lib/prism/node.rb:5742 + # pkg:gem/prism#lib/prism/node.rb:5750 sig do params( source: Prism::Source, @@ -8115,12 +8103,12 @@ class Prism::ConstantPathTargetNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5849 + # pkg:gem/prism#lib/prism/node.rb:5857 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5754 + # pkg:gem/prism#lib/prism/node.rb:5762 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -8133,25 +8121,25 @@ class Prism::ConstantPathTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5759 + # pkg:gem/prism#lib/prism/node.rb:5767 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5778 + # pkg:gem/prism#lib/prism/node.rb:5786 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5771 + # pkg:gem/prism#lib/prism/node.rb:5779 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?parent: Prism::node?, ?name: Symbol?, ?delimiter_loc: Location, ?name_loc: Location) -> ConstantPathTargetNode # - # pkg:gem/prism#lib/prism/node.rb:5783 + # pkg:gem/prism#lib/prism/node.rb:5791 sig do params( node_id: Integer, @@ -8168,25 +8156,25 @@ class Prism::ConstantPathTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5788 + # pkg:gem/prism#lib/prism/node.rb:5796 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, parent: Prism::node?, name: Symbol?, delimiter_loc: Location, name_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:5791 + # pkg:gem/prism#lib/prism/node.rb:5799 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def delimiter: () -> String # - # pkg:gem/prism#lib/prism/node.rb:5828 + # pkg:gem/prism#lib/prism/node.rb:5836 sig { returns(String) } def delimiter; end # attr_reader delimiter_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5802 + # pkg:gem/prism#lib/prism/node.rb:5810 sig { returns(Prism::Location) } def delimiter_loc; end @@ -8194,7 +8182,7 @@ class Prism::ConstantPathTargetNode < ::Prism::Node # # @yield [parent] # - # pkg:gem/prism#lib/prism/node.rb:5764 + # pkg:gem/prism#lib/prism/node.rb:5772 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -8215,50 +8203,50 @@ class Prism::ConstantPathTargetNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5833 + # pkg:gem/prism#lib/prism/node.rb:5841 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol? # - # pkg:gem/prism#lib/prism/node.rb:5799 + # pkg:gem/prism#lib/prism/node.rb:5807 sig { returns(T.nilable(Symbol)) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:5815 + # pkg:gem/prism#lib/prism/node.rb:5823 sig { returns(Prism::Location) } def name_loc; end # attr_reader parent: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:5796 + # pkg:gem/prism#lib/prism/node.rb:5804 sig { returns(T.nilable(Prism::Node)) } def parent; end # Save the delimiter_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5810 + # pkg:gem/prism#lib/prism/node.rb:5818 def save_delimiter_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5823 + # pkg:gem/prism#lib/prism/node.rb:5831 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5838 + # pkg:gem/prism#lib/prism/node.rb:5846 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5843 + # pkg:gem/prism#lib/prism/node.rb:5851 def type; end end end @@ -8274,13 +8262,13 @@ end # ::Foo::Bar = 1 # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:5868 +# pkg:gem/prism#lib/prism/node.rb:5876 class Prism::ConstantPathWriteNode < ::Prism::Node # Initialize a new ConstantPathWriteNode node. # # @return [ConstantPathWriteNode] a new instance of ConstantPathWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5870 + # pkg:gem/prism#lib/prism/node.rb:5878 sig do params( source: Prism::Source, @@ -8297,36 +8285,36 @@ class Prism::ConstantPathWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:5974 + # pkg:gem/prism#lib/prism/node.rb:5982 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5881 + # pkg:gem/prism#lib/prism/node.rb:5889 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5886 + # pkg:gem/prism#lib/prism/node.rb:5894 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:5904 + # pkg:gem/prism#lib/prism/node.rb:5912 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:5899 + # pkg:gem/prism#lib/prism/node.rb:5907 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node) -> ConstantPathWriteNode # - # pkg:gem/prism#lib/prism/node.rb:5909 + # pkg:gem/prism#lib/prism/node.rb:5917 sig do params( node_id: Integer, @@ -8342,13 +8330,13 @@ class Prism::ConstantPathWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:5914 + # pkg:gem/prism#lib/prism/node.rb:5922 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, target: ConstantPathNode, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:5917 + # pkg:gem/prism#lib/prism/node.rb:5925 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -8356,7 +8344,7 @@ class Prism::ConstantPathWriteNode < ::Prism::Node # # @yield [target] # - # pkg:gem/prism#lib/prism/node.rb:5891 + # pkg:gem/prism#lib/prism/node.rb:5899 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -8364,13 +8352,13 @@ class Prism::ConstantPathWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:5958 + # pkg:gem/prism#lib/prism/node.rb:5966 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:5953 + # pkg:gem/prism#lib/prism/node.rb:5961 sig { returns(String) } def operator; end @@ -8379,14 +8367,14 @@ class Prism::ConstantPathWriteNode < ::Prism::Node # ::ABC = 123 # ^ # - # pkg:gem/prism#lib/prism/node.rb:5934 + # pkg:gem/prism#lib/prism/node.rb:5942 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:5942 + # pkg:gem/prism#lib/prism/node.rb:5950 def save_operator_loc(repository); end # A node representing the constant path being written to. @@ -8397,13 +8385,13 @@ class Prism::ConstantPathWriteNode < ::Prism::Node # ::Foo = :abc # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:5928 + # pkg:gem/prism#lib/prism/node.rb:5936 sig { returns(Prism::ConstantPathNode) } def target; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:5963 + # pkg:gem/prism#lib/prism/node.rb:5971 sig { override.returns(Symbol) } def type; end @@ -8412,14 +8400,14 @@ class Prism::ConstantPathWriteNode < ::Prism::Node # FOO::BAR = :abc # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:5950 + # pkg:gem/prism#lib/prism/node.rb:5958 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:5968 + # pkg:gem/prism#lib/prism/node.rb:5976 def type; end end end @@ -8429,49 +8417,49 @@ end # Foo # ^^^ # -# pkg:gem/prism#lib/prism/node.rb:5986 +# pkg:gem/prism#lib/prism/node.rb:5994 class Prism::ConstantReadNode < ::Prism::Node # Initialize a new ConstantReadNode node. # # @return [ConstantReadNode] a new instance of ConstantReadNode # - # pkg:gem/prism#lib/prism/node.rb:5988 + # pkg:gem/prism#lib/prism/node.rb:5996 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:6059 + # pkg:gem/prism#lib/prism/node.rb:6067 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:5997 + # pkg:gem/prism#lib/prism/node.rb:6005 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6002 + # pkg:gem/prism#lib/prism/node.rb:6010 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6018 + # pkg:gem/prism#lib/prism/node.rb:6026 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6013 + # pkg:gem/prism#lib/prism/node.rb:6021 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantReadNode # - # pkg:gem/prism#lib/prism/node.rb:6023 + # pkg:gem/prism#lib/prism/node.rb:6031 sig do params( node_id: Integer, @@ -8485,19 +8473,19 @@ class Prism::ConstantReadNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6028 + # pkg:gem/prism#lib/prism/node.rb:6036 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:6031 + # pkg:gem/prism#lib/prism/node.rb:6039 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:6007 + # pkg:gem/prism#lib/prism/node.rb:6015 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -8518,7 +8506,7 @@ class Prism::ConstantReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:6043 + # pkg:gem/prism#lib/prism/node.rb:6051 sig { override.returns(String) } def inspect; end @@ -8528,20 +8516,20 @@ class Prism::ConstantReadNode < ::Prism::Node # # SOME_CONSTANT # name `:SOME_CONSTANT` # - # pkg:gem/prism#lib/prism/node.rb:6040 + # pkg:gem/prism#lib/prism/node.rb:6048 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:6048 + # pkg:gem/prism#lib/prism/node.rb:6056 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:6053 + # pkg:gem/prism#lib/prism/node.rb:6061 def type; end end end @@ -8551,49 +8539,49 @@ end # Foo, Bar = baz # ^^^ ^^^ # -# pkg:gem/prism#lib/prism/node.rb:6069 +# pkg:gem/prism#lib/prism/node.rb:6077 class Prism::ConstantTargetNode < ::Prism::Node # Initialize a new ConstantTargetNode node. # # @return [ConstantTargetNode] a new instance of ConstantTargetNode # - # pkg:gem/prism#lib/prism/node.rb:6071 + # pkg:gem/prism#lib/prism/node.rb:6079 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:6138 + # pkg:gem/prism#lib/prism/node.rb:6146 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:6080 + # pkg:gem/prism#lib/prism/node.rb:6088 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6085 + # pkg:gem/prism#lib/prism/node.rb:6093 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6101 + # pkg:gem/prism#lib/prism/node.rb:6109 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6096 + # pkg:gem/prism#lib/prism/node.rb:6104 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> ConstantTargetNode # - # pkg:gem/prism#lib/prism/node.rb:6106 + # pkg:gem/prism#lib/prism/node.rb:6114 sig do params( node_id: Integer, @@ -8607,19 +8595,19 @@ class Prism::ConstantTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6111 + # pkg:gem/prism#lib/prism/node.rb:6119 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:6114 + # pkg:gem/prism#lib/prism/node.rb:6122 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:6090 + # pkg:gem/prism#lib/prism/node.rb:6098 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -8640,26 +8628,26 @@ class Prism::ConstantTargetNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:6122 + # pkg:gem/prism#lib/prism/node.rb:6130 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:6119 + # pkg:gem/prism#lib/prism/node.rb:6127 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:6127 + # pkg:gem/prism#lib/prism/node.rb:6135 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:6132 + # pkg:gem/prism#lib/prism/node.rb:6140 def type; end end end @@ -8669,13 +8657,13 @@ end # Foo = 1 # ^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:6148 +# pkg:gem/prism#lib/prism/node.rb:6156 class Prism::ConstantWriteNode < ::Prism::Node # Initialize a new ConstantWriteNode node. # # @return [ConstantWriteNode] a new instance of ConstantWriteNode # - # pkg:gem/prism#lib/prism/node.rb:6150 + # pkg:gem/prism#lib/prism/node.rb:6158 sig do params( source: Prism::Source, @@ -8693,36 +8681,36 @@ class Prism::ConstantWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:6271 + # pkg:gem/prism#lib/prism/node.rb:6279 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:6162 + # pkg:gem/prism#lib/prism/node.rb:6170 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6167 + # pkg:gem/prism#lib/prism/node.rb:6175 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6184 + # pkg:gem/prism#lib/prism/node.rb:6192 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6179 + # pkg:gem/prism#lib/prism/node.rb:6187 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> ConstantWriteNode # - # pkg:gem/prism#lib/prism/node.rb:6189 + # pkg:gem/prism#lib/prism/node.rb:6197 sig do params( node_id: Integer, @@ -8739,13 +8727,13 @@ class Prism::ConstantWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6194 + # pkg:gem/prism#lib/prism/node.rb:6202 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:6197 + # pkg:gem/prism#lib/prism/node.rb:6205 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -8753,7 +8741,7 @@ class Prism::ConstantWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:6172 + # pkg:gem/prism#lib/prism/node.rb:6180 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -8774,7 +8762,7 @@ class Prism::ConstantWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:6255 + # pkg:gem/prism#lib/prism/node.rb:6263 sig { override.returns(String) } def inspect; end @@ -8784,7 +8772,7 @@ class Prism::ConstantWriteNode < ::Prism::Node # # XYZ = 1 # name `:XYZ` # - # pkg:gem/prism#lib/prism/node.rb:6206 + # pkg:gem/prism#lib/prism/node.rb:6214 sig { returns(Symbol) } def name; end @@ -8793,13 +8781,13 @@ class Prism::ConstantWriteNode < ::Prism::Node # FOO = 1 # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:6212 + # pkg:gem/prism#lib/prism/node.rb:6220 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:6250 + # pkg:gem/prism#lib/prism/node.rb:6258 sig { returns(String) } def operator; end @@ -8808,25 +8796,25 @@ class Prism::ConstantWriteNode < ::Prism::Node # FOO = :bar # ^ # - # pkg:gem/prism#lib/prism/node.rb:6237 + # pkg:gem/prism#lib/prism/node.rb:6245 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6220 + # pkg:gem/prism#lib/prism/node.rb:6228 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6245 + # pkg:gem/prism#lib/prism/node.rb:6253 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:6260 + # pkg:gem/prism#lib/prism/node.rb:6268 sig { override.returns(Symbol) } def type; end @@ -8838,27 +8826,27 @@ class Prism::ConstantWriteNode < ::Prism::Node # MyClass = Class.new # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:6231 + # pkg:gem/prism#lib/prism/node.rb:6239 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:6265 + # pkg:gem/prism#lib/prism/node.rb:6273 def type; end end end # Raised when requested to parse as the currently running Ruby version but Prism has no support for it. # -# pkg:gem/prism#lib/prism.rb:41 +# pkg:gem/prism#lib/prism.rb:39 class Prism::CurrentVersionError < ::ArgumentError # Initialize a new exception for the given ruby version string. # # @return [CurrentVersionError] a new instance of CurrentVersionError # - # pkg:gem/prism#lib/prism.rb:43 + # pkg:gem/prism#lib/prism.rb:41 def initialize(version); end end @@ -11516,13 +11504,13 @@ end # end # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:6285 +# pkg:gem/prism#lib/prism/node.rb:6293 class Prism::DefNode < ::Prism::Node # Initialize a new DefNode node. # # @return [DefNode] a new instance of DefNode # - # pkg:gem/prism#lib/prism/node.rb:6287 + # pkg:gem/prism#lib/prism/node.rb:6295 sig do params( source: Prism::Source, @@ -11548,42 +11536,42 @@ class Prism::DefNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:6535 + # pkg:gem/prism#lib/prism/node.rb:6543 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:6307 + # pkg:gem/prism#lib/prism/node.rb:6315 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader body: StatementsNode | BeginNode | nil # - # pkg:gem/prism#lib/prism/node.rb:6375 + # pkg:gem/prism#lib/prism/node.rb:6383 sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6312 + # pkg:gem/prism#lib/prism/node.rb:6320 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6335 + # pkg:gem/prism#lib/prism/node.rb:6343 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6326 + # pkg:gem/prism#lib/prism/node.rb:6334 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: StatementsNode | BeginNode | nil, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode # - # pkg:gem/prism#lib/prism/node.rb:6340 + # pkg:gem/prism#lib/prism/node.rb:6348 sig do params( node_id: Integer, @@ -11608,25 +11596,25 @@ class Prism::DefNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6345 + # pkg:gem/prism#lib/prism/node.rb:6353 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: StatementsNode | BeginNode | nil, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:6348 + # pkg:gem/prism#lib/prism/node.rb:6356 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def def_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:6489 + # pkg:gem/prism#lib/prism/node.rb:6497 sig { returns(String) } def def_keyword; end # attr_reader def_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:6381 + # pkg:gem/prism#lib/prism/node.rb:6389 sig { returns(Prism::Location) } def def_keyword_loc; end @@ -11634,30 +11622,30 @@ class Prism::DefNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:6317 + # pkg:gem/prism#lib/prism/node.rb:6325 def each_child_node; end # def end_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6514 + # pkg:gem/prism#lib/prism/node.rb:6522 sig { returns(T.nilable(String)) } def end_keyword; end # attr_reader end_keyword_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6470 + # pkg:gem/prism#lib/prism/node.rb:6478 sig { returns(T.nilable(Prism::Location)) } def end_keyword_loc; end # def equal: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6509 + # pkg:gem/prism#lib/prism/node.rb:6517 sig { returns(T.nilable(String)) } def equal; end # attr_reader equal_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6451 + # pkg:gem/prism#lib/prism/node.rb:6459 sig { returns(T.nilable(Prism::Location)) } def equal_loc; end @@ -11666,128 +11654,128 @@ class Prism::DefNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:6519 + # pkg:gem/prism#lib/prism/node.rb:6527 sig { override.returns(String) } def inspect; end # attr_reader locals: Array[Symbol] # - # pkg:gem/prism#lib/prism/node.rb:6378 + # pkg:gem/prism#lib/prism/node.rb:6386 sig { returns(T::Array[Symbol]) } def locals; end # def lparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6499 + # pkg:gem/prism#lib/prism/node.rb:6507 sig { returns(T.nilable(String)) } def lparen; end # attr_reader lparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6413 + # pkg:gem/prism#lib/prism/node.rb:6421 sig { returns(T.nilable(Prism::Location)) } def lparen_loc; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:6353 + # pkg:gem/prism#lib/prism/node.rb:6361 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:6356 + # pkg:gem/prism#lib/prism/node.rb:6364 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6494 + # pkg:gem/prism#lib/prism/node.rb:6502 sig { returns(T.nilable(String)) } def operator; end # attr_reader operator_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6394 + # pkg:gem/prism#lib/prism/node.rb:6402 sig { returns(T.nilable(Prism::Location)) } def operator_loc; end # attr_reader parameters: ParametersNode? # - # pkg:gem/prism#lib/prism/node.rb:6372 + # pkg:gem/prism#lib/prism/node.rb:6380 sig { returns(T.nilable(Prism::ParametersNode)) } def parameters; end # attr_reader receiver: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:6369 + # pkg:gem/prism#lib/prism/node.rb:6377 sig { returns(T.nilable(Prism::Node)) } def receiver; end # def rparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6504 + # pkg:gem/prism#lib/prism/node.rb:6512 sig { returns(T.nilable(String)) } def rparen; end # attr_reader rparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6432 + # pkg:gem/prism#lib/prism/node.rb:6440 sig { returns(T.nilable(Prism::Location)) } def rparen_loc; end # Save the def_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6389 + # pkg:gem/prism#lib/prism/node.rb:6397 def save_def_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6484 + # pkg:gem/prism#lib/prism/node.rb:6492 def save_end_keyword_loc(repository); end # Save the equal_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6465 + # pkg:gem/prism#lib/prism/node.rb:6473 def save_equal_loc(repository); end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6427 + # pkg:gem/prism#lib/prism/node.rb:6435 def save_lparen_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6364 + # pkg:gem/prism#lib/prism/node.rb:6372 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6408 + # pkg:gem/prism#lib/prism/node.rb:6416 def save_operator_loc(repository); end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6446 + # pkg:gem/prism#lib/prism/node.rb:6454 def save_rparen_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:6524 + # pkg:gem/prism#lib/prism/node.rb:6532 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:6529 + # pkg:gem/prism#lib/prism/node.rb:6537 def type; end end end @@ -11797,13 +11785,13 @@ end # defined?(a) # ^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:6557 +# pkg:gem/prism#lib/prism/node.rb:6565 class Prism::DefinedNode < ::Prism::Node # Initialize a new DefinedNode node. # # @return [DefinedNode] a new instance of DefinedNode # - # pkg:gem/prism#lib/prism/node.rb:6559 + # pkg:gem/prism#lib/prism/node.rb:6567 sig do params( source: Prism::Source, @@ -11821,36 +11809,36 @@ class Prism::DefinedNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:6696 + # pkg:gem/prism#lib/prism/node.rb:6704 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:6571 + # pkg:gem/prism#lib/prism/node.rb:6579 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6576 + # pkg:gem/prism#lib/prism/node.rb:6584 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6593 + # pkg:gem/prism#lib/prism/node.rb:6601 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6588 + # pkg:gem/prism#lib/prism/node.rb:6596 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lparen_loc: Location?, ?value: Prism::node, ?rparen_loc: Location?, ?keyword_loc: Location) -> DefinedNode # - # pkg:gem/prism#lib/prism/node.rb:6598 + # pkg:gem/prism#lib/prism/node.rb:6606 sig do params( node_id: Integer, @@ -11867,13 +11855,13 @@ class Prism::DefinedNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6603 + # pkg:gem/prism#lib/prism/node.rb:6611 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lparen_loc: Location?, value: Prism::node, rparen_loc: Location?, keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:6606 + # pkg:gem/prism#lib/prism/node.rb:6614 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -11881,7 +11869,7 @@ class Prism::DefinedNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:6581 + # pkg:gem/prism#lib/prism/node.rb:6589 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -11889,80 +11877,80 @@ class Prism::DefinedNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:6680 + # pkg:gem/prism#lib/prism/node.rb:6688 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:6675 + # pkg:gem/prism#lib/prism/node.rb:6683 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:6652 + # pkg:gem/prism#lib/prism/node.rb:6660 sig { returns(Prism::Location) } def keyword_loc; end # def lparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6665 + # pkg:gem/prism#lib/prism/node.rb:6673 sig { returns(T.nilable(String)) } def lparen; end # attr_reader lparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6611 + # pkg:gem/prism#lib/prism/node.rb:6619 sig { returns(T.nilable(Prism::Location)) } def lparen_loc; end # def rparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6670 + # pkg:gem/prism#lib/prism/node.rb:6678 sig { returns(T.nilable(String)) } def rparen; end # attr_reader rparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6633 + # pkg:gem/prism#lib/prism/node.rb:6641 sig { returns(T.nilable(Prism::Location)) } def rparen_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6660 + # pkg:gem/prism#lib/prism/node.rb:6668 def save_keyword_loc(repository); end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6625 + # pkg:gem/prism#lib/prism/node.rb:6633 def save_lparen_loc(repository); end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6647 + # pkg:gem/prism#lib/prism/node.rb:6655 def save_rparen_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:6685 + # pkg:gem/prism#lib/prism/node.rb:6693 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:6630 + # pkg:gem/prism#lib/prism/node.rb:6638 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:6690 + # pkg:gem/prism#lib/prism/node.rb:6698 def type; end end end @@ -14983,13 +14971,13 @@ end # if a then b else c end # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:6709 +# pkg:gem/prism#lib/prism/node.rb:6717 class Prism::ElseNode < ::Prism::Node # Initialize a new ElseNode node. # # @return [ElseNode] a new instance of ElseNode # - # pkg:gem/prism#lib/prism/node.rb:6711 + # pkg:gem/prism#lib/prism/node.rb:6719 sig do params( source: Prism::Source, @@ -15006,36 +14994,36 @@ class Prism::ElseNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:6825 + # pkg:gem/prism#lib/prism/node.rb:6833 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:6722 + # pkg:gem/prism#lib/prism/node.rb:6730 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6727 + # pkg:gem/prism#lib/prism/node.rb:6735 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6746 + # pkg:gem/prism#lib/prism/node.rb:6754 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6739 + # pkg:gem/prism#lib/prism/node.rb:6747 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?else_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location?) -> ElseNode # - # pkg:gem/prism#lib/prism/node.rb:6751 + # pkg:gem/prism#lib/prism/node.rb:6759 sig do params( node_id: Integer, @@ -15051,13 +15039,13 @@ class Prism::ElseNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6756 + # pkg:gem/prism#lib/prism/node.rb:6764 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:6759 + # pkg:gem/prism#lib/prism/node.rb:6767 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -15065,30 +15053,30 @@ class Prism::ElseNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:6732 + # pkg:gem/prism#lib/prism/node.rb:6740 def each_child_node; end # def else_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:6799 + # pkg:gem/prism#lib/prism/node.rb:6807 sig { returns(String) } def else_keyword; end # attr_reader else_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:6764 + # pkg:gem/prism#lib/prism/node.rb:6772 sig { returns(Prism::Location) } def else_keyword_loc; end # def end_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:6804 + # pkg:gem/prism#lib/prism/node.rb:6812 sig { returns(T.nilable(String)) } def end_keyword; end # attr_reader end_keyword_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:6780 + # pkg:gem/prism#lib/prism/node.rb:6788 sig { returns(T.nilable(Prism::Location)) } def end_keyword_loc; end @@ -15097,38 +15085,38 @@ class Prism::ElseNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:6809 + # pkg:gem/prism#lib/prism/node.rb:6817 sig { override.returns(String) } def inspect; end # Save the else_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6772 + # pkg:gem/prism#lib/prism/node.rb:6780 def save_else_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6794 + # pkg:gem/prism#lib/prism/node.rb:6802 def save_end_keyword_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:6777 + # pkg:gem/prism#lib/prism/node.rb:6785 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:6814 + # pkg:gem/prism#lib/prism/node.rb:6822 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:6819 + # pkg:gem/prism#lib/prism/node.rb:6827 def type; end end end @@ -15136,11 +15124,11 @@ end # EmbDocComment objects correspond to comments that are surrounded by =begin # and =end. # -# pkg:gem/prism#lib/prism/parse_result.rb:549 +# pkg:gem/prism#lib/prism/parse_result.rb:558 class Prism::EmbDocComment < ::Prism::Comment # Returns a string representation of this comment. # - # pkg:gem/prism#lib/prism/parse_result.rb:556 + # pkg:gem/prism#lib/prism/parse_result.rb:565 sig { returns(String) } def inspect; end @@ -15148,7 +15136,7 @@ class Prism::EmbDocComment < ::Prism::Comment # # @return [Boolean] # - # pkg:gem/prism#lib/prism/parse_result.rb:551 + # pkg:gem/prism#lib/prism/parse_result.rb:560 sig { override.returns(T::Boolean) } def trailing?; end end @@ -15158,13 +15146,13 @@ end # "foo #{bar}" # ^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:6837 +# pkg:gem/prism#lib/prism/node.rb:6845 class Prism::EmbeddedStatementsNode < ::Prism::Node # Initialize a new EmbeddedStatementsNode node. # # @return [EmbeddedStatementsNode] a new instance of EmbeddedStatementsNode # - # pkg:gem/prism#lib/prism/node.rb:6839 + # pkg:gem/prism#lib/prism/node.rb:6847 sig do params( source: Prism::Source, @@ -15181,48 +15169,48 @@ class Prism::EmbeddedStatementsNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:6947 + # pkg:gem/prism#lib/prism/node.rb:6955 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:6850 + # pkg:gem/prism#lib/prism/node.rb:6858 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6855 + # pkg:gem/prism#lib/prism/node.rb:6863 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:6926 + # pkg:gem/prism#lib/prism/node.rb:6934 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:6908 + # pkg:gem/prism#lib/prism/node.rb:6916 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6874 + # pkg:gem/prism#lib/prism/node.rb:6882 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6867 + # pkg:gem/prism#lib/prism/node.rb:6875 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?statements: StatementsNode?, ?closing_loc: Location) -> EmbeddedStatementsNode # - # pkg:gem/prism#lib/prism/node.rb:6879 + # pkg:gem/prism#lib/prism/node.rb:6887 sig do params( node_id: Integer, @@ -15238,13 +15226,13 @@ class Prism::EmbeddedStatementsNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6884 + # pkg:gem/prism#lib/prism/node.rb:6892 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, statements: StatementsNode?, closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:6887 + # pkg:gem/prism#lib/prism/node.rb:6895 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -15252,7 +15240,7 @@ class Prism::EmbeddedStatementsNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:6860 + # pkg:gem/prism#lib/prism/node.rb:6868 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -15260,50 +15248,50 @@ class Prism::EmbeddedStatementsNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:6931 + # pkg:gem/prism#lib/prism/node.rb:6939 sig { override.returns(String) } def inspect; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:6921 + # pkg:gem/prism#lib/prism/node.rb:6929 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:6892 + # pkg:gem/prism#lib/prism/node.rb:6900 sig { returns(Prism::Location) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6916 + # pkg:gem/prism#lib/prism/node.rb:6924 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:6900 + # pkg:gem/prism#lib/prism/node.rb:6908 def save_opening_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:6905 + # pkg:gem/prism#lib/prism/node.rb:6913 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:6936 + # pkg:gem/prism#lib/prism/node.rb:6944 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:6941 + # pkg:gem/prism#lib/prism/node.rb:6949 def type; end end end @@ -15313,13 +15301,13 @@ end # "foo #@bar" # ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:6959 +# pkg:gem/prism#lib/prism/node.rb:6967 class Prism::EmbeddedVariableNode < ::Prism::Node # Initialize a new EmbeddedVariableNode node. # # @return [EmbeddedVariableNode] a new instance of EmbeddedVariableNode # - # pkg:gem/prism#lib/prism/node.rb:6961 + # pkg:gem/prism#lib/prism/node.rb:6969 sig do params( source: Prism::Source, @@ -15335,36 +15323,36 @@ class Prism::EmbeddedVariableNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7048 + # pkg:gem/prism#lib/prism/node.rb:7056 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:6971 + # pkg:gem/prism#lib/prism/node.rb:6979 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:6976 + # pkg:gem/prism#lib/prism/node.rb:6984 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:6993 + # pkg:gem/prism#lib/prism/node.rb:7001 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:6988 + # pkg:gem/prism#lib/prism/node.rb:6996 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode) -> EmbeddedVariableNode # - # pkg:gem/prism#lib/prism/node.rb:6998 + # pkg:gem/prism#lib/prism/node.rb:7006 sig do params( node_id: Integer, @@ -15379,13 +15367,13 @@ class Prism::EmbeddedVariableNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7003 + # pkg:gem/prism#lib/prism/node.rb:7011 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode } # - # pkg:gem/prism#lib/prism/node.rb:7006 + # pkg:gem/prism#lib/prism/node.rb:7014 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -15393,7 +15381,7 @@ class Prism::EmbeddedVariableNode < ::Prism::Node # # @yield [variable] # - # pkg:gem/prism#lib/prism/node.rb:6981 + # pkg:gem/prism#lib/prism/node.rb:6989 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -15401,37 +15389,37 @@ class Prism::EmbeddedVariableNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7032 + # pkg:gem/prism#lib/prism/node.rb:7040 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:7027 + # pkg:gem/prism#lib/prism/node.rb:7035 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:7011 + # pkg:gem/prism#lib/prism/node.rb:7019 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7019 + # pkg:gem/prism#lib/prism/node.rb:7027 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7037 + # pkg:gem/prism#lib/prism/node.rb:7045 sig { override.returns(Symbol) } def type; end # attr_reader variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode # - # pkg:gem/prism#lib/prism/node.rb:7024 + # pkg:gem/prism#lib/prism/node.rb:7032 sig do returns(T.any(Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)) end @@ -15440,24 +15428,24 @@ class Prism::EmbeddedVariableNode < ::Prism::Node class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7042 + # pkg:gem/prism#lib/prism/node.rb:7050 def type; end end end # Flags for nodes that have unescaped content. # -# pkg:gem/prism#lib/prism/node.rb:19811 +# pkg:gem/prism#lib/prism/node.rb:19819 module Prism::EncodingFlags; end # internal bytes forced the encoding to binary # -# pkg:gem/prism#lib/prism/node.rb:19816 +# pkg:gem/prism#lib/prism/node.rb:19824 Prism::EncodingFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) # internal bytes forced the encoding to UTF-8 # -# pkg:gem/prism#lib/prism/node.rb:19813 +# pkg:gem/prism#lib/prism/node.rb:19821 Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) # Represents an `ensure` clause in a `begin` statement. @@ -15469,13 +15457,13 @@ Prism::EncodingFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) # bar # end # -# pkg:gem/prism#lib/prism/node.rb:7063 +# pkg:gem/prism#lib/prism/node.rb:7071 class Prism::EnsureNode < ::Prism::Node # Initialize a new EnsureNode node. # # @return [EnsureNode] a new instance of EnsureNode # - # pkg:gem/prism#lib/prism/node.rb:7065 + # pkg:gem/prism#lib/prism/node.rb:7073 sig do params( source: Prism::Source, @@ -15492,36 +15480,36 @@ class Prism::EnsureNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7173 + # pkg:gem/prism#lib/prism/node.rb:7181 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7076 + # pkg:gem/prism#lib/prism/node.rb:7084 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7081 + # pkg:gem/prism#lib/prism/node.rb:7089 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7100 + # pkg:gem/prism#lib/prism/node.rb:7108 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7093 + # pkg:gem/prism#lib/prism/node.rb:7101 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?ensure_keyword_loc: Location, ?statements: StatementsNode?, ?end_keyword_loc: Location) -> EnsureNode # - # pkg:gem/prism#lib/prism/node.rb:7105 + # pkg:gem/prism#lib/prism/node.rb:7113 sig do params( node_id: Integer, @@ -15537,13 +15525,13 @@ class Prism::EnsureNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7110 + # pkg:gem/prism#lib/prism/node.rb:7118 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:7113 + # pkg:gem/prism#lib/prism/node.rb:7121 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -15551,30 +15539,30 @@ class Prism::EnsureNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:7086 + # pkg:gem/prism#lib/prism/node.rb:7094 def each_child_node; end # def end_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:7152 + # pkg:gem/prism#lib/prism/node.rb:7160 sig { returns(String) } def end_keyword; end # attr_reader end_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:7134 + # pkg:gem/prism#lib/prism/node.rb:7142 sig { returns(Prism::Location) } def end_keyword_loc; end # def ensure_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:7147 + # pkg:gem/prism#lib/prism/node.rb:7155 sig { returns(String) } def ensure_keyword; end # attr_reader ensure_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:7118 + # pkg:gem/prism#lib/prism/node.rb:7126 sig { returns(Prism::Location) } def ensure_keyword_loc; end @@ -15583,38 +15571,38 @@ class Prism::EnsureNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7157 + # pkg:gem/prism#lib/prism/node.rb:7165 sig { override.returns(String) } def inspect; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7142 + # pkg:gem/prism#lib/prism/node.rb:7150 def save_end_keyword_loc(repository); end # Save the ensure_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7126 + # pkg:gem/prism#lib/prism/node.rb:7134 def save_ensure_keyword_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:7131 + # pkg:gem/prism#lib/prism/node.rb:7139 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7162 + # pkg:gem/prism#lib/prism/node.rb:7170 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7167 + # pkg:gem/prism#lib/prism/node.rb:7175 def type; end end end @@ -15624,68 +15612,68 @@ end # false # ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:7185 +# pkg:gem/prism#lib/prism/node.rb:7193 class Prism::FalseNode < ::Prism::Node # Initialize a new FalseNode node. # # @return [FalseNode] a new instance of FalseNode # - # pkg:gem/prism#lib/prism/node.rb:7187 + # pkg:gem/prism#lib/prism/node.rb:7195 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7250 + # pkg:gem/prism#lib/prism/node.rb:7258 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7195 + # pkg:gem/prism#lib/prism/node.rb:7203 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7200 + # pkg:gem/prism#lib/prism/node.rb:7208 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7216 + # pkg:gem/prism#lib/prism/node.rb:7224 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7211 + # pkg:gem/prism#lib/prism/node.rb:7219 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> FalseNode # - # pkg:gem/prism#lib/prism/node.rb:7221 + # pkg:gem/prism#lib/prism/node.rb:7229 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::FalseNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7226 + # pkg:gem/prism#lib/prism/node.rb:7234 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:7229 + # pkg:gem/prism#lib/prism/node.rb:7237 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:7205 + # pkg:gem/prism#lib/prism/node.rb:7213 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -15693,20 +15681,20 @@ class Prism::FalseNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7234 + # pkg:gem/prism#lib/prism/node.rb:7242 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7239 + # pkg:gem/prism#lib/prism/node.rb:7247 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7244 + # pkg:gem/prism#lib/prism/node.rb:7252 def type; end end end @@ -15725,13 +15713,13 @@ end # foo => *bar, baz, *qux # ^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:7268 +# pkg:gem/prism#lib/prism/node.rb:7276 class Prism::FindPatternNode < ::Prism::Node # Initialize a new FindPatternNode node. # # @return [FindPatternNode] a new instance of FindPatternNode # - # pkg:gem/prism#lib/prism/node.rb:7270 + # pkg:gem/prism#lib/prism/node.rb:7278 sig do params( source: Prism::Source, @@ -15751,24 +15739,24 @@ class Prism::FindPatternNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7441 + # pkg:gem/prism#lib/prism/node.rb:7449 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7284 + # pkg:gem/prism#lib/prism/node.rb:7292 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7289 + # pkg:gem/prism#lib/prism/node.rb:7297 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:7420 + # pkg:gem/prism#lib/prism/node.rb:7428 sig { returns(T.nilable(String)) } def closing; end @@ -15780,19 +15768,19 @@ class Prism::FindPatternNode < ::Prism::Node # foo in Foo(*bar, baz, *qux) # ^ # - # pkg:gem/prism#lib/prism/node.rb:7396 + # pkg:gem/prism#lib/prism/node.rb:7404 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7314 + # pkg:gem/prism#lib/prism/node.rb:7322 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7304 + # pkg:gem/prism#lib/prism/node.rb:7312 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -15801,13 +15789,13 @@ class Prism::FindPatternNode < ::Prism::Node # foo in Foo(*bar, baz, *qux) # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:7335 + # pkg:gem/prism#lib/prism/node.rb:7343 sig { returns(T.nilable(T.any(Prism::ConstantPathNode, Prism::ConstantReadNode))) } def constant; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode # - # pkg:gem/prism#lib/prism/node.rb:7319 + # pkg:gem/prism#lib/prism/node.rb:7327 sig do params( node_id: Integer, @@ -15826,13 +15814,13 @@ class Prism::FindPatternNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7324 + # pkg:gem/prism#lib/prism/node.rb:7332 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:7327 + # pkg:gem/prism#lib/prism/node.rb:7335 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -15840,7 +15828,7 @@ class Prism::FindPatternNode < ::Prism::Node # # @yield [constant] # - # pkg:gem/prism#lib/prism/node.rb:7294 + # pkg:gem/prism#lib/prism/node.rb:7302 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -15848,7 +15836,7 @@ class Prism::FindPatternNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7425 + # pkg:gem/prism#lib/prism/node.rb:7433 sig { override.returns(String) } def inspect; end @@ -15860,13 +15848,13 @@ class Prism::FindPatternNode < ::Prism::Node # foo in Foo(*bar, baz, *qux) # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:7344 + # pkg:gem/prism#lib/prism/node.rb:7352 sig { returns(Prism::SplatNode) } def left; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:7415 + # pkg:gem/prism#lib/prism/node.rb:7423 sig { returns(T.nilable(String)) } def opening; end @@ -15878,7 +15866,7 @@ class Prism::FindPatternNode < ::Prism::Node # foo in Foo(*bar, baz, *qux) # ^ # - # pkg:gem/prism#lib/prism/node.rb:7371 + # pkg:gem/prism#lib/prism/node.rb:7379 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end @@ -15890,7 +15878,7 @@ class Prism::FindPatternNode < ::Prism::Node # foo in Foo(*bar, baz, 1, *qux) # ^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:7353 + # pkg:gem/prism#lib/prism/node.rb:7361 sig { returns(T::Array[Prism::Node]) } def requireds; end @@ -15902,32 +15890,32 @@ class Prism::FindPatternNode < ::Prism::Node # foo in Foo(*bar, baz, *qux) # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:7362 + # pkg:gem/prism#lib/prism/node.rb:7370 sig { returns(T.any(Prism::SplatNode, Prism::MissingNode)) } def right; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7410 + # pkg:gem/prism#lib/prism/node.rb:7418 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7385 + # pkg:gem/prism#lib/prism/node.rb:7393 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7430 + # pkg:gem/prism#lib/prism/node.rb:7438 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7435 + # pkg:gem/prism#lib/prism/node.rb:7443 def type; end end end @@ -15937,13 +15925,13 @@ end # baz if foo .. bar # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:7457 +# pkg:gem/prism#lib/prism/node.rb:7465 class Prism::FlipFlopNode < ::Prism::Node # Initialize a new FlipFlopNode node. # # @return [FlipFlopNode] a new instance of FlipFlopNode # - # pkg:gem/prism#lib/prism/node.rb:7459 + # pkg:gem/prism#lib/prism/node.rb:7467 sig do params( source: Prism::Source, @@ -15960,36 +15948,36 @@ class Prism::FlipFlopNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7559 + # pkg:gem/prism#lib/prism/node.rb:7567 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7470 + # pkg:gem/prism#lib/prism/node.rb:7478 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7475 + # pkg:gem/prism#lib/prism/node.rb:7483 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7496 + # pkg:gem/prism#lib/prism/node.rb:7504 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7488 + # pkg:gem/prism#lib/prism/node.rb:7496 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> FlipFlopNode # - # pkg:gem/prism#lib/prism/node.rb:7501 + # pkg:gem/prism#lib/prism/node.rb:7509 sig do params( node_id: Integer, @@ -16005,13 +15993,13 @@ class Prism::FlipFlopNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7506 + # pkg:gem/prism#lib/prism/node.rb:7514 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:7509 + # pkg:gem/prism#lib/prism/node.rb:7517 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -16019,14 +16007,14 @@ class Prism::FlipFlopNode < ::Prism::Node # # @yield [left] # - # pkg:gem/prism#lib/prism/node.rb:7480 + # pkg:gem/prism#lib/prism/node.rb:7488 def each_child_node; end # def exclude_end?: () -> bool # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:7514 + # pkg:gem/prism#lib/prism/node.rb:7522 sig { returns(T::Boolean) } def exclude_end?; end @@ -16035,50 +16023,50 @@ class Prism::FlipFlopNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7543 + # pkg:gem/prism#lib/prism/node.rb:7551 sig { override.returns(String) } def inspect; end # attr_reader left: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:7519 + # pkg:gem/prism#lib/prism/node.rb:7527 sig { returns(T.nilable(Prism::Node)) } def left; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:7538 + # pkg:gem/prism#lib/prism/node.rb:7546 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:7525 + # pkg:gem/prism#lib/prism/node.rb:7533 sig { returns(Prism::Location) } def operator_loc; end # attr_reader right: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:7522 + # pkg:gem/prism#lib/prism/node.rb:7530 sig { returns(T.nilable(Prism::Node)) } def right; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7533 + # pkg:gem/prism#lib/prism/node.rb:7541 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7548 + # pkg:gem/prism#lib/prism/node.rb:7556 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7553 + # pkg:gem/prism#lib/prism/node.rb:7561 def type; end end end @@ -16088,68 +16076,68 @@ end # 1.0 # ^^^ # -# pkg:gem/prism#lib/prism/node.rb:7572 +# pkg:gem/prism#lib/prism/node.rb:7580 class Prism::FloatNode < ::Prism::Node # Initialize a new FloatNode node. # # @return [FloatNode] a new instance of FloatNode # - # pkg:gem/prism#lib/prism/node.rb:7574 + # pkg:gem/prism#lib/prism/node.rb:7582 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, value: Float).void } def initialize(source, node_id, location, flags, value); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7641 + # pkg:gem/prism#lib/prism/node.rb:7649 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7583 + # pkg:gem/prism#lib/prism/node.rb:7591 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7588 + # pkg:gem/prism#lib/prism/node.rb:7596 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7604 + # pkg:gem/prism#lib/prism/node.rb:7612 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7599 + # pkg:gem/prism#lib/prism/node.rb:7607 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Float) -> FloatNode # - # pkg:gem/prism#lib/prism/node.rb:7609 + # pkg:gem/prism#lib/prism/node.rb:7617 sig { params(node_id: Integer, location: Prism::Location, flags: Integer, value: Float).returns(Prism::FloatNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil), value: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7614 + # pkg:gem/prism#lib/prism/node.rb:7622 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Float } # - # pkg:gem/prism#lib/prism/node.rb:7617 + # pkg:gem/prism#lib/prism/node.rb:7625 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:7593 + # pkg:gem/prism#lib/prism/node.rb:7601 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -16157,26 +16145,26 @@ class Prism::FloatNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7625 + # pkg:gem/prism#lib/prism/node.rb:7633 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7630 + # pkg:gem/prism#lib/prism/node.rb:7638 sig { override.returns(Symbol) } def type; end # The value of the floating point number as a Float. # - # pkg:gem/prism#lib/prism/node.rb:7622 + # pkg:gem/prism#lib/prism/node.rb:7630 sig { returns(Float) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7635 + # pkg:gem/prism#lib/prism/node.rb:7643 def type; end end end @@ -16186,13 +16174,13 @@ end # for i in a end # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:7651 +# pkg:gem/prism#lib/prism/node.rb:7659 class Prism::ForNode < ::Prism::Node # Initialize a new ForNode node. # # @return [ForNode] a new instance of ForNode # - # pkg:gem/prism#lib/prism/node.rb:7653 + # pkg:gem/prism#lib/prism/node.rb:7661 sig do params( source: Prism::Source, @@ -16213,18 +16201,18 @@ class Prism::ForNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7840 + # pkg:gem/prism#lib/prism/node.rb:7848 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7668 + # pkg:gem/prism#lib/prism/node.rb:7676 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7673 + # pkg:gem/prism#lib/prism/node.rb:7681 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -16233,25 +16221,25 @@ class Prism::ForNode < ::Prism::Node # for i in a end # ^ # - # pkg:gem/prism#lib/prism/node.rb:7723 + # pkg:gem/prism#lib/prism/node.rb:7731 sig { returns(Prism::Node) } def collection; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7696 + # pkg:gem/prism#lib/prism/node.rb:7704 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7687 + # pkg:gem/prism#lib/prism/node.rb:7695 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode # - # pkg:gem/prism#lib/prism/node.rb:7701 + # pkg:gem/prism#lib/prism/node.rb:7709 sig do params( node_id: Integer, @@ -16271,19 +16259,19 @@ class Prism::ForNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7706 + # pkg:gem/prism#lib/prism/node.rb:7714 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:7709 + # pkg:gem/prism#lib/prism/node.rb:7717 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def do_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:7814 + # pkg:gem/prism#lib/prism/node.rb:7822 sig { returns(T.nilable(String)) } def do_keyword; end @@ -16292,7 +16280,7 @@ class Prism::ForNode < ::Prism::Node # for i in a do end # ^^ # - # pkg:gem/prism#lib/prism/node.rb:7769 + # pkg:gem/prism#lib/prism/node.rb:7777 sig { returns(T.nilable(Prism::Location)) } def do_keyword_loc; end @@ -16300,12 +16288,12 @@ class Prism::ForNode < ::Prism::Node # # @yield [index] # - # pkg:gem/prism#lib/prism/node.rb:7678 + # pkg:gem/prism#lib/prism/node.rb:7686 def each_child_node; end # def end_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:7819 + # pkg:gem/prism#lib/prism/node.rb:7827 sig { returns(String) } def end_keyword; end @@ -16314,7 +16302,7 @@ class Prism::ForNode < ::Prism::Node # for i in a end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:7791 + # pkg:gem/prism#lib/prism/node.rb:7799 sig { returns(Prism::Location) } def end_keyword_loc; end @@ -16323,7 +16311,7 @@ class Prism::ForNode < ::Prism::Node # def for_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:7804 + # pkg:gem/prism#lib/prism/node.rb:7812 sig { returns(String) } def for_keyword; end @@ -16332,13 +16320,13 @@ class Prism::ForNode < ::Prism::Node # for i in a end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:7737 + # pkg:gem/prism#lib/prism/node.rb:7745 sig { returns(Prism::Location) } def for_keyword_loc; end # def in_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:7809 + # pkg:gem/prism#lib/prism/node.rb:7817 sig { returns(String) } def in_keyword; end @@ -16347,7 +16335,7 @@ class Prism::ForNode < ::Prism::Node # for i in a end # ^^ # - # pkg:gem/prism#lib/prism/node.rb:7753 + # pkg:gem/prism#lib/prism/node.rb:7761 sig { returns(Prism::Location) } def in_keyword_loc; end @@ -16356,7 +16344,7 @@ class Prism::ForNode < ::Prism::Node # for i in a end # ^ # - # pkg:gem/prism#lib/prism/node.rb:7717 + # pkg:gem/prism#lib/prism/node.rb:7725 sig do returns(T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode)) end @@ -16364,32 +16352,32 @@ class Prism::ForNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7824 + # pkg:gem/prism#lib/prism/node.rb:7832 sig { override.returns(String) } def inspect; end # Save the do_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7783 + # pkg:gem/prism#lib/prism/node.rb:7791 def save_do_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7799 + # pkg:gem/prism#lib/prism/node.rb:7807 def save_end_keyword_loc(repository); end # Save the for_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7745 + # pkg:gem/prism#lib/prism/node.rb:7753 def save_for_keyword_loc(repository); end # Save the in_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:7761 + # pkg:gem/prism#lib/prism/node.rb:7769 def save_in_keyword_loc(repository); end # Represents the body of statements to execute for each iteration of the loop. @@ -16399,20 +16387,20 @@ class Prism::ForNode < ::Prism::Node # ^^^^^^ # end # - # pkg:gem/prism#lib/prism/node.rb:7731 + # pkg:gem/prism#lib/prism/node.rb:7739 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7829 + # pkg:gem/prism#lib/prism/node.rb:7837 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7834 + # pkg:gem/prism#lib/prism/node.rb:7842 def type; end end end @@ -16424,68 +16412,68 @@ end # ^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:7858 +# pkg:gem/prism#lib/prism/node.rb:7866 class Prism::ForwardingArgumentsNode < ::Prism::Node # Initialize a new ForwardingArgumentsNode node. # # @return [ForwardingArgumentsNode] a new instance of ForwardingArgumentsNode # - # pkg:gem/prism#lib/prism/node.rb:7860 + # pkg:gem/prism#lib/prism/node.rb:7868 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7923 + # pkg:gem/prism#lib/prism/node.rb:7931 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7868 + # pkg:gem/prism#lib/prism/node.rb:7876 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7873 + # pkg:gem/prism#lib/prism/node.rb:7881 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7889 + # pkg:gem/prism#lib/prism/node.rb:7897 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7884 + # pkg:gem/prism#lib/prism/node.rb:7892 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingArgumentsNode # - # pkg:gem/prism#lib/prism/node.rb:7894 + # pkg:gem/prism#lib/prism/node.rb:7902 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ForwardingArgumentsNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7899 + # pkg:gem/prism#lib/prism/node.rb:7907 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:7902 + # pkg:gem/prism#lib/prism/node.rb:7910 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:7878 + # pkg:gem/prism#lib/prism/node.rb:7886 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -16493,20 +16481,20 @@ class Prism::ForwardingArgumentsNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7907 + # pkg:gem/prism#lib/prism/node.rb:7915 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7912 + # pkg:gem/prism#lib/prism/node.rb:7920 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7917 + # pkg:gem/prism#lib/prism/node.rb:7925 def type; end end end @@ -16517,68 +16505,68 @@ end # ^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:7933 +# pkg:gem/prism#lib/prism/node.rb:7941 class Prism::ForwardingParameterNode < ::Prism::Node # Initialize a new ForwardingParameterNode node. # # @return [ForwardingParameterNode] a new instance of ForwardingParameterNode # - # pkg:gem/prism#lib/prism/node.rb:7935 + # pkg:gem/prism#lib/prism/node.rb:7943 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:7998 + # pkg:gem/prism#lib/prism/node.rb:8006 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:7943 + # pkg:gem/prism#lib/prism/node.rb:7951 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7948 + # pkg:gem/prism#lib/prism/node.rb:7956 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:7964 + # pkg:gem/prism#lib/prism/node.rb:7972 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:7959 + # pkg:gem/prism#lib/prism/node.rb:7967 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ForwardingParameterNode # - # pkg:gem/prism#lib/prism/node.rb:7969 + # pkg:gem/prism#lib/prism/node.rb:7977 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ForwardingParameterNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:7974 + # pkg:gem/prism#lib/prism/node.rb:7982 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:7977 + # pkg:gem/prism#lib/prism/node.rb:7985 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:7953 + # pkg:gem/prism#lib/prism/node.rb:7961 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -16586,20 +16574,20 @@ class Prism::ForwardingParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:7982 + # pkg:gem/prism#lib/prism/node.rb:7990 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:7987 + # pkg:gem/prism#lib/prism/node.rb:7995 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:7992 + # pkg:gem/prism#lib/prism/node.rb:8000 def type; end end end @@ -16614,13 +16602,13 @@ end # # If it has any other arguments, it would be a `SuperNode` instead. # -# pkg:gem/prism#lib/prism/node.rb:8012 +# pkg:gem/prism#lib/prism/node.rb:8020 class Prism::ForwardingSuperNode < ::Prism::Node # Initialize a new ForwardingSuperNode node. # # @return [ForwardingSuperNode] a new instance of ForwardingSuperNode # - # pkg:gem/prism#lib/prism/node.rb:8014 + # pkg:gem/prism#lib/prism/node.rb:8022 sig do params( source: Prism::Source, @@ -16635,42 +16623,42 @@ class Prism::ForwardingSuperNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8084 + # pkg:gem/prism#lib/prism/node.rb:8092 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8023 + # pkg:gem/prism#lib/prism/node.rb:8031 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # All other arguments are forwarded as normal, except the original block is replaced with the new block. # - # pkg:gem/prism#lib/prism/node.rb:8065 + # pkg:gem/prism#lib/prism/node.rb:8073 sig { returns(T.nilable(Prism::BlockNode)) } def block; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8028 + # pkg:gem/prism#lib/prism/node.rb:8036 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8047 + # pkg:gem/prism#lib/prism/node.rb:8055 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8040 + # pkg:gem/prism#lib/prism/node.rb:8048 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?block: BlockNode?) -> ForwardingSuperNode # - # pkg:gem/prism#lib/prism/node.rb:8052 + # pkg:gem/prism#lib/prism/node.rb:8060 sig do params( node_id: Integer, @@ -16684,13 +16672,13 @@ class Prism::ForwardingSuperNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8057 + # pkg:gem/prism#lib/prism/node.rb:8065 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, block: BlockNode? } # - # pkg:gem/prism#lib/prism/node.rb:8060 + # pkg:gem/prism#lib/prism/node.rb:8068 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -16698,7 +16686,7 @@ class Prism::ForwardingSuperNode < ::Prism::Node # # @yield [block] # - # pkg:gem/prism#lib/prism/node.rb:8033 + # pkg:gem/prism#lib/prism/node.rb:8041 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -16706,20 +16694,20 @@ class Prism::ForwardingSuperNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8068 + # pkg:gem/prism#lib/prism/node.rb:8076 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8073 + # pkg:gem/prism#lib/prism/node.rb:8081 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8078 + # pkg:gem/prism#lib/prism/node.rb:8086 def type; end end end @@ -16729,13 +16717,13 @@ end # $target &&= value # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8094 +# pkg:gem/prism#lib/prism/node.rb:8102 class Prism::GlobalVariableAndWriteNode < ::Prism::Node # Initialize a new GlobalVariableAndWriteNode node. # # @return [GlobalVariableAndWriteNode] a new instance of GlobalVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8096 + # pkg:gem/prism#lib/prism/node.rb:8104 sig do params( source: Prism::Source, @@ -16753,36 +16741,36 @@ class Prism::GlobalVariableAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8201 + # pkg:gem/prism#lib/prism/node.rb:8209 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8108 + # pkg:gem/prism#lib/prism/node.rb:8116 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8113 + # pkg:gem/prism#lib/prism/node.rb:8121 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8130 + # pkg:gem/prism#lib/prism/node.rb:8138 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8125 + # pkg:gem/prism#lib/prism/node.rb:8133 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8135 + # pkg:gem/prism#lib/prism/node.rb:8143 sig do params( node_id: Integer, @@ -16799,13 +16787,13 @@ class Prism::GlobalVariableAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8140 + # pkg:gem/prism#lib/prism/node.rb:8148 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:8143 + # pkg:gem/prism#lib/prism/node.rb:8151 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -16816,7 +16804,7 @@ class Prism::GlobalVariableAndWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:8118 + # pkg:gem/prism#lib/prism/node.rb:8126 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -16824,62 +16812,62 @@ class Prism::GlobalVariableAndWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8185 + # pkg:gem/prism#lib/prism/node.rb:8193 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:8148 + # pkg:gem/prism#lib/prism/node.rb:8156 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:8151 + # pkg:gem/prism#lib/prism/node.rb:8159 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:8180 + # pkg:gem/prism#lib/prism/node.rb:8188 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:8164 + # pkg:gem/prism#lib/prism/node.rb:8172 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8159 + # pkg:gem/prism#lib/prism/node.rb:8167 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8172 + # pkg:gem/prism#lib/prism/node.rb:8180 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8190 + # pkg:gem/prism#lib/prism/node.rb:8198 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:8177 + # pkg:gem/prism#lib/prism/node.rb:8185 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8195 + # pkg:gem/prism#lib/prism/node.rb:8203 def type; end end end @@ -16889,13 +16877,13 @@ end # $target += value # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8214 +# pkg:gem/prism#lib/prism/node.rb:8222 class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node # Initialize a new GlobalVariableOperatorWriteNode node. # # @return [GlobalVariableOperatorWriteNode] a new instance of GlobalVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8216 + # pkg:gem/prism#lib/prism/node.rb:8224 sig do params( source: Prism::Source, @@ -16914,48 +16902,48 @@ class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8320 + # pkg:gem/prism#lib/prism/node.rb:8328 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8229 + # pkg:gem/prism#lib/prism/node.rb:8237 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader binary_operator: Symbol # - # pkg:gem/prism#lib/prism/node.rb:8301 + # pkg:gem/prism#lib/prism/node.rb:8309 sig { returns(Symbol) } def binary_operator; end # attr_reader binary_operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:8285 + # pkg:gem/prism#lib/prism/node.rb:8293 sig { returns(Prism::Location) } def binary_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8234 + # pkg:gem/prism#lib/prism/node.rb:8242 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8251 + # pkg:gem/prism#lib/prism/node.rb:8259 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8246 + # pkg:gem/prism#lib/prism/node.rb:8254 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> GlobalVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8256 + # pkg:gem/prism#lib/prism/node.rb:8264 sig do params( node_id: Integer, @@ -16973,13 +16961,13 @@ class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8261 + # pkg:gem/prism#lib/prism/node.rb:8269 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:8264 + # pkg:gem/prism#lib/prism/node.rb:8272 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -16990,7 +16978,7 @@ class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:8239 + # pkg:gem/prism#lib/prism/node.rb:8247 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -16998,19 +16986,19 @@ class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8304 + # pkg:gem/prism#lib/prism/node.rb:8312 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:8269 + # pkg:gem/prism#lib/prism/node.rb:8277 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:8272 + # pkg:gem/prism#lib/prism/node.rb:8280 sig { returns(Prism::Location) } def name_loc; end @@ -17029,31 +17017,31 @@ class Prism::GlobalVariableOperatorWriteNode < ::Prism::Node # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8293 + # pkg:gem/prism#lib/prism/node.rb:8301 def save_binary_operator_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8280 + # pkg:gem/prism#lib/prism/node.rb:8288 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8309 + # pkg:gem/prism#lib/prism/node.rb:8317 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:8298 + # pkg:gem/prism#lib/prism/node.rb:8306 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8314 + # pkg:gem/prism#lib/prism/node.rb:8322 def type; end end end @@ -17063,13 +17051,13 @@ end # $target ||= value # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8334 +# pkg:gem/prism#lib/prism/node.rb:8342 class Prism::GlobalVariableOrWriteNode < ::Prism::Node # Initialize a new GlobalVariableOrWriteNode node. # # @return [GlobalVariableOrWriteNode] a new instance of GlobalVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8336 + # pkg:gem/prism#lib/prism/node.rb:8344 sig do params( source: Prism::Source, @@ -17087,36 +17075,36 @@ class Prism::GlobalVariableOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8441 + # pkg:gem/prism#lib/prism/node.rb:8449 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8348 + # pkg:gem/prism#lib/prism/node.rb:8356 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8353 + # pkg:gem/prism#lib/prism/node.rb:8361 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8370 + # pkg:gem/prism#lib/prism/node.rb:8378 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8365 + # pkg:gem/prism#lib/prism/node.rb:8373 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> GlobalVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8375 + # pkg:gem/prism#lib/prism/node.rb:8383 sig do params( node_id: Integer, @@ -17133,13 +17121,13 @@ class Prism::GlobalVariableOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8380 + # pkg:gem/prism#lib/prism/node.rb:8388 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:8383 + # pkg:gem/prism#lib/prism/node.rb:8391 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -17150,7 +17138,7 @@ class Prism::GlobalVariableOrWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:8358 + # pkg:gem/prism#lib/prism/node.rb:8366 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -17158,62 +17146,62 @@ class Prism::GlobalVariableOrWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8425 + # pkg:gem/prism#lib/prism/node.rb:8433 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:8388 + # pkg:gem/prism#lib/prism/node.rb:8396 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:8391 + # pkg:gem/prism#lib/prism/node.rb:8399 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:8420 + # pkg:gem/prism#lib/prism/node.rb:8428 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:8404 + # pkg:gem/prism#lib/prism/node.rb:8412 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8399 + # pkg:gem/prism#lib/prism/node.rb:8407 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8412 + # pkg:gem/prism#lib/prism/node.rb:8420 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8430 + # pkg:gem/prism#lib/prism/node.rb:8438 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:8417 + # pkg:gem/prism#lib/prism/node.rb:8425 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8435 + # pkg:gem/prism#lib/prism/node.rb:8443 def type; end end end @@ -17223,49 +17211,49 @@ end # $foo # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8454 +# pkg:gem/prism#lib/prism/node.rb:8462 class Prism::GlobalVariableReadNode < ::Prism::Node # Initialize a new GlobalVariableReadNode node. # # @return [GlobalVariableReadNode] a new instance of GlobalVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:8456 + # pkg:gem/prism#lib/prism/node.rb:8464 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8527 + # pkg:gem/prism#lib/prism/node.rb:8535 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8465 + # pkg:gem/prism#lib/prism/node.rb:8473 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8470 + # pkg:gem/prism#lib/prism/node.rb:8478 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8486 + # pkg:gem/prism#lib/prism/node.rb:8494 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8481 + # pkg:gem/prism#lib/prism/node.rb:8489 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:8491 + # pkg:gem/prism#lib/prism/node.rb:8499 sig do params( node_id: Integer, @@ -17279,19 +17267,19 @@ class Prism::GlobalVariableReadNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8496 + # pkg:gem/prism#lib/prism/node.rb:8504 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:8499 + # pkg:gem/prism#lib/prism/node.rb:8507 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:8475 + # pkg:gem/prism#lib/prism/node.rb:8483 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -17299,7 +17287,7 @@ class Prism::GlobalVariableReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8511 + # pkg:gem/prism#lib/prism/node.rb:8519 sig { override.returns(String) } def inspect; end @@ -17309,20 +17297,20 @@ class Prism::GlobalVariableReadNode < ::Prism::Node # # $_Test # name `:$_Test` # - # pkg:gem/prism#lib/prism/node.rb:8508 + # pkg:gem/prism#lib/prism/node.rb:8516 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8516 + # pkg:gem/prism#lib/prism/node.rb:8524 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8521 + # pkg:gem/prism#lib/prism/node.rb:8529 def type; end end end @@ -17332,49 +17320,49 @@ end # $foo, $bar = baz # ^^^^ ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8537 +# pkg:gem/prism#lib/prism/node.rb:8545 class Prism::GlobalVariableTargetNode < ::Prism::Node # Initialize a new GlobalVariableTargetNode node. # # @return [GlobalVariableTargetNode] a new instance of GlobalVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:8539 + # pkg:gem/prism#lib/prism/node.rb:8547 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8606 + # pkg:gem/prism#lib/prism/node.rb:8614 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8548 + # pkg:gem/prism#lib/prism/node.rb:8556 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8553 + # pkg:gem/prism#lib/prism/node.rb:8561 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8569 + # pkg:gem/prism#lib/prism/node.rb:8577 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8564 + # pkg:gem/prism#lib/prism/node.rb:8572 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> GlobalVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:8574 + # pkg:gem/prism#lib/prism/node.rb:8582 sig do params( node_id: Integer, @@ -17388,19 +17376,19 @@ class Prism::GlobalVariableTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8579 + # pkg:gem/prism#lib/prism/node.rb:8587 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:8582 + # pkg:gem/prism#lib/prism/node.rb:8590 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:8558 + # pkg:gem/prism#lib/prism/node.rb:8566 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -17408,26 +17396,26 @@ class Prism::GlobalVariableTargetNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8590 + # pkg:gem/prism#lib/prism/node.rb:8598 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:8587 + # pkg:gem/prism#lib/prism/node.rb:8595 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8595 + # pkg:gem/prism#lib/prism/node.rb:8603 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8600 + # pkg:gem/prism#lib/prism/node.rb:8608 def type; end end end @@ -17437,13 +17425,13 @@ end # $foo = 1 # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8616 +# pkg:gem/prism#lib/prism/node.rb:8624 class Prism::GlobalVariableWriteNode < ::Prism::Node # Initialize a new GlobalVariableWriteNode node. # # @return [GlobalVariableWriteNode] a new instance of GlobalVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8618 + # pkg:gem/prism#lib/prism/node.rb:8626 sig do params( source: Prism::Source, @@ -17461,36 +17449,36 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8739 + # pkg:gem/prism#lib/prism/node.rb:8747 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8630 + # pkg:gem/prism#lib/prism/node.rb:8638 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8635 + # pkg:gem/prism#lib/prism/node.rb:8643 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8652 + # pkg:gem/prism#lib/prism/node.rb:8660 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8647 + # pkg:gem/prism#lib/prism/node.rb:8655 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> GlobalVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:8657 + # pkg:gem/prism#lib/prism/node.rb:8665 sig do params( node_id: Integer, @@ -17507,13 +17495,13 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8662 + # pkg:gem/prism#lib/prism/node.rb:8670 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:8665 + # pkg:gem/prism#lib/prism/node.rb:8673 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -17521,7 +17509,7 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:8640 + # pkg:gem/prism#lib/prism/node.rb:8648 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -17529,7 +17517,7 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8723 + # pkg:gem/prism#lib/prism/node.rb:8731 sig { override.returns(String) } def inspect; end @@ -17539,7 +17527,7 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # # $_Test = 123 # name `:$_Test` # - # pkg:gem/prism#lib/prism/node.rb:8674 + # pkg:gem/prism#lib/prism/node.rb:8682 sig { returns(Symbol) } def name; end @@ -17548,13 +17536,13 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # $foo = :bar # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:8680 + # pkg:gem/prism#lib/prism/node.rb:8688 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:8718 + # pkg:gem/prism#lib/prism/node.rb:8726 sig { returns(String) } def operator; end @@ -17563,25 +17551,25 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # $foo = :bar # ^ # - # pkg:gem/prism#lib/prism/node.rb:8705 + # pkg:gem/prism#lib/prism/node.rb:8713 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8688 + # pkg:gem/prism#lib/prism/node.rb:8696 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8713 + # pkg:gem/prism#lib/prism/node.rb:8721 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8728 + # pkg:gem/prism#lib/prism/node.rb:8736 sig { override.returns(Symbol) } def type; end @@ -17593,14 +17581,14 @@ class Prism::GlobalVariableWriteNode < ::Prism::Node # $-xyz = 123 # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:8699 + # pkg:gem/prism#lib/prism/node.rb:8707 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8733 + # pkg:gem/prism#lib/prism/node.rb:8741 def type; end end end @@ -17610,13 +17598,13 @@ end # { a => b } # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8752 +# pkg:gem/prism#lib/prism/node.rb:8760 class Prism::HashNode < ::Prism::Node # Initialize a new HashNode node. # # @return [HashNode] a new instance of HashNode # - # pkg:gem/prism#lib/prism/node.rb:8754 + # pkg:gem/prism#lib/prism/node.rb:8762 sig do params( source: Prism::Source, @@ -17633,24 +17621,24 @@ class Prism::HashNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:8872 + # pkg:gem/prism#lib/prism/node.rb:8880 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8765 + # pkg:gem/prism#lib/prism/node.rb:8773 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8770 + # pkg:gem/prism#lib/prism/node.rb:8778 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:8851 + # pkg:gem/prism#lib/prism/node.rb:8859 sig { returns(String) } def closing; end @@ -17659,25 +17647,25 @@ class Prism::HashNode < ::Prism::Node # { a => b } # ^ # - # pkg:gem/prism#lib/prism/node.rb:8833 + # pkg:gem/prism#lib/prism/node.rb:8841 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8787 + # pkg:gem/prism#lib/prism/node.rb:8795 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8782 + # pkg:gem/prism#lib/prism/node.rb:8790 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?elements: Array[AssocNode | AssocSplatNode], ?closing_loc: Location) -> HashNode # - # pkg:gem/prism#lib/prism/node.rb:8792 + # pkg:gem/prism#lib/prism/node.rb:8800 sig do params( node_id: Integer, @@ -17693,19 +17681,19 @@ class Prism::HashNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8797 + # pkg:gem/prism#lib/prism/node.rb:8805 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, elements: Array[AssocNode | AssocSplatNode], closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:8800 + # pkg:gem/prism#lib/prism/node.rb:8808 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:8775 + # pkg:gem/prism#lib/prism/node.rb:8783 def each_child_node; end # The elements of the hash. These can be either `AssocNode`s or `AssocSplatNode`s. @@ -17716,7 +17704,7 @@ class Prism::HashNode < ::Prism::Node # { **foo } # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:8827 + # pkg:gem/prism#lib/prism/node.rb:8835 sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) } def elements; end @@ -17725,13 +17713,13 @@ class Prism::HashNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:8856 + # pkg:gem/prism#lib/prism/node.rb:8864 sig { override.returns(String) } def inspect; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:8846 + # pkg:gem/prism#lib/prism/node.rb:8854 sig { returns(String) } def opening; end @@ -17740,32 +17728,32 @@ class Prism::HashNode < ::Prism::Node # { a => b } # ^ # - # pkg:gem/prism#lib/prism/node.rb:8808 + # pkg:gem/prism#lib/prism/node.rb:8816 sig { returns(Prism::Location) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8841 + # pkg:gem/prism#lib/prism/node.rb:8849 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:8816 + # pkg:gem/prism#lib/prism/node.rb:8824 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:8861 + # pkg:gem/prism#lib/prism/node.rb:8869 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:8866 + # pkg:gem/prism#lib/prism/node.rb:8874 def type; end end end @@ -17784,13 +17772,13 @@ end # foo in { a: 1, b: 2 } # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:8894 +# pkg:gem/prism#lib/prism/node.rb:8902 class Prism::HashPatternNode < ::Prism::Node # Initialize a new HashPatternNode node. # # @return [HashPatternNode] a new instance of HashPatternNode # - # pkg:gem/prism#lib/prism/node.rb:8896 + # pkg:gem/prism#lib/prism/node.rb:8904 sig do params( source: Prism::Source, @@ -17809,24 +17797,24 @@ class Prism::HashPatternNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:9058 + # pkg:gem/prism#lib/prism/node.rb:9066 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:8909 + # pkg:gem/prism#lib/prism/node.rb:8917 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8914 + # pkg:gem/prism#lib/prism/node.rb:8922 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:9037 + # pkg:gem/prism#lib/prism/node.rb:9045 sig { returns(T.nilable(String)) } def closing; end @@ -17838,19 +17826,19 @@ class Prism::HashPatternNode < ::Prism::Node # foo => Bar[a: 1] # ^ # - # pkg:gem/prism#lib/prism/node.rb:9013 + # pkg:gem/prism#lib/prism/node.rb:9021 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:8937 + # pkg:gem/prism#lib/prism/node.rb:8945 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:8928 + # pkg:gem/prism#lib/prism/node.rb:8936 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -17862,13 +17850,13 @@ class Prism::HashPatternNode < ::Prism::Node # foo => Bar::Baz[a: 1, b: 2] # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:8961 + # pkg:gem/prism#lib/prism/node.rb:8969 sig { returns(T.nilable(T.any(Prism::ConstantPathNode, Prism::ConstantReadNode))) } def constant; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantPathNode | ConstantReadNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode # - # pkg:gem/prism#lib/prism/node.rb:8942 + # pkg:gem/prism#lib/prism/node.rb:8950 sig do params( node_id: Integer, @@ -17886,13 +17874,13 @@ class Prism::HashPatternNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:8947 + # pkg:gem/prism#lib/prism/node.rb:8955 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantPathNode | ConstantReadNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:8950 + # pkg:gem/prism#lib/prism/node.rb:8958 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -17900,7 +17888,7 @@ class Prism::HashPatternNode < ::Prism::Node # # @yield [constant] # - # pkg:gem/prism#lib/prism/node.rb:8919 + # pkg:gem/prism#lib/prism/node.rb:8927 def each_child_node; end # Represents the explicit named hash keys and values. @@ -17908,7 +17896,7 @@ class Prism::HashPatternNode < ::Prism::Node # foo => { a: 1, b:, ** } # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:8967 + # pkg:gem/prism#lib/prism/node.rb:8975 sig { returns(T::Array[Prism::AssocNode]) } def elements; end @@ -17917,13 +17905,13 @@ class Prism::HashPatternNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:9042 + # pkg:gem/prism#lib/prism/node.rb:9050 sig { override.returns(String) } def inspect; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:9032 + # pkg:gem/prism#lib/prism/node.rb:9040 sig { returns(T.nilable(String)) } def opening; end @@ -17935,7 +17923,7 @@ class Prism::HashPatternNode < ::Prism::Node # foo => Bar[a: 1] # ^ # - # pkg:gem/prism#lib/prism/node.rb:8988 + # pkg:gem/prism#lib/prism/node.rb:8996 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end @@ -17950,32 +17938,32 @@ class Prism::HashPatternNode < ::Prism::Node # foo => { a: 1, b:, **nil } # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:8979 + # pkg:gem/prism#lib/prism/node.rb:8987 sig { returns(T.nilable(T.any(Prism::AssocSplatNode, Prism::NoKeywordsParameterNode))) } def rest; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9027 + # pkg:gem/prism#lib/prism/node.rb:9035 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9002 + # pkg:gem/prism#lib/prism/node.rb:9010 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:9047 + # pkg:gem/prism#lib/prism/node.rb:9055 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:9052 + # pkg:gem/prism#lib/prism/node.rb:9060 def type; end end end @@ -18001,13 +17989,13 @@ end # foo ? bar : baz # ^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:9079 +# pkg:gem/prism#lib/prism/node.rb:9087 class Prism::IfNode < ::Prism::Node # Initialize a new IfNode node. # # @return [IfNode] a new instance of IfNode # - # pkg:gem/prism#lib/prism/node.rb:9081 + # pkg:gem/prism#lib/prism/node.rb:9089 sig do params( source: Prism::Source, @@ -18027,30 +18015,30 @@ class Prism::IfNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:9284 + # pkg:gem/prism#lib/prism/node.rb:9292 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:9095 + # pkg:gem/prism#lib/prism/node.rb:9103 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9100 + # pkg:gem/prism#lib/prism/node.rb:9108 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:9123 + # pkg:gem/prism#lib/prism/node.rb:9131 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:9114 + # pkg:gem/prism#lib/prism/node.rb:9122 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -18062,7 +18050,7 @@ class Prism::IfNode < ::Prism::Node # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?if_keyword_loc: Location?, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: ElseNode | IfNode | nil, ?end_keyword_loc: Location?) -> IfNode # - # pkg:gem/prism#lib/prism/node.rb:9128 + # pkg:gem/prism#lib/prism/node.rb:9136 sig do params( node_id: Integer, @@ -18081,13 +18069,13 @@ class Prism::IfNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9133 + # pkg:gem/prism#lib/prism/node.rb:9141 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, if_keyword_loc: Location?, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: ElseNode | IfNode | nil, end_keyword_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:9136 + # pkg:gem/prism#lib/prism/node.rb:9144 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -18095,12 +18083,12 @@ class Prism::IfNode < ::Prism::Node # # @yield [predicate] # - # pkg:gem/prism#lib/prism/node.rb:9105 + # pkg:gem/prism#lib/prism/node.rb:9113 def each_child_node; end # def end_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:9263 + # pkg:gem/prism#lib/prism/node.rb:9271 sig { returns(T.nilable(String)) } def end_keyword; end @@ -18111,7 +18099,7 @@ class Prism::IfNode < ::Prism::Node # end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:9234 + # pkg:gem/prism#lib/prism/node.rb:9242 sig { returns(T.nilable(Prism::Location)) } def end_keyword_loc; end @@ -18120,7 +18108,7 @@ class Prism::IfNode < ::Prism::Node # def if_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:9253 + # pkg:gem/prism#lib/prism/node.rb:9261 sig { returns(T.nilable(String)) } def if_keyword; end @@ -18131,13 +18119,13 @@ class Prism::IfNode < ::Prism::Node # # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression. # - # pkg:gem/prism#lib/prism/node.rb:9146 + # pkg:gem/prism#lib/prism/node.rb:9154 sig { returns(T.nilable(Prism::Location)) } def if_keyword_loc; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:9268 + # pkg:gem/prism#lib/prism/node.rb:9276 sig { override.returns(String) } def inspect; end @@ -18157,26 +18145,26 @@ class Prism::IfNode < ::Prism::Node # foo ? bar : baz # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:9176 + # pkg:gem/prism#lib/prism/node.rb:9184 sig { returns(Prism::Node) } def predicate; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9248 + # pkg:gem/prism#lib/prism/node.rb:9256 def save_end_keyword_loc(repository); end # Save the if_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9160 + # pkg:gem/prism#lib/prism/node.rb:9168 def save_if_keyword_loc(repository); end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9199 + # pkg:gem/prism#lib/prism/node.rb:9207 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. @@ -18188,7 +18176,7 @@ class Prism::IfNode < ::Prism::Node # ^^^ # end # - # pkg:gem/prism#lib/prism/node.rb:9211 + # pkg:gem/prism#lib/prism/node.rb:9219 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end @@ -18206,13 +18194,13 @@ class Prism::IfNode < ::Prism::Node # if foo then bar else baz end # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:9226 + # pkg:gem/prism#lib/prism/node.rb:9234 sig { returns(T.nilable(T.any(Prism::ElseNode, Prism::IfNode))) } def subsequent; end # def then_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:9258 + # pkg:gem/prism#lib/prism/node.rb:9266 sig { returns(T.nilable(String)) } def then_keyword; end @@ -18224,20 +18212,20 @@ class Prism::IfNode < ::Prism::Node # a ? b : c # ^ # - # pkg:gem/prism#lib/prism/node.rb:9185 + # pkg:gem/prism#lib/prism/node.rb:9193 sig { returns(T.nilable(Prism::Location)) } def then_keyword_loc; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:9273 + # pkg:gem/prism#lib/prism/node.rb:9281 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:9278 + # pkg:gem/prism#lib/prism/node.rb:9286 def type; end end end @@ -18247,13 +18235,13 @@ end # 1.0i # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:9299 +# pkg:gem/prism#lib/prism/node.rb:9307 class Prism::ImaginaryNode < ::Prism::Node # Initialize a new ImaginaryNode node. # # @return [ImaginaryNode] a new instance of ImaginaryNode # - # pkg:gem/prism#lib/prism/node.rb:9301 + # pkg:gem/prism#lib/prism/node.rb:9309 sig do params( source: Prism::Source, @@ -18268,36 +18256,36 @@ class Prism::ImaginaryNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:9369 + # pkg:gem/prism#lib/prism/node.rb:9377 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:9310 + # pkg:gem/prism#lib/prism/node.rb:9318 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9315 + # pkg:gem/prism#lib/prism/node.rb:9323 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:9332 + # pkg:gem/prism#lib/prism/node.rb:9340 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:9327 + # pkg:gem/prism#lib/prism/node.rb:9335 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numeric: FloatNode | IntegerNode | RationalNode) -> ImaginaryNode # - # pkg:gem/prism#lib/prism/node.rb:9337 + # pkg:gem/prism#lib/prism/node.rb:9345 sig do params( node_id: Integer, @@ -18311,13 +18299,13 @@ class Prism::ImaginaryNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9342 + # pkg:gem/prism#lib/prism/node.rb:9350 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numeric: FloatNode | IntegerNode | RationalNode } # - # pkg:gem/prism#lib/prism/node.rb:9345 + # pkg:gem/prism#lib/prism/node.rb:9353 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -18325,7 +18313,7 @@ class Prism::ImaginaryNode < ::Prism::Node # # @yield [numeric] # - # pkg:gem/prism#lib/prism/node.rb:9320 + # pkg:gem/prism#lib/prism/node.rb:9328 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -18333,19 +18321,19 @@ class Prism::ImaginaryNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:9353 + # pkg:gem/prism#lib/prism/node.rb:9361 sig { override.returns(String) } def inspect; end # attr_reader numeric: FloatNode | IntegerNode | RationalNode # - # pkg:gem/prism#lib/prism/node.rb:9350 + # pkg:gem/prism#lib/prism/node.rb:9358 sig { returns(T.any(Prism::FloatNode, Prism::IntegerNode, Prism::RationalNode)) } def numeric; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:9358 + # pkg:gem/prism#lib/prism/node.rb:9366 sig { override.returns(Symbol) } def type; end @@ -18358,7 +18346,7 @@ class Prism::ImaginaryNode < ::Prism::Node class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:9363 + # pkg:gem/prism#lib/prism/node.rb:9371 def type; end end end @@ -18374,13 +18362,13 @@ end # foo in { bar: } # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:9385 +# pkg:gem/prism#lib/prism/node.rb:9393 class Prism::ImplicitNode < ::Prism::Node # Initialize a new ImplicitNode node. # # @return [ImplicitNode] a new instance of ImplicitNode # - # pkg:gem/prism#lib/prism/node.rb:9387 + # pkg:gem/prism#lib/prism/node.rb:9395 sig do params( source: Prism::Source, @@ -18395,36 +18383,36 @@ class Prism::ImplicitNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:9455 + # pkg:gem/prism#lib/prism/node.rb:9463 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:9396 + # pkg:gem/prism#lib/prism/node.rb:9404 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9401 + # pkg:gem/prism#lib/prism/node.rb:9409 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:9418 + # pkg:gem/prism#lib/prism/node.rb:9426 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:9413 + # pkg:gem/prism#lib/prism/node.rb:9421 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode) -> ImplicitNode # - # pkg:gem/prism#lib/prism/node.rb:9423 + # pkg:gem/prism#lib/prism/node.rb:9431 sig do params( node_id: Integer, @@ -18438,13 +18426,13 @@ class Prism::ImplicitNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9428 + # pkg:gem/prism#lib/prism/node.rb:9436 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode } # - # pkg:gem/prism#lib/prism/node.rb:9431 + # pkg:gem/prism#lib/prism/node.rb:9439 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -18452,7 +18440,7 @@ class Prism::ImplicitNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:9406 + # pkg:gem/prism#lib/prism/node.rb:9414 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -18460,19 +18448,19 @@ class Prism::ImplicitNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:9439 + # pkg:gem/prism#lib/prism/node.rb:9447 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:9444 + # pkg:gem/prism#lib/prism/node.rb:9452 sig { override.returns(Symbol) } def type; end # attr_reader value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:9436 + # pkg:gem/prism#lib/prism/node.rb:9444 sig do returns(T.any(Prism::LocalVariableReadNode, Prism::CallNode, Prism::ConstantReadNode, Prism::LocalVariableTargetNode)) end @@ -18481,7 +18469,7 @@ class Prism::ImplicitNode < ::Prism::Node class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:9449 + # pkg:gem/prism#lib/prism/node.rb:9457 def type; end end end @@ -18500,68 +18488,68 @@ end # foo, = bar # ^ # -# pkg:gem/prism#lib/prism/node.rb:9474 +# pkg:gem/prism#lib/prism/node.rb:9482 class Prism::ImplicitRestNode < ::Prism::Node # Initialize a new ImplicitRestNode node. # # @return [ImplicitRestNode] a new instance of ImplicitRestNode # - # pkg:gem/prism#lib/prism/node.rb:9476 + # pkg:gem/prism#lib/prism/node.rb:9484 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:9539 + # pkg:gem/prism#lib/prism/node.rb:9547 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:9484 + # pkg:gem/prism#lib/prism/node.rb:9492 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9489 + # pkg:gem/prism#lib/prism/node.rb:9497 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:9505 + # pkg:gem/prism#lib/prism/node.rb:9513 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:9500 + # pkg:gem/prism#lib/prism/node.rb:9508 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ImplicitRestNode # - # pkg:gem/prism#lib/prism/node.rb:9510 + # pkg:gem/prism#lib/prism/node.rb:9518 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ImplicitRestNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9515 + # pkg:gem/prism#lib/prism/node.rb:9523 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:9518 + # pkg:gem/prism#lib/prism/node.rb:9526 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:9494 + # pkg:gem/prism#lib/prism/node.rb:9502 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -18569,20 +18557,20 @@ class Prism::ImplicitRestNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:9523 + # pkg:gem/prism#lib/prism/node.rb:9531 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:9528 + # pkg:gem/prism#lib/prism/node.rb:9536 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:9533 + # pkg:gem/prism#lib/prism/node.rb:9541 def type; end end end @@ -18592,13 +18580,13 @@ end # case a; in b then c end # ^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:9548 +# pkg:gem/prism#lib/prism/node.rb:9556 class Prism::InNode < ::Prism::Node # Initialize a new InNode node. # # @return [InNode] a new instance of InNode # - # pkg:gem/prism#lib/prism/node.rb:9550 + # pkg:gem/prism#lib/prism/node.rb:9558 sig do params( source: Prism::Source, @@ -18616,36 +18604,36 @@ class Prism::InNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:9670 + # pkg:gem/prism#lib/prism/node.rb:9678 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:9562 + # pkg:gem/prism#lib/prism/node.rb:9570 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9567 + # pkg:gem/prism#lib/prism/node.rb:9575 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:9588 + # pkg:gem/prism#lib/prism/node.rb:9596 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:9580 + # pkg:gem/prism#lib/prism/node.rb:9588 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?pattern: Prism::node, ?statements: StatementsNode?, ?in_loc: Location, ?then_loc: Location?) -> InNode # - # pkg:gem/prism#lib/prism/node.rb:9593 + # pkg:gem/prism#lib/prism/node.rb:9601 sig do params( node_id: Integer, @@ -18662,13 +18650,13 @@ class Prism::InNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9598 + # pkg:gem/prism#lib/prism/node.rb:9606 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, pattern: Prism::node, statements: StatementsNode?, in_loc: Location, then_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:9601 + # pkg:gem/prism#lib/prism/node.rb:9609 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -18676,7 +18664,7 @@ class Prism::InNode < ::Prism::Node # # @yield [pattern] # - # pkg:gem/prism#lib/prism/node.rb:9572 + # pkg:gem/prism#lib/prism/node.rb:9580 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -18684,68 +18672,68 @@ class Prism::InNode < ::Prism::Node # def in: () -> String # - # pkg:gem/prism#lib/prism/node.rb:9644 + # pkg:gem/prism#lib/prism/node.rb:9652 sig { returns(String) } def in; end # attr_reader in_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:9612 + # pkg:gem/prism#lib/prism/node.rb:9620 sig { returns(Prism::Location) } def in_loc; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:9654 + # pkg:gem/prism#lib/prism/node.rb:9662 sig { override.returns(String) } def inspect; end # attr_reader pattern: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:9606 + # pkg:gem/prism#lib/prism/node.rb:9614 sig { returns(Prism::Node) } def pattern; end # Save the in_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9620 + # pkg:gem/prism#lib/prism/node.rb:9628 def save_in_loc(repository); end # Save the then_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9639 + # pkg:gem/prism#lib/prism/node.rb:9647 def save_then_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:9609 + # pkg:gem/prism#lib/prism/node.rb:9617 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # def then: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:9649 + # pkg:gem/prism#lib/prism/node.rb:9657 sig { returns(T.nilable(String)) } def then; end # attr_reader then_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:9625 + # pkg:gem/prism#lib/prism/node.rb:9633 sig { returns(T.nilable(Prism::Location)) } def then_loc; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:9659 + # pkg:gem/prism#lib/prism/node.rb:9667 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:9664 + # pkg:gem/prism#lib/prism/node.rb:9672 def type; end end end @@ -18755,13 +18743,13 @@ end # foo.bar[baz] &&= value # ^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:9683 +# pkg:gem/prism#lib/prism/node.rb:9691 class Prism::IndexAndWriteNode < ::Prism::Node # Initialize a new IndexAndWriteNode node. # # @return [IndexAndWriteNode] a new instance of IndexAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:9685 + # pkg:gem/prism#lib/prism/node.rb:9693 sig do params( source: Prism::Source, @@ -18783,18 +18771,18 @@ class Prism::IndexAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:9875 + # pkg:gem/prism#lib/prism/node.rb:9883 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:9701 + # pkg:gem/prism#lib/prism/node.rb:9709 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader arguments: ArgumentsNode? # - # pkg:gem/prism#lib/prism/node.rb:9804 + # pkg:gem/prism#lib/prism/node.rb:9812 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end @@ -18802,61 +18790,61 @@ class Prism::IndexAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9759 + # pkg:gem/prism#lib/prism/node.rb:9767 sig { returns(T::Boolean) } def attribute_write?; end # attr_reader block: BlockArgumentNode? # - # pkg:gem/prism#lib/prism/node.rb:9820 + # pkg:gem/prism#lib/prism/node.rb:9828 sig { returns(T.nilable(Prism::BlockArgumentNode)) } def block; end # def call_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:9839 + # pkg:gem/prism#lib/prism/node.rb:9847 sig { returns(T.nilable(String)) } def call_operator; end # attr_reader call_operator_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:9772 + # pkg:gem/prism#lib/prism/node.rb:9780 sig { returns(T.nilable(Prism::Location)) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9706 + # pkg:gem/prism#lib/prism/node.rb:9714 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:9849 + # pkg:gem/prism#lib/prism/node.rb:9857 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:9807 + # pkg:gem/prism#lib/prism/node.rb:9815 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:9731 + # pkg:gem/prism#lib/prism/node.rb:9739 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:9721 + # pkg:gem/prism#lib/prism/node.rb:9729 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:9736 + # pkg:gem/prism#lib/prism/node.rb:9744 sig do params( node_id: Integer, @@ -18877,13 +18865,13 @@ class Prism::IndexAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9741 + # pkg:gem/prism#lib/prism/node.rb:9749 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:9744 + # pkg:gem/prism#lib/prism/node.rb:9752 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -18891,7 +18879,7 @@ class Prism::IndexAndWriteNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:9711 + # pkg:gem/prism#lib/prism/node.rb:9719 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -18901,43 +18889,43 @@ class Prism::IndexAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9764 + # pkg:gem/prism#lib/prism/node.rb:9772 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:9859 + # pkg:gem/prism#lib/prism/node.rb:9867 sig { override.returns(String) } def inspect; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:9844 + # pkg:gem/prism#lib/prism/node.rb:9852 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:9791 + # pkg:gem/prism#lib/prism/node.rb:9799 sig { returns(Prism::Location) } def opening_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:9854 + # pkg:gem/prism#lib/prism/node.rb:9862 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:9823 + # pkg:gem/prism#lib/prism/node.rb:9831 sig { returns(Prism::Location) } def operator_loc; end # attr_reader receiver: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:9769 + # pkg:gem/prism#lib/prism/node.rb:9777 sig { returns(T.nilable(Prism::Node)) } def receiver; end @@ -18945,43 +18933,43 @@ class Prism::IndexAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9749 + # pkg:gem/prism#lib/prism/node.rb:9757 sig { returns(T::Boolean) } def safe_navigation?; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9786 + # pkg:gem/prism#lib/prism/node.rb:9794 def save_call_operator_loc(repository); end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9815 + # pkg:gem/prism#lib/prism/node.rb:9823 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9799 + # pkg:gem/prism#lib/prism/node.rb:9807 def save_opening_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9831 + # pkg:gem/prism#lib/prism/node.rb:9839 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:9864 + # pkg:gem/prism#lib/prism/node.rb:9872 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:9836 + # pkg:gem/prism#lib/prism/node.rb:9844 sig { returns(Prism::Node) } def value; end @@ -18989,14 +18977,14 @@ class Prism::IndexAndWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9754 + # pkg:gem/prism#lib/prism/node.rb:9762 sig { returns(T::Boolean) } def variable_call?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:9869 + # pkg:gem/prism#lib/prism/node.rb:9877 def type; end end end @@ -19006,13 +18994,13 @@ end # foo.bar[baz] += value # ^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:9893 +# pkg:gem/prism#lib/prism/node.rb:9901 class Prism::IndexOperatorWriteNode < ::Prism::Node # Initialize a new IndexOperatorWriteNode node. # # @return [IndexOperatorWriteNode] a new instance of IndexOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:9895 + # pkg:gem/prism#lib/prism/node.rb:9903 sig do params( source: Prism::Source, @@ -19035,18 +19023,18 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10084 + # pkg:gem/prism#lib/prism/node.rb:10092 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:9912 + # pkg:gem/prism#lib/prism/node.rb:9920 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader arguments: ArgumentsNode? # - # pkg:gem/prism#lib/prism/node.rb:10015 + # pkg:gem/prism#lib/prism/node.rb:10023 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end @@ -19054,73 +19042,73 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9970 + # pkg:gem/prism#lib/prism/node.rb:9978 sig { returns(T::Boolean) } def attribute_write?; end # attr_reader binary_operator: Symbol # - # pkg:gem/prism#lib/prism/node.rb:10034 + # pkg:gem/prism#lib/prism/node.rb:10042 sig { returns(Symbol) } def binary_operator; end # attr_reader binary_operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10037 + # pkg:gem/prism#lib/prism/node.rb:10045 sig { returns(Prism::Location) } def binary_operator_loc; end # attr_reader block: BlockArgumentNode? # - # pkg:gem/prism#lib/prism/node.rb:10031 + # pkg:gem/prism#lib/prism/node.rb:10039 sig { returns(T.nilable(Prism::BlockArgumentNode)) } def block; end # def call_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:10053 + # pkg:gem/prism#lib/prism/node.rb:10061 sig { returns(T.nilable(String)) } def call_operator; end # attr_reader call_operator_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:9983 + # pkg:gem/prism#lib/prism/node.rb:9991 sig { returns(T.nilable(Prism::Location)) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9917 + # pkg:gem/prism#lib/prism/node.rb:9925 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10063 + # pkg:gem/prism#lib/prism/node.rb:10071 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10018 + # pkg:gem/prism#lib/prism/node.rb:10026 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:9942 + # pkg:gem/prism#lib/prism/node.rb:9950 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:9932 + # pkg:gem/prism#lib/prism/node.rb:9940 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:9947 + # pkg:gem/prism#lib/prism/node.rb:9955 sig do params( node_id: Integer, @@ -19142,13 +19130,13 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:9952 + # pkg:gem/prism#lib/prism/node.rb:9960 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:9955 + # pkg:gem/prism#lib/prism/node.rb:9963 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -19156,7 +19144,7 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:9922 + # pkg:gem/prism#lib/prism/node.rb:9930 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -19166,25 +19154,25 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9975 + # pkg:gem/prism#lib/prism/node.rb:9983 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10068 + # pkg:gem/prism#lib/prism/node.rb:10076 sig { override.returns(String) } def inspect; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10058 + # pkg:gem/prism#lib/prism/node.rb:10066 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10002 + # pkg:gem/prism#lib/prism/node.rb:10010 sig { returns(Prism::Location) } def opening_loc; end @@ -19202,7 +19190,7 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # attr_reader receiver: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:9980 + # pkg:gem/prism#lib/prism/node.rb:9988 sig { returns(T.nilable(Prism::Node)) } def receiver; end @@ -19210,43 +19198,43 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9960 + # pkg:gem/prism#lib/prism/node.rb:9968 sig { returns(T::Boolean) } def safe_navigation?; end # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10045 + # pkg:gem/prism#lib/prism/node.rb:10053 def save_binary_operator_loc(repository); end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:9997 + # pkg:gem/prism#lib/prism/node.rb:10005 def save_call_operator_loc(repository); end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10026 + # pkg:gem/prism#lib/prism/node.rb:10034 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10010 + # pkg:gem/prism#lib/prism/node.rb:10018 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10073 + # pkg:gem/prism#lib/prism/node.rb:10081 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:10050 + # pkg:gem/prism#lib/prism/node.rb:10058 sig { returns(Prism::Node) } def value; end @@ -19254,14 +19242,14 @@ class Prism::IndexOperatorWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:9965 + # pkg:gem/prism#lib/prism/node.rb:9973 sig { returns(T::Boolean) } def variable_call?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10078 + # pkg:gem/prism#lib/prism/node.rb:10086 def type; end end end @@ -19271,13 +19259,13 @@ end # foo.bar[baz] ||= value # ^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:10103 +# pkg:gem/prism#lib/prism/node.rb:10111 class Prism::IndexOrWriteNode < ::Prism::Node # Initialize a new IndexOrWriteNode node. # # @return [IndexOrWriteNode] a new instance of IndexOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10105 + # pkg:gem/prism#lib/prism/node.rb:10113 sig do params( source: Prism::Source, @@ -19299,18 +19287,18 @@ class Prism::IndexOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10295 + # pkg:gem/prism#lib/prism/node.rb:10303 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:10121 + # pkg:gem/prism#lib/prism/node.rb:10129 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader arguments: ArgumentsNode? # - # pkg:gem/prism#lib/prism/node.rb:10224 + # pkg:gem/prism#lib/prism/node.rb:10232 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end @@ -19318,61 +19306,61 @@ class Prism::IndexOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10179 + # pkg:gem/prism#lib/prism/node.rb:10187 sig { returns(T::Boolean) } def attribute_write?; end # attr_reader block: BlockArgumentNode? # - # pkg:gem/prism#lib/prism/node.rb:10240 + # pkg:gem/prism#lib/prism/node.rb:10248 sig { returns(T.nilable(Prism::BlockArgumentNode)) } def block; end # def call_operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:10259 + # pkg:gem/prism#lib/prism/node.rb:10267 sig { returns(T.nilable(String)) } def call_operator; end # attr_reader call_operator_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:10192 + # pkg:gem/prism#lib/prism/node.rb:10200 sig { returns(T.nilable(Prism::Location)) } def call_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10126 + # pkg:gem/prism#lib/prism/node.rb:10134 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10269 + # pkg:gem/prism#lib/prism/node.rb:10277 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10227 + # pkg:gem/prism#lib/prism/node.rb:10235 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:10151 + # pkg:gem/prism#lib/prism/node.rb:10159 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:10141 + # pkg:gem/prism#lib/prism/node.rb:10149 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10156 + # pkg:gem/prism#lib/prism/node.rb:10164 sig do params( node_id: Integer, @@ -19393,13 +19381,13 @@ class Prism::IndexOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10161 + # pkg:gem/prism#lib/prism/node.rb:10169 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:10164 + # pkg:gem/prism#lib/prism/node.rb:10172 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -19407,7 +19395,7 @@ class Prism::IndexOrWriteNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:10131 + # pkg:gem/prism#lib/prism/node.rb:10139 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -19417,43 +19405,43 @@ class Prism::IndexOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10184 + # pkg:gem/prism#lib/prism/node.rb:10192 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10279 + # pkg:gem/prism#lib/prism/node.rb:10287 sig { override.returns(String) } def inspect; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10264 + # pkg:gem/prism#lib/prism/node.rb:10272 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10211 + # pkg:gem/prism#lib/prism/node.rb:10219 sig { returns(Prism::Location) } def opening_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10274 + # pkg:gem/prism#lib/prism/node.rb:10282 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10243 + # pkg:gem/prism#lib/prism/node.rb:10251 sig { returns(Prism::Location) } def operator_loc; end # attr_reader receiver: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:10189 + # pkg:gem/prism#lib/prism/node.rb:10197 sig { returns(T.nilable(Prism::Node)) } def receiver; end @@ -19461,43 +19449,43 @@ class Prism::IndexOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10169 + # pkg:gem/prism#lib/prism/node.rb:10177 sig { returns(T::Boolean) } def safe_navigation?; end # Save the call_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10206 + # pkg:gem/prism#lib/prism/node.rb:10214 def save_call_operator_loc(repository); end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10235 + # pkg:gem/prism#lib/prism/node.rb:10243 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10219 + # pkg:gem/prism#lib/prism/node.rb:10227 def save_opening_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10251 + # pkg:gem/prism#lib/prism/node.rb:10259 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10284 + # pkg:gem/prism#lib/prism/node.rb:10292 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:10256 + # pkg:gem/prism#lib/prism/node.rb:10264 sig { returns(Prism::Node) } def value; end @@ -19505,14 +19493,14 @@ class Prism::IndexOrWriteNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10174 + # pkg:gem/prism#lib/prism/node.rb:10182 sig { returns(T::Boolean) } def variable_call?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10289 + # pkg:gem/prism#lib/prism/node.rb:10297 def type; end end end @@ -19530,13 +19518,13 @@ end # for foo[bar] in baz do end # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:10321 +# pkg:gem/prism#lib/prism/node.rb:10329 class Prism::IndexTargetNode < ::Prism::Node # Initialize a new IndexTargetNode node. # # @return [IndexTargetNode] a new instance of IndexTargetNode # - # pkg:gem/prism#lib/prism/node.rb:10323 + # pkg:gem/prism#lib/prism/node.rb:10331 sig do params( source: Prism::Source, @@ -19555,18 +19543,18 @@ class Prism::IndexTargetNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10463 + # pkg:gem/prism#lib/prism/node.rb:10471 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:10336 + # pkg:gem/prism#lib/prism/node.rb:10344 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader arguments: ArgumentsNode? # - # pkg:gem/prism#lib/prism/node.rb:10418 + # pkg:gem/prism#lib/prism/node.rb:10426 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end @@ -19574,49 +19562,49 @@ class Prism::IndexTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10392 + # pkg:gem/prism#lib/prism/node.rb:10400 sig { returns(T::Boolean) } def attribute_write?; end # attr_reader block: BlockArgumentNode? # - # pkg:gem/prism#lib/prism/node.rb:10434 + # pkg:gem/prism#lib/prism/node.rb:10442 sig { returns(T.nilable(Prism::BlockArgumentNode)) } def block; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10341 + # pkg:gem/prism#lib/prism/node.rb:10349 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10442 + # pkg:gem/prism#lib/prism/node.rb:10450 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10421 + # pkg:gem/prism#lib/prism/node.rb:10429 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:10364 + # pkg:gem/prism#lib/prism/node.rb:10372 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:10355 + # pkg:gem/prism#lib/prism/node.rb:10363 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?) -> IndexTargetNode # - # pkg:gem/prism#lib/prism/node.rb:10369 + # pkg:gem/prism#lib/prism/node.rb:10377 sig do params( node_id: Integer, @@ -19634,13 +19622,13 @@ class Prism::IndexTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10374 + # pkg:gem/prism#lib/prism/node.rb:10382 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode? } # - # pkg:gem/prism#lib/prism/node.rb:10377 + # pkg:gem/prism#lib/prism/node.rb:10385 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -19648,7 +19636,7 @@ class Prism::IndexTargetNode < ::Prism::Node # # @yield [receiver] # - # pkg:gem/prism#lib/prism/node.rb:10346 + # pkg:gem/prism#lib/prism/node.rb:10354 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -19658,31 +19646,31 @@ class Prism::IndexTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10397 + # pkg:gem/prism#lib/prism/node.rb:10405 sig { returns(T::Boolean) } def ignore_visibility?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10447 + # pkg:gem/prism#lib/prism/node.rb:10455 sig { override.returns(String) } def inspect; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10437 + # pkg:gem/prism#lib/prism/node.rb:10445 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10405 + # pkg:gem/prism#lib/prism/node.rb:10413 sig { returns(Prism::Location) } def opening_loc; end # attr_reader receiver: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:10402 + # pkg:gem/prism#lib/prism/node.rb:10410 sig { returns(Prism::Node) } def receiver; end @@ -19690,25 +19678,25 @@ class Prism::IndexTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10382 + # pkg:gem/prism#lib/prism/node.rb:10390 sig { returns(T::Boolean) } def safe_navigation?; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10429 + # pkg:gem/prism#lib/prism/node.rb:10437 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10413 + # pkg:gem/prism#lib/prism/node.rb:10421 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10452 + # pkg:gem/prism#lib/prism/node.rb:10460 sig { override.returns(Symbol) } def type; end @@ -19716,14 +19704,14 @@ class Prism::IndexTargetNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:10387 + # pkg:gem/prism#lib/prism/node.rb:10395 sig { returns(T::Boolean) } def variable_call?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10457 + # pkg:gem/prism#lib/prism/node.rb:10465 def type; end end end @@ -19731,11 +19719,11 @@ end # InlineComment objects are the most common. They correspond to comments in # the source file like this one that start with #. # -# pkg:gem/prism#lib/prism/parse_result.rb:534 +# pkg:gem/prism#lib/prism/parse_result.rb:543 class Prism::InlineComment < ::Prism::Comment # Returns a string representation of this comment. # - # pkg:gem/prism#lib/prism/parse_result.rb:542 + # pkg:gem/prism#lib/prism/parse_result.rb:551 sig { returns(String) } def inspect; end @@ -19744,7 +19732,7 @@ class Prism::InlineComment < ::Prism::Comment # # @return [Boolean] # - # pkg:gem/prism#lib/prism/parse_result.rb:537 + # pkg:gem/prism#lib/prism/parse_result.rb:546 sig { override.returns(T::Boolean) } def trailing?; end end @@ -20576,13 +20564,13 @@ end # @target &&= value # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:10478 +# pkg:gem/prism#lib/prism/node.rb:10486 class Prism::InstanceVariableAndWriteNode < ::Prism::Node # Initialize a new InstanceVariableAndWriteNode node. # # @return [InstanceVariableAndWriteNode] a new instance of InstanceVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10480 + # pkg:gem/prism#lib/prism/node.rb:10488 sig do params( source: Prism::Source, @@ -20600,36 +20588,36 @@ class Prism::InstanceVariableAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10585 + # pkg:gem/prism#lib/prism/node.rb:10593 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:10492 + # pkg:gem/prism#lib/prism/node.rb:10500 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10497 + # pkg:gem/prism#lib/prism/node.rb:10505 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:10514 + # pkg:gem/prism#lib/prism/node.rb:10522 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:10509 + # pkg:gem/prism#lib/prism/node.rb:10517 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10519 + # pkg:gem/prism#lib/prism/node.rb:10527 sig do params( node_id: Integer, @@ -20646,13 +20634,13 @@ class Prism::InstanceVariableAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10524 + # pkg:gem/prism#lib/prism/node.rb:10532 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:10527 + # pkg:gem/prism#lib/prism/node.rb:10535 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -20663,7 +20651,7 @@ class Prism::InstanceVariableAndWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:10502 + # pkg:gem/prism#lib/prism/node.rb:10510 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -20671,62 +20659,62 @@ class Prism::InstanceVariableAndWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10569 + # pkg:gem/prism#lib/prism/node.rb:10577 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:10532 + # pkg:gem/prism#lib/prism/node.rb:10540 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10535 + # pkg:gem/prism#lib/prism/node.rb:10543 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10564 + # pkg:gem/prism#lib/prism/node.rb:10572 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10548 + # pkg:gem/prism#lib/prism/node.rb:10556 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10543 + # pkg:gem/prism#lib/prism/node.rb:10551 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10556 + # pkg:gem/prism#lib/prism/node.rb:10564 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10574 + # pkg:gem/prism#lib/prism/node.rb:10582 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:10561 + # pkg:gem/prism#lib/prism/node.rb:10569 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10579 + # pkg:gem/prism#lib/prism/node.rb:10587 def type; end end end @@ -20736,13 +20724,13 @@ end # @target += value # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:10598 +# pkg:gem/prism#lib/prism/node.rb:10606 class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node # Initialize a new InstanceVariableOperatorWriteNode node. # # @return [InstanceVariableOperatorWriteNode] a new instance of InstanceVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10600 + # pkg:gem/prism#lib/prism/node.rb:10608 sig do params( source: Prism::Source, @@ -20761,48 +20749,48 @@ class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10704 + # pkg:gem/prism#lib/prism/node.rb:10712 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:10613 + # pkg:gem/prism#lib/prism/node.rb:10621 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader binary_operator: Symbol # - # pkg:gem/prism#lib/prism/node.rb:10685 + # pkg:gem/prism#lib/prism/node.rb:10693 sig { returns(Symbol) } def binary_operator; end # attr_reader binary_operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10669 + # pkg:gem/prism#lib/prism/node.rb:10677 sig { returns(Prism::Location) } def binary_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10618 + # pkg:gem/prism#lib/prism/node.rb:10626 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:10635 + # pkg:gem/prism#lib/prism/node.rb:10643 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:10630 + # pkg:gem/prism#lib/prism/node.rb:10638 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol) -> InstanceVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10640 + # pkg:gem/prism#lib/prism/node.rb:10648 sig do params( node_id: Integer, @@ -20820,13 +20808,13 @@ class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10645 + # pkg:gem/prism#lib/prism/node.rb:10653 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:10648 + # pkg:gem/prism#lib/prism/node.rb:10656 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -20837,7 +20825,7 @@ class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:10623 + # pkg:gem/prism#lib/prism/node.rb:10631 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -20845,19 +20833,19 @@ class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10688 + # pkg:gem/prism#lib/prism/node.rb:10696 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:10653 + # pkg:gem/prism#lib/prism/node.rb:10661 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10656 + # pkg:gem/prism#lib/prism/node.rb:10664 sig { returns(Prism::Location) } def name_loc; end @@ -20876,31 +20864,31 @@ class Prism::InstanceVariableOperatorWriteNode < ::Prism::Node # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10677 + # pkg:gem/prism#lib/prism/node.rb:10685 def save_binary_operator_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10664 + # pkg:gem/prism#lib/prism/node.rb:10672 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10693 + # pkg:gem/prism#lib/prism/node.rb:10701 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:10682 + # pkg:gem/prism#lib/prism/node.rb:10690 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10698 + # pkg:gem/prism#lib/prism/node.rb:10706 def type; end end end @@ -20910,13 +20898,13 @@ end # @target ||= value # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:10718 +# pkg:gem/prism#lib/prism/node.rb:10726 class Prism::InstanceVariableOrWriteNode < ::Prism::Node # Initialize a new InstanceVariableOrWriteNode node. # # @return [InstanceVariableOrWriteNode] a new instance of InstanceVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10720 + # pkg:gem/prism#lib/prism/node.rb:10728 sig do params( source: Prism::Source, @@ -20934,36 +20922,36 @@ class Prism::InstanceVariableOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10825 + # pkg:gem/prism#lib/prism/node.rb:10833 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:10732 + # pkg:gem/prism#lib/prism/node.rb:10740 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10737 + # pkg:gem/prism#lib/prism/node.rb:10745 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:10754 + # pkg:gem/prism#lib/prism/node.rb:10762 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:10749 + # pkg:gem/prism#lib/prism/node.rb:10757 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> InstanceVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:10759 + # pkg:gem/prism#lib/prism/node.rb:10767 sig do params( node_id: Integer, @@ -20980,13 +20968,13 @@ class Prism::InstanceVariableOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10764 + # pkg:gem/prism#lib/prism/node.rb:10772 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:10767 + # pkg:gem/prism#lib/prism/node.rb:10775 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -20997,7 +20985,7 @@ class Prism::InstanceVariableOrWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:10742 + # pkg:gem/prism#lib/prism/node.rb:10750 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -21005,62 +20993,62 @@ class Prism::InstanceVariableOrWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10809 + # pkg:gem/prism#lib/prism/node.rb:10817 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:10772 + # pkg:gem/prism#lib/prism/node.rb:10780 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10775 + # pkg:gem/prism#lib/prism/node.rb:10783 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:10804 + # pkg:gem/prism#lib/prism/node.rb:10812 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:10788 + # pkg:gem/prism#lib/prism/node.rb:10796 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10783 + # pkg:gem/prism#lib/prism/node.rb:10791 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:10796 + # pkg:gem/prism#lib/prism/node.rb:10804 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10814 + # pkg:gem/prism#lib/prism/node.rb:10822 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:10801 + # pkg:gem/prism#lib/prism/node.rb:10809 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10819 + # pkg:gem/prism#lib/prism/node.rb:10827 def type; end end end @@ -21070,49 +21058,49 @@ end # @foo # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:10838 +# pkg:gem/prism#lib/prism/node.rb:10846 class Prism::InstanceVariableReadNode < ::Prism::Node # Initialize a new InstanceVariableReadNode node. # # @return [InstanceVariableReadNode] a new instance of InstanceVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:10840 + # pkg:gem/prism#lib/prism/node.rb:10848 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10911 + # pkg:gem/prism#lib/prism/node.rb:10919 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:10849 + # pkg:gem/prism#lib/prism/node.rb:10857 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10854 + # pkg:gem/prism#lib/prism/node.rb:10862 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:10870 + # pkg:gem/prism#lib/prism/node.rb:10878 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:10865 + # pkg:gem/prism#lib/prism/node.rb:10873 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:10875 + # pkg:gem/prism#lib/prism/node.rb:10883 sig do params( node_id: Integer, @@ -21126,19 +21114,19 @@ class Prism::InstanceVariableReadNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10880 + # pkg:gem/prism#lib/prism/node.rb:10888 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:10883 + # pkg:gem/prism#lib/prism/node.rb:10891 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:10859 + # pkg:gem/prism#lib/prism/node.rb:10867 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -21146,7 +21134,7 @@ class Prism::InstanceVariableReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10895 + # pkg:gem/prism#lib/prism/node.rb:10903 sig { override.returns(String) } def inspect; end @@ -21156,20 +21144,20 @@ class Prism::InstanceVariableReadNode < ::Prism::Node # # @_test # name `:@_test` # - # pkg:gem/prism#lib/prism/node.rb:10892 + # pkg:gem/prism#lib/prism/node.rb:10900 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10900 + # pkg:gem/prism#lib/prism/node.rb:10908 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10905 + # pkg:gem/prism#lib/prism/node.rb:10913 def type; end end end @@ -21179,49 +21167,49 @@ end # @foo, @bar = baz # ^^^^ ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:10921 +# pkg:gem/prism#lib/prism/node.rb:10929 class Prism::InstanceVariableTargetNode < ::Prism::Node # Initialize a new InstanceVariableTargetNode node. # # @return [InstanceVariableTargetNode] a new instance of InstanceVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:10923 + # pkg:gem/prism#lib/prism/node.rb:10931 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:10990 + # pkg:gem/prism#lib/prism/node.rb:10998 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:10932 + # pkg:gem/prism#lib/prism/node.rb:10940 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10937 + # pkg:gem/prism#lib/prism/node.rb:10945 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:10953 + # pkg:gem/prism#lib/prism/node.rb:10961 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:10948 + # pkg:gem/prism#lib/prism/node.rb:10956 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> InstanceVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:10958 + # pkg:gem/prism#lib/prism/node.rb:10966 sig do params( node_id: Integer, @@ -21235,19 +21223,19 @@ class Prism::InstanceVariableTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:10963 + # pkg:gem/prism#lib/prism/node.rb:10971 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:10966 + # pkg:gem/prism#lib/prism/node.rb:10974 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:10942 + # pkg:gem/prism#lib/prism/node.rb:10950 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -21255,26 +21243,26 @@ class Prism::InstanceVariableTargetNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:10974 + # pkg:gem/prism#lib/prism/node.rb:10982 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:10971 + # pkg:gem/prism#lib/prism/node.rb:10979 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:10979 + # pkg:gem/prism#lib/prism/node.rb:10987 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:10984 + # pkg:gem/prism#lib/prism/node.rb:10992 def type; end end end @@ -21284,13 +21272,13 @@ end # @foo = 1 # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:11000 +# pkg:gem/prism#lib/prism/node.rb:11008 class Prism::InstanceVariableWriteNode < ::Prism::Node # Initialize a new InstanceVariableWriteNode node. # # @return [InstanceVariableWriteNode] a new instance of InstanceVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:11002 + # pkg:gem/prism#lib/prism/node.rb:11010 sig do params( source: Prism::Source, @@ -21308,36 +21296,36 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:11123 + # pkg:gem/prism#lib/prism/node.rb:11131 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11014 + # pkg:gem/prism#lib/prism/node.rb:11022 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11019 + # pkg:gem/prism#lib/prism/node.rb:11027 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:11036 + # pkg:gem/prism#lib/prism/node.rb:11044 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:11031 + # pkg:gem/prism#lib/prism/node.rb:11039 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> InstanceVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:11041 + # pkg:gem/prism#lib/prism/node.rb:11049 sig do params( node_id: Integer, @@ -21354,13 +21342,13 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11046 + # pkg:gem/prism#lib/prism/node.rb:11054 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:11049 + # pkg:gem/prism#lib/prism/node.rb:11057 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -21368,7 +21356,7 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:11024 + # pkg:gem/prism#lib/prism/node.rb:11032 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -21376,7 +21364,7 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:11107 + # pkg:gem/prism#lib/prism/node.rb:11115 sig { override.returns(String) } def inspect; end @@ -21386,7 +21374,7 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # # @_foo = "bar" # name `@_foo` # - # pkg:gem/prism#lib/prism/node.rb:11058 + # pkg:gem/prism#lib/prism/node.rb:11066 sig { returns(Symbol) } def name; end @@ -21395,13 +21383,13 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # @_x = 1 # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:11064 + # pkg:gem/prism#lib/prism/node.rb:11072 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:11102 + # pkg:gem/prism#lib/prism/node.rb:11110 sig { returns(String) } def operator; end @@ -21410,25 +21398,25 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # @x = y # ^ # - # pkg:gem/prism#lib/prism/node.rb:11089 + # pkg:gem/prism#lib/prism/node.rb:11097 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11072 + # pkg:gem/prism#lib/prism/node.rb:11080 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11097 + # pkg:gem/prism#lib/prism/node.rb:11105 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:11112 + # pkg:gem/prism#lib/prism/node.rb:11120 sig { override.returns(Symbol) } def type; end @@ -21440,41 +21428,41 @@ class Prism::InstanceVariableWriteNode < ::Prism::Node # @_x = 1234 # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:11083 + # pkg:gem/prism#lib/prism/node.rb:11091 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:11117 + # pkg:gem/prism#lib/prism/node.rb:11125 def type; end end end # Flags for integer nodes that correspond to the base of the integer. # -# pkg:gem/prism#lib/prism/node.rb:19820 +# pkg:gem/prism#lib/prism/node.rb:19828 module Prism::IntegerBaseFlags; end # 0b prefix # -# pkg:gem/prism#lib/prism/node.rb:19822 +# pkg:gem/prism#lib/prism/node.rb:19830 Prism::IntegerBaseFlags::BINARY = T.let(T.unsafe(nil), Integer) # 0d or no prefix # -# pkg:gem/prism#lib/prism/node.rb:19825 +# pkg:gem/prism#lib/prism/node.rb:19833 Prism::IntegerBaseFlags::DECIMAL = T.let(T.unsafe(nil), Integer) # 0x prefix # -# pkg:gem/prism#lib/prism/node.rb:19831 +# pkg:gem/prism#lib/prism/node.rb:19839 Prism::IntegerBaseFlags::HEXADECIMAL = T.let(T.unsafe(nil), Integer) # 0o or 0 prefix # -# pkg:gem/prism#lib/prism/node.rb:19828 +# pkg:gem/prism#lib/prism/node.rb:19836 Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer) # Represents an integer number literal. @@ -21482,13 +21470,13 @@ Prism::IntegerBaseFlags::OCTAL = T.let(T.unsafe(nil), Integer) # 1 # ^ # -# pkg:gem/prism#lib/prism/node.rb:11136 +# pkg:gem/prism#lib/prism/node.rb:11144 class Prism::IntegerNode < ::Prism::Node # Initialize a new IntegerNode node. # # @return [IntegerNode] a new instance of IntegerNode # - # pkg:gem/prism#lib/prism/node.rb:11138 + # pkg:gem/prism#lib/prism/node.rb:11146 sig do params( source: Prism::Source, @@ -21503,12 +21491,12 @@ class Prism::IntegerNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:11225 + # pkg:gem/prism#lib/prism/node.rb:11233 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11147 + # pkg:gem/prism#lib/prism/node.rb:11155 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -21516,31 +21504,31 @@ class Prism::IntegerNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11186 + # pkg:gem/prism#lib/prism/node.rb:11194 sig { returns(T::Boolean) } def binary?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11152 + # pkg:gem/prism#lib/prism/node.rb:11160 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:11168 + # pkg:gem/prism#lib/prism/node.rb:11176 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:11163 + # pkg:gem/prism#lib/prism/node.rb:11171 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Integer) -> IntegerNode # - # pkg:gem/prism#lib/prism/node.rb:11173 + # pkg:gem/prism#lib/prism/node.rb:11181 sig do params( node_id: Integer, @@ -21555,26 +21543,26 @@ class Prism::IntegerNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11191 + # pkg:gem/prism#lib/prism/node.rb:11199 sig { returns(T::Boolean) } def decimal?; end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11178 + # pkg:gem/prism#lib/prism/node.rb:11186 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Integer } # - # pkg:gem/prism#lib/prism/node.rb:11181 + # pkg:gem/prism#lib/prism/node.rb:11189 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:11157 + # pkg:gem/prism#lib/prism/node.rb:11165 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -21584,13 +21572,13 @@ class Prism::IntegerNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11201 + # pkg:gem/prism#lib/prism/node.rb:11209 sig { returns(T::Boolean) } def hexadecimal?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:11209 + # pkg:gem/prism#lib/prism/node.rb:11217 sig { override.returns(String) } def inspect; end @@ -21598,26 +21586,26 @@ class Prism::IntegerNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11196 + # pkg:gem/prism#lib/prism/node.rb:11204 sig { returns(T::Boolean) } def octal?; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:11214 + # pkg:gem/prism#lib/prism/node.rb:11222 sig { override.returns(Symbol) } def type; end # The value of the integer literal as a number. # - # pkg:gem/prism#lib/prism/node.rb:11206 + # pkg:gem/prism#lib/prism/node.rb:11214 sig { returns(Integer) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:11219 + # pkg:gem/prism#lib/prism/node.rb:11227 def type; end end end @@ -21627,7 +21615,7 @@ end # if /foo #{bar} baz/ then end # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:11236 +# pkg:gem/prism#lib/prism/node.rb:11244 class Prism::InterpolatedMatchLastLineNode < ::Prism::Node include ::Prism::RegularExpressionOptions @@ -21635,7 +21623,7 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [InterpolatedMatchLastLineNode] a new instance of InterpolatedMatchLastLineNode # - # pkg:gem/prism#lib/prism/node.rb:11238 + # pkg:gem/prism#lib/prism/node.rb:11246 sig do params( source: Prism::Source, @@ -21652,12 +21640,12 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:11399 + # pkg:gem/prism#lib/prism/node.rb:11407 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11249 + # pkg:gem/prism#lib/prism/node.rb:11257 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -21665,43 +21653,43 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11314 + # pkg:gem/prism#lib/prism/node.rb:11322 sig { returns(T::Boolean) } def ascii_8bit?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11254 + # pkg:gem/prism#lib/prism/node.rb:11262 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:11378 + # pkg:gem/prism#lib/prism/node.rb:11386 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:11360 + # pkg:gem/prism#lib/prism/node.rb:11368 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:11271 + # pkg:gem/prism#lib/prism/node.rb:11279 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:11266 + # pkg:gem/prism#lib/prism/node.rb:11274 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedMatchLastLineNode # - # pkg:gem/prism#lib/prism/node.rb:11276 + # pkg:gem/prism#lib/prism/node.rb:11284 sig do params( node_id: Integer, @@ -21717,26 +21705,26 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11281 + # pkg:gem/prism#lib/prism/node.rb:11289 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:11284 + # pkg:gem/prism#lib/prism/node.rb:11292 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:11259 + # pkg:gem/prism#lib/prism/node.rb:11267 def each_child_node; end # def euc_jp?: () -> bool # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11309 + # pkg:gem/prism#lib/prism/node.rb:11317 sig { returns(T::Boolean) } def euc_jp?; end @@ -21744,7 +21732,7 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11294 + # pkg:gem/prism#lib/prism/node.rb:11302 sig { returns(T::Boolean) } def extended?; end @@ -21755,7 +21743,7 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11334 + # pkg:gem/prism#lib/prism/node.rb:11342 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -21763,7 +21751,7 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11339 + # pkg:gem/prism#lib/prism/node.rb:11347 sig { returns(T::Boolean) } def forced_us_ascii_encoding?; end @@ -21771,7 +21759,7 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11329 + # pkg:gem/prism#lib/prism/node.rb:11337 sig { returns(T::Boolean) } def forced_utf8_encoding?; end @@ -21779,13 +21767,13 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11289 + # pkg:gem/prism#lib/prism/node.rb:11297 sig { returns(T::Boolean) } def ignore_case?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:11383 + # pkg:gem/prism#lib/prism/node.rb:11391 sig { override.returns(String) } def inspect; end @@ -21793,7 +21781,7 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11299 + # pkg:gem/prism#lib/prism/node.rb:11307 sig { returns(T::Boolean) } def multi_line?; end @@ -21804,19 +21792,19 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11304 + # pkg:gem/prism#lib/prism/node.rb:11312 sig { returns(T::Boolean) } def once?; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:11373 + # pkg:gem/prism#lib/prism/node.rb:11381 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:11344 + # pkg:gem/prism#lib/prism/node.rb:11352 sig { returns(Prism::Location) } def opening_loc; end @@ -21825,25 +21813,25 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] # - # pkg:gem/prism#lib/prism/node.rb:11357 + # pkg:gem/prism#lib/prism/node.rb:11365 sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } def parts; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11368 + # pkg:gem/prism#lib/prism/node.rb:11376 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11352 + # pkg:gem/prism#lib/prism/node.rb:11360 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:11388 + # pkg:gem/prism#lib/prism/node.rb:11396 sig { override.returns(Symbol) } def type; end @@ -21851,7 +21839,7 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11324 + # pkg:gem/prism#lib/prism/node.rb:11332 sig { returns(T::Boolean) } def utf_8?; end @@ -21859,14 +21847,14 @@ class Prism::InterpolatedMatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11319 + # pkg:gem/prism#lib/prism/node.rb:11327 sig { returns(T::Boolean) } def windows_31j?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:11393 + # pkg:gem/prism#lib/prism/node.rb:11401 def type; end end end @@ -21876,7 +21864,7 @@ end # /foo #{bar} baz/ # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:11413 +# pkg:gem/prism#lib/prism/node.rb:11421 class Prism::InterpolatedRegularExpressionNode < ::Prism::Node include ::Prism::RegularExpressionOptions @@ -21884,7 +21872,7 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [InterpolatedRegularExpressionNode] a new instance of InterpolatedRegularExpressionNode # - # pkg:gem/prism#lib/prism/node.rb:11415 + # pkg:gem/prism#lib/prism/node.rb:11423 sig do params( source: Prism::Source, @@ -21901,12 +21889,12 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:11576 + # pkg:gem/prism#lib/prism/node.rb:11584 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11426 + # pkg:gem/prism#lib/prism/node.rb:11434 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -21914,43 +21902,43 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11491 + # pkg:gem/prism#lib/prism/node.rb:11499 sig { returns(T::Boolean) } def ascii_8bit?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11431 + # pkg:gem/prism#lib/prism/node.rb:11439 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:11555 + # pkg:gem/prism#lib/prism/node.rb:11563 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:11537 + # pkg:gem/prism#lib/prism/node.rb:11545 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:11448 + # pkg:gem/prism#lib/prism/node.rb:11456 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:11443 + # pkg:gem/prism#lib/prism/node.rb:11451 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedRegularExpressionNode # - # pkg:gem/prism#lib/prism/node.rb:11453 + # pkg:gem/prism#lib/prism/node.rb:11461 sig do params( node_id: Integer, @@ -21966,26 +21954,26 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11458 + # pkg:gem/prism#lib/prism/node.rb:11466 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:11461 + # pkg:gem/prism#lib/prism/node.rb:11469 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:11436 + # pkg:gem/prism#lib/prism/node.rb:11444 def each_child_node; end # def euc_jp?: () -> bool # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11486 + # pkg:gem/prism#lib/prism/node.rb:11494 sig { returns(T::Boolean) } def euc_jp?; end @@ -21993,7 +21981,7 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11471 + # pkg:gem/prism#lib/prism/node.rb:11479 sig { returns(T::Boolean) } def extended?; end @@ -22004,7 +21992,7 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11511 + # pkg:gem/prism#lib/prism/node.rb:11519 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -22012,7 +22000,7 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11516 + # pkg:gem/prism#lib/prism/node.rb:11524 sig { returns(T::Boolean) } def forced_us_ascii_encoding?; end @@ -22020,7 +22008,7 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11506 + # pkg:gem/prism#lib/prism/node.rb:11514 sig { returns(T::Boolean) } def forced_utf8_encoding?; end @@ -22028,13 +22016,13 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11466 + # pkg:gem/prism#lib/prism/node.rb:11474 sig { returns(T::Boolean) } def ignore_case?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:11560 + # pkg:gem/prism#lib/prism/node.rb:11568 sig { override.returns(String) } def inspect; end @@ -22042,7 +22030,7 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11476 + # pkg:gem/prism#lib/prism/node.rb:11484 sig { returns(T::Boolean) } def multi_line?; end @@ -22053,19 +22041,19 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11481 + # pkg:gem/prism#lib/prism/node.rb:11489 sig { returns(T::Boolean) } def once?; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:11550 + # pkg:gem/prism#lib/prism/node.rb:11558 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:11521 + # pkg:gem/prism#lib/prism/node.rb:11529 sig { returns(Prism::Location) } def opening_loc; end @@ -22074,25 +22062,25 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] # - # pkg:gem/prism#lib/prism/node.rb:11534 + # pkg:gem/prism#lib/prism/node.rb:11542 sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } def parts; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11545 + # pkg:gem/prism#lib/prism/node.rb:11553 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11529 + # pkg:gem/prism#lib/prism/node.rb:11537 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:11565 + # pkg:gem/prism#lib/prism/node.rb:11573 sig { override.returns(Symbol) } def type; end @@ -22100,7 +22088,7 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11501 + # pkg:gem/prism#lib/prism/node.rb:11509 sig { returns(T::Boolean) } def utf_8?; end @@ -22108,14 +22096,14 @@ class Prism::InterpolatedRegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11496 + # pkg:gem/prism#lib/prism/node.rb:11504 sig { returns(T::Boolean) } def windows_31j?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:11570 + # pkg:gem/prism#lib/prism/node.rb:11578 def type; end end end @@ -22125,7 +22113,7 @@ end # "foo #{bar} baz" # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:11590 +# pkg:gem/prism#lib/prism/node.rb:11598 class Prism::InterpolatedStringNode < ::Prism::Node include ::Prism::HeredocQuery @@ -22133,7 +22121,7 @@ class Prism::InterpolatedStringNode < ::Prism::Node # # @return [InterpolatedStringNode] a new instance of InterpolatedStringNode # - # pkg:gem/prism#lib/prism/node.rb:11592 + # pkg:gem/prism#lib/prism/node.rb:11600 sig do params( source: Prism::Source, @@ -22150,48 +22138,48 @@ class Prism::InterpolatedStringNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:11720 + # pkg:gem/prism#lib/prism/node.rb:11728 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11603 + # pkg:gem/prism#lib/prism/node.rb:11611 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11608 + # pkg:gem/prism#lib/prism/node.rb:11616 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:11699 + # pkg:gem/prism#lib/prism/node.rb:11707 sig { returns(T.nilable(String)) } def closing; end # attr_reader closing_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:11675 + # pkg:gem/prism#lib/prism/node.rb:11683 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:11625 + # pkg:gem/prism#lib/prism/node.rb:11633 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:11620 + # pkg:gem/prism#lib/prism/node.rb:11628 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], ?closing_loc: Location?) -> InterpolatedStringNode # - # pkg:gem/prism#lib/prism/node.rb:11630 + # pkg:gem/prism#lib/prism/node.rb:11638 sig do params( node_id: Integer, @@ -22207,19 +22195,19 @@ class Prism::InterpolatedStringNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11635 + # pkg:gem/prism#lib/prism/node.rb:11643 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode], closing_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:11638 + # pkg:gem/prism#lib/prism/node.rb:11646 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:11613 + # pkg:gem/prism#lib/prism/node.rb:11621 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -22229,7 +22217,7 @@ class Prism::InterpolatedStringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11643 + # pkg:gem/prism#lib/prism/node.rb:11651 sig { returns(T::Boolean) } def frozen?; end @@ -22238,7 +22226,7 @@ class Prism::InterpolatedStringNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:11704 + # pkg:gem/prism#lib/prism/node.rb:11712 sig { override.returns(String) } def inspect; end @@ -22246,7 +22234,7 @@ class Prism::InterpolatedStringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:11648 + # pkg:gem/prism#lib/prism/node.rb:11656 sig { returns(T::Boolean) } def mutable?; end @@ -22255,19 +22243,19 @@ class Prism::InterpolatedStringNode < ::Prism::Node # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:11694 + # pkg:gem/prism#lib/prism/node.rb:11702 sig { returns(T.nilable(String)) } def opening; end # attr_reader opening_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:11653 + # pkg:gem/prism#lib/prism/node.rb:11661 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode | InterpolatedStringNode | XStringNode | InterpolatedXStringNode | SymbolNode | InterpolatedSymbolNode] # - # pkg:gem/prism#lib/prism/node.rb:11672 + # pkg:gem/prism#lib/prism/node.rb:11680 sig do returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode, Prism::InterpolatedStringNode, Prism::XStringNode, Prism::InterpolatedXStringNode, Prism::SymbolNode, Prism::InterpolatedSymbolNode)]) end @@ -22276,38 +22264,38 @@ class Prism::InterpolatedStringNode < ::Prism::Node # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11689 + # pkg:gem/prism#lib/prism/node.rb:11697 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11667 + # pkg:gem/prism#lib/prism/node.rb:11675 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:11709 + # pkg:gem/prism#lib/prism/node.rb:11717 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:11714 + # pkg:gem/prism#lib/prism/node.rb:11722 def type; end end end # Flags for interpolated string nodes that indicated mutability if they are also marked as literals. # -# pkg:gem/prism#lib/prism/node.rb:19835 +# pkg:gem/prism#lib/prism/node.rb:19843 module Prism::InterpolatedStringNodeFlags; end -# pkg:gem/prism#lib/prism/node.rb:19837 +# pkg:gem/prism#lib/prism/node.rb:19845 Prism::InterpolatedStringNodeFlags::FROZEN = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/node.rb:19840 +# pkg:gem/prism#lib/prism/node.rb:19848 Prism::InterpolatedStringNodeFlags::MUTABLE = T.let(T.unsafe(nil), Integer) # Represents a symbol literal that contains interpolation. @@ -22315,13 +22303,13 @@ Prism::InterpolatedStringNodeFlags::MUTABLE = T.let(T.unsafe(nil), Integer) # :"foo #{bar} baz" # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:11734 +# pkg:gem/prism#lib/prism/node.rb:11742 class Prism::InterpolatedSymbolNode < ::Prism::Node # Initialize a new InterpolatedSymbolNode node. # # @return [InterpolatedSymbolNode] a new instance of InterpolatedSymbolNode # - # pkg:gem/prism#lib/prism/node.rb:11736 + # pkg:gem/prism#lib/prism/node.rb:11744 sig do params( source: Prism::Source, @@ -22338,48 +22326,48 @@ class Prism::InterpolatedSymbolNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:11854 + # pkg:gem/prism#lib/prism/node.rb:11862 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11747 + # pkg:gem/prism#lib/prism/node.rb:11755 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11752 + # pkg:gem/prism#lib/prism/node.rb:11760 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:11833 + # pkg:gem/prism#lib/prism/node.rb:11841 sig { returns(T.nilable(String)) } def closing; end # attr_reader closing_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:11809 + # pkg:gem/prism#lib/prism/node.rb:11817 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:11769 + # pkg:gem/prism#lib/prism/node.rb:11777 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:11764 + # pkg:gem/prism#lib/prism/node.rb:11772 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location?) -> InterpolatedSymbolNode # - # pkg:gem/prism#lib/prism/node.rb:11774 + # pkg:gem/prism#lib/prism/node.rb:11782 sig do params( node_id: Integer, @@ -22395,19 +22383,19 @@ class Prism::InterpolatedSymbolNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11779 + # pkg:gem/prism#lib/prism/node.rb:11787 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:11782 + # pkg:gem/prism#lib/prism/node.rb:11790 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:11757 + # pkg:gem/prism#lib/prism/node.rb:11765 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -22415,7 +22403,7 @@ class Prism::InterpolatedSymbolNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:11838 + # pkg:gem/prism#lib/prism/node.rb:11846 sig { override.returns(String) } def inspect; end @@ -22424,44 +22412,44 @@ class Prism::InterpolatedSymbolNode < ::Prism::Node # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:11828 + # pkg:gem/prism#lib/prism/node.rb:11836 sig { returns(T.nilable(String)) } def opening; end # attr_reader opening_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:11787 + # pkg:gem/prism#lib/prism/node.rb:11795 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] # - # pkg:gem/prism#lib/prism/node.rb:11806 + # pkg:gem/prism#lib/prism/node.rb:11814 sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } def parts; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11823 + # pkg:gem/prism#lib/prism/node.rb:11831 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11801 + # pkg:gem/prism#lib/prism/node.rb:11809 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:11843 + # pkg:gem/prism#lib/prism/node.rb:11851 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:11848 + # pkg:gem/prism#lib/prism/node.rb:11856 def type; end end end @@ -22471,7 +22459,7 @@ end # `foo #{bar} baz` # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:11867 +# pkg:gem/prism#lib/prism/node.rb:11875 class Prism::InterpolatedXStringNode < ::Prism::Node include ::Prism::HeredocQuery @@ -22479,7 +22467,7 @@ class Prism::InterpolatedXStringNode < ::Prism::Node # # @return [InterpolatedXStringNode] a new instance of InterpolatedXStringNode # - # pkg:gem/prism#lib/prism/node.rb:11869 + # pkg:gem/prism#lib/prism/node.rb:11877 sig do params( source: Prism::Source, @@ -22496,48 +22484,48 @@ class Prism::InterpolatedXStringNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:11975 + # pkg:gem/prism#lib/prism/node.rb:11983 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11880 + # pkg:gem/prism#lib/prism/node.rb:11888 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11885 + # pkg:gem/prism#lib/prism/node.rb:11893 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:11954 + # pkg:gem/prism#lib/prism/node.rb:11962 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:11936 + # pkg:gem/prism#lib/prism/node.rb:11944 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:11902 + # pkg:gem/prism#lib/prism/node.rb:11910 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:11897 + # pkg:gem/prism#lib/prism/node.rb:11905 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], ?closing_loc: Location) -> InterpolatedXStringNode # - # pkg:gem/prism#lib/prism/node.rb:11907 + # pkg:gem/prism#lib/prism/node.rb:11915 sig do params( node_id: Integer, @@ -22553,19 +22541,19 @@ class Prism::InterpolatedXStringNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:11912 + # pkg:gem/prism#lib/prism/node.rb:11920 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode], closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:11915 + # pkg:gem/prism#lib/prism/node.rb:11923 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:11890 + # pkg:gem/prism#lib/prism/node.rb:11898 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -22576,7 +22564,7 @@ class Prism::InterpolatedXStringNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:11959 + # pkg:gem/prism#lib/prism/node.rb:11967 sig { override.returns(String) } def inspect; end @@ -22585,44 +22573,44 @@ class Prism::InterpolatedXStringNode < ::Prism::Node # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:11949 + # pkg:gem/prism#lib/prism/node.rb:11957 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:11920 + # pkg:gem/prism#lib/prism/node.rb:11928 sig { returns(Prism::Location) } def opening_loc; end # attr_reader parts: Array[StringNode | EmbeddedStatementsNode | EmbeddedVariableNode] # - # pkg:gem/prism#lib/prism/node.rb:11933 + # pkg:gem/prism#lib/prism/node.rb:11941 sig { returns(T::Array[T.any(Prism::StringNode, Prism::EmbeddedStatementsNode, Prism::EmbeddedVariableNode)]) } def parts; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11944 + # pkg:gem/prism#lib/prism/node.rb:11952 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:11928 + # pkg:gem/prism#lib/prism/node.rb:11936 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:11964 + # pkg:gem/prism#lib/prism/node.rb:11972 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:11969 + # pkg:gem/prism#lib/prism/node.rb:11977 def type; end end end @@ -22632,68 +22620,68 @@ end # -> { it } # ^^ # -# pkg:gem/prism#lib/prism/node.rb:11988 +# pkg:gem/prism#lib/prism/node.rb:11996 class Prism::ItLocalVariableReadNode < ::Prism::Node # Initialize a new ItLocalVariableReadNode node. # # @return [ItLocalVariableReadNode] a new instance of ItLocalVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:11990 + # pkg:gem/prism#lib/prism/node.rb:11998 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12053 + # pkg:gem/prism#lib/prism/node.rb:12061 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:11998 + # pkg:gem/prism#lib/prism/node.rb:12006 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12003 + # pkg:gem/prism#lib/prism/node.rb:12011 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12019 + # pkg:gem/prism#lib/prism/node.rb:12027 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12014 + # pkg:gem/prism#lib/prism/node.rb:12022 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItLocalVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:12024 + # pkg:gem/prism#lib/prism/node.rb:12032 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ItLocalVariableReadNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12029 + # pkg:gem/prism#lib/prism/node.rb:12037 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:12032 + # pkg:gem/prism#lib/prism/node.rb:12040 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:12008 + # pkg:gem/prism#lib/prism/node.rb:12016 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -22701,20 +22689,20 @@ class Prism::ItLocalVariableReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12037 + # pkg:gem/prism#lib/prism/node.rb:12045 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12042 + # pkg:gem/prism#lib/prism/node.rb:12050 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12047 + # pkg:gem/prism#lib/prism/node.rb:12055 def type; end end end @@ -22724,68 +22712,68 @@ end # -> { it + it } # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:12062 +# pkg:gem/prism#lib/prism/node.rb:12070 class Prism::ItParametersNode < ::Prism::Node # Initialize a new ItParametersNode node. # # @return [ItParametersNode] a new instance of ItParametersNode # - # pkg:gem/prism#lib/prism/node.rb:12064 + # pkg:gem/prism#lib/prism/node.rb:12072 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12127 + # pkg:gem/prism#lib/prism/node.rb:12135 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12072 + # pkg:gem/prism#lib/prism/node.rb:12080 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12077 + # pkg:gem/prism#lib/prism/node.rb:12085 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12093 + # pkg:gem/prism#lib/prism/node.rb:12101 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12088 + # pkg:gem/prism#lib/prism/node.rb:12096 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> ItParametersNode # - # pkg:gem/prism#lib/prism/node.rb:12098 + # pkg:gem/prism#lib/prism/node.rb:12106 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::ItParametersNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12103 + # pkg:gem/prism#lib/prism/node.rb:12111 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:12106 + # pkg:gem/prism#lib/prism/node.rb:12114 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:12082 + # pkg:gem/prism#lib/prism/node.rb:12090 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -22793,20 +22781,20 @@ class Prism::ItParametersNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12111 + # pkg:gem/prism#lib/prism/node.rb:12119 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12116 + # pkg:gem/prism#lib/prism/node.rb:12124 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12121 + # pkg:gem/prism#lib/prism/node.rb:12129 def type; end end end @@ -22816,13 +22804,13 @@ end # foo(a: b) # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:12136 +# pkg:gem/prism#lib/prism/node.rb:12144 class Prism::KeywordHashNode < ::Prism::Node # Initialize a new KeywordHashNode node. # # @return [KeywordHashNode] a new instance of KeywordHashNode # - # pkg:gem/prism#lib/prism/node.rb:12138 + # pkg:gem/prism#lib/prism/node.rb:12146 sig do params( source: Prism::Source, @@ -22837,36 +22825,36 @@ class Prism::KeywordHashNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12211 + # pkg:gem/prism#lib/prism/node.rb:12219 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12147 + # pkg:gem/prism#lib/prism/node.rb:12155 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12152 + # pkg:gem/prism#lib/prism/node.rb:12160 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12169 + # pkg:gem/prism#lib/prism/node.rb:12177 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12164 + # pkg:gem/prism#lib/prism/node.rb:12172 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?elements: Array[AssocNode | AssocSplatNode]) -> KeywordHashNode # - # pkg:gem/prism#lib/prism/node.rb:12174 + # pkg:gem/prism#lib/prism/node.rb:12182 sig do params( node_id: Integer, @@ -22880,24 +22868,24 @@ class Prism::KeywordHashNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12179 + # pkg:gem/prism#lib/prism/node.rb:12187 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, elements: Array[AssocNode | AssocSplatNode] } # - # pkg:gem/prism#lib/prism/node.rb:12182 + # pkg:gem/prism#lib/prism/node.rb:12190 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:12157 + # pkg:gem/prism#lib/prism/node.rb:12165 def each_child_node; end # attr_reader elements: Array[AssocNode | AssocSplatNode] # - # pkg:gem/prism#lib/prism/node.rb:12192 + # pkg:gem/prism#lib/prism/node.rb:12200 sig { returns(T::Array[T.any(Prism::AssocNode, Prism::AssocSplatNode)]) } def elements; end @@ -22906,7 +22894,7 @@ class Prism::KeywordHashNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12195 + # pkg:gem/prism#lib/prism/node.rb:12203 sig { override.returns(String) } def inspect; end @@ -22914,32 +22902,32 @@ class Prism::KeywordHashNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:12187 + # pkg:gem/prism#lib/prism/node.rb:12195 sig { returns(T::Boolean) } def symbol_keys?; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12200 + # pkg:gem/prism#lib/prism/node.rb:12208 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12205 + # pkg:gem/prism#lib/prism/node.rb:12213 def type; end end end # Flags for keyword hash nodes. # -# pkg:gem/prism#lib/prism/node.rb:19844 +# pkg:gem/prism#lib/prism/node.rb:19852 module Prism::KeywordHashNodeFlags; end # a keyword hash which only has `AssocNode` elements all with symbol keys, which means the elements can be treated as keyword arguments # -# pkg:gem/prism#lib/prism/node.rb:19846 +# pkg:gem/prism#lib/prism/node.rb:19854 Prism::KeywordHashNodeFlags::SYMBOL_KEYS = T.let(T.unsafe(nil), Integer) # Represents a keyword rest parameter to a method, block, or lambda definition. @@ -22948,13 +22936,13 @@ Prism::KeywordHashNodeFlags::SYMBOL_KEYS = T.let(T.unsafe(nil), Integer) # ^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:12224 +# pkg:gem/prism#lib/prism/node.rb:12232 class Prism::KeywordRestParameterNode < ::Prism::Node # Initialize a new KeywordRestParameterNode node. # # @return [KeywordRestParameterNode] a new instance of KeywordRestParameterNode # - # pkg:gem/prism#lib/prism/node.rb:12226 + # pkg:gem/prism#lib/prism/node.rb:12234 sig do params( source: Prism::Source, @@ -22971,36 +22959,36 @@ class Prism::KeywordRestParameterNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12337 + # pkg:gem/prism#lib/prism/node.rb:12345 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12237 + # pkg:gem/prism#lib/prism/node.rb:12245 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12242 + # pkg:gem/prism#lib/prism/node.rb:12250 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12258 + # pkg:gem/prism#lib/prism/node.rb:12266 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12253 + # pkg:gem/prism#lib/prism/node.rb:12261 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> KeywordRestParameterNode # - # pkg:gem/prism#lib/prism/node.rb:12263 + # pkg:gem/prism#lib/prism/node.rb:12271 sig do params( node_id: Integer, @@ -23016,19 +23004,19 @@ class Prism::KeywordRestParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12268 + # pkg:gem/prism#lib/prism/node.rb:12276 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:12271 + # pkg:gem/prism#lib/prism/node.rb:12279 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:12247 + # pkg:gem/prism#lib/prism/node.rb:12255 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -23036,31 +23024,31 @@ class Prism::KeywordRestParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12321 + # pkg:gem/prism#lib/prism/node.rb:12329 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol? # - # pkg:gem/prism#lib/prism/node.rb:12281 + # pkg:gem/prism#lib/prism/node.rb:12289 sig { returns(T.nilable(Symbol)) } def name; end # attr_reader name_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:12284 + # pkg:gem/prism#lib/prism/node.rb:12292 sig { returns(T.nilable(Prism::Location)) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:12316 + # pkg:gem/prism#lib/prism/node.rb:12324 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12303 + # pkg:gem/prism#lib/prism/node.rb:12311 sig { returns(Prism::Location) } def operator_loc; end @@ -23068,32 +23056,32 @@ class Prism::KeywordRestParameterNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:12276 + # pkg:gem/prism#lib/prism/node.rb:12284 sig { returns(T::Boolean) } def repeated_parameter?; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12298 + # pkg:gem/prism#lib/prism/node.rb:12306 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12311 + # pkg:gem/prism#lib/prism/node.rb:12319 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12326 + # pkg:gem/prism#lib/prism/node.rb:12334 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12331 + # pkg:gem/prism#lib/prism/node.rb:12339 def type; end end end @@ -23103,13 +23091,13 @@ end # ->(value) { value * 2 } # ^^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:12350 +# pkg:gem/prism#lib/prism/node.rb:12358 class Prism::LambdaNode < ::Prism::Node # Initialize a new LambdaNode node. # # @return [LambdaNode] a new instance of LambdaNode # - # pkg:gem/prism#lib/prism/node.rb:12352 + # pkg:gem/prism#lib/prism/node.rb:12360 sig do params( source: Prism::Source, @@ -23129,54 +23117,54 @@ class Prism::LambdaNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12489 + # pkg:gem/prism#lib/prism/node.rb:12497 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12366 + # pkg:gem/prism#lib/prism/node.rb:12374 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader body: StatementsNode | BeginNode | nil # - # pkg:gem/prism#lib/prism/node.rb:12455 + # pkg:gem/prism#lib/prism/node.rb:12463 sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12371 + # pkg:gem/prism#lib/prism/node.rb:12379 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:12468 + # pkg:gem/prism#lib/prism/node.rb:12476 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12439 + # pkg:gem/prism#lib/prism/node.rb:12447 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12392 + # pkg:gem/prism#lib/prism/node.rb:12400 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12384 + # pkg:gem/prism#lib/prism/node.rb:12392 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil) -> LambdaNode # - # pkg:gem/prism#lib/prism/node.rb:12397 + # pkg:gem/prism#lib/prism/node.rb:12405 sig do params( node_id: Integer, @@ -23195,13 +23183,13 @@ class Prism::LambdaNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12402 + # pkg:gem/prism#lib/prism/node.rb:12410 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil } # - # pkg:gem/prism#lib/prism/node.rb:12405 + # pkg:gem/prism#lib/prism/node.rb:12413 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -23209,7 +23197,7 @@ class Prism::LambdaNode < ::Prism::Node # # @yield [parameters] # - # pkg:gem/prism#lib/prism/node.rb:12376 + # pkg:gem/prism#lib/prism/node.rb:12384 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -23217,74 +23205,74 @@ class Prism::LambdaNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12473 + # pkg:gem/prism#lib/prism/node.rb:12481 sig { override.returns(String) } def inspect; end # attr_reader locals: Array[Symbol] # - # pkg:gem/prism#lib/prism/node.rb:12410 + # pkg:gem/prism#lib/prism/node.rb:12418 sig { returns(T::Array[Symbol]) } def locals; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:12463 + # pkg:gem/prism#lib/prism/node.rb:12471 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12426 + # pkg:gem/prism#lib/prism/node.rb:12434 sig { returns(Prism::Location) } def opening_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:12458 + # pkg:gem/prism#lib/prism/node.rb:12466 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12413 + # pkg:gem/prism#lib/prism/node.rb:12421 sig { returns(Prism::Location) } def operator_loc; end # attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil # - # pkg:gem/prism#lib/prism/node.rb:12452 + # pkg:gem/prism#lib/prism/node.rb:12460 sig { returns(T.nilable(T.any(Prism::BlockParametersNode, Prism::NumberedParametersNode, Prism::ItParametersNode))) } def parameters; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12447 + # pkg:gem/prism#lib/prism/node.rb:12455 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12434 + # pkg:gem/prism#lib/prism/node.rb:12442 def save_opening_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12421 + # pkg:gem/prism#lib/prism/node.rb:12429 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12478 + # pkg:gem/prism#lib/prism/node.rb:12486 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12483 + # pkg:gem/prism#lib/prism/node.rb:12491 def type; end end end @@ -23295,53 +23283,42 @@ end # generally lines up. However, there are a few cases that require special # handling. # -# pkg:gem/prism#lib/prism/lex_compat.rb:12 +# pkg:gem/prism#lib/prism/lex_compat.rb:10 class Prism::LexCompat # @return [LexCompat] a new instance of LexCompat # - # pkg:gem/prism#lib/prism/lex_compat.rb:624 - def initialize(source, **options); end + # pkg:gem/prism#lib/prism/lex_compat.rb:586 + def initialize(code, **options); end + + # pkg:gem/prism#lib/prism/lex_compat.rb:828 + def add_on_sp_tokens(tokens, source, data_loc, bom, eof_token); end # Returns the value of attribute options. # - # pkg:gem/prism#lib/prism/lex_compat.rb:622 + # pkg:gem/prism#lib/prism/lex_compat.rb:584 def options; end - # pkg:gem/prism#lib/prism/lex_compat.rb:629 + # pkg:gem/prism#lib/prism/lex_compat.rb:591 def result; end - - # Returns the value of attribute source. - # - # pkg:gem/prism#lib/prism/lex_compat.rb:622 - def source; 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. # -# pkg:gem/prism#lib/prism/lex_compat.rb:619 +# pkg:gem/prism#lib/prism/lex_compat.rb:581 Prism::LexCompat::BOM_FLUSHED = T.let(T.unsafe(nil), TrueClass) -# Ripper doesn't include the rest of the token in the event, so we need to -# trim it down to just the content on the first line when comparing. -# -# pkg:gem/prism#lib/prism/lex_compat.rb:230 -class Prism::LexCompat::EndContentToken < ::Prism::LexCompat::Token - # pkg:gem/prism#lib/prism/lex_compat.rb:231 - def ==(other); end -end - # 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 # closes. # -# pkg:gem/prism#lib/prism/lex_compat.rb:291 +# pkg:gem/prism#lib/prism/lex_compat.rb:253 module Prism::LexCompat::Heredoc class << self # Here we will split between the two types of heredocs and return the # object that will store their tokens. # - # pkg:gem/prism#lib/prism/lex_compat.rb:603 + # pkg:gem/prism#lib/prism/lex_compat.rb:565 def build(opening); end end end @@ -23350,23 +23327,23 @@ end # that need to be split on "\\\n" to mimic Ripper's behavior. We also need # to keep track of the state that the heredoc was opened in. # -# pkg:gem/prism#lib/prism/lex_compat.rb:315 +# pkg:gem/prism#lib/prism/lex_compat.rb:277 class Prism::LexCompat::Heredoc::DashHeredoc # @return [DashHeredoc] a new instance of DashHeredoc # - # pkg:gem/prism#lib/prism/lex_compat.rb:318 + # pkg:gem/prism#lib/prism/lex_compat.rb:280 def initialize(split); end - # pkg:gem/prism#lib/prism/lex_compat.rb:323 + # pkg:gem/prism#lib/prism/lex_compat.rb:285 def <<(token); end - # pkg:gem/prism#lib/prism/lex_compat.rb:316 + # pkg:gem/prism#lib/prism/lex_compat.rb:278 def split; end - # pkg:gem/prism#lib/prism/lex_compat.rb:327 + # pkg:gem/prism#lib/prism/lex_compat.rb:289 def to_a; end - # pkg:gem/prism#lib/prism/lex_compat.rb:316 + # pkg:gem/prism#lib/prism/lex_compat.rb:278 def tokens; end end @@ -23381,45 +23358,45 @@ end # some extra manipulation on the tokens to make them match Ripper's # output by mirroring the dedent logic that Ripper uses. # -# pkg:gem/prism#lib/prism/lex_compat.rb:374 +# pkg:gem/prism#lib/prism/lex_compat.rb:336 class Prism::LexCompat::Heredoc::DedentingHeredoc # @return [DedentingHeredoc] a new instance of DedentingHeredoc # - # pkg:gem/prism#lib/prism/lex_compat.rb:379 + # pkg:gem/prism#lib/prism/lex_compat.rb:341 def initialize; end # As tokens are coming in, we track the minimum amount of common leading # whitespace on plain string content tokens. This allows us to later # remove that amount of whitespace from the beginning of each line. # - # pkg:gem/prism#lib/prism/lex_compat.rb:390 + # pkg:gem/prism#lib/prism/lex_compat.rb:352 def <<(token); end # Returns the value of attribute dedent. # - # pkg:gem/prism#lib/prism/lex_compat.rb:377 + # pkg:gem/prism#lib/prism/lex_compat.rb:339 def dedent; end # Returns the value of attribute dedent_next. # - # pkg:gem/prism#lib/prism/lex_compat.rb:377 + # pkg:gem/prism#lib/prism/lex_compat.rb:339 def dedent_next; end # Returns the value of attribute embexpr_balance. # - # pkg:gem/prism#lib/prism/lex_compat.rb:377 + # pkg:gem/prism#lib/prism/lex_compat.rb:339 def embexpr_balance; end - # pkg:gem/prism#lib/prism/lex_compat.rb:427 + # pkg:gem/prism#lib/prism/lex_compat.rb:389 def to_a; end # Returns the value of attribute tokens. # - # pkg:gem/prism#lib/prism/lex_compat.rb:377 + # pkg:gem/prism#lib/prism/lex_compat.rb:339 def tokens; end end -# pkg:gem/prism#lib/prism/lex_compat.rb:375 +# pkg:gem/prism#lib/prism/lex_compat.rb:337 Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), Integer) # Heredocs that are no dash or tilde heredocs are just a list of tokens. @@ -23427,64 +23404,29 @@ Prism::LexCompat::Heredoc::DedentingHeredoc::TAB_WIDTH = T.let(T.unsafe(nil), In # order back into the token stream and set the state of the last token to # the state that the heredoc was opened in. # -# pkg:gem/prism#lib/prism/lex_compat.rb:296 +# pkg:gem/prism#lib/prism/lex_compat.rb:258 class Prism::LexCompat::Heredoc::PlainHeredoc # @return [PlainHeredoc] a new instance of PlainHeredoc # - # pkg:gem/prism#lib/prism/lex_compat.rb:299 + # pkg:gem/prism#lib/prism/lex_compat.rb:261 def initialize; end - # pkg:gem/prism#lib/prism/lex_compat.rb:303 + # pkg:gem/prism#lib/prism/lex_compat.rb:265 def <<(token); end - # pkg:gem/prism#lib/prism/lex_compat.rb:307 + # pkg:gem/prism#lib/prism/lex_compat.rb:269 def to_a; end - # pkg:gem/prism#lib/prism/lex_compat.rb:297 + # pkg:gem/prism#lib/prism/lex_compat.rb:259 def tokens; end end -# Ident tokens for the most part are exactly the same, except sometimes we -# know an ident is a local when ripper doesn't (when they are introduced -# through named captures in regular expressions). In that case we don't -# compare the state. -# -# pkg:gem/prism#lib/prism/lex_compat.rb:248 -class Prism::LexCompat::IdentToken < ::Prism::LexCompat::Token - # pkg:gem/prism#lib/prism/lex_compat.rb:249 - def ==(other); end -end - # Tokens where state should be ignored -# used for :on_comment, :on_heredoc_end, :on_embexpr_end +# used for :on_sp, :on_comment, :on_heredoc_end, :on_embexpr_end # -# pkg:gem/prism#lib/prism/lex_compat.rb:238 +# pkg:gem/prism#lib/prism/lex_compat.rb:244 class Prism::LexCompat::IgnoreStateToken < ::Prism::LexCompat::Token - # pkg:gem/prism#lib/prism/lex_compat.rb:239 - def ==(other); end -end - -# Ignored newlines can occasionally have a LABEL state attached to them, so -# we compare the state differently here. -# -# pkg:gem/prism#lib/prism/lex_compat.rb:259 -class Prism::LexCompat::IgnoredNewlineToken < ::Prism::LexCompat::Token - # pkg:gem/prism#lib/prism/lex_compat.rb:260 - def ==(other); end -end - -# If we have an identifier that follows a method name like: -# -# def foo bar -# -# then Ripper will mark bar as END|LABEL if there is a local in a parent -# scope named bar because it hasn't pushed the local table yet. We do this -# more accurately, so we need to allow comparing against both END and -# END|LABEL. -# -# pkg:gem/prism#lib/prism/lex_compat.rb:279 -class Prism::LexCompat::ParamToken < ::Prism::LexCompat::Token - # pkg:gem/prism#lib/prism/lex_compat.rb:280 + # pkg:gem/prism#lib/prism/lex_compat.rb:245 def ==(other); end end @@ -23492,28 +23434,28 @@ end # many-to-one mapping because we split up our token types, whereas Ripper # tends to group them. # -# pkg:gem/prism#lib/prism/lex_compat.rb:33 +# pkg:gem/prism#lib/prism/lex_compat.rb:31 Prism::LexCompat::RIPPER = T.let(T.unsafe(nil), Hash) # A result class specialized for holding tokens produced by the lexer. # -# pkg:gem/prism#lib/prism/lex_compat.rb:14 +# pkg:gem/prism#lib/prism/lex_compat.rb:12 class Prism::LexCompat::Result < ::Prism::Result # Create a new lex compat result object with the given values. # # @return [Result] a new instance of Result # - # pkg:gem/prism#lib/prism/lex_compat.rb:19 + # pkg:gem/prism#lib/prism/lex_compat.rb:17 def initialize(value, comments, magic_comments, data_loc, errors, warnings, source); end # Implement the hash pattern matching interface for Result. # - # pkg:gem/prism#lib/prism/lex_compat.rb:25 + # pkg:gem/prism#lib/prism/lex_compat.rb:23 def deconstruct_keys(keys); end # The list of tokens that were produced by the lexer. # - # pkg:gem/prism#lib/prism/lex_compat.rb:16 + # pkg:gem/prism#lib/prism/lex_compat.rb:14 def value; end end @@ -23521,38 +23463,60 @@ end # However, we add a couple of convenience methods onto them to make them a # little easier to work with. We delegate all other methods to the array. # -# pkg:gem/prism#lib/prism/lex_compat.rb:204 -class Prism::LexCompat::Token < ::SimpleDelegator +# pkg:gem/prism#lib/prism/lex_compat.rb:202 +class Prism::LexCompat::Token < ::BasicObject + # Create a new token object with the given ripper-compatible array. + # + # @return [Token] a new instance of Token + # + # pkg:gem/prism#lib/prism/lex_compat.rb:204 + def initialize(array); end + + # We want to pretend that this is just an Array. + # + # pkg:gem/prism#lib/prism/lex_compat.rb:229 + def ==(other); end + # The type of the token. # - # pkg:gem/prism#lib/prism/lex_compat.rb:213 + # pkg:gem/prism#lib/prism/lex_compat.rb:214 def event; end # The location of the token in the source. # - # pkg:gem/prism#lib/prism/lex_compat.rb:208 + # pkg:gem/prism#lib/prism/lex_compat.rb:209 def location; end + # pkg:gem/prism#lib/prism/lex_compat.rb:237 + def method_missing(name, *_arg1, **_arg2, &_arg3); end + # The state of the lexer when this token was produced. # - # pkg:gem/prism#lib/prism/lex_compat.rb:223 + # pkg:gem/prism#lib/prism/lex_compat.rb:224 def state; end # The slice of the source that this token represents. # - # pkg:gem/prism#lib/prism/lex_compat.rb:218 + # pkg:gem/prism#lib/prism/lex_compat.rb:219 def value; end + + private + + # @return [Boolean] + # + # pkg:gem/prism#lib/prism/lex_compat.rb:233 + def respond_to_missing?(name, include_private = T.unsafe(nil)); end end # This is a result specific to the `lex` and `lex_file` methods. # -# pkg:gem/prism#lib/prism/parse_result.rb:769 +# pkg:gem/prism#lib/prism/parse_result.rb:778 class Prism::LexResult < ::Prism::Result # Create a new lex result object with the given values. # # @return [LexResult] a new instance of LexResult # - # pkg:gem/prism#lib/prism/parse_result.rb:774 + # pkg:gem/prism#lib/prism/parse_result.rb:783 sig do params( value: T::Array[T.untyped], @@ -23568,51 +23532,29 @@ class Prism::LexResult < ::Prism::Result # Implement the hash pattern matching interface for LexResult. # - # pkg:gem/prism#lib/prism/parse_result.rb:780 + # pkg:gem/prism#lib/prism/parse_result.rb:789 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # The list of tokens that were parsed from the source code. # - # pkg:gem/prism#lib/prism/parse_result.rb:771 + # pkg:gem/prism#lib/prism/parse_result.rb:780 sig { returns(T::Array[T.untyped]) } def value; end end -# This is a class that wraps the Ripper lexer to produce almost exactly the -# same tokens. -# -# pkg:gem/prism#lib/prism/lex_ripper.rb:9 -class Prism::LexRipper - # @return [LexRipper] a new instance of LexRipper - # - # pkg:gem/prism#lib/prism/lex_ripper.rb:12 - def initialize(source); end - - # pkg:gem/prism#lib/prism/lex_ripper.rb:16 - def result; end - - # pkg:gem/prism#lib/prism/lex_ripper.rb:10 - def source; end - - private - - # pkg:gem/prism#lib/prism/lex_ripper.rb:50 - def lex(source); end -end - # Represents the use of the `&&=` operator for assignment to a local variable. # # target &&= value # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:12505 +# pkg:gem/prism#lib/prism/node.rb:12513 class Prism::LocalVariableAndWriteNode < ::Prism::Node # Initialize a new LocalVariableAndWriteNode node. # # @return [LocalVariableAndWriteNode] a new instance of LocalVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:12507 + # pkg:gem/prism#lib/prism/node.rb:12515 sig do params( source: Prism::Source, @@ -23631,36 +23573,36 @@ class Prism::LocalVariableAndWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12616 + # pkg:gem/prism#lib/prism/node.rb:12624 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12520 + # pkg:gem/prism#lib/prism/node.rb:12528 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12525 + # pkg:gem/prism#lib/prism/node.rb:12533 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12542 + # pkg:gem/prism#lib/prism/node.rb:12550 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12537 + # pkg:gem/prism#lib/prism/node.rb:12545 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableAndWriteNode # - # pkg:gem/prism#lib/prism/node.rb:12547 + # pkg:gem/prism#lib/prism/node.rb:12555 sig do params( node_id: Integer, @@ -23678,19 +23620,19 @@ class Prism::LocalVariableAndWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12552 + # pkg:gem/prism#lib/prism/node.rb:12560 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer } # - # pkg:gem/prism#lib/prism/node.rb:12555 + # pkg:gem/prism#lib/prism/node.rb:12563 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # attr_reader depth: Integer # - # pkg:gem/prism#lib/prism/node.rb:12592 + # pkg:gem/prism#lib/prism/node.rb:12600 sig { returns(Integer) } def depth; end @@ -23701,7 +23643,7 @@ class Prism::LocalVariableAndWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:12530 + # pkg:gem/prism#lib/prism/node.rb:12538 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -23709,62 +23651,62 @@ class Prism::LocalVariableAndWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12600 + # pkg:gem/prism#lib/prism/node.rb:12608 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:12589 + # pkg:gem/prism#lib/prism/node.rb:12597 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12560 + # pkg:gem/prism#lib/prism/node.rb:12568 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:12595 + # pkg:gem/prism#lib/prism/node.rb:12603 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12573 + # pkg:gem/prism#lib/prism/node.rb:12581 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12568 + # pkg:gem/prism#lib/prism/node.rb:12576 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12581 + # pkg:gem/prism#lib/prism/node.rb:12589 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12605 + # pkg:gem/prism#lib/prism/node.rb:12613 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:12586 + # pkg:gem/prism#lib/prism/node.rb:12594 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12610 + # pkg:gem/prism#lib/prism/node.rb:12618 def type; end end end @@ -23774,13 +23716,13 @@ end # target += value # ^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:12630 +# pkg:gem/prism#lib/prism/node.rb:12638 class Prism::LocalVariableOperatorWriteNode < ::Prism::Node # Initialize a new LocalVariableOperatorWriteNode node. # # @return [LocalVariableOperatorWriteNode] a new instance of LocalVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:12632 + # pkg:gem/prism#lib/prism/node.rb:12640 sig do params( source: Prism::Source, @@ -23800,48 +23742,48 @@ class Prism::LocalVariableOperatorWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12740 + # pkg:gem/prism#lib/prism/node.rb:12748 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12646 + # pkg:gem/prism#lib/prism/node.rb:12654 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader binary_operator: Symbol # - # pkg:gem/prism#lib/prism/node.rb:12718 + # pkg:gem/prism#lib/prism/node.rb:12726 sig { returns(Symbol) } def binary_operator; end # attr_reader binary_operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12699 + # pkg:gem/prism#lib/prism/node.rb:12707 sig { returns(Prism::Location) } def binary_operator_loc; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12651 + # pkg:gem/prism#lib/prism/node.rb:12659 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12668 + # pkg:gem/prism#lib/prism/node.rb:12676 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12663 + # pkg:gem/prism#lib/prism/node.rb:12671 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer) -> LocalVariableOperatorWriteNode # - # pkg:gem/prism#lib/prism/node.rb:12673 + # pkg:gem/prism#lib/prism/node.rb:12681 sig do params( node_id: Integer, @@ -23860,19 +23802,19 @@ class Prism::LocalVariableOperatorWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12678 + # pkg:gem/prism#lib/prism/node.rb:12686 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer } # - # pkg:gem/prism#lib/prism/node.rb:12681 + # pkg:gem/prism#lib/prism/node.rb:12689 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # attr_reader depth: Integer # - # pkg:gem/prism#lib/prism/node.rb:12721 + # pkg:gem/prism#lib/prism/node.rb:12729 sig { returns(Integer) } def depth; end @@ -23883,7 +23825,7 @@ class Prism::LocalVariableOperatorWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:12656 + # pkg:gem/prism#lib/prism/node.rb:12664 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -23891,19 +23833,19 @@ class Prism::LocalVariableOperatorWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12724 + # pkg:gem/prism#lib/prism/node.rb:12732 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:12715 + # pkg:gem/prism#lib/prism/node.rb:12723 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12686 + # pkg:gem/prism#lib/prism/node.rb:12694 sig { returns(Prism::Location) } def name_loc; end @@ -23922,31 +23864,31 @@ class Prism::LocalVariableOperatorWriteNode < ::Prism::Node # Save the binary_operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12707 + # pkg:gem/prism#lib/prism/node.rb:12715 def save_binary_operator_loc(repository); end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12694 + # pkg:gem/prism#lib/prism/node.rb:12702 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12729 + # pkg:gem/prism#lib/prism/node.rb:12737 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:12712 + # pkg:gem/prism#lib/prism/node.rb:12720 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12734 + # pkg:gem/prism#lib/prism/node.rb:12742 def type; end end end @@ -23956,13 +23898,13 @@ end # target ||= value # ^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:12755 +# pkg:gem/prism#lib/prism/node.rb:12763 class Prism::LocalVariableOrWriteNode < ::Prism::Node # Initialize a new LocalVariableOrWriteNode node. # # @return [LocalVariableOrWriteNode] a new instance of LocalVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:12757 + # pkg:gem/prism#lib/prism/node.rb:12765 sig do params( source: Prism::Source, @@ -23981,36 +23923,36 @@ class Prism::LocalVariableOrWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12866 + # pkg:gem/prism#lib/prism/node.rb:12874 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12770 + # pkg:gem/prism#lib/prism/node.rb:12778 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12775 + # pkg:gem/prism#lib/prism/node.rb:12783 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12792 + # pkg:gem/prism#lib/prism/node.rb:12800 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12787 + # pkg:gem/prism#lib/prism/node.rb:12795 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?depth: Integer) -> LocalVariableOrWriteNode # - # pkg:gem/prism#lib/prism/node.rb:12797 + # pkg:gem/prism#lib/prism/node.rb:12805 sig do params( node_id: Integer, @@ -24028,19 +23970,19 @@ class Prism::LocalVariableOrWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12802 + # pkg:gem/prism#lib/prism/node.rb:12810 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, depth: Integer } # - # pkg:gem/prism#lib/prism/node.rb:12805 + # pkg:gem/prism#lib/prism/node.rb:12813 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # attr_reader depth: Integer # - # pkg:gem/prism#lib/prism/node.rb:12842 + # pkg:gem/prism#lib/prism/node.rb:12850 sig { returns(Integer) } def depth; end @@ -24051,7 +23993,7 @@ class Prism::LocalVariableOrWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:12780 + # pkg:gem/prism#lib/prism/node.rb:12788 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -24059,62 +24001,62 @@ class Prism::LocalVariableOrWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12850 + # pkg:gem/prism#lib/prism/node.rb:12858 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:12839 + # pkg:gem/prism#lib/prism/node.rb:12847 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12810 + # pkg:gem/prism#lib/prism/node.rb:12818 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:12845 + # pkg:gem/prism#lib/prism/node.rb:12853 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:12823 + # pkg:gem/prism#lib/prism/node.rb:12831 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12818 + # pkg:gem/prism#lib/prism/node.rb:12826 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:12831 + # pkg:gem/prism#lib/prism/node.rb:12839 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12855 + # pkg:gem/prism#lib/prism/node.rb:12863 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:12836 + # pkg:gem/prism#lib/prism/node.rb:12844 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12860 + # pkg:gem/prism#lib/prism/node.rb:12868 def type; end end end @@ -24124,13 +24066,13 @@ end # foo # ^^^ # -# pkg:gem/prism#lib/prism/node.rb:12880 +# pkg:gem/prism#lib/prism/node.rb:12888 class Prism::LocalVariableReadNode < ::Prism::Node # Initialize a new LocalVariableReadNode node. # # @return [LocalVariableReadNode] a new instance of LocalVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:12882 + # pkg:gem/prism#lib/prism/node.rb:12890 sig do params( source: Prism::Source, @@ -24146,36 +24088,36 @@ class Prism::LocalVariableReadNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:12967 + # pkg:gem/prism#lib/prism/node.rb:12975 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12892 + # pkg:gem/prism#lib/prism/node.rb:12900 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12897 + # pkg:gem/prism#lib/prism/node.rb:12905 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:12913 + # pkg:gem/prism#lib/prism/node.rb:12921 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:12908 + # pkg:gem/prism#lib/prism/node.rb:12916 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableReadNode # - # pkg:gem/prism#lib/prism/node.rb:12918 + # pkg:gem/prism#lib/prism/node.rb:12926 sig do params( node_id: Integer, @@ -24190,13 +24132,13 @@ class Prism::LocalVariableReadNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12923 + # pkg:gem/prism#lib/prism/node.rb:12931 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer } # - # pkg:gem/prism#lib/prism/node.rb:12926 + # pkg:gem/prism#lib/prism/node.rb:12934 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -24208,13 +24150,13 @@ class Prism::LocalVariableReadNode < ::Prism::Node # # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md). # - # pkg:gem/prism#lib/prism/node.rb:12948 + # pkg:gem/prism#lib/prism/node.rb:12956 sig { returns(Integer) } def depth; end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:12902 + # pkg:gem/prism#lib/prism/node.rb:12910 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -24222,7 +24164,7 @@ class Prism::LocalVariableReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:12951 + # pkg:gem/prism#lib/prism/node.rb:12959 sig { override.returns(String) } def inspect; end @@ -24236,20 +24178,20 @@ class Prism::LocalVariableReadNode < ::Prism::Node # # _1 # name `:_1` # - # pkg:gem/prism#lib/prism/node.rb:12939 + # pkg:gem/prism#lib/prism/node.rb:12947 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:12956 + # pkg:gem/prism#lib/prism/node.rb:12964 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:12961 + # pkg:gem/prism#lib/prism/node.rb:12969 def type; end end end @@ -24262,13 +24204,13 @@ end # foo => baz # ^^^ # -# pkg:gem/prism#lib/prism/node.rb:12981 +# pkg:gem/prism#lib/prism/node.rb:12989 class Prism::LocalVariableTargetNode < ::Prism::Node # Initialize a new LocalVariableTargetNode node. # # @return [LocalVariableTargetNode] a new instance of LocalVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:12983 + # pkg:gem/prism#lib/prism/node.rb:12991 sig do params( source: Prism::Source, @@ -24284,36 +24226,36 @@ class Prism::LocalVariableTargetNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13054 + # pkg:gem/prism#lib/prism/node.rb:13062 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:12993 + # pkg:gem/prism#lib/prism/node.rb:13001 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:12998 + # pkg:gem/prism#lib/prism/node.rb:13006 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13014 + # pkg:gem/prism#lib/prism/node.rb:13022 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13009 + # pkg:gem/prism#lib/prism/node.rb:13017 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer) -> LocalVariableTargetNode # - # pkg:gem/prism#lib/prism/node.rb:13019 + # pkg:gem/prism#lib/prism/node.rb:13027 sig do params( node_id: Integer, @@ -24328,25 +24270,25 @@ class Prism::LocalVariableTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13024 + # pkg:gem/prism#lib/prism/node.rb:13032 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer } # - # pkg:gem/prism#lib/prism/node.rb:13027 + # pkg:gem/prism#lib/prism/node.rb:13035 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # attr_reader depth: Integer # - # pkg:gem/prism#lib/prism/node.rb:13035 + # pkg:gem/prism#lib/prism/node.rb:13043 sig { returns(Integer) } def depth; end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:13003 + # pkg:gem/prism#lib/prism/node.rb:13011 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -24354,26 +24296,26 @@ class Prism::LocalVariableTargetNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13038 + # pkg:gem/prism#lib/prism/node.rb:13046 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:13032 + # pkg:gem/prism#lib/prism/node.rb:13040 sig { returns(Symbol) } def name; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13043 + # pkg:gem/prism#lib/prism/node.rb:13051 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13048 + # pkg:gem/prism#lib/prism/node.rb:13056 def type; end end end @@ -24383,13 +24325,13 @@ end # foo = 1 # ^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:13065 +# pkg:gem/prism#lib/prism/node.rb:13073 class Prism::LocalVariableWriteNode < ::Prism::Node # Initialize a new LocalVariableWriteNode node. # # @return [LocalVariableWriteNode] a new instance of LocalVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:13067 + # pkg:gem/prism#lib/prism/node.rb:13075 sig do params( source: Prism::Source, @@ -24408,36 +24350,36 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13202 + # pkg:gem/prism#lib/prism/node.rb:13210 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13080 + # pkg:gem/prism#lib/prism/node.rb:13088 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13085 + # pkg:gem/prism#lib/prism/node.rb:13093 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13102 + # pkg:gem/prism#lib/prism/node.rb:13110 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13097 + # pkg:gem/prism#lib/prism/node.rb:13105 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?depth: Integer, ?name_loc: Location, ?value: Prism::node, ?operator_loc: Location) -> LocalVariableWriteNode # - # pkg:gem/prism#lib/prism/node.rb:13107 + # pkg:gem/prism#lib/prism/node.rb:13115 sig do params( node_id: Integer, @@ -24455,13 +24397,13 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13112 + # pkg:gem/prism#lib/prism/node.rb:13120 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, depth: Integer, name_loc: Location, value: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:13115 + # pkg:gem/prism#lib/prism/node.rb:13123 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -24473,7 +24415,7 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md). # - # pkg:gem/prism#lib/prism/node.rb:13133 + # pkg:gem/prism#lib/prism/node.rb:13141 sig { returns(Integer) } def depth; end @@ -24481,7 +24423,7 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:13090 + # pkg:gem/prism#lib/prism/node.rb:13098 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -24489,7 +24431,7 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13186 + # pkg:gem/prism#lib/prism/node.rb:13194 sig { override.returns(String) } def inspect; end @@ -24499,7 +24441,7 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # # abc = 123 # name `:abc` # - # pkg:gem/prism#lib/prism/node.rb:13124 + # pkg:gem/prism#lib/prism/node.rb:13132 sig { returns(Symbol) } def name; end @@ -24508,13 +24450,13 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # foo = :bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:13139 + # pkg:gem/prism#lib/prism/node.rb:13147 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13181 + # pkg:gem/prism#lib/prism/node.rb:13189 sig { returns(String) } def operator; end @@ -24523,25 +24465,25 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # x = :y # ^ # - # pkg:gem/prism#lib/prism/node.rb:13168 + # pkg:gem/prism#lib/prism/node.rb:13176 sig { returns(Prism::Location) } def operator_loc; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13147 + # pkg:gem/prism#lib/prism/node.rb:13155 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13176 + # pkg:gem/prism#lib/prism/node.rb:13184 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13191 + # pkg:gem/prism#lib/prism/node.rb:13199 sig { override.returns(Symbol) } def type; end @@ -24557,34 +24499,34 @@ class Prism::LocalVariableWriteNode < ::Prism::Node # # foo = foo # - # pkg:gem/prism#lib/prism/node.rb:13162 + # pkg:gem/prism#lib/prism/node.rb:13170 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13196 + # pkg:gem/prism#lib/prism/node.rb:13204 def type; end end end # This represents a location in the source. # -# pkg:gem/prism#lib/prism/parse_result.rb:278 +# pkg:gem/prism#lib/prism/parse_result.rb:287 class Prism::Location # Create a new location object with the given source, start byte offset, and # byte length. # # @return [Location] a new instance of Location # - # pkg:gem/prism#lib/prism/parse_result.rb:293 + # pkg:gem/prism#lib/prism/parse_result.rb:302 sig { params(source: Prism::Source, start_offset: Integer, length: Integer).void } def initialize(source, start_offset, length); end # Returns true if the given other location is equal to this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:481 + # pkg:gem/prism#lib/prism/parse_result.rb:490 sig { params(other: T.untyped).returns(T::Boolean) } def ==(other); end @@ -24592,14 +24534,14 @@ class Prism::Location # that occurs after this location on the same line, and return the new # location. This will raise an error if the string does not exist. # - # pkg:gem/prism#lib/prism/parse_result.rb:500 + # pkg:gem/prism#lib/prism/parse_result.rb:509 sig { params(string: String).returns(Prism::Location) } def adjoin(string); end # The end column in code units using the given cache to fetch or calculate # the value. # - # pkg:gem/prism#lib/prism/parse_result.rb:466 + # pkg:gem/prism#lib/prism/parse_result.rb:475 sig do params( cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer)) @@ -24610,7 +24552,7 @@ class Prism::Location # The end offset from the start of the file in code units using the given # cache to fetch or calculate the value. # - # pkg:gem/prism#lib/prism/parse_result.rb:402 + # pkg:gem/prism#lib/prism/parse_result.rb:411 sig do params( cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer)) @@ -24621,7 +24563,7 @@ class Prism::Location # The start column in code units using the given cache to fetch or calculate # the value. # - # pkg:gem/prism#lib/prism/parse_result.rb:442 + # pkg:gem/prism#lib/prism/parse_result.rb:451 sig do params( cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer)) @@ -24632,7 +24574,7 @@ class Prism::Location # The start offset from the start of the file in code units using the given # cache to fetch or calculate the value. # - # pkg:gem/prism#lib/prism/parse_result.rb:380 + # pkg:gem/prism#lib/prism/parse_result.rb:389 sig do params( cache: T.any(Prism::CodeUnitsCache, T.proc.params(byte_offset: Integer).returns(Integer)) @@ -24642,78 +24584,78 @@ class Prism::Location # Returns a new location that is the result of chopping off the last byte. # - # pkg:gem/prism#lib/prism/parse_result.rb:339 + # pkg:gem/prism#lib/prism/parse_result.rb:348 sig { returns(Prism::Location) } def chop; end # Returns all comments that are associated with this location (both leading # and trailing comments). # - # pkg:gem/prism#lib/prism/parse_result.rb:329 + # pkg:gem/prism#lib/prism/parse_result.rb:338 sig { returns(T::Array[Prism::Comment]) } def comments; end # Create a new location object with the given options. # - # pkg:gem/prism#lib/prism/parse_result.rb:334 + # pkg:gem/prism#lib/prism/parse_result.rb:343 sig { params(source: Prism::Source, start_offset: Integer, length: Integer).returns(Prism::Location) } def copy(source: T.unsafe(nil), start_offset: T.unsafe(nil), length: T.unsafe(nil)); end # Implement the hash pattern matching interface for Location. # - # pkg:gem/prism#lib/prism/parse_result.rb:471 + # pkg:gem/prism#lib/prism/parse_result.rb:480 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # The column number in characters where this location ends from the start of # the line. # - # pkg:gem/prism#lib/prism/parse_result.rb:454 + # pkg:gem/prism#lib/prism/parse_result.rb:463 sig { returns(Integer) } def end_character_column; end # The character offset from the beginning of the source where this location # ends. # - # pkg:gem/prism#lib/prism/parse_result.rb:391 + # pkg:gem/prism#lib/prism/parse_result.rb:400 sig { returns(Integer) } def end_character_offset; end # The column number in code units of the given encoding where this location # ends from the start of the line. # - # pkg:gem/prism#lib/prism/parse_result.rb:460 + # pkg:gem/prism#lib/prism/parse_result.rb:469 sig { params(encoding: Encoding).returns(Integer) } def end_code_units_column(encoding = T.unsafe(nil)); end # The offset from the start of the file in code units of the given encoding. # - # pkg:gem/prism#lib/prism/parse_result.rb:396 + # pkg:gem/prism#lib/prism/parse_result.rb:405 sig { params(encoding: Encoding).returns(Integer) } def end_code_units_offset(encoding = T.unsafe(nil)); end # The column number in bytes where this location ends from the start of the # line. # - # pkg:gem/prism#lib/prism/parse_result.rb:448 + # pkg:gem/prism#lib/prism/parse_result.rb:457 sig { returns(Integer) } def end_column; end # The line number where this location ends. # - # pkg:gem/prism#lib/prism/parse_result.rb:418 + # pkg:gem/prism#lib/prism/parse_result.rb:427 sig { returns(Integer) } def end_line; end # The byte offset from the beginning of the source where this location ends. # - # pkg:gem/prism#lib/prism/parse_result.rb:385 + # pkg:gem/prism#lib/prism/parse_result.rb:394 sig { returns(Integer) } def end_offset; end # Returns a string representation of this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:344 + # pkg:gem/prism#lib/prism/parse_result.rb:353 sig { returns(String) } def inspect; end @@ -24721,38 +24663,38 @@ class Prism::Location # other location. Raises an error if this location is not before the other # location or if they don't share the same source. # - # pkg:gem/prism#lib/prism/parse_result.rb:490 + # pkg:gem/prism#lib/prism/parse_result.rb:499 sig { params(other: Prism::Location).returns(Prism::Location) } def join(other); end # Attach a comment to the leading comments of this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:312 + # pkg:gem/prism#lib/prism/parse_result.rb:321 sig { params(comment: Prism::Comment).void } def leading_comment(comment); end # These are the comments that are associated with this location that exist # before the start of this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:307 + # pkg:gem/prism#lib/prism/parse_result.rb:316 sig { returns(T::Array[Prism::Comment]) } def leading_comments; end # The length of this location in bytes. # - # pkg:gem/prism#lib/prism/parse_result.rb:289 + # pkg:gem/prism#lib/prism/parse_result.rb:298 sig { returns(Integer) } def length; end # Implement the pretty print interface for Location. # - # pkg:gem/prism#lib/prism/parse_result.rb:476 + # pkg:gem/prism#lib/prism/parse_result.rb:485 sig { params(q: T.untyped).void } def pretty_print(q); end # The source code that this location represents. # - # pkg:gem/prism#lib/prism/parse_result.rb:354 + # pkg:gem/prism#lib/prism/parse_result.rb:363 sig { returns(String) } def slice; end @@ -24760,78 +24702,78 @@ class Prism::Location # of the line that this location starts on to the end of the line that this # location ends on. # - # pkg:gem/prism#lib/prism/parse_result.rb:361 + # pkg:gem/prism#lib/prism/parse_result.rb:370 def slice_lines; end # Returns all of the lines of the source code associated with this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:349 + # pkg:gem/prism#lib/prism/parse_result.rb:358 sig { returns(T::Array[String]) } def source_lines; end # The column number in characters where this location ends from the start of # the line. # - # pkg:gem/prism#lib/prism/parse_result.rb:430 + # pkg:gem/prism#lib/prism/parse_result.rb:439 sig { returns(Integer) } def start_character_column; end # The character offset from the beginning of the source where this location # starts. # - # pkg:gem/prism#lib/prism/parse_result.rb:369 + # pkg:gem/prism#lib/prism/parse_result.rb:378 sig { returns(Integer) } def start_character_offset; end # The column number in code units of the given encoding where this location # starts from the start of the line. # - # pkg:gem/prism#lib/prism/parse_result.rb:436 + # pkg:gem/prism#lib/prism/parse_result.rb:445 sig { params(encoding: Encoding).returns(Integer) } def start_code_units_column(encoding = T.unsafe(nil)); end # The offset from the start of the file in code units of the given encoding. # - # pkg:gem/prism#lib/prism/parse_result.rb:374 + # pkg:gem/prism#lib/prism/parse_result.rb:383 sig { params(encoding: Encoding).returns(Integer) } def start_code_units_offset(encoding = T.unsafe(nil)); end # The column number in bytes where this location starts from the start of # the line. # - # pkg:gem/prism#lib/prism/parse_result.rb:424 + # pkg:gem/prism#lib/prism/parse_result.rb:433 sig { returns(Integer) } def start_column; end # The line number where this location starts. # - # pkg:gem/prism#lib/prism/parse_result.rb:407 + # pkg:gem/prism#lib/prism/parse_result.rb:416 sig { returns(Integer) } def start_line; end # The content of the line where this location starts before this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:412 + # pkg:gem/prism#lib/prism/parse_result.rb:421 sig { returns(String) } def start_line_slice; end # The byte offset from the beginning of the source where this location # starts. # - # pkg:gem/prism#lib/prism/parse_result.rb:286 + # pkg:gem/prism#lib/prism/parse_result.rb:295 sig { returns(Integer) } def start_offset; end # Attach a comment to the trailing comments of this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:323 + # pkg:gem/prism#lib/prism/parse_result.rb:332 sig { params(comment: Prism::Comment).void } def trailing_comment(comment); end # These are the comments that are associated with this location that exist # after the end of this location. # - # pkg:gem/prism#lib/prism/parse_result.rb:318 + # pkg:gem/prism#lib/prism/parse_result.rb:327 sig { returns(T::Array[Prism::Comment]) } def trailing_comments; end @@ -24840,66 +24782,66 @@ class Prism::Location # A Source object that is used to determine more information from the given # offset and length. # - # pkg:gem/prism#lib/prism/parse_result.rb:281 + # pkg:gem/prism#lib/prism/parse_result.rb:290 sig { returns(Prism::Source) } def source; end end # Flags for while and until loop nodes. # -# pkg:gem/prism#lib/prism/node.rb:19850 +# pkg:gem/prism#lib/prism/node.rb:19858 module Prism::LoopFlags; end # a loop after a begin statement, so the body is executed first before the condition # -# pkg:gem/prism#lib/prism/node.rb:19852 +# pkg:gem/prism#lib/prism/node.rb:19860 Prism::LoopFlags::BEGIN_MODIFIER = T.let(T.unsafe(nil), Integer) # This represents a magic comment that was encountered during parsing. # -# pkg:gem/prism#lib/prism/parse_result.rb:562 +# pkg:gem/prism#lib/prism/parse_result.rb:571 class Prism::MagicComment # Create a new magic comment object with the given key and value locations. # # @return [MagicComment] a new instance of MagicComment # - # pkg:gem/prism#lib/prism/parse_result.rb:570 + # pkg:gem/prism#lib/prism/parse_result.rb:579 sig { params(key_loc: Prism::Location, value_loc: Prism::Location).void } def initialize(key_loc, value_loc); end # Implement the hash pattern matching interface for MagicComment. # - # pkg:gem/prism#lib/prism/parse_result.rb:586 + # pkg:gem/prism#lib/prism/parse_result.rb:595 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. # - # pkg:gem/prism#lib/prism/parse_result.rb:591 + # pkg:gem/prism#lib/prism/parse_result.rb:600 sig { returns(String) } def inspect; end # Returns the key of the magic comment by slicing it from the source code. # - # pkg:gem/prism#lib/prism/parse_result.rb:576 + # pkg:gem/prism#lib/prism/parse_result.rb:585 sig { returns(String) } def key; end # A Location object representing the location of the key in the source. # - # pkg:gem/prism#lib/prism/parse_result.rb:564 + # pkg:gem/prism#lib/prism/parse_result.rb:573 sig { returns(Prism::Location) } def key_loc; end # Returns the value of the magic comment by slicing it from the source code. # - # pkg:gem/prism#lib/prism/parse_result.rb:581 + # pkg:gem/prism#lib/prism/parse_result.rb:590 sig { returns(String) } def value; end # A Location object representing the location of the value in the source. # - # pkg:gem/prism#lib/prism/parse_result.rb:567 + # pkg:gem/prism#lib/prism/parse_result.rb:576 sig { returns(Prism::Location) } def value_loc; end end @@ -24909,7 +24851,7 @@ end # if /foo/i then end # ^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:13216 +# pkg:gem/prism#lib/prism/node.rb:13224 class Prism::MatchLastLineNode < ::Prism::Node include ::Prism::RegularExpressionOptions @@ -24917,7 +24859,7 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [MatchLastLineNode] a new instance of MatchLastLineNode # - # pkg:gem/prism#lib/prism/node.rb:13218 + # pkg:gem/prism#lib/prism/node.rb:13226 sig do params( source: Prism::Source, @@ -24935,12 +24877,12 @@ class Prism::MatchLastLineNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13397 + # pkg:gem/prism#lib/prism/node.rb:13405 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13230 + # pkg:gem/prism#lib/prism/node.rb:13238 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -24948,55 +24890,55 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13294 + # pkg:gem/prism#lib/prism/node.rb:13302 sig { returns(T::Boolean) } def ascii_8bit?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13235 + # pkg:gem/prism#lib/prism/node.rb:13243 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13376 + # pkg:gem/prism#lib/prism/node.rb:13384 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:13350 + # pkg:gem/prism#lib/prism/node.rb:13358 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13251 + # pkg:gem/prism#lib/prism/node.rb:13259 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13246 + # pkg:gem/prism#lib/prism/node.rb:13254 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def content: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13371 + # pkg:gem/prism#lib/prism/node.rb:13379 sig { returns(String) } def content; end # attr_reader content_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:13337 + # pkg:gem/prism#lib/prism/node.rb:13345 sig { returns(Prism::Location) } def content_loc; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> MatchLastLineNode # - # pkg:gem/prism#lib/prism/node.rb:13256 + # pkg:gem/prism#lib/prism/node.rb:13264 sig do params( node_id: Integer, @@ -25013,26 +24955,26 @@ class Prism::MatchLastLineNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13261 + # pkg:gem/prism#lib/prism/node.rb:13269 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String } # - # pkg:gem/prism#lib/prism/node.rb:13264 + # pkg:gem/prism#lib/prism/node.rb:13272 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:13240 + # pkg:gem/prism#lib/prism/node.rb:13248 def each_child_node; end # def euc_jp?: () -> bool # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13289 + # pkg:gem/prism#lib/prism/node.rb:13297 sig { returns(T::Boolean) } def euc_jp?; end @@ -25040,7 +24982,7 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13274 + # pkg:gem/prism#lib/prism/node.rb:13282 sig { returns(T::Boolean) } def extended?; end @@ -25051,7 +24993,7 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13314 + # pkg:gem/prism#lib/prism/node.rb:13322 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -25059,7 +25001,7 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13319 + # pkg:gem/prism#lib/prism/node.rb:13327 sig { returns(T::Boolean) } def forced_us_ascii_encoding?; end @@ -25067,7 +25009,7 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13309 + # pkg:gem/prism#lib/prism/node.rb:13317 sig { returns(T::Boolean) } def forced_utf8_encoding?; end @@ -25075,13 +25017,13 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13269 + # pkg:gem/prism#lib/prism/node.rb:13277 sig { returns(T::Boolean) } def ignore_case?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13381 + # pkg:gem/prism#lib/prism/node.rb:13389 sig { override.returns(String) } def inspect; end @@ -25089,7 +25031,7 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13279 + # pkg:gem/prism#lib/prism/node.rb:13287 sig { returns(T::Boolean) } def multi_line?; end @@ -25097,19 +25039,19 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13284 + # pkg:gem/prism#lib/prism/node.rb:13292 sig { returns(T::Boolean) } def once?; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13366 + # pkg:gem/prism#lib/prism/node.rb:13374 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:13324 + # pkg:gem/prism#lib/prism/node.rb:13332 sig { returns(Prism::Location) } def opening_loc; end @@ -25119,30 +25061,30 @@ class Prism::MatchLastLineNode < ::Prism::Node # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13358 + # pkg:gem/prism#lib/prism/node.rb:13366 def save_closing_loc(repository); end # Save the content_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13345 + # pkg:gem/prism#lib/prism/node.rb:13353 def save_content_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13332 + # pkg:gem/prism#lib/prism/node.rb:13340 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13386 + # pkg:gem/prism#lib/prism/node.rb:13394 sig { override.returns(Symbol) } def type; end # attr_reader unescaped: String # - # pkg:gem/prism#lib/prism/node.rb:13363 + # pkg:gem/prism#lib/prism/node.rb:13371 sig { returns(String) } def unescaped; end @@ -25150,7 +25092,7 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13304 + # pkg:gem/prism#lib/prism/node.rb:13312 sig { returns(T::Boolean) } def utf_8?; end @@ -25158,14 +25100,14 @@ class Prism::MatchLastLineNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:13299 + # pkg:gem/prism#lib/prism/node.rb:13307 sig { returns(T::Boolean) } def windows_31j?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13391 + # pkg:gem/prism#lib/prism/node.rb:13399 def type; end end end @@ -25175,13 +25117,13 @@ end # foo in bar # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:13411 +# pkg:gem/prism#lib/prism/node.rb:13419 class Prism::MatchPredicateNode < ::Prism::Node # Initialize a new MatchPredicateNode node. # # @return [MatchPredicateNode] a new instance of MatchPredicateNode # - # pkg:gem/prism#lib/prism/node.rb:13413 + # pkg:gem/prism#lib/prism/node.rb:13421 sig do params( source: Prism::Source, @@ -25198,36 +25140,36 @@ class Prism::MatchPredicateNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13505 + # pkg:gem/prism#lib/prism/node.rb:13513 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13424 + # pkg:gem/prism#lib/prism/node.rb:13432 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13429 + # pkg:gem/prism#lib/prism/node.rb:13437 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13447 + # pkg:gem/prism#lib/prism/node.rb:13455 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13442 + # pkg:gem/prism#lib/prism/node.rb:13450 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchPredicateNode # - # pkg:gem/prism#lib/prism/node.rb:13452 + # pkg:gem/prism#lib/prism/node.rb:13460 sig do params( node_id: Integer, @@ -25243,13 +25185,13 @@ class Prism::MatchPredicateNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13457 + # pkg:gem/prism#lib/prism/node.rb:13465 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:13460 + # pkg:gem/prism#lib/prism/node.rb:13468 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -25257,7 +25199,7 @@ class Prism::MatchPredicateNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:13434 + # pkg:gem/prism#lib/prism/node.rb:13442 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -25265,50 +25207,50 @@ class Prism::MatchPredicateNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13489 + # pkg:gem/prism#lib/prism/node.rb:13497 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13484 + # pkg:gem/prism#lib/prism/node.rb:13492 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:13471 + # pkg:gem/prism#lib/prism/node.rb:13479 sig { returns(Prism::Location) } def operator_loc; end # attr_reader pattern: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:13468 + # pkg:gem/prism#lib/prism/node.rb:13476 sig { returns(Prism::Node) } def pattern; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13479 + # pkg:gem/prism#lib/prism/node.rb:13487 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13494 + # pkg:gem/prism#lib/prism/node.rb:13502 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:13465 + # pkg:gem/prism#lib/prism/node.rb:13473 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13499 + # pkg:gem/prism#lib/prism/node.rb:13507 def type; end end end @@ -25318,13 +25260,13 @@ end # foo => bar # ^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:13517 +# pkg:gem/prism#lib/prism/node.rb:13525 class Prism::MatchRequiredNode < ::Prism::Node # Initialize a new MatchRequiredNode node. # # @return [MatchRequiredNode] a new instance of MatchRequiredNode # - # pkg:gem/prism#lib/prism/node.rb:13519 + # pkg:gem/prism#lib/prism/node.rb:13527 sig do params( source: Prism::Source, @@ -25341,36 +25283,36 @@ class Prism::MatchRequiredNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13659 + # pkg:gem/prism#lib/prism/node.rb:13667 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13530 + # pkg:gem/prism#lib/prism/node.rb:13538 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13535 + # pkg:gem/prism#lib/prism/node.rb:13543 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13553 + # pkg:gem/prism#lib/prism/node.rb:13561 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13548 + # pkg:gem/prism#lib/prism/node.rb:13556 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?pattern: Prism::node, ?operator_loc: Location) -> MatchRequiredNode # - # pkg:gem/prism#lib/prism/node.rb:13558 + # pkg:gem/prism#lib/prism/node.rb:13566 sig do params( node_id: Integer, @@ -25386,13 +25328,13 @@ class Prism::MatchRequiredNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13563 + # pkg:gem/prism#lib/prism/node.rb:13571 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, pattern: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:13566 + # pkg:gem/prism#lib/prism/node.rb:13574 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -25400,7 +25342,7 @@ class Prism::MatchRequiredNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:13540 + # pkg:gem/prism#lib/prism/node.rb:13548 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -25408,13 +25350,13 @@ class Prism::MatchRequiredNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13643 + # pkg:gem/prism#lib/prism/node.rb:13651 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13638 + # pkg:gem/prism#lib/prism/node.rb:13646 sig { returns(String) } def operator; end @@ -25423,7 +25365,7 @@ class Prism::MatchRequiredNode < ::Prism::Node # foo => bar # ^^ # - # pkg:gem/prism#lib/prism/node.rb:13625 + # pkg:gem/prism#lib/prism/node.rb:13633 sig { returns(Prism::Location) } def operator_loc; end @@ -25471,19 +25413,19 @@ class Prism::MatchRequiredNode < ::Prism::Node # # foo => CONST # - # pkg:gem/prism#lib/prism/node.rb:13619 + # pkg:gem/prism#lib/prism/node.rb:13627 sig { returns(Prism::Node) } def pattern; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13633 + # pkg:gem/prism#lib/prism/node.rb:13641 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13648 + # pkg:gem/prism#lib/prism/node.rb:13656 sig { override.returns(Symbol) } def type; end @@ -25492,14 +25434,14 @@ class Prism::MatchRequiredNode < ::Prism::Node # foo => bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:13574 + # pkg:gem/prism#lib/prism/node.rb:13582 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13653 + # pkg:gem/prism#lib/prism/node.rb:13661 def type; end end end @@ -25509,13 +25451,13 @@ end # /(?bar)/ =~ baz # ^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:13671 +# pkg:gem/prism#lib/prism/node.rb:13679 class Prism::MatchWriteNode < ::Prism::Node # Initialize a new MatchWriteNode node. # # @return [MatchWriteNode] a new instance of MatchWriteNode # - # pkg:gem/prism#lib/prism/node.rb:13673 + # pkg:gem/prism#lib/prism/node.rb:13681 sig do params( source: Prism::Source, @@ -25531,42 +25473,42 @@ class Prism::MatchWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13746 + # pkg:gem/prism#lib/prism/node.rb:13754 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13683 + # pkg:gem/prism#lib/prism/node.rb:13691 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader call: CallNode # - # pkg:gem/prism#lib/prism/node.rb:13724 + # pkg:gem/prism#lib/prism/node.rb:13732 sig { returns(Prism::CallNode) } def call; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13688 + # pkg:gem/prism#lib/prism/node.rb:13696 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13706 + # pkg:gem/prism#lib/prism/node.rb:13714 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13701 + # pkg:gem/prism#lib/prism/node.rb:13709 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?call: CallNode, ?targets: Array[LocalVariableTargetNode]) -> MatchWriteNode # - # pkg:gem/prism#lib/prism/node.rb:13711 + # pkg:gem/prism#lib/prism/node.rb:13719 sig do params( node_id: Integer, @@ -25581,13 +25523,13 @@ class Prism::MatchWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13716 + # pkg:gem/prism#lib/prism/node.rb:13724 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, call: CallNode, targets: Array[LocalVariableTargetNode] } # - # pkg:gem/prism#lib/prism/node.rb:13719 + # pkg:gem/prism#lib/prism/node.rb:13727 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -25595,7 +25537,7 @@ class Prism::MatchWriteNode < ::Prism::Node # # @yield [call] # - # pkg:gem/prism#lib/prism/node.rb:13693 + # pkg:gem/prism#lib/prism/node.rb:13701 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -25603,94 +25545,94 @@ class Prism::MatchWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13730 + # pkg:gem/prism#lib/prism/node.rb:13738 sig { override.returns(String) } def inspect; end # attr_reader targets: Array[LocalVariableTargetNode] # - # pkg:gem/prism#lib/prism/node.rb:13727 + # pkg:gem/prism#lib/prism/node.rb:13735 sig { returns(T::Array[Prism::LocalVariableTargetNode]) } def targets; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13735 + # pkg:gem/prism#lib/prism/node.rb:13743 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13740 + # pkg:gem/prism#lib/prism/node.rb:13748 def type; end end end # Represents a node that is missing from the source and results in a syntax error. # -# pkg:gem/prism#lib/prism/node.rb:13755 +# pkg:gem/prism#lib/prism/node.rb:13763 class Prism::MissingNode < ::Prism::Node # Initialize a new MissingNode node. # # @return [MissingNode] a new instance of MissingNode # - # pkg:gem/prism#lib/prism/node.rb:13757 + # pkg:gem/prism#lib/prism/node.rb:13765 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13820 + # pkg:gem/prism#lib/prism/node.rb:13828 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13765 + # pkg:gem/prism#lib/prism/node.rb:13773 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13770 + # pkg:gem/prism#lib/prism/node.rb:13778 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13786 + # pkg:gem/prism#lib/prism/node.rb:13794 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13781 + # pkg:gem/prism#lib/prism/node.rb:13789 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> MissingNode # - # pkg:gem/prism#lib/prism/node.rb:13791 + # pkg:gem/prism#lib/prism/node.rb:13799 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::MissingNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13796 + # pkg:gem/prism#lib/prism/node.rb:13804 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:13799 + # pkg:gem/prism#lib/prism/node.rb:13807 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:13775 + # pkg:gem/prism#lib/prism/node.rb:13783 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -25698,20 +25640,20 @@ class Prism::MissingNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13804 + # pkg:gem/prism#lib/prism/node.rb:13812 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13809 + # pkg:gem/prism#lib/prism/node.rb:13817 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13814 + # pkg:gem/prism#lib/prism/node.rb:13822 def type; end end end @@ -25721,13 +25663,13 @@ end # module Foo end # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:13829 +# pkg:gem/prism#lib/prism/node.rb:13837 class Prism::ModuleNode < ::Prism::Node # Initialize a new ModuleNode node. # # @return [ModuleNode] a new instance of ModuleNode # - # pkg:gem/prism#lib/prism/node.rb:13831 + # pkg:gem/prism#lib/prism/node.rb:13839 sig do params( source: Prism::Source, @@ -25747,48 +25689,48 @@ class Prism::ModuleNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:13953 + # pkg:gem/prism#lib/prism/node.rb:13961 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13845 + # pkg:gem/prism#lib/prism/node.rb:13853 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader body: StatementsNode | BeginNode | nil # - # pkg:gem/prism#lib/prism/node.rb:13908 + # pkg:gem/prism#lib/prism/node.rb:13916 sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13850 + # pkg:gem/prism#lib/prism/node.rb:13858 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:13871 + # pkg:gem/prism#lib/prism/node.rb:13879 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:13863 + # pkg:gem/prism#lib/prism/node.rb:13871 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # attr_reader constant_path: ConstantReadNode | ConstantPathNode | MissingNode # - # pkg:gem/prism#lib/prism/node.rb:13905 + # pkg:gem/prism#lib/prism/node.rb:13913 sig { returns(T.any(Prism::ConstantReadNode, Prism::ConstantPathNode, Prism::MissingNode)) } def constant_path; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | MissingNode, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ModuleNode # - # pkg:gem/prism#lib/prism/node.rb:13876 + # pkg:gem/prism#lib/prism/node.rb:13884 sig do params( node_id: Integer, @@ -25807,13 +25749,13 @@ class Prism::ModuleNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13881 + # pkg:gem/prism#lib/prism/node.rb:13889 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | MissingNode, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:13884 + # pkg:gem/prism#lib/prism/node.rb:13892 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -25821,18 +25763,18 @@ class Prism::ModuleNode < ::Prism::Node # # @yield [constant_path] # - # pkg:gem/prism#lib/prism/node.rb:13855 + # pkg:gem/prism#lib/prism/node.rb:13863 def each_child_node; end # def end_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13932 + # pkg:gem/prism#lib/prism/node.rb:13940 sig { returns(String) } def end_keyword; end # attr_reader end_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:13911 + # pkg:gem/prism#lib/prism/node.rb:13919 sig { returns(Prism::Location) } def end_keyword_loc; end @@ -25841,56 +25783,56 @@ class Prism::ModuleNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:13937 + # pkg:gem/prism#lib/prism/node.rb:13945 sig { override.returns(String) } def inspect; end # attr_reader locals: Array[Symbol] # - # pkg:gem/prism#lib/prism/node.rb:13889 + # pkg:gem/prism#lib/prism/node.rb:13897 sig { returns(T::Array[Symbol]) } def locals; end # def module_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:13927 + # pkg:gem/prism#lib/prism/node.rb:13935 sig { returns(String) } def module_keyword; end # attr_reader module_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:13892 + # pkg:gem/prism#lib/prism/node.rb:13900 sig { returns(Prism::Location) } def module_keyword_loc; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:13924 + # pkg:gem/prism#lib/prism/node.rb:13932 sig { returns(Symbol) } def name; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13919 + # pkg:gem/prism#lib/prism/node.rb:13927 def save_end_keyword_loc(repository); end # Save the module_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:13900 + # pkg:gem/prism#lib/prism/node.rb:13908 def save_module_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:13942 + # pkg:gem/prism#lib/prism/node.rb:13950 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:13947 + # pkg:gem/prism#lib/prism/node.rb:13955 def type; end end end @@ -25905,13 +25847,13 @@ end # for a, b in [[1, 2], [3, 4]] # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:13974 +# pkg:gem/prism#lib/prism/node.rb:13982 class Prism::MultiTargetNode < ::Prism::Node # Initialize a new MultiTargetNode node. # # @return [MultiTargetNode] a new instance of MultiTargetNode # - # pkg:gem/prism#lib/prism/node.rb:13976 + # pkg:gem/prism#lib/prism/node.rb:13984 sig do params( source: Prism::Source, @@ -25930,36 +25872,36 @@ class Prism::MultiTargetNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14138 + # pkg:gem/prism#lib/prism/node.rb:14146 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:13989 + # pkg:gem/prism#lib/prism/node.rb:13997 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:13994 + # pkg:gem/prism#lib/prism/node.rb:14002 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14017 + # pkg:gem/prism#lib/prism/node.rb:14025 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14008 + # pkg:gem/prism#lib/prism/node.rb:14016 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?) -> MultiTargetNode # - # pkg:gem/prism#lib/prism/node.rb:14022 + # pkg:gem/prism#lib/prism/node.rb:14030 sig do params( node_id: Integer, @@ -25977,13 +25919,13 @@ class Prism::MultiTargetNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14027 + # pkg:gem/prism#lib/prism/node.rb:14035 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:14030 + # pkg:gem/prism#lib/prism/node.rb:14038 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -25991,7 +25933,7 @@ class Prism::MultiTargetNode < ::Prism::Node # # @yield [rest] # - # pkg:gem/prism#lib/prism/node.rb:13999 + # pkg:gem/prism#lib/prism/node.rb:14007 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -25999,7 +25941,7 @@ class Prism::MultiTargetNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14122 + # pkg:gem/prism#lib/prism/node.rb:14130 sig { override.returns(String) } def inspect; end @@ -26013,7 +25955,7 @@ class Prism::MultiTargetNode < ::Prism::Node # a, (b, c) = 1, 2, 3, 4, 5 # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:14043 + # pkg:gem/prism#lib/prism/node.rb:14051 sig do returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)]) end @@ -26021,7 +25963,7 @@ class Prism::MultiTargetNode < ::Prism::Node # def lparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:14112 + # pkg:gem/prism#lib/prism/node.rb:14120 sig { returns(T.nilable(String)) } def lparen; end @@ -26030,7 +25972,7 @@ class Prism::MultiTargetNode < ::Prism::Node # a, (b, c) = 1, 2, 3 # ^ # - # pkg:gem/prism#lib/prism/node.rb:14071 + # pkg:gem/prism#lib/prism/node.rb:14079 sig { returns(T.nilable(Prism::Location)) } def lparen_loc; end @@ -26049,7 +25991,7 @@ class Prism::MultiTargetNode < ::Prism::Node # a, (b,) = 1, 2, 3, 4 # ^ # - # pkg:gem/prism#lib/prism/node.rb:14059 + # pkg:gem/prism#lib/prism/node.rb:14067 sig { returns(T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode))) } def rest; end @@ -26058,7 +26000,7 @@ class Prism::MultiTargetNode < ::Prism::Node # a, (*, b, c) = 1, 2, 3, 4, 5 # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:14065 + # pkg:gem/prism#lib/prism/node.rb:14073 sig do returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::RequiredParameterNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)]) end @@ -26066,7 +26008,7 @@ class Prism::MultiTargetNode < ::Prism::Node # def rparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:14117 + # pkg:gem/prism#lib/prism/node.rb:14125 sig { returns(T.nilable(String)) } def rparen; end @@ -26075,32 +26017,32 @@ class Prism::MultiTargetNode < ::Prism::Node # a, (b, c) = 1, 2, 3 # ^ # - # pkg:gem/prism#lib/prism/node.rb:14093 + # pkg:gem/prism#lib/prism/node.rb:14101 sig { returns(T.nilable(Prism::Location)) } def rparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14085 + # pkg:gem/prism#lib/prism/node.rb:14093 def save_lparen_loc(repository); end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14107 + # pkg:gem/prism#lib/prism/node.rb:14115 def save_rparen_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14127 + # pkg:gem/prism#lib/prism/node.rb:14135 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14132 + # pkg:gem/prism#lib/prism/node.rb:14140 def type; end end end @@ -26110,13 +26052,13 @@ end # a, b, c = 1, 2, 3 # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:14154 +# pkg:gem/prism#lib/prism/node.rb:14162 class Prism::MultiWriteNode < ::Prism::Node # Initialize a new MultiWriteNode node. # # @return [MultiWriteNode] a new instance of MultiWriteNode # - # pkg:gem/prism#lib/prism/node.rb:14156 + # pkg:gem/prism#lib/prism/node.rb:14164 sig do params( source: Prism::Source, @@ -26137,36 +26079,36 @@ class Prism::MultiWriteNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14349 + # pkg:gem/prism#lib/prism/node.rb:14357 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14171 + # pkg:gem/prism#lib/prism/node.rb:14179 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14176 + # pkg:gem/prism#lib/prism/node.rb:14184 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14201 + # pkg:gem/prism#lib/prism/node.rb:14209 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14191 + # pkg:gem/prism#lib/prism/node.rb:14199 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node) -> MultiWriteNode # - # pkg:gem/prism#lib/prism/node.rb:14206 + # pkg:gem/prism#lib/prism/node.rb:14214 sig do params( node_id: Integer, @@ -26186,13 +26128,13 @@ class Prism::MultiWriteNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14211 + # pkg:gem/prism#lib/prism/node.rb:14219 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:14214 + # pkg:gem/prism#lib/prism/node.rb:14222 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -26200,7 +26142,7 @@ class Prism::MultiWriteNode < ::Prism::Node # # @yield [rest] # - # pkg:gem/prism#lib/prism/node.rb:14181 + # pkg:gem/prism#lib/prism/node.rb:14189 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -26208,7 +26150,7 @@ class Prism::MultiWriteNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14333 + # pkg:gem/prism#lib/prism/node.rb:14341 sig { override.returns(String) } def inspect; end @@ -26222,7 +26164,7 @@ class Prism::MultiWriteNode < ::Prism::Node # a, b, c = 1, 2, 3, 4, 5 # ^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:14227 + # pkg:gem/prism#lib/prism/node.rb:14235 sig do returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)]) end @@ -26230,7 +26172,7 @@ class Prism::MultiWriteNode < ::Prism::Node # def lparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:14318 + # pkg:gem/prism#lib/prism/node.rb:14326 sig { returns(T.nilable(String)) } def lparen; end @@ -26239,13 +26181,13 @@ class Prism::MultiWriteNode < ::Prism::Node # (a, b, c) = 1, 2, 3 # ^ # - # pkg:gem/prism#lib/prism/node.rb:14255 + # pkg:gem/prism#lib/prism/node.rb:14263 sig { returns(T.nilable(Prism::Location)) } def lparen_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:14328 + # pkg:gem/prism#lib/prism/node.rb:14336 sig { returns(String) } def operator; end @@ -26254,7 +26196,7 @@ class Prism::MultiWriteNode < ::Prism::Node # a, b, c = 1, 2, 3 # ^ # - # pkg:gem/prism#lib/prism/node.rb:14299 + # pkg:gem/prism#lib/prism/node.rb:14307 sig { returns(Prism::Location) } def operator_loc; end @@ -26273,7 +26215,7 @@ class Prism::MultiWriteNode < ::Prism::Node # a, b, = 1, 2, 3, 4 # ^ # - # pkg:gem/prism#lib/prism/node.rb:14243 + # pkg:gem/prism#lib/prism/node.rb:14251 sig { returns(T.nilable(T.any(Prism::ImplicitRestNode, Prism::SplatNode))) } def rest; end @@ -26282,7 +26224,7 @@ class Prism::MultiWriteNode < ::Prism::Node # a, *, b, c = 1, 2, 3, 4, 5 # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:14249 + # pkg:gem/prism#lib/prism/node.rb:14257 sig do returns(T::Array[T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::MultiTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode)]) end @@ -26290,7 +26232,7 @@ class Prism::MultiWriteNode < ::Prism::Node # def rparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:14323 + # pkg:gem/prism#lib/prism/node.rb:14331 sig { returns(T.nilable(String)) } def rparen; end @@ -26299,31 +26241,31 @@ class Prism::MultiWriteNode < ::Prism::Node # (a, b, c) = 1, 2, 3 # ^ # - # pkg:gem/prism#lib/prism/node.rb:14277 + # pkg:gem/prism#lib/prism/node.rb:14285 sig { returns(T.nilable(Prism::Location)) } def rparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14269 + # pkg:gem/prism#lib/prism/node.rb:14277 def save_lparen_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14307 + # pkg:gem/prism#lib/prism/node.rb:14315 def save_operator_loc(repository); end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14291 + # pkg:gem/prism#lib/prism/node.rb:14299 def save_rparen_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14338 + # pkg:gem/prism#lib/prism/node.rb:14346 sig { override.returns(Symbol) } def type; end @@ -26332,14 +26274,14 @@ class Prism::MultiWriteNode < ::Prism::Node # a, b, c = 1, 2, 3 # ^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:14315 + # pkg:gem/prism#lib/prism/node.rb:14323 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14343 + # pkg:gem/prism#lib/prism/node.rb:14351 def type; end end end @@ -27111,13 +27053,13 @@ end # next 1 # ^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:14367 +# pkg:gem/prism#lib/prism/node.rb:14375 class Prism::NextNode < ::Prism::Node # Initialize a new NextNode node. # # @return [NextNode] a new instance of NextNode # - # pkg:gem/prism#lib/prism/node.rb:14369 + # pkg:gem/prism#lib/prism/node.rb:14377 sig do params( source: Prism::Source, @@ -27133,42 +27075,42 @@ class Prism::NextNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14458 + # pkg:gem/prism#lib/prism/node.rb:14466 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14379 + # pkg:gem/prism#lib/prism/node.rb:14387 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader arguments: ArgumentsNode? # - # pkg:gem/prism#lib/prism/node.rb:14421 + # pkg:gem/prism#lib/prism/node.rb:14429 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14384 + # pkg:gem/prism#lib/prism/node.rb:14392 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14403 + # pkg:gem/prism#lib/prism/node.rb:14411 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14396 + # pkg:gem/prism#lib/prism/node.rb:14404 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?arguments: ArgumentsNode?, ?keyword_loc: Location) -> NextNode # - # pkg:gem/prism#lib/prism/node.rb:14408 + # pkg:gem/prism#lib/prism/node.rb:14416 sig do params( node_id: Integer, @@ -27183,13 +27125,13 @@ class Prism::NextNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14413 + # pkg:gem/prism#lib/prism/node.rb:14421 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, arguments: ArgumentsNode?, keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:14416 + # pkg:gem/prism#lib/prism/node.rb:14424 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -27197,7 +27139,7 @@ class Prism::NextNode < ::Prism::Node # # @yield [arguments] # - # pkg:gem/prism#lib/prism/node.rb:14389 + # pkg:gem/prism#lib/prism/node.rb:14397 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -27205,38 +27147,38 @@ class Prism::NextNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14442 + # pkg:gem/prism#lib/prism/node.rb:14450 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:14437 + # pkg:gem/prism#lib/prism/node.rb:14445 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:14424 + # pkg:gem/prism#lib/prism/node.rb:14432 sig { returns(Prism::Location) } def keyword_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14432 + # pkg:gem/prism#lib/prism/node.rb:14440 def save_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14447 + # pkg:gem/prism#lib/prism/node.rb:14455 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14452 + # pkg:gem/prism#lib/prism/node.rb:14460 def type; end end end @@ -27246,68 +27188,68 @@ end # nil # ^^^ # -# pkg:gem/prism#lib/prism/node.rb:14469 +# pkg:gem/prism#lib/prism/node.rb:14477 class Prism::NilNode < ::Prism::Node # Initialize a new NilNode node. # # @return [NilNode] a new instance of NilNode # - # pkg:gem/prism#lib/prism/node.rb:14471 + # pkg:gem/prism#lib/prism/node.rb:14479 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14534 + # pkg:gem/prism#lib/prism/node.rb:14542 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14479 + # pkg:gem/prism#lib/prism/node.rb:14487 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14484 + # pkg:gem/prism#lib/prism/node.rb:14492 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14500 + # pkg:gem/prism#lib/prism/node.rb:14508 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14495 + # pkg:gem/prism#lib/prism/node.rb:14503 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> NilNode # - # pkg:gem/prism#lib/prism/node.rb:14505 + # pkg:gem/prism#lib/prism/node.rb:14513 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::NilNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14510 + # pkg:gem/prism#lib/prism/node.rb:14518 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:14513 + # pkg:gem/prism#lib/prism/node.rb:14521 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:14489 + # pkg:gem/prism#lib/prism/node.rb:14497 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -27315,20 +27257,20 @@ class Prism::NilNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14518 + # pkg:gem/prism#lib/prism/node.rb:14526 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14523 + # pkg:gem/prism#lib/prism/node.rb:14531 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14528 + # pkg:gem/prism#lib/prism/node.rb:14536 def type; end end end @@ -27339,13 +27281,13 @@ end # ^^^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:14544 +# pkg:gem/prism#lib/prism/node.rb:14552 class Prism::NoKeywordsParameterNode < ::Prism::Node # Initialize a new NoKeywordsParameterNode node. # # @return [NoKeywordsParameterNode] a new instance of NoKeywordsParameterNode # - # pkg:gem/prism#lib/prism/node.rb:14546 + # pkg:gem/prism#lib/prism/node.rb:14554 sig do params( source: Prism::Source, @@ -27361,36 +27303,36 @@ class Prism::NoKeywordsParameterNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14647 + # pkg:gem/prism#lib/prism/node.rb:14655 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14556 + # pkg:gem/prism#lib/prism/node.rb:14564 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14561 + # pkg:gem/prism#lib/prism/node.rb:14569 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14577 + # pkg:gem/prism#lib/prism/node.rb:14585 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14572 + # pkg:gem/prism#lib/prism/node.rb:14580 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?keyword_loc: Location) -> NoKeywordsParameterNode # - # pkg:gem/prism#lib/prism/node.rb:14582 + # pkg:gem/prism#lib/prism/node.rb:14590 sig do params( node_id: Integer, @@ -27405,19 +27347,19 @@ class Prism::NoKeywordsParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14587 + # pkg:gem/prism#lib/prism/node.rb:14595 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:14590 + # pkg:gem/prism#lib/prism/node.rb:14598 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:14566 + # pkg:gem/prism#lib/prism/node.rb:14574 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -27425,56 +27367,56 @@ class Prism::NoKeywordsParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14631 + # pkg:gem/prism#lib/prism/node.rb:14639 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:14626 + # pkg:gem/prism#lib/prism/node.rb:14634 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:14608 + # pkg:gem/prism#lib/prism/node.rb:14616 sig { returns(Prism::Location) } def keyword_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:14621 + # pkg:gem/prism#lib/prism/node.rb:14629 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:14595 + # pkg:gem/prism#lib/prism/node.rb:14603 sig { returns(Prism::Location) } def operator_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14616 + # pkg:gem/prism#lib/prism/node.rb:14624 def save_keyword_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14603 + # pkg:gem/prism#lib/prism/node.rb:14611 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14636 + # pkg:gem/prism#lib/prism/node.rb:14644 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14641 + # pkg:gem/prism#lib/prism/node.rb:14649 def type; end end end @@ -27490,20 +27432,30 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:261 + # pkg:gem/prism#lib/prism/node.rb:269 sig { abstract.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # Returns the first node that matches the given block when visited in a - # depth-first search. This is useful for finding a node that matches a + # breadth-first search. This is useful for finding a node that matches a # particular condition. # # node.breadth_first_search { |node| node.node_id == node_id } # - # pkg:gem/prism#lib/prism/node.rb:231 + # pkg:gem/prism#lib/prism/node.rb:219 sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T.nilable(Prism::Node)) } def breadth_first_search(&block); end + # Returns all of the nodes that match the given block when visited in a + # breadth-first search. This is useful for finding all nodes that match a + # particular condition. + # + # node.breadth_first_search_all { |node| node.is_a?(Prism::CallNode) } + # + # pkg:gem/prism#lib/prism/node.rb:237 + sig { params(block: T.proc.params(node: Prism::Node).returns(T::Boolean)).returns(T::Array[Prism::Node]) } + def breadth_first_search_all(&block); end + # Delegates to the cached_end_code_units_column of the associated location # object. # @@ -27533,7 +27485,7 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:267 + # pkg:gem/prism#lib/prism/node.rb:275 sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end @@ -27542,7 +27494,7 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:288 + # pkg:gem/prism#lib/prism/node.rb:296 sig { abstract.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end @@ -27556,7 +27508,7 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:282 + # pkg:gem/prism#lib/prism/node.rb:290 sig { abstract.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -27565,7 +27517,7 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:271 + # pkg:gem/prism#lib/prism/node.rb:279 sig { abstract.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end @@ -27578,7 +27530,7 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:276 + # pkg:gem/prism#lib/prism/node.rb:284 def each_child_node; end # Delegates to the end_character_column of the associated location object. @@ -27611,11 +27563,29 @@ class Prism::Node sig { abstract.returns(T::Array[Prism::Reflection::Field]) } def fields; end + # Returns the first node that matches the given block when visited in a + # breadth-first search. This is useful for finding a node that matches a + # particular condition. + # + # node.breadth_first_search { |node| node.node_id == node_id } + # + # pkg:gem/prism#lib/prism/node.rb:229 + def find(&block); end + + # Returns all of the nodes that match the given block when visited in a + # breadth-first search. This is useful for finding all nodes that match a + # particular condition. + # + # node.breadth_first_search_all { |node| node.is_a?(Prism::CallNode) } + # + # pkg:gem/prism#lib/prism/node.rb:248 + def find_all(&block); end + # Returns a string representation of the node. # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:293 + # pkg:gem/prism#lib/prism/node.rb:301 sig { abstract.returns(String) } def inspect; end @@ -27773,7 +27743,7 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:309 + # pkg:gem/prism#lib/prism/node.rb:317 sig { abstract.returns(Symbol) } def type; end @@ -27801,7 +27771,7 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:245 + # pkg:gem/prism#lib/prism/node.rb:253 def fields; end # Similar to #type, this method returns a symbol that you can use for @@ -27811,26 +27781,26 @@ class Prism::Node # # @raise [NoMethodError] # - # pkg:gem/prism#lib/prism/node.rb:317 + # pkg:gem/prism#lib/prism/node.rb:325 def type; end end end # The flags that are common to all nodes. # -# pkg:gem/prism#lib/prism/node.rb:19949 +# pkg:gem/prism#lib/prism/node.rb:19957 module Prism::NodeFlags; end # A flag to indicate that the node is a candidate to emit a :line event # through tracepoint when compiled. # -# pkg:gem/prism#lib/prism/node.rb:19952 +# pkg:gem/prism#lib/prism/node.rb:19960 Prism::NodeFlags::NEWLINE = T.let(T.unsafe(nil), Integer) # A flag to indicate that the value that the node represents is a value that # can be determined at parse-time. # -# pkg:gem/prism#lib/prism/node.rb:19956 +# pkg:gem/prism#lib/prism/node.rb:19964 Prism::NodeFlags::STATIC_LITERAL = T.let(T.unsafe(nil), Integer) # Represents an implicit set of parameters through the use of numbered parameters within a block or lambda. @@ -27838,13 +27808,13 @@ Prism::NodeFlags::STATIC_LITERAL = T.let(T.unsafe(nil), Integer) # -> { _1 + _2 } # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:14658 +# pkg:gem/prism#lib/prism/node.rb:14666 class Prism::NumberedParametersNode < ::Prism::Node # Initialize a new NumberedParametersNode node. # # @return [NumberedParametersNode] a new instance of NumberedParametersNode # - # pkg:gem/prism#lib/prism/node.rb:14660 + # pkg:gem/prism#lib/prism/node.rb:14668 sig do params( source: Prism::Source, @@ -27859,36 +27829,36 @@ class Prism::NumberedParametersNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14727 + # pkg:gem/prism#lib/prism/node.rb:14735 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14669 + # pkg:gem/prism#lib/prism/node.rb:14677 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14674 + # pkg:gem/prism#lib/prism/node.rb:14682 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14690 + # pkg:gem/prism#lib/prism/node.rb:14698 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14685 + # pkg:gem/prism#lib/prism/node.rb:14693 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?maximum: Integer) -> NumberedParametersNode # - # pkg:gem/prism#lib/prism/node.rb:14695 + # pkg:gem/prism#lib/prism/node.rb:14703 sig do params( node_id: Integer, @@ -27902,19 +27872,19 @@ class Prism::NumberedParametersNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14700 + # pkg:gem/prism#lib/prism/node.rb:14708 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, maximum: Integer } # - # pkg:gem/prism#lib/prism/node.rb:14703 + # pkg:gem/prism#lib/prism/node.rb:14711 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:14679 + # pkg:gem/prism#lib/prism/node.rb:14687 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -27922,26 +27892,26 @@ class Prism::NumberedParametersNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14711 + # pkg:gem/prism#lib/prism/node.rb:14719 sig { override.returns(String) } def inspect; end # attr_reader maximum: Integer # - # pkg:gem/prism#lib/prism/node.rb:14708 + # pkg:gem/prism#lib/prism/node.rb:14716 sig { returns(Integer) } def maximum; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14716 + # pkg:gem/prism#lib/prism/node.rb:14724 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14721 + # pkg:gem/prism#lib/prism/node.rb:14729 def type; end end end @@ -27951,13 +27921,13 @@ end # $1 # ^^ # -# pkg:gem/prism#lib/prism/node.rb:14737 +# pkg:gem/prism#lib/prism/node.rb:14745 class Prism::NumberedReferenceReadNode < ::Prism::Node # Initialize a new NumberedReferenceReadNode node. # # @return [NumberedReferenceReadNode] a new instance of NumberedReferenceReadNode # - # pkg:gem/prism#lib/prism/node.rb:14739 + # pkg:gem/prism#lib/prism/node.rb:14747 sig do params( source: Prism::Source, @@ -27972,36 +27942,36 @@ class Prism::NumberedReferenceReadNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14812 + # pkg:gem/prism#lib/prism/node.rb:14820 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14748 + # pkg:gem/prism#lib/prism/node.rb:14756 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14753 + # pkg:gem/prism#lib/prism/node.rb:14761 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14769 + # pkg:gem/prism#lib/prism/node.rb:14777 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14764 + # pkg:gem/prism#lib/prism/node.rb:14772 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?number: Integer) -> NumberedReferenceReadNode # - # pkg:gem/prism#lib/prism/node.rb:14774 + # pkg:gem/prism#lib/prism/node.rb:14782 sig do params( node_id: Integer, @@ -28015,19 +27985,19 @@ class Prism::NumberedReferenceReadNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14779 + # pkg:gem/prism#lib/prism/node.rb:14787 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, number: Integer } # - # pkg:gem/prism#lib/prism/node.rb:14782 + # pkg:gem/prism#lib/prism/node.rb:14790 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:14758 + # pkg:gem/prism#lib/prism/node.rb:14766 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -28035,7 +28005,7 @@ class Prism::NumberedReferenceReadNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14796 + # pkg:gem/prism#lib/prism/node.rb:14804 sig { override.returns(String) } def inspect; end @@ -28047,20 +28017,20 @@ class Prism::NumberedReferenceReadNode < ::Prism::Node # # $4294967296 # number `0` # - # pkg:gem/prism#lib/prism/node.rb:14793 + # pkg:gem/prism#lib/prism/node.rb:14801 sig { returns(Integer) } def number; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14801 + # pkg:gem/prism#lib/prism/node.rb:14809 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14806 + # pkg:gem/prism#lib/prism/node.rb:14814 def type; end end end @@ -28071,13 +28041,13 @@ end # ^^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:14823 +# pkg:gem/prism#lib/prism/node.rb:14831 class Prism::OptionalKeywordParameterNode < ::Prism::Node # Initialize a new OptionalKeywordParameterNode node. # # @return [OptionalKeywordParameterNode] a new instance of OptionalKeywordParameterNode # - # pkg:gem/prism#lib/prism/node.rb:14825 + # pkg:gem/prism#lib/prism/node.rb:14833 sig do params( source: Prism::Source, @@ -28094,36 +28064,36 @@ class Prism::OptionalKeywordParameterNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:14916 + # pkg:gem/prism#lib/prism/node.rb:14924 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14836 + # pkg:gem/prism#lib/prism/node.rb:14844 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14841 + # pkg:gem/prism#lib/prism/node.rb:14849 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14858 + # pkg:gem/prism#lib/prism/node.rb:14866 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14853 + # pkg:gem/prism#lib/prism/node.rb:14861 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?value: Prism::node) -> OptionalKeywordParameterNode # - # pkg:gem/prism#lib/prism/node.rb:14863 + # pkg:gem/prism#lib/prism/node.rb:14871 sig do params( node_id: Integer, @@ -28139,13 +28109,13 @@ class Prism::OptionalKeywordParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14868 + # pkg:gem/prism#lib/prism/node.rb:14876 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:14871 + # pkg:gem/prism#lib/prism/node.rb:14879 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -28153,7 +28123,7 @@ class Prism::OptionalKeywordParameterNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:14846 + # pkg:gem/prism#lib/prism/node.rb:14854 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -28161,19 +28131,19 @@ class Prism::OptionalKeywordParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:14900 + # pkg:gem/prism#lib/prism/node.rb:14908 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:14881 + # pkg:gem/prism#lib/prism/node.rb:14889 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:14884 + # pkg:gem/prism#lib/prism/node.rb:14892 sig { returns(Prism::Location) } def name_loc; end @@ -28181,32 +28151,32 @@ class Prism::OptionalKeywordParameterNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:14876 + # pkg:gem/prism#lib/prism/node.rb:14884 sig { returns(T::Boolean) } def repeated_parameter?; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:14892 + # pkg:gem/prism#lib/prism/node.rb:14900 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:14905 + # pkg:gem/prism#lib/prism/node.rb:14913 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:14897 + # pkg:gem/prism#lib/prism/node.rb:14905 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:14910 + # pkg:gem/prism#lib/prism/node.rb:14918 def type; end end end @@ -28217,13 +28187,13 @@ end # ^^^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:14930 +# pkg:gem/prism#lib/prism/node.rb:14938 class Prism::OptionalParameterNode < ::Prism::Node # Initialize a new OptionalParameterNode node. # # @return [OptionalParameterNode] a new instance of OptionalParameterNode # - # pkg:gem/prism#lib/prism/node.rb:14932 + # pkg:gem/prism#lib/prism/node.rb:14940 sig do params( source: Prism::Source, @@ -28241,36 +28211,36 @@ class Prism::OptionalParameterNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15042 + # pkg:gem/prism#lib/prism/node.rb:15050 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:14944 + # pkg:gem/prism#lib/prism/node.rb:14952 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14949 + # pkg:gem/prism#lib/prism/node.rb:14957 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:14966 + # pkg:gem/prism#lib/prism/node.rb:14974 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:14961 + # pkg:gem/prism#lib/prism/node.rb:14969 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node) -> OptionalParameterNode # - # pkg:gem/prism#lib/prism/node.rb:14971 + # pkg:gem/prism#lib/prism/node.rb:14979 sig do params( node_id: Integer, @@ -28287,13 +28257,13 @@ class Prism::OptionalParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:14976 + # pkg:gem/prism#lib/prism/node.rb:14984 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:14979 + # pkg:gem/prism#lib/prism/node.rb:14987 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -28301,7 +28271,7 @@ class Prism::OptionalParameterNode < ::Prism::Node # # @yield [value] # - # pkg:gem/prism#lib/prism/node.rb:14954 + # pkg:gem/prism#lib/prism/node.rb:14962 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -28309,31 +28279,31 @@ class Prism::OptionalParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15026 + # pkg:gem/prism#lib/prism/node.rb:15034 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:14989 + # pkg:gem/prism#lib/prism/node.rb:14997 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:14992 + # pkg:gem/prism#lib/prism/node.rb:15000 sig { returns(Prism::Location) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15021 + # pkg:gem/prism#lib/prism/node.rb:15029 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15005 + # pkg:gem/prism#lib/prism/node.rb:15013 sig { returns(Prism::Location) } def operator_loc; end @@ -28341,38 +28311,38 @@ class Prism::OptionalParameterNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:14984 + # pkg:gem/prism#lib/prism/node.rb:14992 sig { returns(T::Boolean) } def repeated_parameter?; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15000 + # pkg:gem/prism#lib/prism/node.rb:15008 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15013 + # pkg:gem/prism#lib/prism/node.rb:15021 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15031 + # pkg:gem/prism#lib/prism/node.rb:15039 sig { override.returns(Symbol) } def type; end # attr_reader value: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:15018 + # pkg:gem/prism#lib/prism/node.rb:15026 sig { returns(Prism::Node) } def value; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15036 + # pkg:gem/prism#lib/prism/node.rb:15044 def type; end end end @@ -28382,13 +28352,13 @@ end # left or right # ^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:15056 +# pkg:gem/prism#lib/prism/node.rb:15064 class Prism::OrNode < ::Prism::Node # Initialize a new OrNode node. # # @return [OrNode] a new instance of OrNode # - # pkg:gem/prism#lib/prism/node.rb:15058 + # pkg:gem/prism#lib/prism/node.rb:15066 sig do params( source: Prism::Source, @@ -28405,36 +28375,36 @@ class Prism::OrNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15165 + # pkg:gem/prism#lib/prism/node.rb:15173 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15069 + # pkg:gem/prism#lib/prism/node.rb:15077 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15074 + # pkg:gem/prism#lib/prism/node.rb:15082 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:15092 + # pkg:gem/prism#lib/prism/node.rb:15100 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:15087 + # pkg:gem/prism#lib/prism/node.rb:15095 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node, ?right: Prism::node, ?operator_loc: Location) -> OrNode # - # pkg:gem/prism#lib/prism/node.rb:15097 + # pkg:gem/prism#lib/prism/node.rb:15105 sig do params( node_id: Integer, @@ -28450,13 +28420,13 @@ class Prism::OrNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15102 + # pkg:gem/prism#lib/prism/node.rb:15110 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node, right: Prism::node, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:15105 + # pkg:gem/prism#lib/prism/node.rb:15113 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -28464,7 +28434,7 @@ class Prism::OrNode < ::Prism::Node # # @yield [left] # - # pkg:gem/prism#lib/prism/node.rb:15079 + # pkg:gem/prism#lib/prism/node.rb:15087 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -28472,7 +28442,7 @@ class Prism::OrNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15149 + # pkg:gem/prism#lib/prism/node.rb:15157 sig { override.returns(String) } def inspect; end @@ -28484,13 +28454,13 @@ class Prism::OrNode < ::Prism::Node # 1 || 2 # ^ # - # pkg:gem/prism#lib/prism/node.rb:15116 + # pkg:gem/prism#lib/prism/node.rb:15124 sig { returns(Prism::Node) } def left; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15144 + # pkg:gem/prism#lib/prism/node.rb:15152 sig { returns(String) } def operator; end @@ -28499,7 +28469,7 @@ class Prism::OrNode < ::Prism::Node # left or right # ^^ # - # pkg:gem/prism#lib/prism/node.rb:15131 + # pkg:gem/prism#lib/prism/node.rb:15139 sig { returns(Prism::Location) } def operator_loc; end @@ -28511,26 +28481,26 @@ class Prism::OrNode < ::Prism::Node # 1 or 2 # ^ # - # pkg:gem/prism#lib/prism/node.rb:15125 + # pkg:gem/prism#lib/prism/node.rb:15133 sig { returns(Prism::Node) } def right; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15139 + # pkg:gem/prism#lib/prism/node.rb:15147 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15154 + # pkg:gem/prism#lib/prism/node.rb:15162 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15159 + # pkg:gem/prism#lib/prism/node.rb:15167 def type; end end end @@ -28540,7 +28510,7 @@ end # pkg:gem/prism#lib/prism/pack.rb:8 module Prism::Pack class << self - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def parse(_arg0, _arg1, _arg2); end end end @@ -28780,12 +28750,12 @@ Prism::Pack::UTF8 = T.let(T.unsafe(nil), Symbol) # Flags for parameter nodes. # -# pkg:gem/prism#lib/prism/node.rb:19856 +# pkg:gem/prism#lib/prism/node.rb:19864 module Prism::ParameterFlags; end # a parameter name that has been repeated in the method signature # -# pkg:gem/prism#lib/prism/node.rb:19858 +# pkg:gem/prism#lib/prism/node.rb:19866 Prism::ParameterFlags::REPEATED_PARAMETER = T.let(T.unsafe(nil), Integer) # Represents the list of parameters on a method, block, or lambda definition. @@ -28794,13 +28764,13 @@ Prism::ParameterFlags::REPEATED_PARAMETER = T.let(T.unsafe(nil), Integer) # ^^^^^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:15178 +# pkg:gem/prism#lib/prism/node.rb:15186 class Prism::ParametersNode < ::Prism::Node # Initialize a new ParametersNode node. # # @return [ParametersNode] a new instance of ParametersNode # - # pkg:gem/prism#lib/prism/node.rb:15180 + # pkg:gem/prism#lib/prism/node.rb:15188 sig do params( source: Prism::Source, @@ -28821,42 +28791,42 @@ class Prism::ParametersNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15286 + # pkg:gem/prism#lib/prism/node.rb:15294 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15195 + # pkg:gem/prism#lib/prism/node.rb:15203 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader block: BlockParameterNode? # - # pkg:gem/prism#lib/prism/node.rb:15267 + # pkg:gem/prism#lib/prism/node.rb:15275 sig { returns(T.nilable(Prism::BlockParameterNode)) } def block; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15200 + # pkg:gem/prism#lib/prism/node.rb:15208 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:15231 + # pkg:gem/prism#lib/prism/node.rb:15239 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:15218 + # pkg:gem/prism#lib/prism/node.rb:15226 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?) -> ParametersNode # - # pkg:gem/prism#lib/prism/node.rb:15236 + # pkg:gem/prism#lib/prism/node.rb:15244 sig do params( node_id: Integer, @@ -28876,13 +28846,13 @@ class Prism::ParametersNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15241 + # pkg:gem/prism#lib/prism/node.rb:15249 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode? } # - # pkg:gem/prism#lib/prism/node.rb:15244 + # pkg:gem/prism#lib/prism/node.rb:15252 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -28890,7 +28860,7 @@ class Prism::ParametersNode < ::Prism::Node # # @yield [rest] # - # pkg:gem/prism#lib/prism/node.rb:15205 + # pkg:gem/prism#lib/prism/node.rb:15213 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -28898,13 +28868,13 @@ class Prism::ParametersNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15270 + # pkg:gem/prism#lib/prism/node.rb:15278 sig { override.returns(String) } def inspect; end # attr_reader keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil # - # pkg:gem/prism#lib/prism/node.rb:15264 + # pkg:gem/prism#lib/prism/node.rb:15272 sig do returns(T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode))) end @@ -28912,19 +28882,19 @@ class Prism::ParametersNode < ::Prism::Node # attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] # - # pkg:gem/prism#lib/prism/node.rb:15261 + # pkg:gem/prism#lib/prism/node.rb:15269 sig { returns(T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)]) } def keywords; end # attr_reader optionals: Array[OptionalParameterNode] # - # pkg:gem/prism#lib/prism/node.rb:15252 + # pkg:gem/prism#lib/prism/node.rb:15260 sig { returns(T::Array[Prism::OptionalParameterNode]) } def optionals; end # attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode] # - # pkg:gem/prism#lib/prism/node.rb:15258 + # pkg:gem/prism#lib/prism/node.rb:15266 sig do returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)]) end @@ -28932,13 +28902,13 @@ class Prism::ParametersNode < ::Prism::Node # attr_reader requireds: Array[RequiredParameterNode | MultiTargetNode] # - # pkg:gem/prism#lib/prism/node.rb:15249 + # pkg:gem/prism#lib/prism/node.rb:15257 sig { returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)]) } def requireds; end # attr_reader rest: RestParameterNode | ImplicitRestNode | nil # - # pkg:gem/prism#lib/prism/node.rb:15255 + # pkg:gem/prism#lib/prism/node.rb:15263 sig { returns(T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode))) } def rest; end @@ -28950,14 +28920,14 @@ class Prism::ParametersNode < ::Prism::Node # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15275 + # pkg:gem/prism#lib/prism/node.rb:15283 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15280 + # pkg:gem/prism#lib/prism/node.rb:15288 def type; end end end @@ -28967,13 +28937,13 @@ end # (10 + 34) # ^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:15306 +# pkg:gem/prism#lib/prism/node.rb:15314 class Prism::ParenthesesNode < ::Prism::Node # Initialize a new ParenthesesNode node. # # @return [ParenthesesNode] a new instance of ParenthesesNode # - # pkg:gem/prism#lib/prism/node.rb:15308 + # pkg:gem/prism#lib/prism/node.rb:15316 sig do params( source: Prism::Source, @@ -28990,54 +28960,54 @@ class Prism::ParenthesesNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15421 + # pkg:gem/prism#lib/prism/node.rb:15429 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15319 + # pkg:gem/prism#lib/prism/node.rb:15327 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader body: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:15366 + # pkg:gem/prism#lib/prism/node.rb:15374 sig { returns(T.nilable(Prism::Node)) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15324 + # pkg:gem/prism#lib/prism/node.rb:15332 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15400 + # pkg:gem/prism#lib/prism/node.rb:15408 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15382 + # pkg:gem/prism#lib/prism/node.rb:15390 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:15343 + # pkg:gem/prism#lib/prism/node.rb:15351 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:15336 + # pkg:gem/prism#lib/prism/node.rb:15344 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Prism::node?, ?opening_loc: Location, ?closing_loc: Location) -> ParenthesesNode # - # pkg:gem/prism#lib/prism/node.rb:15348 + # pkg:gem/prism#lib/prism/node.rb:15356 sig do params( node_id: Integer, @@ -29053,13 +29023,13 @@ class Prism::ParenthesesNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15353 + # pkg:gem/prism#lib/prism/node.rb:15361 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Prism::node?, opening_loc: Location, closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:15356 + # pkg:gem/prism#lib/prism/node.rb:15364 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -29067,7 +29037,7 @@ class Prism::ParenthesesNode < ::Prism::Node # # @yield [body] # - # pkg:gem/prism#lib/prism/node.rb:15329 + # pkg:gem/prism#lib/prism/node.rb:15337 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -29075,7 +29045,7 @@ class Prism::ParenthesesNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15405 + # pkg:gem/prism#lib/prism/node.rb:15413 sig { override.returns(String) } def inspect; end @@ -29083,7 +29053,7 @@ class Prism::ParenthesesNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:15361 + # pkg:gem/prism#lib/prism/node.rb:15369 sig { returns(T::Boolean) } def multiple_statements?; end @@ -29092,111 +29062,111 @@ class Prism::ParenthesesNode < ::Prism::Node # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15395 + # pkg:gem/prism#lib/prism/node.rb:15403 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15369 + # pkg:gem/prism#lib/prism/node.rb:15377 sig { returns(Prism::Location) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15390 + # pkg:gem/prism#lib/prism/node.rb:15398 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15377 + # pkg:gem/prism#lib/prism/node.rb:15385 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15410 + # pkg:gem/prism#lib/prism/node.rb:15418 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15415 + # pkg:gem/prism#lib/prism/node.rb:15423 def type; end end end # Flags for parentheses nodes. # -# pkg:gem/prism#lib/prism/node.rb:19862 +# pkg:gem/prism#lib/prism/node.rb:19870 module Prism::ParenthesesNodeFlags; end # parentheses that contain multiple potentially void statements # -# pkg:gem/prism#lib/prism/node.rb:19864 +# pkg:gem/prism#lib/prism/node.rb:19872 Prism::ParenthesesNodeFlags::MULTIPLE_STATEMENTS = T.let(T.unsafe(nil), Integer) # This represents an error that was encountered during parsing. # -# pkg:gem/prism#lib/prism/parse_result.rb:597 +# pkg:gem/prism#lib/prism/parse_result.rb:606 class Prism::ParseError # Create a new error object with the given message and location. # # @return [ParseError] a new instance of ParseError # - # pkg:gem/prism#lib/prism/parse_result.rb:612 + # pkg:gem/prism#lib/prism/parse_result.rb:621 sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void } def initialize(type, message, location, level); end # Implement the hash pattern matching interface for ParseError. # - # pkg:gem/prism#lib/prism/parse_result.rb:620 + # pkg:gem/prism#lib/prism/parse_result.rb:629 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. # - # pkg:gem/prism#lib/prism/parse_result.rb:625 + # pkg:gem/prism#lib/prism/parse_result.rb:634 sig { returns(String) } def inspect; end # The level of this error. # - # pkg:gem/prism#lib/prism/parse_result.rb:609 + # pkg:gem/prism#lib/prism/parse_result.rb:618 sig { returns(Symbol) } def level; end # A Location object representing the location of this error in the source. # - # pkg:gem/prism#lib/prism/parse_result.rb:606 + # pkg:gem/prism#lib/prism/parse_result.rb:615 sig { returns(Prism::Location) } def location; end # The message associated with this error. # - # pkg:gem/prism#lib/prism/parse_result.rb:603 + # pkg:gem/prism#lib/prism/parse_result.rb:612 sig { returns(String) } def message; end # The type of error. This is an _internal_ symbol that is used for # communicating with translation layers. It is not meant to be public API. # - # pkg:gem/prism#lib/prism/parse_result.rb:600 + # pkg:gem/prism#lib/prism/parse_result.rb:609 sig { returns(Symbol) } def type; end end # This is a result specific to the `parse_lex` and `parse_lex_file` methods. # -# pkg:gem/prism#lib/prism/parse_result.rb:786 +# pkg:gem/prism#lib/prism/parse_result.rb:795 class Prism::ParseLexResult < ::Prism::Result # Create a new parse lex result object with the given values. # # @return [ParseLexResult] a new instance of ParseLexResult # - # pkg:gem/prism#lib/prism/parse_result.rb:792 + # pkg:gem/prism#lib/prism/parse_result.rb:801 sig do params( value: [Prism::ProgramNode, T::Array[T.untyped]], @@ -29212,27 +29182,27 @@ class Prism::ParseLexResult < ::Prism::Result # Implement the hash pattern matching interface for ParseLexResult. # - # pkg:gem/prism#lib/prism/parse_result.rb:798 + # pkg:gem/prism#lib/prism/parse_result.rb:807 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # A tuple of the syntax tree and the list of tokens that were parsed from # the source code. # - # pkg:gem/prism#lib/prism/parse_result.rb:789 + # pkg:gem/prism#lib/prism/parse_result.rb:798 sig { returns([Prism::ProgramNode, T::Array[T.untyped]]) } def value; end end # This is a result specific to the `parse` and `parse_file` methods. # -# pkg:gem/prism#lib/prism/parse_result.rb:727 +# pkg:gem/prism#lib/prism/parse_result.rb:736 class Prism::ParseResult < ::Prism::Result # Create a new parse result object with the given values. # # @return [ParseResult] a new instance of ParseResult # - # pkg:gem/prism#lib/prism/parse_result.rb:740 + # pkg:gem/prism#lib/prism/parse_result.rb:749 sig do params( value: Prism::ProgramNode, @@ -29248,30 +29218,30 @@ class Prism::ParseResult < ::Prism::Result # Attach the list of comments to their respective locations in the tree. # - # pkg:gem/prism#lib/prism/parse_result.rb:751 + # pkg:gem/prism#lib/prism/parse_result.rb:760 def attach_comments!; end # Implement the hash pattern matching interface for ParseResult. # - # pkg:gem/prism#lib/prism/parse_result.rb:746 + # pkg:gem/prism#lib/prism/parse_result.rb:755 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # Returns a string representation of the syntax tree with the errors # displayed inline. # - # pkg:gem/prism#lib/prism/parse_result.rb:763 + # pkg:gem/prism#lib/prism/parse_result.rb:772 def errors_format; end # Walk the tree and mark nodes that are on a new line, loosely emulating # the behavior of CRuby's `:line` tracepoint event. # - # pkg:gem/prism#lib/prism/parse_result.rb:757 + # pkg:gem/prism#lib/prism/parse_result.rb:766 def mark_newlines!; end # The syntax tree that was parsed from the source code. # - # pkg:gem/prism#lib/prism/parse_result.rb:737 + # pkg:gem/prism#lib/prism/parse_result.rb:746 sig { returns(Prism::ProgramNode) } def value; end end @@ -29464,50 +29434,50 @@ end # This represents a warning that was encountered during parsing. # -# pkg:gem/prism#lib/prism/parse_result.rb:631 +# pkg:gem/prism#lib/prism/parse_result.rb:640 class Prism::ParseWarning # Create a new warning object with the given message and location. # # @return [ParseWarning] a new instance of ParseWarning # - # pkg:gem/prism#lib/prism/parse_result.rb:646 + # pkg:gem/prism#lib/prism/parse_result.rb:655 sig { params(type: Symbol, message: String, location: Prism::Location, level: Symbol).void } def initialize(type, message, location, level); end # Implement the hash pattern matching interface for ParseWarning. # - # pkg:gem/prism#lib/prism/parse_result.rb:654 + # pkg:gem/prism#lib/prism/parse_result.rb:663 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. # - # pkg:gem/prism#lib/prism/parse_result.rb:659 + # pkg:gem/prism#lib/prism/parse_result.rb:668 sig { returns(String) } def inspect; end # The level of this warning. # - # pkg:gem/prism#lib/prism/parse_result.rb:643 + # pkg:gem/prism#lib/prism/parse_result.rb:652 sig { returns(Symbol) } def level; end # A Location object representing the location of this warning in the source. # - # pkg:gem/prism#lib/prism/parse_result.rb:640 + # pkg:gem/prism#lib/prism/parse_result.rb:649 sig { returns(Prism::Location) } def location; end # The message associated with this warning. # - # pkg:gem/prism#lib/prism/parse_result.rb:637 + # pkg:gem/prism#lib/prism/parse_result.rb:646 sig { returns(String) } def message; end # The type of warning. This is an _internal_ symbol that is used for # communicating with translation layers. It is not meant to be public API. # - # pkg:gem/prism#lib/prism/parse_result.rb:634 + # pkg:gem/prism#lib/prism/parse_result.rb:643 sig { returns(Symbol) } def type; end end @@ -29678,13 +29648,13 @@ end # foo in ^(bar) # ^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:15434 +# pkg:gem/prism#lib/prism/node.rb:15442 class Prism::PinnedExpressionNode < ::Prism::Node # Initialize a new PinnedExpressionNode node. # # @return [PinnedExpressionNode] a new instance of PinnedExpressionNode # - # pkg:gem/prism#lib/prism/node.rb:15436 + # pkg:gem/prism#lib/prism/node.rb:15444 sig do params( source: Prism::Source, @@ -29702,36 +29672,36 @@ class Prism::PinnedExpressionNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15573 + # pkg:gem/prism#lib/prism/node.rb:15581 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15448 + # pkg:gem/prism#lib/prism/node.rb:15456 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15453 + # pkg:gem/prism#lib/prism/node.rb:15461 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:15470 + # pkg:gem/prism#lib/prism/node.rb:15478 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:15465 + # pkg:gem/prism#lib/prism/node.rb:15473 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?operator_loc: Location, ?lparen_loc: Location, ?rparen_loc: Location) -> PinnedExpressionNode # - # pkg:gem/prism#lib/prism/node.rb:15475 + # pkg:gem/prism#lib/prism/node.rb:15483 sig do params( node_id: Integer, @@ -29748,13 +29718,13 @@ class Prism::PinnedExpressionNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15480 + # pkg:gem/prism#lib/prism/node.rb:15488 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, operator_loc: Location, lparen_loc: Location, rparen_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:15483 + # pkg:gem/prism#lib/prism/node.rb:15491 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -29762,7 +29732,7 @@ class Prism::PinnedExpressionNode < ::Prism::Node # # @yield [expression] # - # pkg:gem/prism#lib/prism/node.rb:15458 + # pkg:gem/prism#lib/prism/node.rb:15466 def each_child_node; end # The expression used in the pinned expression @@ -29770,7 +29740,7 @@ class Prism::PinnedExpressionNode < ::Prism::Node # foo in ^(bar) # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:15491 + # pkg:gem/prism#lib/prism/node.rb:15499 sig { returns(Prism::Node) } def expression; end @@ -29779,13 +29749,13 @@ class Prism::PinnedExpressionNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15557 + # pkg:gem/prism#lib/prism/node.rb:15565 sig { override.returns(String) } def inspect; end # def lparen: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15547 + # pkg:gem/prism#lib/prism/node.rb:15555 sig { returns(String) } def lparen; end @@ -29794,13 +29764,13 @@ class Prism::PinnedExpressionNode < ::Prism::Node # foo in ^(bar) # ^ # - # pkg:gem/prism#lib/prism/node.rb:15513 + # pkg:gem/prism#lib/prism/node.rb:15521 sig { returns(Prism::Location) } def lparen_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15542 + # pkg:gem/prism#lib/prism/node.rb:15550 sig { returns(String) } def operator; end @@ -29809,13 +29779,13 @@ class Prism::PinnedExpressionNode < ::Prism::Node # foo in ^(bar) # ^ # - # pkg:gem/prism#lib/prism/node.rb:15497 + # pkg:gem/prism#lib/prism/node.rb:15505 sig { returns(Prism::Location) } def operator_loc; end # def rparen: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15552 + # pkg:gem/prism#lib/prism/node.rb:15560 sig { returns(String) } def rparen; end @@ -29824,38 +29794,38 @@ class Prism::PinnedExpressionNode < ::Prism::Node # foo in ^(bar) # ^ # - # pkg:gem/prism#lib/prism/node.rb:15529 + # pkg:gem/prism#lib/prism/node.rb:15537 sig { returns(Prism::Location) } def rparen_loc; end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15521 + # pkg:gem/prism#lib/prism/node.rb:15529 def save_lparen_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15505 + # pkg:gem/prism#lib/prism/node.rb:15513 def save_operator_loc(repository); end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15537 + # pkg:gem/prism#lib/prism/node.rb:15545 def save_rparen_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15562 + # pkg:gem/prism#lib/prism/node.rb:15570 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15567 + # pkg:gem/prism#lib/prism/node.rb:15575 def type; end end end @@ -29865,13 +29835,13 @@ end # foo in ^bar # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:15586 +# pkg:gem/prism#lib/prism/node.rb:15594 class Prism::PinnedVariableNode < ::Prism::Node # Initialize a new PinnedVariableNode node. # # @return [PinnedVariableNode] a new instance of PinnedVariableNode # - # pkg:gem/prism#lib/prism/node.rb:15588 + # pkg:gem/prism#lib/prism/node.rb:15596 sig do params( source: Prism::Source, @@ -29887,36 +29857,36 @@ class Prism::PinnedVariableNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15681 + # pkg:gem/prism#lib/prism/node.rb:15689 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15598 + # pkg:gem/prism#lib/prism/node.rb:15606 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15603 + # pkg:gem/prism#lib/prism/node.rb:15611 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:15620 + # pkg:gem/prism#lib/prism/node.rb:15628 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:15615 + # pkg:gem/prism#lib/prism/node.rb:15623 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, ?operator_loc: Location) -> PinnedVariableNode # - # pkg:gem/prism#lib/prism/node.rb:15625 + # pkg:gem/prism#lib/prism/node.rb:15633 sig do params( node_id: Integer, @@ -29931,13 +29901,13 @@ class Prism::PinnedVariableNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15630 + # pkg:gem/prism#lib/prism/node.rb:15638 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:15633 + # pkg:gem/prism#lib/prism/node.rb:15641 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -29945,7 +29915,7 @@ class Prism::PinnedVariableNode < ::Prism::Node # # @yield [variable] # - # pkg:gem/prism#lib/prism/node.rb:15608 + # pkg:gem/prism#lib/prism/node.rb:15616 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -29953,13 +29923,13 @@ class Prism::PinnedVariableNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15665 + # pkg:gem/prism#lib/prism/node.rb:15673 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15660 + # pkg:gem/prism#lib/prism/node.rb:15668 sig { returns(String) } def operator; end @@ -29968,19 +29938,19 @@ class Prism::PinnedVariableNode < ::Prism::Node # foo in ^bar # ^ # - # pkg:gem/prism#lib/prism/node.rb:15647 + # pkg:gem/prism#lib/prism/node.rb:15655 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15655 + # pkg:gem/prism#lib/prism/node.rb:15663 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15670 + # pkg:gem/prism#lib/prism/node.rb:15678 sig { override.returns(Symbol) } def type; end @@ -29989,7 +29959,7 @@ class Prism::PinnedVariableNode < ::Prism::Node # foo in ^bar # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:15641 + # pkg:gem/prism#lib/prism/node.rb:15649 sig do returns(T.any(Prism::LocalVariableReadNode, Prism::InstanceVariableReadNode, Prism::ClassVariableReadNode, Prism::GlobalVariableReadNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::ItLocalVariableReadNode, Prism::MissingNode)) end @@ -29998,7 +29968,7 @@ class Prism::PinnedVariableNode < ::Prism::Node class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15675 + # pkg:gem/prism#lib/prism/node.rb:15683 def type; end end end @@ -30008,13 +29978,13 @@ end # END { foo } # ^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:15692 +# pkg:gem/prism#lib/prism/node.rb:15700 class Prism::PostExecutionNode < ::Prism::Node # Initialize a new PostExecutionNode node. # # @return [PostExecutionNode] a new instance of PostExecutionNode # - # pkg:gem/prism#lib/prism/node.rb:15694 + # pkg:gem/prism#lib/prism/node.rb:15702 sig do params( source: Prism::Source, @@ -30032,48 +30002,48 @@ class Prism::PostExecutionNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15821 + # pkg:gem/prism#lib/prism/node.rb:15829 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15706 + # pkg:gem/prism#lib/prism/node.rb:15714 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15711 + # pkg:gem/prism#lib/prism/node.rb:15719 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15800 + # pkg:gem/prism#lib/prism/node.rb:15808 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15777 + # pkg:gem/prism#lib/prism/node.rb:15785 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:15730 + # pkg:gem/prism#lib/prism/node.rb:15738 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:15723 + # pkg:gem/prism#lib/prism/node.rb:15731 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PostExecutionNode # - # pkg:gem/prism#lib/prism/node.rb:15735 + # pkg:gem/prism#lib/prism/node.rb:15743 sig do params( node_id: Integer, @@ -30090,13 +30060,13 @@ class Prism::PostExecutionNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15740 + # pkg:gem/prism#lib/prism/node.rb:15748 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:15743 + # pkg:gem/prism#lib/prism/node.rb:15751 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -30104,7 +30074,7 @@ class Prism::PostExecutionNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:15716 + # pkg:gem/prism#lib/prism/node.rb:15724 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -30112,68 +30082,68 @@ class Prism::PostExecutionNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15805 + # pkg:gem/prism#lib/prism/node.rb:15813 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15790 + # pkg:gem/prism#lib/prism/node.rb:15798 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15751 + # pkg:gem/prism#lib/prism/node.rb:15759 sig { returns(Prism::Location) } def keyword_loc; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15795 + # pkg:gem/prism#lib/prism/node.rb:15803 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15764 + # pkg:gem/prism#lib/prism/node.rb:15772 sig { returns(Prism::Location) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15785 + # pkg:gem/prism#lib/prism/node.rb:15793 def save_closing_loc(repository); end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15759 + # pkg:gem/prism#lib/prism/node.rb:15767 def save_keyword_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15772 + # pkg:gem/prism#lib/prism/node.rb:15780 def save_opening_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:15748 + # pkg:gem/prism#lib/prism/node.rb:15756 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15810 + # pkg:gem/prism#lib/prism/node.rb:15818 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15815 + # pkg:gem/prism#lib/prism/node.rb:15823 def type; end end end @@ -30183,13 +30153,13 @@ end # BEGIN { foo } # ^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:15834 +# pkg:gem/prism#lib/prism/node.rb:15842 class Prism::PreExecutionNode < ::Prism::Node # Initialize a new PreExecutionNode node. # # @return [PreExecutionNode] a new instance of PreExecutionNode # - # pkg:gem/prism#lib/prism/node.rb:15836 + # pkg:gem/prism#lib/prism/node.rb:15844 sig do params( source: Prism::Source, @@ -30207,48 +30177,48 @@ class Prism::PreExecutionNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:15963 + # pkg:gem/prism#lib/prism/node.rb:15971 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15848 + # pkg:gem/prism#lib/prism/node.rb:15856 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15853 + # pkg:gem/prism#lib/prism/node.rb:15861 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15942 + # pkg:gem/prism#lib/prism/node.rb:15950 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15919 + # pkg:gem/prism#lib/prism/node.rb:15927 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:15872 + # pkg:gem/prism#lib/prism/node.rb:15880 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:15865 + # pkg:gem/prism#lib/prism/node.rb:15873 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?statements: StatementsNode?, ?keyword_loc: Location, ?opening_loc: Location, ?closing_loc: Location) -> PreExecutionNode # - # pkg:gem/prism#lib/prism/node.rb:15877 + # pkg:gem/prism#lib/prism/node.rb:15885 sig do params( node_id: Integer, @@ -30265,13 +30235,13 @@ class Prism::PreExecutionNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15882 + # pkg:gem/prism#lib/prism/node.rb:15890 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:15885 + # pkg:gem/prism#lib/prism/node.rb:15893 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -30279,7 +30249,7 @@ class Prism::PreExecutionNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:15858 + # pkg:gem/prism#lib/prism/node.rb:15866 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -30287,81 +30257,81 @@ class Prism::PreExecutionNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:15947 + # pkg:gem/prism#lib/prism/node.rb:15955 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15932 + # pkg:gem/prism#lib/prism/node.rb:15940 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15893 + # pkg:gem/prism#lib/prism/node.rb:15901 sig { returns(Prism::Location) } def keyword_loc; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:15937 + # pkg:gem/prism#lib/prism/node.rb:15945 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:15906 + # pkg:gem/prism#lib/prism/node.rb:15914 sig { returns(Prism::Location) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15927 + # pkg:gem/prism#lib/prism/node.rb:15935 def save_closing_loc(repository); end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15901 + # pkg:gem/prism#lib/prism/node.rb:15909 def save_keyword_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:15914 + # pkg:gem/prism#lib/prism/node.rb:15922 def save_opening_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:15890 + # pkg:gem/prism#lib/prism/node.rb:15898 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:15952 + # pkg:gem/prism#lib/prism/node.rb:15960 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:15957 + # pkg:gem/prism#lib/prism/node.rb:15965 def type; end end end # The top level node of any parse tree. # -# pkg:gem/prism#lib/prism/node.rb:15973 +# pkg:gem/prism#lib/prism/node.rb:15981 class Prism::ProgramNode < ::Prism::Node # Initialize a new ProgramNode node. # # @return [ProgramNode] a new instance of ProgramNode # - # pkg:gem/prism#lib/prism/node.rb:15975 + # pkg:gem/prism#lib/prism/node.rb:15983 sig do params( source: Prism::Source, @@ -30377,36 +30347,36 @@ class Prism::ProgramNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16047 + # pkg:gem/prism#lib/prism/node.rb:16055 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:15985 + # pkg:gem/prism#lib/prism/node.rb:15993 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:15990 + # pkg:gem/prism#lib/prism/node.rb:15998 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16007 + # pkg:gem/prism#lib/prism/node.rb:16015 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16002 + # pkg:gem/prism#lib/prism/node.rb:16010 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?statements: StatementsNode) -> ProgramNode # - # pkg:gem/prism#lib/prism/node.rb:16012 + # pkg:gem/prism#lib/prism/node.rb:16020 sig do params( node_id: Integer, @@ -30421,13 +30391,13 @@ class Prism::ProgramNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16017 + # pkg:gem/prism#lib/prism/node.rb:16025 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], statements: StatementsNode } # - # pkg:gem/prism#lib/prism/node.rb:16020 + # pkg:gem/prism#lib/prism/node.rb:16028 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -30435,7 +30405,7 @@ class Prism::ProgramNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:15995 + # pkg:gem/prism#lib/prism/node.rb:16003 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -30443,44 +30413,44 @@ class Prism::ProgramNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16031 + # pkg:gem/prism#lib/prism/node.rb:16039 sig { override.returns(String) } def inspect; end # attr_reader locals: Array[Symbol] # - # pkg:gem/prism#lib/prism/node.rb:16025 + # pkg:gem/prism#lib/prism/node.rb:16033 sig { returns(T::Array[Symbol]) } def locals; end # attr_reader statements: StatementsNode # - # pkg:gem/prism#lib/prism/node.rb:16028 + # pkg:gem/prism#lib/prism/node.rb:16036 sig { returns(Prism::StatementsNode) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16036 + # pkg:gem/prism#lib/prism/node.rb:16044 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16041 + # pkg:gem/prism#lib/prism/node.rb:16049 def type; end end end # Flags for range and flip-flop nodes. # -# pkg:gem/prism#lib/prism/node.rb:19868 +# pkg:gem/prism#lib/prism/node.rb:19876 module Prism::RangeFlags; end # ... operator # -# pkg:gem/prism#lib/prism/node.rb:19870 +# pkg:gem/prism#lib/prism/node.rb:19878 Prism::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer) # Represents the use of the `..` or `...` operators. @@ -30491,13 +30461,13 @@ Prism::RangeFlags::EXCLUDE_END = T.let(T.unsafe(nil), Integer) # c if a =~ /left/ ... b =~ /right/ # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:16062 +# pkg:gem/prism#lib/prism/node.rb:16070 class Prism::RangeNode < ::Prism::Node # Initialize a new RangeNode node. # # @return [RangeNode] a new instance of RangeNode # - # pkg:gem/prism#lib/prism/node.rb:16064 + # pkg:gem/prism#lib/prism/node.rb:16072 sig do params( source: Prism::Source, @@ -30514,36 +30484,36 @@ class Prism::RangeNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16177 + # pkg:gem/prism#lib/prism/node.rb:16185 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16075 + # pkg:gem/prism#lib/prism/node.rb:16083 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16080 + # pkg:gem/prism#lib/prism/node.rb:16088 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16101 + # pkg:gem/prism#lib/prism/node.rb:16109 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16093 + # pkg:gem/prism#lib/prism/node.rb:16101 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?left: Prism::node?, ?right: Prism::node?, ?operator_loc: Location) -> RangeNode # - # pkg:gem/prism#lib/prism/node.rb:16106 + # pkg:gem/prism#lib/prism/node.rb:16114 sig do params( node_id: Integer, @@ -30559,13 +30529,13 @@ class Prism::RangeNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16111 + # pkg:gem/prism#lib/prism/node.rb:16119 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, left: Prism::node?, right: Prism::node?, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:16114 + # pkg:gem/prism#lib/prism/node.rb:16122 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -30573,14 +30543,14 @@ class Prism::RangeNode < ::Prism::Node # # @yield [left] # - # pkg:gem/prism#lib/prism/node.rb:16085 + # pkg:gem/prism#lib/prism/node.rb:16093 def each_child_node; end # def exclude_end?: () -> bool # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16119 + # pkg:gem/prism#lib/prism/node.rb:16127 sig { returns(T::Boolean) } def exclude_end?; end @@ -30589,7 +30559,7 @@ class Prism::RangeNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16161 + # pkg:gem/prism#lib/prism/node.rb:16169 sig { override.returns(String) } def inspect; end @@ -30601,19 +30571,19 @@ class Prism::RangeNode < ::Prism::Node # hello...goodbye # ^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:16130 + # pkg:gem/prism#lib/prism/node.rb:16138 sig { returns(T.nilable(Prism::Node)) } def left; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:16156 + # pkg:gem/prism#lib/prism/node.rb:16164 sig { returns(String) } def operator; end # The location of the `..` or `...` operator. # - # pkg:gem/prism#lib/prism/node.rb:16143 + # pkg:gem/prism#lib/prism/node.rb:16151 sig { returns(Prism::Location) } def operator_loc; end @@ -30626,26 +30596,26 @@ class Prism::RangeNode < ::Prism::Node # ^^^ # If neither right-hand or left-hand side was included, this will be a MissingNode. # - # pkg:gem/prism#lib/prism/node.rb:16140 + # pkg:gem/prism#lib/prism/node.rb:16148 sig { returns(T.nilable(Prism::Node)) } def right; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16151 + # pkg:gem/prism#lib/prism/node.rb:16159 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16166 + # pkg:gem/prism#lib/prism/node.rb:16174 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16171 + # pkg:gem/prism#lib/prism/node.rb:16179 def type; end end end @@ -30655,13 +30625,13 @@ end # 1.0r # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:16190 +# pkg:gem/prism#lib/prism/node.rb:16198 class Prism::RationalNode < ::Prism::Node # Initialize a new RationalNode node. # # @return [RationalNode] a new instance of RationalNode # - # pkg:gem/prism#lib/prism/node.rb:16192 + # pkg:gem/prism#lib/prism/node.rb:16200 sig do params( source: Prism::Source, @@ -30677,12 +30647,12 @@ class Prism::RationalNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16287 + # pkg:gem/prism#lib/prism/node.rb:16295 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16202 + # pkg:gem/prism#lib/prism/node.rb:16210 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -30690,31 +30660,31 @@ class Prism::RationalNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16241 + # pkg:gem/prism#lib/prism/node.rb:16249 sig { returns(T::Boolean) } def binary?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16207 + # pkg:gem/prism#lib/prism/node.rb:16215 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16223 + # pkg:gem/prism#lib/prism/node.rb:16231 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16218 + # pkg:gem/prism#lib/prism/node.rb:16226 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?numerator: Integer, ?denominator: Integer) -> RationalNode # - # pkg:gem/prism#lib/prism/node.rb:16228 + # pkg:gem/prism#lib/prism/node.rb:16236 sig do params( node_id: Integer, @@ -30730,20 +30700,20 @@ class Prism::RationalNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16246 + # pkg:gem/prism#lib/prism/node.rb:16254 sig { returns(T::Boolean) } def decimal?; end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16233 + # pkg:gem/prism#lib/prism/node.rb:16241 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, numerator: Integer, denominator: Integer } # - # pkg:gem/prism#lib/prism/node.rb:16236 + # pkg:gem/prism#lib/prism/node.rb:16244 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -30751,13 +30721,13 @@ class Prism::RationalNode < ::Prism::Node # # 1.5r # denominator 2 # - # pkg:gem/prism#lib/prism/node.rb:16268 + # pkg:gem/prism#lib/prism/node.rb:16276 sig { returns(Integer) } def denominator; end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:16212 + # pkg:gem/prism#lib/prism/node.rb:16220 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -30767,13 +30737,13 @@ class Prism::RationalNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16256 + # pkg:gem/prism#lib/prism/node.rb:16264 sig { returns(T::Boolean) } def hexadecimal?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16271 + # pkg:gem/prism#lib/prism/node.rb:16279 sig { override.returns(String) } def inspect; end @@ -30781,7 +30751,7 @@ class Prism::RationalNode < ::Prism::Node # # 1.5r # numerator 3 # - # pkg:gem/prism#lib/prism/node.rb:16263 + # pkg:gem/prism#lib/prism/node.rb:16271 sig { returns(Integer) } def numerator; end @@ -30795,13 +30765,13 @@ class Prism::RationalNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16251 + # pkg:gem/prism#lib/prism/node.rb:16259 sig { returns(T::Boolean) } def octal?; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16276 + # pkg:gem/prism#lib/prism/node.rb:16284 sig { override.returns(Symbol) } def type; end @@ -30814,7 +30784,7 @@ class Prism::RationalNode < ::Prism::Node class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16281 + # pkg:gem/prism#lib/prism/node.rb:16289 def type; end end end @@ -30824,68 +30794,68 @@ end # redo # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:16299 +# pkg:gem/prism#lib/prism/node.rb:16307 class Prism::RedoNode < ::Prism::Node # Initialize a new RedoNode node. # # @return [RedoNode] a new instance of RedoNode # - # pkg:gem/prism#lib/prism/node.rb:16301 + # pkg:gem/prism#lib/prism/node.rb:16309 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16364 + # pkg:gem/prism#lib/prism/node.rb:16372 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16309 + # pkg:gem/prism#lib/prism/node.rb:16317 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16314 + # pkg:gem/prism#lib/prism/node.rb:16322 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16330 + # pkg:gem/prism#lib/prism/node.rb:16338 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16325 + # pkg:gem/prism#lib/prism/node.rb:16333 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RedoNode # - # pkg:gem/prism#lib/prism/node.rb:16335 + # pkg:gem/prism#lib/prism/node.rb:16343 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::RedoNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16340 + # pkg:gem/prism#lib/prism/node.rb:16348 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:16343 + # pkg:gem/prism#lib/prism/node.rb:16351 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:16319 + # pkg:gem/prism#lib/prism/node.rb:16327 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -30893,20 +30863,20 @@ class Prism::RedoNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16348 + # pkg:gem/prism#lib/prism/node.rb:16356 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16353 + # pkg:gem/prism#lib/prism/node.rb:16361 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16358 + # pkg:gem/prism#lib/prism/node.rb:16366 def type; end end end @@ -31043,62 +31013,62 @@ class Prism::Reflection::StringField < ::Prism::Reflection::Field; end # Flags for regular expression and match last line nodes. # -# pkg:gem/prism#lib/prism/node.rb:19874 +# pkg:gem/prism#lib/prism/node.rb:19882 module Prism::RegularExpressionFlags; end # n - forces the ASCII-8BIT encoding # -# pkg:gem/prism#lib/prism/node.rb:19891 +# pkg:gem/prism#lib/prism/node.rb:19899 Prism::RegularExpressionFlags::ASCII_8BIT = T.let(T.unsafe(nil), Integer) # e - forces the EUC-JP encoding # -# pkg:gem/prism#lib/prism/node.rb:19888 +# pkg:gem/prism#lib/prism/node.rb:19896 Prism::RegularExpressionFlags::EUC_JP = T.let(T.unsafe(nil), Integer) # x - ignores whitespace and allows comments in regular expressions # -# pkg:gem/prism#lib/prism/node.rb:19879 +# pkg:gem/prism#lib/prism/node.rb:19887 Prism::RegularExpressionFlags::EXTENDED = T.let(T.unsafe(nil), Integer) # internal bytes forced the encoding to binary # -# pkg:gem/prism#lib/prism/node.rb:19903 +# pkg:gem/prism#lib/prism/node.rb:19911 Prism::RegularExpressionFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) # internal bytes forced the encoding to US-ASCII # -# pkg:gem/prism#lib/prism/node.rb:19906 +# pkg:gem/prism#lib/prism/node.rb:19914 Prism::RegularExpressionFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer) # internal bytes forced the encoding to UTF-8 # -# pkg:gem/prism#lib/prism/node.rb:19900 +# pkg:gem/prism#lib/prism/node.rb:19908 Prism::RegularExpressionFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) # i - ignores the case of characters when matching # -# pkg:gem/prism#lib/prism/node.rb:19876 +# pkg:gem/prism#lib/prism/node.rb:19884 Prism::RegularExpressionFlags::IGNORE_CASE = T.let(T.unsafe(nil), Integer) # m - allows $ to match the end of lines within strings # -# pkg:gem/prism#lib/prism/node.rb:19882 +# pkg:gem/prism#lib/prism/node.rb:19890 Prism::RegularExpressionFlags::MULTI_LINE = T.let(T.unsafe(nil), Integer) # o - only interpolates values into the regular expression once # -# pkg:gem/prism#lib/prism/node.rb:19885 +# pkg:gem/prism#lib/prism/node.rb:19893 Prism::RegularExpressionFlags::ONCE = T.let(T.unsafe(nil), Integer) # u - forces the UTF-8 encoding # -# pkg:gem/prism#lib/prism/node.rb:19897 +# pkg:gem/prism#lib/prism/node.rb:19905 Prism::RegularExpressionFlags::UTF_8 = T.let(T.unsafe(nil), Integer) # s - forces the Windows-31J encoding # -# pkg:gem/prism#lib/prism/node.rb:19894 +# pkg:gem/prism#lib/prism/node.rb:19902 Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer) # Represents a regular expression literal with no interpolation. @@ -31106,7 +31076,7 @@ Prism::RegularExpressionFlags::WINDOWS_31J = T.let(T.unsafe(nil), Integer) # /foo/i # ^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:16373 +# pkg:gem/prism#lib/prism/node.rb:16381 class Prism::RegularExpressionNode < ::Prism::Node include ::Prism::RegularExpressionOptions @@ -31114,7 +31084,7 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [RegularExpressionNode] a new instance of RegularExpressionNode # - # pkg:gem/prism#lib/prism/node.rb:16375 + # pkg:gem/prism#lib/prism/node.rb:16383 sig do params( source: Prism::Source, @@ -31132,12 +31102,12 @@ class Prism::RegularExpressionNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16554 + # pkg:gem/prism#lib/prism/node.rb:16562 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16387 + # pkg:gem/prism#lib/prism/node.rb:16395 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -31145,55 +31115,55 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16451 + # pkg:gem/prism#lib/prism/node.rb:16459 sig { returns(T::Boolean) } def ascii_8bit?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16392 + # pkg:gem/prism#lib/prism/node.rb:16400 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:16533 + # pkg:gem/prism#lib/prism/node.rb:16541 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:16507 + # pkg:gem/prism#lib/prism/node.rb:16515 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16408 + # pkg:gem/prism#lib/prism/node.rb:16416 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16403 + # pkg:gem/prism#lib/prism/node.rb:16411 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def content: () -> String # - # pkg:gem/prism#lib/prism/node.rb:16528 + # pkg:gem/prism#lib/prism/node.rb:16536 sig { returns(String) } def content; end # attr_reader content_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:16494 + # pkg:gem/prism#lib/prism/node.rb:16502 sig { returns(Prism::Location) } def content_loc; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> RegularExpressionNode # - # pkg:gem/prism#lib/prism/node.rb:16413 + # pkg:gem/prism#lib/prism/node.rb:16421 sig do params( node_id: Integer, @@ -31210,26 +31180,26 @@ class Prism::RegularExpressionNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16418 + # pkg:gem/prism#lib/prism/node.rb:16426 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String } # - # pkg:gem/prism#lib/prism/node.rb:16421 + # pkg:gem/prism#lib/prism/node.rb:16429 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:16397 + # pkg:gem/prism#lib/prism/node.rb:16405 def each_child_node; end # def euc_jp?: () -> bool # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16446 + # pkg:gem/prism#lib/prism/node.rb:16454 sig { returns(T::Boolean) } def euc_jp?; end @@ -31237,7 +31207,7 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16431 + # pkg:gem/prism#lib/prism/node.rb:16439 sig { returns(T::Boolean) } def extended?; end @@ -31248,7 +31218,7 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16471 + # pkg:gem/prism#lib/prism/node.rb:16479 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -31256,7 +31226,7 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16476 + # pkg:gem/prism#lib/prism/node.rb:16484 sig { returns(T::Boolean) } def forced_us_ascii_encoding?; end @@ -31264,7 +31234,7 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16466 + # pkg:gem/prism#lib/prism/node.rb:16474 sig { returns(T::Boolean) } def forced_utf8_encoding?; end @@ -31272,13 +31242,13 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16426 + # pkg:gem/prism#lib/prism/node.rb:16434 sig { returns(T::Boolean) } def ignore_case?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16538 + # pkg:gem/prism#lib/prism/node.rb:16546 sig { override.returns(String) } def inspect; end @@ -31286,7 +31256,7 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16436 + # pkg:gem/prism#lib/prism/node.rb:16444 sig { returns(T::Boolean) } def multi_line?; end @@ -31294,19 +31264,19 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16441 + # pkg:gem/prism#lib/prism/node.rb:16449 sig { returns(T::Boolean) } def once?; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:16523 + # pkg:gem/prism#lib/prism/node.rb:16531 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:16481 + # pkg:gem/prism#lib/prism/node.rb:16489 sig { returns(Prism::Location) } def opening_loc; end @@ -31316,30 +31286,30 @@ class Prism::RegularExpressionNode < ::Prism::Node # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16515 + # pkg:gem/prism#lib/prism/node.rb:16523 def save_closing_loc(repository); end # Save the content_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16502 + # pkg:gem/prism#lib/prism/node.rb:16510 def save_content_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16489 + # pkg:gem/prism#lib/prism/node.rb:16497 def save_opening_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16543 + # pkg:gem/prism#lib/prism/node.rb:16551 sig { override.returns(Symbol) } def type; end # attr_reader unescaped: String # - # pkg:gem/prism#lib/prism/node.rb:16520 + # pkg:gem/prism#lib/prism/node.rb:16528 sig { returns(String) } def unescaped; end @@ -31347,7 +31317,7 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16461 + # pkg:gem/prism#lib/prism/node.rb:16469 sig { returns(T::Boolean) } def utf_8?; end @@ -31355,14 +31325,14 @@ class Prism::RegularExpressionNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16456 + # pkg:gem/prism#lib/prism/node.rb:16464 sig { returns(T::Boolean) } def windows_31j?; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16548 + # pkg:gem/prism#lib/prism/node.rb:16556 def type; end end end @@ -31911,13 +31881,13 @@ end # ^^ # end # -# pkg:gem/prism#lib/prism/node.rb:16569 +# pkg:gem/prism#lib/prism/node.rb:16577 class Prism::RequiredKeywordParameterNode < ::Prism::Node # Initialize a new RequiredKeywordParameterNode node. # # @return [RequiredKeywordParameterNode] a new instance of RequiredKeywordParameterNode # - # pkg:gem/prism#lib/prism/node.rb:16571 + # pkg:gem/prism#lib/prism/node.rb:16579 sig do params( source: Prism::Source, @@ -31933,36 +31903,36 @@ class Prism::RequiredKeywordParameterNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16657 + # pkg:gem/prism#lib/prism/node.rb:16665 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16581 + # pkg:gem/prism#lib/prism/node.rb:16589 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16586 + # pkg:gem/prism#lib/prism/node.rb:16594 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16602 + # pkg:gem/prism#lib/prism/node.rb:16610 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16597 + # pkg:gem/prism#lib/prism/node.rb:16605 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location) -> RequiredKeywordParameterNode # - # pkg:gem/prism#lib/prism/node.rb:16607 + # pkg:gem/prism#lib/prism/node.rb:16615 sig do params( node_id: Integer, @@ -31977,19 +31947,19 @@ class Prism::RequiredKeywordParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16612 + # pkg:gem/prism#lib/prism/node.rb:16620 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:16615 + # pkg:gem/prism#lib/prism/node.rb:16623 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:16591 + # pkg:gem/prism#lib/prism/node.rb:16599 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -31997,19 +31967,19 @@ class Prism::RequiredKeywordParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16641 + # pkg:gem/prism#lib/prism/node.rb:16649 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:16625 + # pkg:gem/prism#lib/prism/node.rb:16633 sig { returns(Symbol) } def name; end # attr_reader name_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:16628 + # pkg:gem/prism#lib/prism/node.rb:16636 sig { returns(Prism::Location) } def name_loc; end @@ -32017,26 +31987,26 @@ class Prism::RequiredKeywordParameterNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16620 + # pkg:gem/prism#lib/prism/node.rb:16628 sig { returns(T::Boolean) } def repeated_parameter?; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16636 + # pkg:gem/prism#lib/prism/node.rb:16644 def save_name_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16646 + # pkg:gem/prism#lib/prism/node.rb:16654 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16651 + # pkg:gem/prism#lib/prism/node.rb:16659 def type; end end end @@ -32047,49 +32017,49 @@ end # ^ # end # -# pkg:gem/prism#lib/prism/node.rb:16670 +# pkg:gem/prism#lib/prism/node.rb:16678 class Prism::RequiredParameterNode < ::Prism::Node # Initialize a new RequiredParameterNode node. # # @return [RequiredParameterNode] a new instance of RequiredParameterNode # - # pkg:gem/prism#lib/prism/node.rb:16672 + # pkg:gem/prism#lib/prism/node.rb:16680 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer, name: Symbol).void } def initialize(source, node_id, location, flags, name); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16744 + # pkg:gem/prism#lib/prism/node.rb:16752 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16681 + # pkg:gem/prism#lib/prism/node.rb:16689 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16686 + # pkg:gem/prism#lib/prism/node.rb:16694 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16702 + # pkg:gem/prism#lib/prism/node.rb:16710 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16697 + # pkg:gem/prism#lib/prism/node.rb:16705 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol) -> RequiredParameterNode # - # pkg:gem/prism#lib/prism/node.rb:16707 + # pkg:gem/prism#lib/prism/node.rb:16715 sig do params( node_id: Integer, @@ -32103,19 +32073,19 @@ class Prism::RequiredParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16712 + # pkg:gem/prism#lib/prism/node.rb:16720 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol } # - # pkg:gem/prism#lib/prism/node.rb:16715 + # pkg:gem/prism#lib/prism/node.rb:16723 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:16691 + # pkg:gem/prism#lib/prism/node.rb:16699 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -32123,13 +32093,13 @@ class Prism::RequiredParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16728 + # pkg:gem/prism#lib/prism/node.rb:16736 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol # - # pkg:gem/prism#lib/prism/node.rb:16725 + # pkg:gem/prism#lib/prism/node.rb:16733 sig { returns(Symbol) } def name; end @@ -32137,20 +32107,20 @@ class Prism::RequiredParameterNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:16720 + # pkg:gem/prism#lib/prism/node.rb:16728 sig { returns(T::Boolean) } def repeated_parameter?; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16733 + # pkg:gem/prism#lib/prism/node.rb:16741 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16738 + # pkg:gem/prism#lib/prism/node.rb:16746 def type; end end end @@ -32160,13 +32130,13 @@ end # foo rescue nil # ^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:16755 +# pkg:gem/prism#lib/prism/node.rb:16763 class Prism::RescueModifierNode < ::Prism::Node # Initialize a new RescueModifierNode node. # # @return [RescueModifierNode] a new instance of RescueModifierNode # - # pkg:gem/prism#lib/prism/node.rb:16757 + # pkg:gem/prism#lib/prism/node.rb:16765 sig do params( source: Prism::Source, @@ -32183,36 +32153,36 @@ class Prism::RescueModifierNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:16849 + # pkg:gem/prism#lib/prism/node.rb:16857 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16768 + # pkg:gem/prism#lib/prism/node.rb:16776 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16773 + # pkg:gem/prism#lib/prism/node.rb:16781 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16791 + # pkg:gem/prism#lib/prism/node.rb:16799 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16786 + # pkg:gem/prism#lib/prism/node.rb:16794 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?expression: Prism::node, ?keyword_loc: Location, ?rescue_expression: Prism::node) -> RescueModifierNode # - # pkg:gem/prism#lib/prism/node.rb:16796 + # pkg:gem/prism#lib/prism/node.rb:16804 sig do params( node_id: Integer, @@ -32228,13 +32198,13 @@ class Prism::RescueModifierNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16801 + # pkg:gem/prism#lib/prism/node.rb:16809 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, expression: Prism::node, keyword_loc: Location, rescue_expression: Prism::node } # - # pkg:gem/prism#lib/prism/node.rb:16804 + # pkg:gem/prism#lib/prism/node.rb:16812 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -32242,12 +32212,12 @@ class Prism::RescueModifierNode < ::Prism::Node # # @yield [expression] # - # pkg:gem/prism#lib/prism/node.rb:16778 + # pkg:gem/prism#lib/prism/node.rb:16786 def each_child_node; end # attr_reader expression: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:16809 + # pkg:gem/prism#lib/prism/node.rb:16817 sig { returns(Prism::Node) } def expression; end @@ -32256,19 +32226,19 @@ class Prism::RescueModifierNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:16833 + # pkg:gem/prism#lib/prism/node.rb:16841 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:16828 + # pkg:gem/prism#lib/prism/node.rb:16836 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:16812 + # pkg:gem/prism#lib/prism/node.rb:16820 sig { returns(Prism::Location) } def keyword_loc; end @@ -32277,26 +32247,26 @@ class Prism::RescueModifierNode < ::Prism::Node # attr_reader rescue_expression: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:16825 + # pkg:gem/prism#lib/prism/node.rb:16833 sig { returns(Prism::Node) } def rescue_expression; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16820 + # pkg:gem/prism#lib/prism/node.rb:16828 def save_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:16838 + # pkg:gem/prism#lib/prism/node.rb:16846 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:16843 + # pkg:gem/prism#lib/prism/node.rb:16851 def type; end end end @@ -32311,13 +32281,13 @@ end # # `Foo, *splat, Bar` are in the `exceptions` field. `ex` is in the `reference` field. # -# pkg:gem/prism#lib/prism/node.rb:16866 +# pkg:gem/prism#lib/prism/node.rb:16874 class Prism::RescueNode < ::Prism::Node # Initialize a new RescueNode node. # # @return [RescueNode] a new instance of RescueNode # - # pkg:gem/prism#lib/prism/node.rb:16868 + # pkg:gem/prism#lib/prism/node.rb:16876 sig do params( source: Prism::Source, @@ -32338,30 +32308,30 @@ class Prism::RescueNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17025 + # pkg:gem/prism#lib/prism/node.rb:17033 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:16883 + # pkg:gem/prism#lib/prism/node.rb:16891 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16888 + # pkg:gem/prism#lib/prism/node.rb:16896 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:16913 + # pkg:gem/prism#lib/prism/node.rb:16921 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:16903 + # pkg:gem/prism#lib/prism/node.rb:16911 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -32373,7 +32343,7 @@ class Prism::RescueNode < ::Prism::Node # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?subsequent: RescueNode?) -> RescueNode # - # pkg:gem/prism#lib/prism/node.rb:16918 + # pkg:gem/prism#lib/prism/node.rb:16926 sig do params( node_id: Integer, @@ -32393,13 +32363,13 @@ class Prism::RescueNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:16923 + # pkg:gem/prism#lib/prism/node.rb:16931 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, then_keyword_loc: Location?, statements: StatementsNode?, subsequent: RescueNode? } # - # pkg:gem/prism#lib/prism/node.rb:16926 + # pkg:gem/prism#lib/prism/node.rb:16934 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -32407,12 +32377,12 @@ class Prism::RescueNode < ::Prism::Node # # @yield [reference] # - # pkg:gem/prism#lib/prism/node.rb:16893 + # pkg:gem/prism#lib/prism/node.rb:16901 def each_child_node; end # attr_reader exceptions: Array[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:16944 + # pkg:gem/prism#lib/prism/node.rb:16952 sig { returns(T::Array[Prism::Node]) } def exceptions; end @@ -32421,37 +32391,37 @@ class Prism::RescueNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17009 + # pkg:gem/prism#lib/prism/node.rb:17017 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:16994 + # pkg:gem/prism#lib/prism/node.rb:17002 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:16931 + # pkg:gem/prism#lib/prism/node.rb:16939 sig { returns(Prism::Location) } def keyword_loc; end # def operator: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:16999 + # pkg:gem/prism#lib/prism/node.rb:17007 sig { returns(T.nilable(String)) } def operator; end # attr_reader operator_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:16947 + # pkg:gem/prism#lib/prism/node.rb:16955 sig { returns(T.nilable(Prism::Location)) } def operator_loc; end # attr_reader reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil # - # pkg:gem/prism#lib/prism/node.rb:16966 + # pkg:gem/prism#lib/prism/node.rb:16974 sig do returns(T.nilable(T.any(Prism::LocalVariableTargetNode, Prism::InstanceVariableTargetNode, Prism::ClassVariableTargetNode, Prism::GlobalVariableTargetNode, Prism::ConstantTargetNode, Prism::ConstantPathTargetNode, Prism::CallTargetNode, Prism::IndexTargetNode, Prism::BackReferenceReadNode, Prism::NumberedReferenceReadNode, Prism::MissingNode))) end @@ -32460,55 +32430,55 @@ class Prism::RescueNode < ::Prism::Node # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16939 + # pkg:gem/prism#lib/prism/node.rb:16947 def save_keyword_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16961 + # pkg:gem/prism#lib/prism/node.rb:16969 def save_operator_loc(repository); end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:16983 + # pkg:gem/prism#lib/prism/node.rb:16991 def save_then_keyword_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:16988 + # pkg:gem/prism#lib/prism/node.rb:16996 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # attr_reader subsequent: RescueNode? # - # pkg:gem/prism#lib/prism/node.rb:16991 + # pkg:gem/prism#lib/prism/node.rb:16999 sig { returns(T.nilable(Prism::RescueNode)) } def subsequent; end # def then_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:17004 + # pkg:gem/prism#lib/prism/node.rb:17012 sig { returns(T.nilable(String)) } def then_keyword; end # attr_reader then_keyword_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:16969 + # pkg:gem/prism#lib/prism/node.rb:16977 sig { returns(T.nilable(Prism::Location)) } def then_keyword_loc; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17014 + # pkg:gem/prism#lib/prism/node.rb:17022 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17019 + # pkg:gem/prism#lib/prism/node.rb:17027 def type; end end end @@ -32519,13 +32489,13 @@ end # ^^ # end # -# pkg:gem/prism#lib/prism/node.rb:17043 +# pkg:gem/prism#lib/prism/node.rb:17051 class Prism::RestParameterNode < ::Prism::Node # Initialize a new RestParameterNode node. # # @return [RestParameterNode] a new instance of RestParameterNode # - # pkg:gem/prism#lib/prism/node.rb:17045 + # pkg:gem/prism#lib/prism/node.rb:17053 sig do params( source: Prism::Source, @@ -32542,36 +32512,36 @@ class Prism::RestParameterNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17156 + # pkg:gem/prism#lib/prism/node.rb:17164 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17056 + # pkg:gem/prism#lib/prism/node.rb:17064 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17061 + # pkg:gem/prism#lib/prism/node.rb:17069 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17077 + # pkg:gem/prism#lib/prism/node.rb:17085 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17072 + # pkg:gem/prism#lib/prism/node.rb:17080 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol?, ?name_loc: Location?, ?operator_loc: Location) -> RestParameterNode # - # pkg:gem/prism#lib/prism/node.rb:17082 + # pkg:gem/prism#lib/prism/node.rb:17090 sig do params( node_id: Integer, @@ -32587,19 +32557,19 @@ class Prism::RestParameterNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17087 + # pkg:gem/prism#lib/prism/node.rb:17095 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol?, name_loc: Location?, operator_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:17090 + # pkg:gem/prism#lib/prism/node.rb:17098 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:17066 + # pkg:gem/prism#lib/prism/node.rb:17074 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -32607,31 +32577,31 @@ class Prism::RestParameterNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17140 + # pkg:gem/prism#lib/prism/node.rb:17148 sig { override.returns(String) } def inspect; end # attr_reader name: Symbol? # - # pkg:gem/prism#lib/prism/node.rb:17100 + # pkg:gem/prism#lib/prism/node.rb:17108 sig { returns(T.nilable(Symbol)) } def name; end # attr_reader name_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:17103 + # pkg:gem/prism#lib/prism/node.rb:17111 sig { returns(T.nilable(Prism::Location)) } def name_loc; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:17135 + # pkg:gem/prism#lib/prism/node.rb:17143 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:17122 + # pkg:gem/prism#lib/prism/node.rb:17130 sig { returns(Prism::Location) } def operator_loc; end @@ -32639,32 +32609,32 @@ class Prism::RestParameterNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17095 + # pkg:gem/prism#lib/prism/node.rb:17103 sig { returns(T::Boolean) } def repeated_parameter?; end # Save the name_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:17117 + # pkg:gem/prism#lib/prism/node.rb:17125 def save_name_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:17130 + # pkg:gem/prism#lib/prism/node.rb:17138 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17145 + # pkg:gem/prism#lib/prism/node.rb:17153 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17150 + # pkg:gem/prism#lib/prism/node.rb:17158 def type; end end end @@ -32673,13 +32643,13 @@ end # the requested structure, any comments that were encounters, and any errors # that were encountered. # -# pkg:gem/prism#lib/prism/parse_result.rb:667 +# pkg:gem/prism#lib/prism/parse_result.rb:676 class Prism::Result # Create a new result object with the given values. # # @return [Result] a new instance of Result # - # pkg:gem/prism#lib/prism/parse_result.rb:689 + # pkg:gem/prism#lib/prism/parse_result.rb:698 sig do params( comments: T::Array[Prism::Comment], @@ -32694,7 +32664,7 @@ class Prism::Result # Create a code units cache for the given encoding. # - # pkg:gem/prism#lib/prism/parse_result.rb:721 + # pkg:gem/prism#lib/prism/parse_result.rb:730 sig do params( encoding: Encoding @@ -32704,7 +32674,7 @@ class Prism::Result # The list of comments that were encountered during parsing. # - # pkg:gem/prism#lib/prism/parse_result.rb:669 + # pkg:gem/prism#lib/prism/parse_result.rb:678 sig { returns(T::Array[Prism::Comment]) } def comments; end @@ -32712,25 +32682,25 @@ class Prism::Result # 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. # - # pkg:gem/prism#lib/prism/parse_result.rb:677 + # pkg:gem/prism#lib/prism/parse_result.rb:686 sig { returns(T.nilable(Prism::Location)) } def data_loc; end # Implement the hash pattern matching interface for Result. # - # pkg:gem/prism#lib/prism/parse_result.rb:699 + # pkg:gem/prism#lib/prism/parse_result.rb:708 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. # - # pkg:gem/prism#lib/prism/parse_result.rb:704 + # pkg:gem/prism#lib/prism/parse_result.rb:713 sig { returns(Encoding) } def encoding; end # The list of errors that were generated during parsing. # - # pkg:gem/prism#lib/prism/parse_result.rb:680 + # pkg:gem/prism#lib/prism/parse_result.rb:689 sig { returns(T::Array[Prism::ParseError]) } def errors; end @@ -32739,19 +32709,19 @@ class Prism::Result # # @return [Boolean] # - # pkg:gem/prism#lib/prism/parse_result.rb:716 + # pkg:gem/prism#lib/prism/parse_result.rb:725 sig { returns(T::Boolean) } def failure?; end # The list of magic comments that were encountered during parsing. # - # pkg:gem/prism#lib/prism/parse_result.rb:672 + # pkg:gem/prism#lib/prism/parse_result.rb:681 sig { returns(T::Array[Prism::MagicComment]) } def magic_comments; end # A Source instance that represents the source code that was parsed. # - # pkg:gem/prism#lib/prism/parse_result.rb:686 + # pkg:gem/prism#lib/prism/parse_result.rb:695 sig { returns(Prism::Source) } def source; end @@ -32760,13 +32730,13 @@ class Prism::Result # # @return [Boolean] # - # pkg:gem/prism#lib/prism/parse_result.rb:710 + # pkg:gem/prism#lib/prism/parse_result.rb:719 sig { returns(T::Boolean) } def success?; end # The list of warnings that were generated during parsing. # - # pkg:gem/prism#lib/prism/parse_result.rb:683 + # pkg:gem/prism#lib/prism/parse_result.rb:692 sig { returns(T::Array[Prism::ParseWarning]) } def warnings; end end @@ -32776,68 +32746,68 @@ end # retry # ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17169 +# pkg:gem/prism#lib/prism/node.rb:17177 class Prism::RetryNode < ::Prism::Node # Initialize a new RetryNode node. # # @return [RetryNode] a new instance of RetryNode # - # pkg:gem/prism#lib/prism/node.rb:17171 + # pkg:gem/prism#lib/prism/node.rb:17179 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17234 + # pkg:gem/prism#lib/prism/node.rb:17242 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17179 + # pkg:gem/prism#lib/prism/node.rb:17187 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17184 + # pkg:gem/prism#lib/prism/node.rb:17192 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17200 + # pkg:gem/prism#lib/prism/node.rb:17208 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17195 + # pkg:gem/prism#lib/prism/node.rb:17203 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> RetryNode # - # pkg:gem/prism#lib/prism/node.rb:17205 + # pkg:gem/prism#lib/prism/node.rb:17213 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::RetryNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17210 + # pkg:gem/prism#lib/prism/node.rb:17218 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:17213 + # pkg:gem/prism#lib/prism/node.rb:17221 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:17189 + # pkg:gem/prism#lib/prism/node.rb:17197 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -32845,20 +32815,20 @@ class Prism::RetryNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17218 + # pkg:gem/prism#lib/prism/node.rb:17226 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17223 + # pkg:gem/prism#lib/prism/node.rb:17231 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17228 + # pkg:gem/prism#lib/prism/node.rb:17236 def type; end end end @@ -32868,13 +32838,13 @@ end # return 1 # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17243 +# pkg:gem/prism#lib/prism/node.rb:17251 class Prism::ReturnNode < ::Prism::Node # Initialize a new ReturnNode node. # # @return [ReturnNode] a new instance of ReturnNode # - # pkg:gem/prism#lib/prism/node.rb:17245 + # pkg:gem/prism#lib/prism/node.rb:17253 sig do params( source: Prism::Source, @@ -32890,42 +32860,42 @@ class Prism::ReturnNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17334 + # pkg:gem/prism#lib/prism/node.rb:17342 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17255 + # pkg:gem/prism#lib/prism/node.rb:17263 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader arguments: ArgumentsNode? # - # pkg:gem/prism#lib/prism/node.rb:17310 + # pkg:gem/prism#lib/prism/node.rb:17318 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17260 + # pkg:gem/prism#lib/prism/node.rb:17268 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17279 + # pkg:gem/prism#lib/prism/node.rb:17287 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17272 + # pkg:gem/prism#lib/prism/node.rb:17280 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?arguments: ArgumentsNode?) -> ReturnNode # - # pkg:gem/prism#lib/prism/node.rb:17284 + # pkg:gem/prism#lib/prism/node.rb:17292 sig do params( node_id: Integer, @@ -32940,13 +32910,13 @@ class Prism::ReturnNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17289 + # pkg:gem/prism#lib/prism/node.rb:17297 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, arguments: ArgumentsNode? } # - # pkg:gem/prism#lib/prism/node.rb:17292 + # pkg:gem/prism#lib/prism/node.rb:17300 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -32954,7 +32924,7 @@ class Prism::ReturnNode < ::Prism::Node # # @yield [arguments] # - # pkg:gem/prism#lib/prism/node.rb:17265 + # pkg:gem/prism#lib/prism/node.rb:17273 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -32962,38 +32932,38 @@ class Prism::ReturnNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17318 + # pkg:gem/prism#lib/prism/node.rb:17326 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:17313 + # pkg:gem/prism#lib/prism/node.rb:17321 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:17297 + # pkg:gem/prism#lib/prism/node.rb:17305 sig { returns(Prism::Location) } def keyword_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:17305 + # pkg:gem/prism#lib/prism/node.rb:17313 def save_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17323 + # pkg:gem/prism#lib/prism/node.rb:17331 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17328 + # pkg:gem/prism#lib/prism/node.rb:17336 def type; end end end @@ -33003,13 +32973,13 @@ end # variables visible at that scope as well as the forwarding parameters # available at that scope. # -# pkg:gem/prism#lib/prism/parse_result.rb:875 +# pkg:gem/prism#lib/prism/parse_result.rb:884 class Prism::Scope # Create a new scope object with the given locals and forwarding. # # @return [Scope] a new instance of Scope # - # pkg:gem/prism#lib/prism/parse_result.rb:886 + # pkg:gem/prism#lib/prism/parse_result.rb:895 sig { params(locals: T::Array[Symbol], forwarding: T::Array[Symbol]).void } def initialize(locals, forwarding); end @@ -33017,14 +32987,14 @@ class Prism::Scope # should by defined as an array of symbols containing the specific values of # :*, :**, :&, or :"...". # - # pkg:gem/prism#lib/prism/parse_result.rb:883 + # pkg:gem/prism#lib/prism/parse_result.rb:892 sig { returns(T::Array[Symbol]) } def forwarding; end # The list of local variables that are defined in this scope. This should be # defined as an array of symbols. # - # pkg:gem/prism#lib/prism/parse_result.rb:878 + # pkg:gem/prism#lib/prism/parse_result.rb:887 sig { returns(T::Array[Symbol]) } def locals; end end @@ -33034,68 +33004,68 @@ end # self # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17345 +# pkg:gem/prism#lib/prism/node.rb:17353 class Prism::SelfNode < ::Prism::Node # Initialize a new SelfNode node. # # @return [SelfNode] a new instance of SelfNode # - # pkg:gem/prism#lib/prism/node.rb:17347 + # pkg:gem/prism#lib/prism/node.rb:17355 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17410 + # pkg:gem/prism#lib/prism/node.rb:17418 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17355 + # pkg:gem/prism#lib/prism/node.rb:17363 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17360 + # pkg:gem/prism#lib/prism/node.rb:17368 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17376 + # pkg:gem/prism#lib/prism/node.rb:17384 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17371 + # pkg:gem/prism#lib/prism/node.rb:17379 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SelfNode # - # pkg:gem/prism#lib/prism/node.rb:17381 + # pkg:gem/prism#lib/prism/node.rb:17389 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::SelfNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17386 + # pkg:gem/prism#lib/prism/node.rb:17394 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:17389 + # pkg:gem/prism#lib/prism/node.rb:17397 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:17365 + # pkg:gem/prism#lib/prism/node.rb:17373 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -33103,20 +33073,20 @@ class Prism::SelfNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17394 + # pkg:gem/prism#lib/prism/node.rb:17402 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17399 + # pkg:gem/prism#lib/prism/node.rb:17407 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17404 + # pkg:gem/prism#lib/prism/node.rb:17412 def type; end end end @@ -33323,13 +33293,13 @@ Prism::Serialize::TOKEN_TYPES = T.let(T.unsafe(nil), Array) # C = { a: 1 } # ^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17420 +# pkg:gem/prism#lib/prism/node.rb:17428 class Prism::ShareableConstantNode < ::Prism::Node # Initialize a new ShareableConstantNode node. # # @return [ShareableConstantNode] a new instance of ShareableConstantNode # - # pkg:gem/prism#lib/prism/node.rb:17422 + # pkg:gem/prism#lib/prism/node.rb:17430 sig do params( source: Prism::Source, @@ -33344,36 +33314,36 @@ class Prism::ShareableConstantNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17505 + # pkg:gem/prism#lib/prism/node.rb:17513 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17431 + # pkg:gem/prism#lib/prism/node.rb:17439 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17436 + # pkg:gem/prism#lib/prism/node.rb:17444 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17453 + # pkg:gem/prism#lib/prism/node.rb:17461 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17448 + # pkg:gem/prism#lib/prism/node.rb:17456 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode) -> ShareableConstantNode # - # pkg:gem/prism#lib/prism/node.rb:17458 + # pkg:gem/prism#lib/prism/node.rb:17466 sig do params( node_id: Integer, @@ -33387,13 +33357,13 @@ class Prism::ShareableConstantNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17463 + # pkg:gem/prism#lib/prism/node.rb:17471 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, write: ConstantWriteNode | ConstantAndWriteNode | ConstantOrWriteNode | ConstantOperatorWriteNode | ConstantPathWriteNode | ConstantPathAndWriteNode | ConstantPathOrWriteNode | ConstantPathOperatorWriteNode } # - # pkg:gem/prism#lib/prism/node.rb:17466 + # pkg:gem/prism#lib/prism/node.rb:17474 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -33401,14 +33371,14 @@ class Prism::ShareableConstantNode < ::Prism::Node # # @yield [write] # - # pkg:gem/prism#lib/prism/node.rb:17441 + # pkg:gem/prism#lib/prism/node.rb:17449 def each_child_node; end # def experimental_copy?: () -> bool # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17481 + # pkg:gem/prism#lib/prism/node.rb:17489 sig { returns(T::Boolean) } def experimental_copy?; end @@ -33416,7 +33386,7 @@ class Prism::ShareableConstantNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17476 + # pkg:gem/prism#lib/prism/node.rb:17484 sig { returns(T::Boolean) } def experimental_everything?; end @@ -33425,7 +33395,7 @@ class Prism::ShareableConstantNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17489 + # pkg:gem/prism#lib/prism/node.rb:17497 sig { override.returns(String) } def inspect; end @@ -33433,19 +33403,19 @@ class Prism::ShareableConstantNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17471 + # pkg:gem/prism#lib/prism/node.rb:17479 sig { returns(T::Boolean) } def literal?; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17494 + # pkg:gem/prism#lib/prism/node.rb:17502 sig { override.returns(Symbol) } def type; end # The constant write that should be modified with the shareability state. # - # pkg:gem/prism#lib/prism/node.rb:17486 + # pkg:gem/prism#lib/prism/node.rb:17494 sig do returns(T.any(Prism::ConstantWriteNode, Prism::ConstantAndWriteNode, Prism::ConstantOrWriteNode, Prism::ConstantOperatorWriteNode, Prism::ConstantPathWriteNode, Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode, Prism::ConstantPathOperatorWriteNode)) end @@ -33454,29 +33424,29 @@ class Prism::ShareableConstantNode < ::Prism::Node class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17499 + # pkg:gem/prism#lib/prism/node.rb:17507 def type; end end end # Flags for shareable constant nodes. # -# pkg:gem/prism#lib/prism/node.rb:19910 +# pkg:gem/prism#lib/prism/node.rb:19918 module Prism::ShareableConstantNodeFlags; end # constant writes that should be modified with shareable constant value experimental copy # -# pkg:gem/prism#lib/prism/node.rb:19918 +# pkg:gem/prism#lib/prism/node.rb:19926 Prism::ShareableConstantNodeFlags::EXPERIMENTAL_COPY = T.let(T.unsafe(nil), Integer) # constant writes that should be modified with shareable constant value experimental everything # -# pkg:gem/prism#lib/prism/node.rb:19915 +# pkg:gem/prism#lib/prism/node.rb:19923 Prism::ShareableConstantNodeFlags::EXPERIMENTAL_EVERYTHING = T.let(T.unsafe(nil), Integer) # constant writes that should be modified with shareable constant value literal # -# pkg:gem/prism#lib/prism/node.rb:19912 +# pkg:gem/prism#lib/prism/node.rb:19920 Prism::ShareableConstantNodeFlags::LITERAL = T.let(T.unsafe(nil), Integer) # Represents a singleton class declaration involving the `class` keyword. @@ -33484,13 +33454,13 @@ Prism::ShareableConstantNodeFlags::LITERAL = T.let(T.unsafe(nil), Integer) # class << self end # ^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17516 +# pkg:gem/prism#lib/prism/node.rb:17524 class Prism::SingletonClassNode < ::Prism::Node # Initialize a new SingletonClassNode node. # # @return [SingletonClassNode] a new instance of SingletonClassNode # - # pkg:gem/prism#lib/prism/node.rb:17518 + # pkg:gem/prism#lib/prism/node.rb:17526 sig do params( source: Prism::Source, @@ -33510,54 +33480,54 @@ class Prism::SingletonClassNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17655 + # pkg:gem/prism#lib/prism/node.rb:17663 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17532 + # pkg:gem/prism#lib/prism/node.rb:17540 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader body: StatementsNode | BeginNode | nil # - # pkg:gem/prism#lib/prism/node.rb:17608 + # pkg:gem/prism#lib/prism/node.rb:17616 sig { returns(T.nilable(T.any(Prism::StatementsNode, Prism::BeginNode))) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17537 + # pkg:gem/prism#lib/prism/node.rb:17545 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def class_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:17624 + # pkg:gem/prism#lib/prism/node.rb:17632 sig { returns(String) } def class_keyword; end # attr_reader class_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:17579 + # pkg:gem/prism#lib/prism/node.rb:17587 sig { returns(Prism::Location) } def class_keyword_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17558 + # pkg:gem/prism#lib/prism/node.rb:17566 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17550 + # pkg:gem/prism#lib/prism/node.rb:17558 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location) -> SingletonClassNode # - # pkg:gem/prism#lib/prism/node.rb:17563 + # pkg:gem/prism#lib/prism/node.rb:17571 sig do params( node_id: Integer, @@ -33576,13 +33546,13 @@ class Prism::SingletonClassNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17568 + # pkg:gem/prism#lib/prism/node.rb:17576 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:17571 + # pkg:gem/prism#lib/prism/node.rb:17579 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -33590,24 +33560,24 @@ class Prism::SingletonClassNode < ::Prism::Node # # @yield [expression] # - # pkg:gem/prism#lib/prism/node.rb:17542 + # pkg:gem/prism#lib/prism/node.rb:17550 def each_child_node; end # def end_keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:17634 + # pkg:gem/prism#lib/prism/node.rb:17642 sig { returns(String) } def end_keyword; end # attr_reader end_keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:17611 + # pkg:gem/prism#lib/prism/node.rb:17619 sig { returns(Prism::Location) } def end_keyword_loc; end # attr_reader expression: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:17605 + # pkg:gem/prism#lib/prism/node.rb:17613 sig { returns(Prism::Node) } def expression; end @@ -33616,56 +33586,56 @@ class Prism::SingletonClassNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17639 + # pkg:gem/prism#lib/prism/node.rb:17647 sig { override.returns(String) } def inspect; end # attr_reader locals: Array[Symbol] # - # pkg:gem/prism#lib/prism/node.rb:17576 + # pkg:gem/prism#lib/prism/node.rb:17584 sig { returns(T::Array[Symbol]) } def locals; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:17629 + # pkg:gem/prism#lib/prism/node.rb:17637 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:17592 + # pkg:gem/prism#lib/prism/node.rb:17600 sig { returns(Prism::Location) } def operator_loc; end # Save the class_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:17587 + # pkg:gem/prism#lib/prism/node.rb:17595 def save_class_keyword_loc(repository); end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:17619 + # pkg:gem/prism#lib/prism/node.rb:17627 def save_end_keyword_loc(repository); end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:17600 + # pkg:gem/prism#lib/prism/node.rb:17608 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17644 + # pkg:gem/prism#lib/prism/node.rb:17652 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17649 + # pkg:gem/prism#lib/prism/node.rb:17657 def type; end end end @@ -33684,22 +33654,27 @@ class Prism::Source sig { params(source: String, start_line: Integer, offsets: T::Array[Integer]).void } def initialize(source, start_line = T.unsafe(nil), offsets = T.unsafe(nil)); end + # Converts the line number and column in bytes to a byte offset. + # + # pkg:gem/prism#lib/prism/parse_result.rb:80 + def byte_offset(line, column); end + # Return the column number in characters for the given byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:108 + # pkg:gem/prism#lib/prism/parse_result.rb:117 sig { params(byte_offset: Integer).returns(Integer) } def character_column(byte_offset); end # Return the character offset for the given byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:103 + # pkg:gem/prism#lib/prism/parse_result.rb:112 sig { params(byte_offset: Integer).returns(Integer) } def character_offset(byte_offset); end # Generate a cache that targets a specific encoding for calculating code # unit offsets. # - # pkg:gem/prism#lib/prism/parse_result.rb:136 + # pkg:gem/prism#lib/prism/parse_result.rb:145 sig do params( encoding: Encoding @@ -33710,7 +33685,7 @@ class Prism::Source # Returns the column number in code units for the given encoding for the # given byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:142 + # pkg:gem/prism#lib/prism/parse_result.rb:151 sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } def code_units_column(byte_offset, encoding); end @@ -33727,19 +33702,19 @@ class Prism::Source # boundary. Second, it's possible that the source code will contain a # character that has no equivalent in the given encoding. # - # pkg:gem/prism#lib/prism/parse_result.rb:124 + # pkg:gem/prism#lib/prism/parse_result.rb:133 sig { params(byte_offset: Integer, encoding: Encoding).returns(Integer) } def code_units_offset(byte_offset, encoding); end # Return the column number for the given byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:98 + # pkg:gem/prism#lib/prism/parse_result.rb:107 sig { params(byte_offset: Integer).returns(Integer) } def column(byte_offset); end # Freeze this object and the objects it contains. # - # pkg:gem/prism#lib/prism/parse_result.rb:147 + # pkg:gem/prism#lib/prism/parse_result.rb:156 def deep_freeze; end # Returns the encoding of the source code, which is set by parameters to the @@ -33752,20 +33727,20 @@ class Prism::Source # Binary search through the offsets to find the line number for the given # byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:81 + # pkg:gem/prism#lib/prism/parse_result.rb:90 sig { params(byte_offset: Integer).returns(Integer) } def line(byte_offset); end # Returns the byte offset of the end of the line corresponding to the given # byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:93 + # pkg:gem/prism#lib/prism/parse_result.rb:102 def line_end(byte_offset); end # Return the byte offset of the start of the line corresponding to the given # byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:87 + # pkg:gem/prism#lib/prism/parse_result.rb:96 sig { params(byte_offset: Integer).returns(Integer) } def line_start(byte_offset); end @@ -33817,7 +33792,7 @@ class Prism::Source # Binary search through the offsets to find the line number for the given # byte offset. # - # pkg:gem/prism#lib/prism/parse_result.rb:157 + # pkg:gem/prism#lib/prism/parse_result.rb:166 def find_line(byte_offset); end class << self @@ -33836,68 +33811,68 @@ end # __ENCODING__ # ^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17671 +# pkg:gem/prism#lib/prism/node.rb:17679 class Prism::SourceEncodingNode < ::Prism::Node # Initialize a new SourceEncodingNode node. # # @return [SourceEncodingNode] a new instance of SourceEncodingNode # - # pkg:gem/prism#lib/prism/node.rb:17673 + # pkg:gem/prism#lib/prism/node.rb:17681 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17736 + # pkg:gem/prism#lib/prism/node.rb:17744 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17681 + # pkg:gem/prism#lib/prism/node.rb:17689 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17686 + # pkg:gem/prism#lib/prism/node.rb:17694 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17702 + # pkg:gem/prism#lib/prism/node.rb:17710 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17697 + # pkg:gem/prism#lib/prism/node.rb:17705 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceEncodingNode # - # pkg:gem/prism#lib/prism/node.rb:17707 + # pkg:gem/prism#lib/prism/node.rb:17715 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::SourceEncodingNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17712 + # pkg:gem/prism#lib/prism/node.rb:17720 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:17715 + # pkg:gem/prism#lib/prism/node.rb:17723 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:17691 + # pkg:gem/prism#lib/prism/node.rb:17699 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -33905,20 +33880,20 @@ class Prism::SourceEncodingNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17720 + # pkg:gem/prism#lib/prism/node.rb:17728 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17725 + # pkg:gem/prism#lib/prism/node.rb:17733 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17730 + # pkg:gem/prism#lib/prism/node.rb:17738 def type; end end end @@ -33928,13 +33903,13 @@ end # __FILE__ # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17745 +# pkg:gem/prism#lib/prism/node.rb:17753 class Prism::SourceFileNode < ::Prism::Node # Initialize a new SourceFileNode node. # # @return [SourceFileNode] a new instance of SourceFileNode # - # pkg:gem/prism#lib/prism/node.rb:17747 + # pkg:gem/prism#lib/prism/node.rb:17755 sig do params( source: Prism::Source, @@ -33949,36 +33924,36 @@ class Prism::SourceFileNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17834 + # pkg:gem/prism#lib/prism/node.rb:17842 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17756 + # pkg:gem/prism#lib/prism/node.rb:17764 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17761 + # pkg:gem/prism#lib/prism/node.rb:17769 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17777 + # pkg:gem/prism#lib/prism/node.rb:17785 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17772 + # pkg:gem/prism#lib/prism/node.rb:17780 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?filepath: String) -> SourceFileNode # - # pkg:gem/prism#lib/prism/node.rb:17782 + # pkg:gem/prism#lib/prism/node.rb:17790 sig do params( node_id: Integer, @@ -33992,19 +33967,19 @@ class Prism::SourceFileNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17787 + # pkg:gem/prism#lib/prism/node.rb:17795 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, filepath: String } # - # pkg:gem/prism#lib/prism/node.rb:17790 + # pkg:gem/prism#lib/prism/node.rb:17798 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:17766 + # pkg:gem/prism#lib/prism/node.rb:17774 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -34012,7 +33987,7 @@ class Prism::SourceFileNode < ::Prism::Node # Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs. # - # pkg:gem/prism#lib/prism/node.rb:17815 + # pkg:gem/prism#lib/prism/node.rb:17823 sig { returns(String) } def filepath; end @@ -34020,7 +33995,7 @@ class Prism::SourceFileNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17800 + # pkg:gem/prism#lib/prism/node.rb:17808 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -34028,7 +34003,7 @@ class Prism::SourceFileNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17795 + # pkg:gem/prism#lib/prism/node.rb:17803 sig { returns(T::Boolean) } def forced_utf8_encoding?; end @@ -34036,13 +34011,13 @@ class Prism::SourceFileNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17805 + # pkg:gem/prism#lib/prism/node.rb:17813 sig { returns(T::Boolean) } def frozen?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17818 + # pkg:gem/prism#lib/prism/node.rb:17826 sig { override.returns(String) } def inspect; end @@ -34050,20 +34025,20 @@ class Prism::SourceFileNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:17810 + # pkg:gem/prism#lib/prism/node.rb:17818 sig { returns(T::Boolean) } def mutable?; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17823 + # pkg:gem/prism#lib/prism/node.rb:17831 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17828 + # pkg:gem/prism#lib/prism/node.rb:17836 def type; end end end @@ -34073,68 +34048,68 @@ end # __LINE__ # ^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:17845 +# pkg:gem/prism#lib/prism/node.rb:17853 class Prism::SourceLineNode < ::Prism::Node # Initialize a new SourceLineNode node. # # @return [SourceLineNode] a new instance of SourceLineNode # - # pkg:gem/prism#lib/prism/node.rb:17847 + # pkg:gem/prism#lib/prism/node.rb:17855 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:17910 + # pkg:gem/prism#lib/prism/node.rb:17918 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17855 + # pkg:gem/prism#lib/prism/node.rb:17863 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17860 + # pkg:gem/prism#lib/prism/node.rb:17868 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17876 + # pkg:gem/prism#lib/prism/node.rb:17884 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17871 + # pkg:gem/prism#lib/prism/node.rb:17879 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> SourceLineNode # - # pkg:gem/prism#lib/prism/node.rb:17881 + # pkg:gem/prism#lib/prism/node.rb:17889 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::SourceLineNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17886 + # pkg:gem/prism#lib/prism/node.rb:17894 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:17889 + # pkg:gem/prism#lib/prism/node.rb:17897 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:17865 + # pkg:gem/prism#lib/prism/node.rb:17873 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -34142,20 +34117,20 @@ class Prism::SourceLineNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17894 + # pkg:gem/prism#lib/prism/node.rb:17902 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17899 + # pkg:gem/prism#lib/prism/node.rb:17907 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:17904 + # pkg:gem/prism#lib/prism/node.rb:17912 def type; end end end @@ -34165,13 +34140,13 @@ end # [*a] # ^^ # -# pkg:gem/prism#lib/prism/node.rb:17919 +# pkg:gem/prism#lib/prism/node.rb:17927 class Prism::SplatNode < ::Prism::Node # Initialize a new SplatNode node. # # @return [SplatNode] a new instance of SplatNode # - # pkg:gem/prism#lib/prism/node.rb:17921 + # pkg:gem/prism#lib/prism/node.rb:17929 sig do params( source: Prism::Source, @@ -34187,36 +34162,36 @@ class Prism::SplatNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18010 + # pkg:gem/prism#lib/prism/node.rb:18018 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:17931 + # pkg:gem/prism#lib/prism/node.rb:17939 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17936 + # pkg:gem/prism#lib/prism/node.rb:17944 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:17955 + # pkg:gem/prism#lib/prism/node.rb:17963 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:17948 + # pkg:gem/prism#lib/prism/node.rb:17956 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?expression: Prism::node?) -> SplatNode # - # pkg:gem/prism#lib/prism/node.rb:17960 + # pkg:gem/prism#lib/prism/node.rb:17968 sig do params( node_id: Integer, @@ -34231,13 +34206,13 @@ class Prism::SplatNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:17965 + # pkg:gem/prism#lib/prism/node.rb:17973 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, expression: Prism::node? } # - # pkg:gem/prism#lib/prism/node.rb:17968 + # pkg:gem/prism#lib/prism/node.rb:17976 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -34245,12 +34220,12 @@ class Prism::SplatNode < ::Prism::Node # # @yield [expression] # - # pkg:gem/prism#lib/prism/node.rb:17941 + # pkg:gem/prism#lib/prism/node.rb:17949 def each_child_node; end # attr_reader expression: Prism::node? # - # pkg:gem/prism#lib/prism/node.rb:17986 + # pkg:gem/prism#lib/prism/node.rb:17994 sig { returns(T.nilable(Prism::Node)) } def expression; end @@ -34259,38 +34234,38 @@ class Prism::SplatNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:17994 + # pkg:gem/prism#lib/prism/node.rb:18002 sig { override.returns(String) } def inspect; end # def operator: () -> String # - # pkg:gem/prism#lib/prism/node.rb:17989 + # pkg:gem/prism#lib/prism/node.rb:17997 sig { returns(String) } def operator; end # attr_reader operator_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:17973 + # pkg:gem/prism#lib/prism/node.rb:17981 sig { returns(Prism::Location) } def operator_loc; end # Save the operator_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:17981 + # pkg:gem/prism#lib/prism/node.rb:17989 def save_operator_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:17999 + # pkg:gem/prism#lib/prism/node.rb:18007 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18004 + # pkg:gem/prism#lib/prism/node.rb:18012 def type; end end end @@ -34300,13 +34275,13 @@ end # foo; bar; baz # ^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:18021 +# pkg:gem/prism#lib/prism/node.rb:18029 class Prism::StatementsNode < ::Prism::Node # Initialize a new StatementsNode node. # # @return [StatementsNode] a new instance of StatementsNode # - # pkg:gem/prism#lib/prism/node.rb:18023 + # pkg:gem/prism#lib/prism/node.rb:18031 sig do params( source: Prism::Source, @@ -34321,42 +34296,42 @@ class Prism::StatementsNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18091 + # pkg:gem/prism#lib/prism/node.rb:18099 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:18032 + # pkg:gem/prism#lib/prism/node.rb:18040 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader body: Array[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:18072 + # pkg:gem/prism#lib/prism/node.rb:18080 sig { returns(T::Array[Prism::Node]) } def body; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18037 + # pkg:gem/prism#lib/prism/node.rb:18045 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:18054 + # pkg:gem/prism#lib/prism/node.rb:18062 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:18049 + # pkg:gem/prism#lib/prism/node.rb:18057 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?body: Array[Prism::node]) -> StatementsNode # - # pkg:gem/prism#lib/prism/node.rb:18059 + # pkg:gem/prism#lib/prism/node.rb:18067 sig do params( node_id: Integer, @@ -34370,19 +34345,19 @@ class Prism::StatementsNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18064 + # pkg:gem/prism#lib/prism/node.rb:18072 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, body: Array[Prism::node] } # - # pkg:gem/prism#lib/prism/node.rb:18067 + # pkg:gem/prism#lib/prism/node.rb:18075 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:18042 + # pkg:gem/prism#lib/prism/node.rb:18050 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -34390,43 +34365,43 @@ class Prism::StatementsNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:18075 + # pkg:gem/prism#lib/prism/node.rb:18083 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:18080 + # pkg:gem/prism#lib/prism/node.rb:18088 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18085 + # pkg:gem/prism#lib/prism/node.rb:18093 def type; end end end # Flags for string nodes. # -# pkg:gem/prism#lib/prism/node.rb:19922 +# pkg:gem/prism#lib/prism/node.rb:19930 module Prism::StringFlags; end # internal bytes forced the encoding to binary # -# pkg:gem/prism#lib/prism/node.rb:19927 +# pkg:gem/prism#lib/prism/node.rb:19935 Prism::StringFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) # internal bytes forced the encoding to UTF-8 # -# pkg:gem/prism#lib/prism/node.rb:19924 +# pkg:gem/prism#lib/prism/node.rb:19932 Prism::StringFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/node.rb:19930 +# pkg:gem/prism#lib/prism/node.rb:19938 Prism::StringFlags::FROZEN = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/node.rb:19933 +# pkg:gem/prism#lib/prism/node.rb:19941 Prism::StringFlags::MUTABLE = T.let(T.unsafe(nil), Integer) # Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string. @@ -34440,7 +34415,7 @@ Prism::StringFlags::MUTABLE = T.let(T.unsafe(nil), Integer) # "foo #{bar} baz" # ^^^^ ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:18108 +# pkg:gem/prism#lib/prism/node.rb:18116 class Prism::StringNode < ::Prism::Node include ::Prism::HeredocQuery @@ -34448,7 +34423,7 @@ class Prism::StringNode < ::Prism::Node # # @return [StringNode] a new instance of StringNode # - # pkg:gem/prism#lib/prism/node.rb:18110 + # pkg:gem/prism#lib/prism/node.rb:18118 sig do params( source: Prism::Source, @@ -34466,60 +34441,60 @@ class Prism::StringNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18266 + # pkg:gem/prism#lib/prism/node.rb:18274 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:18122 + # pkg:gem/prism#lib/prism/node.rb:18130 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18127 + # pkg:gem/prism#lib/prism/node.rb:18135 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18245 + # pkg:gem/prism#lib/prism/node.rb:18253 sig { returns(T.nilable(String)) } def closing; end # attr_reader closing_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:18213 + # pkg:gem/prism#lib/prism/node.rb:18221 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:18143 + # pkg:gem/prism#lib/prism/node.rb:18151 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:18138 + # pkg:gem/prism#lib/prism/node.rb:18146 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def content: () -> String # - # pkg:gem/prism#lib/prism/node.rb:18240 + # pkg:gem/prism#lib/prism/node.rb:18248 sig { returns(String) } def content; end # attr_reader content_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:18200 + # pkg:gem/prism#lib/prism/node.rb:18208 sig { returns(Prism::Location) } def content_loc; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?content_loc: Location, ?closing_loc: Location?, ?unescaped: String) -> StringNode # - # pkg:gem/prism#lib/prism/node.rb:18148 + # pkg:gem/prism#lib/prism/node.rb:18156 sig do params( node_id: Integer, @@ -34536,19 +34511,19 @@ class Prism::StringNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18153 + # pkg:gem/prism#lib/prism/node.rb:18161 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, content_loc: Location, closing_loc: Location?, unescaped: String } # - # pkg:gem/prism#lib/prism/node.rb:18156 + # pkg:gem/prism#lib/prism/node.rb:18164 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:18132 + # pkg:gem/prism#lib/prism/node.rb:18140 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -34558,7 +34533,7 @@ class Prism::StringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:18166 + # pkg:gem/prism#lib/prism/node.rb:18174 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -34566,7 +34541,7 @@ class Prism::StringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:18161 + # pkg:gem/prism#lib/prism/node.rb:18169 sig { returns(T::Boolean) } def forced_utf8_encoding?; end @@ -34574,7 +34549,7 @@ class Prism::StringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:18171 + # pkg:gem/prism#lib/prism/node.rb:18179 sig { returns(T::Boolean) } def frozen?; end @@ -34583,7 +34558,7 @@ class Prism::StringNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:18250 + # pkg:gem/prism#lib/prism/node.rb:18258 sig { override.returns(String) } def inspect; end @@ -34591,38 +34566,38 @@ class Prism::StringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:18176 + # pkg:gem/prism#lib/prism/node.rb:18184 sig { returns(T::Boolean) } def mutable?; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18235 + # pkg:gem/prism#lib/prism/node.rb:18243 sig { returns(T.nilable(String)) } def opening; end # attr_reader opening_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:18181 + # pkg:gem/prism#lib/prism/node.rb:18189 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18227 + # pkg:gem/prism#lib/prism/node.rb:18235 def save_closing_loc(repository); end # Save the content_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18208 + # pkg:gem/prism#lib/prism/node.rb:18216 def save_content_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18195 + # pkg:gem/prism#lib/prism/node.rb:18203 def save_opening_loc(repository); end # Occasionally it's helpful to treat a string as if it were interpolated so @@ -34634,20 +34609,20 @@ class Prism::StringNode < ::Prism::Node # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:18255 + # pkg:gem/prism#lib/prism/node.rb:18263 sig { override.returns(Symbol) } def type; end # attr_reader unescaped: String # - # pkg:gem/prism#lib/prism/node.rb:18232 + # pkg:gem/prism#lib/prism/node.rb:18240 sig { returns(String) } def unescaped; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18260 + # pkg:gem/prism#lib/prism/node.rb:18268 def type; end end end @@ -34695,21 +34670,21 @@ class Prism::StringQuery # # @return [Boolean] # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def constant?(_arg0); end # Mirrors the C extension's StringQuery::local? method. # # @return [Boolean] # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def local?(_arg0); end # Mirrors the C extension's StringQuery::method_name? method. # # @return [Boolean] # - # pkg:gem/prism#lib/prism.rb:105 + # pkg:gem/prism#lib/prism.rb:92 def method_name?(_arg0); end end end @@ -34724,13 +34699,13 @@ end # # If no arguments are provided (except for a block), it would be a `ForwardingSuperNode` instead. # -# pkg:gem/prism#lib/prism/node.rb:18285 +# pkg:gem/prism#lib/prism/node.rb:18293 class Prism::SuperNode < ::Prism::Node # Initialize a new SuperNode node. # # @return [SuperNode] a new instance of SuperNode # - # pkg:gem/prism#lib/prism/node.rb:18287 + # pkg:gem/prism#lib/prism/node.rb:18295 sig do params( source: Prism::Source, @@ -34749,48 +34724,48 @@ class Prism::SuperNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18432 + # pkg:gem/prism#lib/prism/node.rb:18440 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:18300 + # pkg:gem/prism#lib/prism/node.rb:18308 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # Can be only `nil` when there are empty parentheses, like `super()`. # - # pkg:gem/prism#lib/prism/node.rb:18376 + # pkg:gem/prism#lib/prism/node.rb:18384 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end # attr_reader block: BlockNode | BlockArgumentNode | nil # - # pkg:gem/prism#lib/prism/node.rb:18398 + # pkg:gem/prism#lib/prism/node.rb:18406 sig { returns(T.nilable(T.any(Prism::BlockNode, Prism::BlockArgumentNode))) } def block; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18305 + # pkg:gem/prism#lib/prism/node.rb:18313 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:18326 + # pkg:gem/prism#lib/prism/node.rb:18334 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:18318 + # pkg:gem/prism#lib/prism/node.rb:18326 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> SuperNode # - # pkg:gem/prism#lib/prism/node.rb:18331 + # pkg:gem/prism#lib/prism/node.rb:18339 sig do params( node_id: Integer, @@ -34808,13 +34783,13 @@ class Prism::SuperNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18336 + # pkg:gem/prism#lib/prism/node.rb:18344 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode | BlockArgumentNode | nil } # - # pkg:gem/prism#lib/prism/node.rb:18339 + # pkg:gem/prism#lib/prism/node.rb:18347 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -34822,7 +34797,7 @@ class Prism::SuperNode < ::Prism::Node # # @yield [arguments] # - # pkg:gem/prism#lib/prism/node.rb:18310 + # pkg:gem/prism#lib/prism/node.rb:18318 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -34830,96 +34805,96 @@ class Prism::SuperNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:18416 + # pkg:gem/prism#lib/prism/node.rb:18424 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:18401 + # pkg:gem/prism#lib/prism/node.rb:18409 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:18344 + # pkg:gem/prism#lib/prism/node.rb:18352 sig { returns(Prism::Location) } def keyword_loc; end # def lparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18406 + # pkg:gem/prism#lib/prism/node.rb:18414 sig { returns(T.nilable(String)) } def lparen; end # attr_reader lparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:18357 + # pkg:gem/prism#lib/prism/node.rb:18365 sig { returns(T.nilable(Prism::Location)) } def lparen_loc; end # def rparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18411 + # pkg:gem/prism#lib/prism/node.rb:18419 sig { returns(T.nilable(String)) } def rparen; end # attr_reader rparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:18379 + # pkg:gem/prism#lib/prism/node.rb:18387 sig { returns(T.nilable(Prism::Location)) } def rparen_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18352 + # pkg:gem/prism#lib/prism/node.rb:18360 def save_keyword_loc(repository); end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18371 + # pkg:gem/prism#lib/prism/node.rb:18379 def save_lparen_loc(repository); end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18393 + # pkg:gem/prism#lib/prism/node.rb:18401 def save_rparen_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:18421 + # pkg:gem/prism#lib/prism/node.rb:18429 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18426 + # pkg:gem/prism#lib/prism/node.rb:18434 def type; end end end # Flags for symbol nodes. # -# pkg:gem/prism#lib/prism/node.rb:19937 +# pkg:gem/prism#lib/prism/node.rb:19945 module Prism::SymbolFlags; end # internal bytes forced the encoding to binary # -# pkg:gem/prism#lib/prism/node.rb:19942 +# pkg:gem/prism#lib/prism/node.rb:19950 Prism::SymbolFlags::FORCED_BINARY_ENCODING = T.let(T.unsafe(nil), Integer) # internal bytes forced the encoding to US-ASCII # -# pkg:gem/prism#lib/prism/node.rb:19945 +# pkg:gem/prism#lib/prism/node.rb:19953 Prism::SymbolFlags::FORCED_US_ASCII_ENCODING = T.let(T.unsafe(nil), Integer) # internal bytes forced the encoding to UTF-8 # -# pkg:gem/prism#lib/prism/node.rb:19939 +# pkg:gem/prism#lib/prism/node.rb:19947 Prism::SymbolFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) # Represents a symbol literal or a symbol contained within a `%i` list. @@ -34930,13 +34905,13 @@ Prism::SymbolFlags::FORCED_UTF8_ENCODING = T.let(T.unsafe(nil), Integer) # %i[foo] # ^^^ # -# pkg:gem/prism#lib/prism/node.rb:18449 +# pkg:gem/prism#lib/prism/node.rb:18457 class Prism::SymbolNode < ::Prism::Node # Initialize a new SymbolNode node. # # @return [SymbolNode] a new instance of SymbolNode # - # pkg:gem/prism#lib/prism/node.rb:18451 + # pkg:gem/prism#lib/prism/node.rb:18459 sig do params( source: Prism::Source, @@ -34954,48 +34929,48 @@ class Prism::SymbolNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18608 + # pkg:gem/prism#lib/prism/node.rb:18616 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:18463 + # pkg:gem/prism#lib/prism/node.rb:18471 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18468 + # pkg:gem/prism#lib/prism/node.rb:18476 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18587 + # pkg:gem/prism#lib/prism/node.rb:18595 sig { returns(T.nilable(String)) } def closing; end # attr_reader closing_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:18555 + # pkg:gem/prism#lib/prism/node.rb:18563 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:18484 + # pkg:gem/prism#lib/prism/node.rb:18492 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:18479 + # pkg:gem/prism#lib/prism/node.rb:18487 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location?, ?value_loc: Location?, ?closing_loc: Location?, ?unescaped: String) -> SymbolNode # - # pkg:gem/prism#lib/prism/node.rb:18489 + # pkg:gem/prism#lib/prism/node.rb:18497 sig do params( node_id: Integer, @@ -35012,19 +34987,19 @@ class Prism::SymbolNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18494 + # pkg:gem/prism#lib/prism/node.rb:18502 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String } # - # pkg:gem/prism#lib/prism/node.rb:18497 + # pkg:gem/prism#lib/prism/node.rb:18505 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:18473 + # pkg:gem/prism#lib/prism/node.rb:18481 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -35034,7 +35009,7 @@ class Prism::SymbolNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:18507 + # pkg:gem/prism#lib/prism/node.rb:18515 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -35042,7 +35017,7 @@ class Prism::SymbolNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:18512 + # pkg:gem/prism#lib/prism/node.rb:18520 sig { returns(T::Boolean) } def forced_us_ascii_encoding?; end @@ -35050,133 +35025,133 @@ class Prism::SymbolNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:18502 + # pkg:gem/prism#lib/prism/node.rb:18510 sig { returns(T::Boolean) } def forced_utf8_encoding?; end # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:18592 + # pkg:gem/prism#lib/prism/node.rb:18600 sig { override.returns(String) } def inspect; end # def opening: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18577 + # pkg:gem/prism#lib/prism/node.rb:18585 sig { returns(T.nilable(String)) } def opening; end # attr_reader opening_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:18517 + # pkg:gem/prism#lib/prism/node.rb:18525 sig { returns(T.nilable(Prism::Location)) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18569 + # pkg:gem/prism#lib/prism/node.rb:18577 def save_closing_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18531 + # pkg:gem/prism#lib/prism/node.rb:18539 def save_opening_loc(repository); end # Save the value_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18550 + # pkg:gem/prism#lib/prism/node.rb:18558 def save_value_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:18597 + # pkg:gem/prism#lib/prism/node.rb:18605 sig { override.returns(Symbol) } def type; end # attr_reader unescaped: String # - # pkg:gem/prism#lib/prism/node.rb:18574 + # pkg:gem/prism#lib/prism/node.rb:18582 sig { returns(String) } def unescaped; end # def value: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18582 + # pkg:gem/prism#lib/prism/node.rb:18590 sig { returns(T.nilable(String)) } def value; end # attr_reader value_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:18536 + # pkg:gem/prism#lib/prism/node.rb:18544 sig { returns(T.nilable(Prism::Location)) } def value_loc; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18602 + # pkg:gem/prism#lib/prism/node.rb:18610 def type; end end end # This represents a token from the Ruby source. # -# pkg:gem/prism#lib/prism/parse_result.rb:804 +# pkg:gem/prism#lib/prism/parse_result.rb:813 class Prism::Token # Create a new token object with the given type, value, and location. # # @return [Token] a new instance of Token # - # pkg:gem/prism#lib/prism/parse_result.rb:816 + # pkg:gem/prism#lib/prism/parse_result.rb:825 sig { params(source: Prism::Source, type: Symbol, value: String, location: T.any(Integer, Prism::Location)).void } def initialize(source, type, value, location); end # Returns true if the given other token is equal to this token. # - # pkg:gem/prism#lib/prism/parse_result.rb:851 + # pkg:gem/prism#lib/prism/parse_result.rb:860 sig { params(other: T.untyped).returns(T::Boolean) } def ==(other); end # Implement the hash pattern matching interface for Token. # - # pkg:gem/prism#lib/prism/parse_result.rb:824 + # pkg:gem/prism#lib/prism/parse_result.rb:833 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # Freeze this object and the objects it contains. # - # pkg:gem/prism#lib/prism/parse_result.rb:864 + # pkg:gem/prism#lib/prism/parse_result.rb:873 def deep_freeze; end # Returns a string representation of this token. # - # pkg:gem/prism#lib/prism/parse_result.rb:858 + # pkg:gem/prism#lib/prism/parse_result.rb:867 def inspect; end # A Location object representing the location of this token in the source. # - # pkg:gem/prism#lib/prism/parse_result.rb:829 + # pkg:gem/prism#lib/prism/parse_result.rb:838 sig { returns(Prism::Location) } def location; end # Implement the pretty print interface for Token. # - # pkg:gem/prism#lib/prism/parse_result.rb:836 + # pkg:gem/prism#lib/prism/parse_result.rb:845 sig { params(q: T.untyped).void } def pretty_print(q); end # The type of token that this token is. # - # pkg:gem/prism#lib/prism/parse_result.rb:810 + # pkg:gem/prism#lib/prism/parse_result.rb:819 sig { returns(Symbol) } def type; end # A byteslice of the source that this token represents. # - # pkg:gem/prism#lib/prism/parse_result.rb:813 + # pkg:gem/prism#lib/prism/parse_result.rb:822 sig { returns(String) } def value; end @@ -35184,7 +35159,7 @@ class Prism::Token # The Source object that represents the source this token came from. # - # pkg:gem/prism#lib/prism/parse_result.rb:806 + # pkg:gem/prism#lib/prism/parse_result.rb:815 sig { returns(Prism::Source) } def source; end end @@ -36859,89 +36834,89 @@ class Prism::Translation::Ripper < ::Prism::Compiler # # @return [Ripper] a new instance of Ripper # - # pkg:gem/prism#lib/prism/translation/ripper.rb:468 + # pkg:gem/prism#lib/prism/translation/ripper.rb:482 def initialize(source, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end # The current column number of the parser. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:465 + # pkg:gem/prism#lib/prism/translation/ripper.rb:479 def column; end # True if the parser encountered an error during parsing. # # @return [Boolean] # - # pkg:gem/prism#lib/prism/translation/ripper.rb:481 + # pkg:gem/prism#lib/prism/translation/ripper.rb:495 sig { returns(T::Boolean) } def error?; end # The filename of the source being parsed. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:459 + # pkg:gem/prism#lib/prism/translation/ripper.rb:473 def filename; end # The current line number of the parser. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:462 + # pkg:gem/prism#lib/prism/translation/ripper.rb:476 def lineno; end # Parse the source and return the result. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:486 + # pkg:gem/prism#lib/prism/translation/ripper.rb:500 sig { returns(T.untyped) } def parse; end # The source that is being parsed. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:456 + # pkg:gem/prism#lib/prism/translation/ripper.rb:470 def source; end # alias $foo $bar # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:585 + # pkg:gem/prism#lib/prism/translation/ripper.rb:599 def visit_alias_global_variable_node(node); end # alias foo bar # ^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:575 + # pkg:gem/prism#lib/prism/translation/ripper.rb:589 def visit_alias_method_node(node); end # foo => bar | baz # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:609 + # pkg:gem/prism#lib/prism/translation/ripper.rb:623 def visit_alternation_pattern_node(node); end # a and b # ^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:629 + # pkg:gem/prism#lib/prism/translation/ripper.rb:643 def visit_and_node(node); end # foo(bar) # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:820 + # pkg:gem/prism#lib/prism/translation/ripper.rb:834 def visit_arguments_node(node); end # [] # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:639 + # pkg:gem/prism#lib/prism/translation/ripper.rb:653 def visit_array_node(node); end # foo => [bar] # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:799 + # pkg:gem/prism#lib/prism/translation/ripper.rb:813 def visit_array_pattern_node(node); end # { a: 1 } # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:827 + # pkg:gem/prism#lib/prism/translation/ripper.rb:841 def visit_assoc_node(node); end # def foo(**); bar(**); end @@ -36950,47 +36925,47 @@ class Prism::Translation::Ripper < ::Prism::Compiler # { **foo } # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:840 + # pkg:gem/prism#lib/prism/translation/ripper.rb:854 def visit_assoc_splat_node(node); end # $+ # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:849 + # pkg:gem/prism#lib/prism/translation/ripper.rb:863 def visit_back_reference_read_node(node); end # begin end # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:856 + # pkg:gem/prism#lib/prism/translation/ripper.rb:870 def visit_begin_node(node); end # foo(&bar) # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:920 + # pkg:gem/prism#lib/prism/translation/ripper.rb:934 def visit_block_argument_node(node); end # foo { |; bar| } # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:926 + # pkg:gem/prism#lib/prism/translation/ripper.rb:940 def visit_block_local_variable_node(node); end # Visit a BlockNode. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:932 + # pkg:gem/prism#lib/prism/translation/ripper.rb:946 def visit_block_node(node); end # def foo(&bar); end # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:968 + # pkg:gem/prism#lib/prism/translation/ripper.rb:982 def visit_block_parameter_node(node); end # A block's parameters. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:982 + # pkg:gem/prism#lib/prism/translation/ripper.rb:996 def visit_block_parameters_node(node); end # break @@ -36999,13 +36974,13 @@ class Prism::Translation::Ripper < ::Prism::Compiler # break foo # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1006 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1020 def visit_break_node(node); end # foo.bar &&= baz # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1228 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1251 def visit_call_and_write_node(node); end # foo @@ -37017,79 +36992,79 @@ class Prism::Translation::Ripper < ::Prism::Compiler # foo.bar() {} # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1026 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1040 def visit_call_node(node); end # foo.bar += baz # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1206 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1229 def visit_call_operator_write_node(node); end # foo.bar ||= baz # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1250 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1273 def visit_call_or_write_node(node); end # foo.bar, = 1 # ^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1272 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1295 def visit_call_target_node(node); end # foo => bar => baz # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1297 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1320 def visit_capture_pattern_node(node); end # case foo; in bar; end # ^^^^^^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1320 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1343 def visit_case_match_node(node); end # case foo; when bar; end # ^^^^^^^^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1307 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1330 def visit_case_node(node); end # class Foo; end # ^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1333 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1356 def visit_class_node(node); end # @@foo &&= bar # ^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1386 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1409 def visit_class_variable_and_write_node(node); end # @@foo += bar # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1372 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1395 def visit_class_variable_operator_write_node(node); end # @@foo ||= bar # ^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1400 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1423 def visit_class_variable_or_write_node(node); end # @@foo # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1351 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1374 def visit_class_variable_read_node(node); end # @@foo, = bar # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1414 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1437 def visit_class_variable_target_node(node); end # @@foo = 1 @@ -37098,55 +37073,55 @@ class Prism::Translation::Ripper < ::Prism::Compiler # @@foo, @@bar = 1 # ^^^^^ ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1361 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1384 def visit_class_variable_write_node(node); end # Foo &&= bar # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1456 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1479 def visit_constant_and_write_node(node); end # Foo += bar # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1442 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1465 def visit_constant_operator_write_node(node); end # Foo ||= bar # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1470 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1493 def visit_constant_or_write_node(node); end # Foo::Bar &&= baz # ^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1557 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1580 def visit_constant_path_and_write_node(node); end # Foo::Bar # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1491 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1514 def visit_constant_path_node(node); end # Foo::Bar += baz # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1543 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1566 def visit_constant_path_operator_write_node(node); end # Foo::Bar ||= baz # ^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1571 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1594 def visit_constant_path_or_write_node(node); end # Foo::Bar, = baz # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1585 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1608 def visit_constant_path_target_node(node); end # Foo::Bar = 1 @@ -37155,19 +37130,19 @@ class Prism::Translation::Ripper < ::Prism::Compiler # Foo::Foo, Bar::Bar = 1 # ^^^^^^^^ ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1514 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1537 def visit_constant_path_write_node(node); end # Foo # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1421 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1444 def visit_constant_read_node(node); end # Foo, = bar # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1484 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1507 def visit_constant_target_node(node); end # Foo = 1 @@ -37176,7 +37151,7 @@ class Prism::Translation::Ripper < ::Prism::Compiler # Foo, Bar = 1 # ^^^ ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1431 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1454 def visit_constant_write_node(node); end # def foo; end @@ -37185,7 +37160,7 @@ class Prism::Translation::Ripper < ::Prism::Compiler # def self.foo; end # ^^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1594 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1617 def visit_def_node(node); end # defined? a @@ -37194,72 +37169,72 @@ class Prism::Translation::Ripper < ::Prism::Compiler # defined?(a) # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1641 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1664 def visit_defined_node(node); end # if foo then bar else baz end # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1663 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1686 def visit_else_node(node); end # "foo #{bar}" # ^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1679 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1702 def visit_embedded_statements_node(node); end # "foo #@bar" # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1700 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1723 def visit_embedded_variable_node(node); end # Visit an EnsureNode node. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1711 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1734 def visit_ensure_node(node); end # false # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1729 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1752 def visit_false_node(node); end # foo => [*, bar, *] # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1736 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1759 def visit_find_pattern_node(node); end # if foo .. bar; end # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1761 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1784 def visit_flip_flop_node(node); end # 1.0 # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1775 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1798 def visit_float_node(node); end # for foo in bar do end # ^^^^^^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1781 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1804 def visit_for_node(node); end # def foo(...); bar(...); end # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1798 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1821 def visit_forwarding_arguments_node(node); end # def foo(...); end # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1805 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1828 def visit_forwarding_parameter_node(node); end # super @@ -37268,37 +37243,37 @@ class Prism::Translation::Ripper < ::Prism::Compiler # super {} # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1815 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1838 def visit_forwarding_super_node(node); end # $foo &&= bar # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1864 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1887 def visit_global_variable_and_write_node(node); end # $foo += bar # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1850 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1873 def visit_global_variable_operator_write_node(node); end # $foo ||= bar # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1878 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1901 def visit_global_variable_or_write_node(node); end # $foo # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1829 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1852 def visit_global_variable_read_node(node); end # $foo, = bar # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1892 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1915 def visit_global_variable_target_node(node); end # $foo = 1 @@ -37307,19 +37282,19 @@ class Prism::Translation::Ripper < ::Prism::Compiler # $foo, $bar = 1 # ^^^^ ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1839 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1862 def visit_global_variable_write_node(node); end # {} # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1899 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1922 def visit_hash_node(node); end # foo => {} # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1914 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1937 def visit_hash_pattern_node(node); end # if foo then bar end @@ -37331,140 +37306,140 @@ class Prism::Translation::Ripper < ::Prism::Compiler # foo ? bar : baz # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1956 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1979 def visit_if_node(node); end # 1i # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1992 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2015 def visit_imaginary_node(node); end # { foo: } # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1998 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2021 def visit_implicit_node(node); end # foo { |bar,| } # ^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2003 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2026 def visit_implicit_rest_node(node); end # case foo; in bar; end # ^^^^^^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2010 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2033 def visit_in_node(node); end # foo[bar] &&= baz # ^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2045 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2068 def visit_index_and_write_node(node); end # foo[bar] += baz # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2028 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2051 def visit_index_operator_write_node(node); end # foo[bar] ||= baz # ^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2062 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2085 def visit_index_or_write_node(node); end # foo[bar], = 1 # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2079 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2102 def visit_index_target_node(node); end # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2121 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2144 def visit_instance_variable_and_write_node(node); end # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2107 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2130 def visit_instance_variable_operator_write_node(node); end # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2135 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2158 def visit_instance_variable_or_write_node(node); end # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2089 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2112 def visit_instance_variable_read_node(node); end # @foo, = bar # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2149 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2172 def visit_instance_variable_target_node(node); end # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2096 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2119 def visit_instance_variable_write_node(node); end # 1 # ^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2156 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2179 def visit_integer_node(node); end # if /foo #{bar}/ then end # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2162 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2185 def visit_interpolated_match_last_line_node(node); end # /foo #{bar}/ # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2181 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2204 def visit_interpolated_regular_expression_node(node); end # "foo #{bar}" # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2200 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2223 def visit_interpolated_string_node(node); end # :"foo #{bar}" # ^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2228 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2251 def visit_interpolated_symbol_node(node); end # `foo #{bar}` # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2241 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2264 def visit_interpolated_x_string_node(node); end # -> { it } # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2271 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2294 def visit_it_local_variable_read_node(node); end # -> { it } # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2278 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2301 def visit_it_parameters_node(node); end # foo(bar: baz) # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2283 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2306 def visit_keyword_hash_node(node); end # def foo(**bar); end @@ -37473,96 +37448,96 @@ class Prism::Translation::Ripper < ::Prism::Compiler # def foo(**); end # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2295 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2318 def visit_keyword_rest_parameter_node(node); end # -> {} # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2309 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2332 def visit_lambda_node(node); end # foo &&= bar # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2401 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2424 def visit_local_variable_and_write_node(node); end # foo += bar # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2387 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2410 def visit_local_variable_operator_write_node(node); end # foo ||= bar # ^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2415 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2438 def visit_local_variable_or_write_node(node); end # foo # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2369 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2392 def visit_local_variable_read_node(node); end # foo, = bar # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2429 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2452 def visit_local_variable_target_node(node); end # foo = 1 # ^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2376 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2399 def visit_local_variable_write_node(node); end # if /foo/ then end # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2436 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2459 def visit_match_last_line_node(node); end # foo in bar # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2451 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2474 def visit_match_predicate_node(node); end # foo => bar # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2460 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2483 def visit_match_required_node(node); end # /(?foo)/ =~ bar # ^^^^^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2469 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2492 def visit_match_write_node(node); end # A node that is missing from the syntax tree. This is only used in the # case of a syntax error. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2475 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2498 def visit_missing_node(node); end # module Foo; end # ^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2481 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2504 def visit_module_node(node); end # (foo, bar), bar = qux # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2498 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2521 def visit_multi_target_node(node); end # foo, bar = baz # ^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2552 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2575 def visit_multi_write_node(node); end # next @@ -37571,55 +37546,55 @@ class Prism::Translation::Ripper < ::Prism::Compiler # next foo # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2572 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2595 def visit_next_node(node); end # nil # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2586 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2609 def visit_nil_node(node); end # def foo(**nil); end # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2593 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2616 def visit_no_keywords_parameter_node(node); end # -> { _1 + _2 } # ^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2602 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2625 def visit_numbered_parameters_node(node); end # $1 # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2607 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2630 def visit_numbered_reference_read_node(node); end # def foo(bar: baz); end # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2614 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2637 def visit_optional_keyword_parameter_node(node); end # def foo(bar = 1); end # ^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2624 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2647 def visit_optional_parameter_node(node); end # a or b # ^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2634 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2657 def visit_or_node(node); end # def foo(bar, *baz); end # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2644 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2667 def visit_parameters_node(node); end # () @@ -37628,84 +37603,84 @@ class Prism::Translation::Ripper < ::Prism::Compiler # (1) # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2671 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2694 def visit_parentheses_node(node); end # foo => ^(bar) # ^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2685 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2708 def visit_pinned_expression_node(node); end # foo = 1 and bar => ^foo # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2694 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2717 def visit_pinned_variable_node(node); end # END {} # ^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2700 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2723 def visit_post_execution_node(node); end # BEGIN {} # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2715 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2738 def visit_pre_execution_node(node); end # The top-level program node. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2729 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2752 def visit_program_node(node); end # 0..5 # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2740 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2763 def visit_range_node(node); end # 1r # ^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2754 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2777 def visit_rational_node(node); end # redo # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2760 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2783 def visit_redo_node(node); end # /foo/ # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2767 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2790 def visit_regular_expression_node(node); end # def foo(bar:); end # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2789 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2812 def visit_required_keyword_parameter_node(node); end # def foo(bar); end # ^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2796 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2819 def visit_required_parameter_node(node); end # foo rescue bar # ^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2803 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2826 def visit_rescue_modifier_node(node); end # begin; rescue; end # ^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2813 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2836 def visit_rescue_node(node); end # def foo(*bar); end @@ -37714,13 +37689,13 @@ class Prism::Translation::Ripper < ::Prism::Compiler # def foo(*); end # ^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2871 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2894 def visit_rest_parameter_node(node); end # retry # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2883 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2906 def visit_retry_node(node); end # return @@ -37729,42 +37704,42 @@ class Prism::Translation::Ripper < ::Prism::Compiler # return 1 # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2893 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2916 def visit_return_node(node); end # self # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2907 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2930 def visit_self_node(node); end # A shareable constant. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2913 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2936 def visit_shareable_constant_node(node); end # class << self; end # ^^^^^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2919 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2942 def visit_singleton_class_node(node); end # __ENCODING__ # ^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2929 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2952 def visit_source_encoding_node(node); end # __FILE__ # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2936 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2959 def visit_source_file_node(node); end # __LINE__ # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2943 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2966 def visit_source_line_node(node); end # foo(*bar) @@ -37776,42 +37751,42 @@ class Prism::Translation::Ripper < ::Prism::Compiler # def foo(*); bar(*); end # ^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2956 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2979 def visit_splat_node(node); end # A list of statements. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2961 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2984 def visit_statements_node(node); end # "foo" # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2978 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3001 def visit_string_node(node); end # super(foo) # ^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3110 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3133 def visit_super_node(node); end # :foo # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3131 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3154 def visit_symbol_node(node); end # true # ^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3155 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3178 def visit_true_node(node); end # undef foo # ^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3162 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3185 def visit_undef_node(node); end # unless foo; bar end @@ -37820,7 +37795,7 @@ class Prism::Translation::Ripper < ::Prism::Compiler # bar unless foo # ^^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3174 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3197 def visit_unless_node(node); end # until foo; bar end @@ -37829,13 +37804,13 @@ class Prism::Translation::Ripper < ::Prism::Compiler # bar until foo # ^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3202 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3225 def visit_until_node(node); end # case foo; when bar; end # ^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3226 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3249 def visit_when_node(node); end # while foo; bar end @@ -37844,13 +37819,13 @@ class Prism::Translation::Ripper < ::Prism::Compiler # bar while foo # ^^^^^^^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3247 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3270 def visit_while_node(node); end # `foo` # ^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3271 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3294 def visit_x_string_node(node); end # yield @@ -37859,33 +37834,33 @@ class Prism::Translation::Ripper < ::Prism::Compiler # yield 1 # ^^^^^^^ # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3294 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3317 def visit_yield_node(node); end private # :stopdoc: # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3434 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3457 def _dispatch_0; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3435 - def _dispatch_1(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3458 + def _dispatch_1(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3436 - def _dispatch_2(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3459 + def _dispatch_2(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3437 - def _dispatch_3(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3460 + def _dispatch_3(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3438 - def _dispatch_4(_, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3461 + def _dispatch_4(arg, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3439 - def _dispatch_5(_, _, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3462 + def _dispatch_5(arg, _, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3440 - def _dispatch_7(_, _, _, _, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3463 + def _dispatch_7(arg, _, _, _, _, _, _); end # This method is responsible for updating lineno and column information # to reflect the current node. @@ -37893,19 +37868,19 @@ class Prism::Translation::Ripper < ::Prism::Compiler # This method could be drastically improved with some caching on the start # of every line, but for now it's good enough. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3424 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3447 def bounds(location); end # Returns true if the given node is a command node. # # @return [Boolean] # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1197 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1220 def command?(node); end # This method is called when the parser found syntax error. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3462 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3485 def compile_error(msg); end # This method is provided by the Ripper C extension. It is called when a @@ -37913,631 +37888,637 @@ class Prism::Translation::Ripper < ::Prism::Compiler # that it will modify the string in place and return the number of bytes # that were removed. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3477 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3500 def dedent_string(string, width); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_BEGIN(_); end + # Extract the arguments and block Ripper-style, which means if the block + # is like `&b` then it's moved to arguments. + # + # pkg:gem/prism#lib/prism/translation/ripper.rb:1184 + def get_arguments_and_block(arguments_node, block_node); end + + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_BEGIN(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_CHAR(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_CHAR(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_END(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_END(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on___end__(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on___end__(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_alias(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_alias(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_alias_error(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_alias_error(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_aref(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_aref(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_aref_field(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_aref_field(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_arg_ambiguous(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_arg_ambiguous(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_arg_paren(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_arg_paren(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_args_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_args_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_args_add_block(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_args_add_block(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_args_add_star(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_args_add_star(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_args_forward; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_args_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_array(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_array(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_aryptn(_, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_aryptn(arg, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_assign(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_assign(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_assign_error(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_assign_error(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_assoc_new(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_assoc_new(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_assoc_splat(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_assoc_splat(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_assoclist_from_args(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_assoclist_from_args(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_backref(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_backref(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_backtick(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_backtick(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_bare_assoc_hash(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_bare_assoc_hash(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_begin(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_begin(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_binary(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_binary(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_block_var(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_block_var(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_blockarg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_blockarg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_bodystmt(_, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_bodystmt(arg, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_brace_block(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_brace_block(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_break(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_break(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_call(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_call(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_case(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_case(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_class(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_class(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_class_name_error(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_class_name_error(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_comma(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_comma(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_command(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_command(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_command_call(_, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_command_call(arg, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_comment(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_comment(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_const(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_const(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_const_path_field(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_const_path_field(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_const_path_ref(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_const_path_ref(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_const_ref(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_const_ref(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_cvar(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_cvar(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_def(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_def(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_defined(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_defined(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_defs(_, _, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_defs(arg, _, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_do_block(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_do_block(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_dot2(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_dot2(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_dot3(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_dot3(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_dyna_symbol(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_dyna_symbol(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_else(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_else(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_elsif(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_elsif(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_embdoc(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_embdoc(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_embdoc_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_embdoc_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_embdoc_end(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_embdoc_end(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_embexpr_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_embexpr_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_embexpr_end(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_embexpr_end(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_embvar(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_embvar(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_ensure(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_ensure(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_excessed_comma; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_fcall(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_fcall(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_field(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_field(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_float(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_float(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_fndptn(_, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_fndptn(arg, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_for(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_for(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_gvar(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_gvar(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_hash(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_hash(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_heredoc_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_heredoc_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_heredoc_dedent(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_heredoc_dedent(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_heredoc_end(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_heredoc_end(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_hshptn(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_hshptn(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_ident(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_ident(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_if(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_if(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_if_mod(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_if_mod(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_ifop(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_ifop(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_ignored_nl(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_ignored_nl(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_ignored_sp(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_ignored_sp(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_imaginary(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_imaginary(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_in(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_in(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_int(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_int(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_ivar(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_ivar(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_kw(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_kw(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_kwrest_param(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_kwrest_param(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_label(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_label(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_label_end(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_label_end(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_lambda(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_lambda(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_lbrace(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_lbrace(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_lbracket(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_lbracket(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_lparen(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_lparen(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_magic_comment(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_magic_comment(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_massign(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_massign(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_method_add_arg(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_method_add_arg(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_method_add_block(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_method_add_block(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_mlhs_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_mlhs_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_mlhs_add_post(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_mlhs_add_post(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_mlhs_add_star(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_mlhs_add_star(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_mlhs_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_mlhs_paren(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_mlhs_paren(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_module(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_module(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_mrhs_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_mrhs_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_mrhs_add_star(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_mrhs_add_star(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_mrhs_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_mrhs_new_from_args(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_mrhs_new_from_args(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_next(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_next(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_nl(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_nl(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_nokw_param(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_nokw_param(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_op(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_op(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_opassign(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_opassign(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_operator_ambiguous(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_operator_ambiguous(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_param_error(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_param_error(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_params(_, _, _, _, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_params(arg, _, _, _, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_paren(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_paren(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_parse_error(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_parse_error(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_period(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_period(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_program(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_program(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_qsymbols_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_qsymbols_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_qsymbols_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_qsymbols_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_qsymbols_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_qwords_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_qwords_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_qwords_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_qwords_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_qwords_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_rational(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_rational(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_rbrace(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_rbrace(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_rbracket(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_rbracket(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_redo; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_regexp_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_regexp_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_regexp_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_regexp_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_regexp_end(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_regexp_end(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_regexp_literal(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_regexp_literal(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_regexp_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_rescue(_, _, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_rescue(arg, _, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_rescue_mod(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_rescue_mod(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_rest_param(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_rest_param(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_retry; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_return(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_return(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_return0; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_rparen(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_rparen(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_sclass(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_sclass(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_semicolon(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_semicolon(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_sp(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_sp(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_stmts_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_stmts_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_stmts_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_string_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_string_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_string_concat(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_string_concat(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_string_content; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_string_dvar(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_string_dvar(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_string_embexpr(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_string_embexpr(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_string_literal(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_string_literal(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_super(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_super(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_symbeg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_symbeg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_symbol(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_symbol(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_symbol_literal(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_symbol_literal(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_symbols_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_symbols_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_symbols_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_symbols_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_symbols_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_tlambda(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_tlambda(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_tlambeg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_tlambeg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_top_const_field(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_top_const_field(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_top_const_ref(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_top_const_ref(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_tstring_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_tstring_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_tstring_content(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_tstring_content(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_tstring_end(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_tstring_end(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_unary(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_unary(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_undef(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_undef(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_unless(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_unless(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_unless_mod(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_unless_mod(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_until(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_until(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_until_mod(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_until_mod(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_var_alias(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_var_alias(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_var_field(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_var_field(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_var_ref(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_var_ref(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_vcall(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_vcall(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_void_stmt; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_when(_, _, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_when(arg, _, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_while(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_while(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_while_mod(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_while_mod(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_word_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_word_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_word_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_words_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_words_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_words_beg(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_words_beg(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_words_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3470 - def on_words_sep(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3493 + def on_words_sep(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_xstring_add(_, _); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_xstring_add(arg, _); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_xstring_literal(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_xstring_literal(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_xstring_new; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 - def on_yield(_); end + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 + def on_yield(arg); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_yield0; end - # pkg:gem/prism#lib/prism/translation/ripper.rb:3448 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3471 def on_zsuper; end # Lazily initialize the parse result. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3320 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3343 def result; end # Returns true if there is a comma between the two locations. # # @return [Boolean] # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3329 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3352 def trailing_comma?(left, right); end # Visit one side of an alias global variable node. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:594 + # pkg:gem/prism#lib/prism/translation/ripper.rb:608 def visit_alias_global_variable_node_value(node); end # Visit a list of elements, like the elements of an array or arguments. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:780 + # pkg:gem/prism#lib/prism/translation/ripper.rb:794 def visit_arguments(elements); end # Visit the clauses of a begin node to form an on_bodystmt call. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:864 + # pkg:gem/prism#lib/prism/translation/ripper.rb:878 def visit_begin_node_clauses(location, node, allow_newline); end # Visit the body of a structure that can have either a set of statements # or statements wrapped in rescue/else/ensure. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:899 + # pkg:gem/prism#lib/prism/translation/ripper.rb:913 def visit_body_node(location, node, allow_newline = T.unsafe(nil)); end # Visit the arguments and block of a call node and return the arguments # and block as they should be used. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1170 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1198 def visit_call_node_arguments(arguments_node, block_node, trailing_comma); end # Visit a constant path that is part of a write node. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:1523 + # pkg:gem/prism#lib/prism/translation/ripper.rb:1546 def visit_constant_path_write_node_target(node); end # Visit a destructured positional parameter node. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2658 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2681 def visit_destructured_parameter_node(node); end # Visit a string that is expressed using a <<~ heredoc. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3029 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3052 def visit_heredoc_node(parts, base); end # Ripper gives back the escaped string content but strips out the common @@ -38546,34 +38527,34 @@ class Prism::Translation::Ripper < ::Prism::Compiler # work well together, so here we need to re-derive the common leading # whitespace. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3004 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3027 def visit_heredoc_node_whitespace(parts); end # Visit a heredoc node that is representing a string. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3075 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3098 def visit_heredoc_string_node(node); end # Visit a heredoc node that is representing an xstring. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3092 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3115 def visit_heredoc_x_string_node(node); end # Visit the targets of a multi-target node. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2511 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2534 def visit_multi_target_node_targets(lefts, rest, rights, skippable); end # Visit a node that represents a number. We need to explicitly handle the # unary - operator. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3368 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3391 def visit_number_node(node); end # Visit a pattern within a pattern match. This is used to bypass the # parenthesis node that can be used to wrap patterns. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:619 + # pkg:gem/prism#lib/prism/translation/ripper.rb:633 def visit_pattern_node(node); end # Visit the list of statements of a statements node. We support nil @@ -38581,49 +38562,49 @@ class Prism::Translation::Ripper < ::Prism::Compiler # structure of the prism parse tree, but we manually add them here so that # we can mirror Ripper's void stmt. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2970 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2993 def visit_statements_node_body(body); end # Visit an individual part of a string-like node. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:2260 + # pkg:gem/prism#lib/prism/translation/ripper.rb:2283 def visit_string_content(part); end # Visit the string content of a particular node. This method is used to # split into the various token types. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3341 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3364 def visit_token(token, allow_keywords = T.unsafe(nil)); end # Dispatch a words_sep event that contains the space between the elements # of list literals. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:769 + # pkg:gem/prism#lib/prism/translation/ripper.rb:783 def visit_words_sep(opening_loc, previous, current); end # Visit a node that represents a write value. This is used to handle the # special case of an implicit array that is generated without brackets. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3386 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3409 def visit_write_value(node); end # Returns true if there is a semicolon between the two locations. # # @return [Boolean] # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3334 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3357 def void_stmt?(left, right, allow_newline); end # This method is called when weak warning is produced by the parser. # +fmt+ and +args+ is printf style. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3453 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3476 def warn(fmt, *args); end # This method is called when strong warning is produced by the parser. # +fmt+ and +args+ is printf style. # - # pkg:gem/prism#lib/prism/translation/ripper.rb:3458 + # pkg:gem/prism#lib/prism/translation/ripper.rb:3481 def warning(fmt, *args); end class << self @@ -38652,7 +38633,7 @@ class Prism::Translation::Ripper < ::Prism::Compiler # pkg:gem/prism#lib/prism/translation/ripper.rb:71 def lex(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end - # pkg:gem/prism#lib/prism/translation/ripper.rb:449 + # pkg:gem/prism#lib/prism/translation/ripper.rb:463 def lex_state_name(state); end # Parses the given Ruby program read from +src+. @@ -38679,7 +38660,7 @@ class Prism::Translation::Ripper < ::Prism::Compiler # [:paren, [:params, [[:@ident, "a", [1, 6]]], nil, nil, nil, nil, nil, nil]], # [:bodystmt, [[:var_ref, [:@kw, "nil", [1, 9]]]], nil, nil, nil]]]] # - # pkg:gem/prism#lib/prism/translation/ripper.rb:380 + # pkg:gem/prism#lib/prism/translation/ripper.rb:393 def sexp(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end # Parses +src+ and create S-exp tree. @@ -38705,87 +38686,231 @@ class Prism::Translation::Ripper < ::Prism::Compiler # nil, # nil]]]] # - # pkg:gem/prism#lib/prism/translation/ripper.rb:415 + # pkg:gem/prism#lib/prism/translation/ripper.rb:428 def sexp_raw(src, filename = T.unsafe(nil), lineno = T.unsafe(nil), raise_errors: T.unsafe(nil)); end + + # Tokenizes the Ruby program and returns an array of strings. + # The +filename+ and +lineno+ arguments are mostly ignored, since the + # return value is just the tokenized input. + # By default, this method does not handle syntax errors in +src+, + # use the +raise_errors+ keyword to raise a SyntaxError for an error in +src+. + # + # p Ripper.tokenize("def m(a) nil end") + # # => ["def", " ", "m", "(", "a", ")", " ", "nil", " ", "end"] + # + # pkg:gem/prism#lib/prism/translation/ripper.rb:90 + def tokenize(*_arg0, **_arg1, &_arg2); end end end # A list of all of the Ruby binary operators. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:336 +# pkg:gem/prism#lib/prism/translation/ripper.rb:349 Prism::Translation::Ripper::BINARY_OPERATORS = T.let(T.unsafe(nil), Array) # This array contains name of all ripper events. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:288 +# pkg:gem/prism#lib/prism/translation/ripper.rb:301 Prism::Translation::Ripper::EVENTS = T.let(T.unsafe(nil), Array) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_ARG = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:446 +# pkg:gem/prism#lib/prism/translation/ripper.rb:460 Prism::Translation::Ripper::EXPR_ARG_ANY = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_BEG = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:445 +# pkg:gem/prism#lib/prism/translation/ripper.rb:459 Prism::Translation::Ripper::EXPR_BEG_ANY = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_CLASS = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_CMDARG = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_DOT = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_END = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_ENDARG = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_ENDFN = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:447 +# pkg:gem/prism#lib/prism/translation/ripper.rb:461 Prism::Translation::Ripper::EXPR_END_ANY = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_FITEM = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_FNAME = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_LABEL = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_LABELED = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:441 +# pkg:gem/prism#lib/prism/translation/ripper.rb:455 Prism::Translation::Ripper::EXPR_MID = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:443 +# pkg:gem/prism#lib/prism/translation/ripper.rb:457 Prism::Translation::Ripper::EXPR_NONE = T.let(T.unsafe(nil), Integer) -# pkg:gem/prism#lib/prism/translation/ripper.rb:444 +# pkg:gem/prism#lib/prism/translation/ripper.rb:458 Prism::Translation::Ripper::EXPR_VALUE = T.let(T.unsafe(nil), Integer) +# pkg:gem/prism#lib/prism/translation/ripper/filter.rb:6 +class Prism::Translation::Ripper::Filter + # :stopdoc: + # + # @return [Filter] a new instance of Filter + # + # pkg:gem/prism#lib/prism/translation/ripper/filter.rb:8 + def initialize(src, filename = T.unsafe(nil), lineno = T.unsafe(nil)); end + + # pkg:gem/prism#lib/prism/translation/ripper/filter.rb:23 + def column; end + + # pkg:gem/prism#lib/prism/translation/ripper/filter.rb:15 + def filename; end + + # pkg:gem/prism#lib/prism/translation/ripper/filter.rb:19 + def lineno; end + + # pkg:gem/prism#lib/prism/translation/ripper/filter.rb:31 + def parse(init = T.unsafe(nil)); end + + # pkg:gem/prism#lib/prism/translation/ripper/filter.rb:27 + def state; end + + private + + # pkg:gem/prism#lib/prism/translation/ripper/filter.rb:46 + def on_default(event, token, data); end +end + # A list of all of the Ruby keywords. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:291 +# pkg:gem/prism#lib/prism/translation/ripper.rb:304 Prism::Translation::Ripper::KEYWORDS = T.let(T.unsafe(nil), Array) # Ripper-internal bitflags. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:435 +# pkg:gem/prism#lib/prism/translation/ripper.rb:449 Prism::Translation::Ripper::LEX_STATE_NAMES = T.let(T.unsafe(nil), Hash) # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:9 -class Prism::Translation::Ripper::Lexer; end +class Prism::Translation::Ripper::Lexer < ::Prism::Translation::Ripper + # Pretty much just the same as Prism.lex_compat. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:111 + def lex(raise_errors: T.unsafe(nil)); end + + # Returns the lex_compat result wrapped in `Elem`. Errors are omitted. + # Since ripper is a streaming parser, tokens are expected to be emitted in the order + # that the parser encounters them. This is not implemented. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:118 + def parse(*_arg0, **_arg1, &_arg2); end + + # Similar to parse but ripper sorts the elements by position in the source. Also + # includes errors. Since prism does error recovery, in cases of syntax errors + # the result may differ greatly compared to ripper. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:127 + def scan(*_arg0, **_arg1, &_arg2); end +end + +# pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:50 +class Prism::Translation::Ripper::Lexer::Elem + # @return [Elem] a new instance of Elem + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:53 + def initialize(pos, event, tok, state, message = T.unsafe(nil)); end + + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:61 + def [](index); end + + # Returns the value of attribute event. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def event; end + + # Sets the attribute event + # + # @param value the value to set the attribute event to. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def event=(_arg0); end + + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:78 + def inspect; end + + # Returns the value of attribute message. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def message; end + + # Sets the attribute message + # + # @param value the value to set the attribute message to. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def message=(_arg0); end + + # Returns the value of attribute pos. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def pos; end + + # Sets the attribute pos + # + # @param value the value to set the attribute pos to. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def pos=(_arg0); end + + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:84 + def pretty_print(q); end + + # Returns the value of attribute state. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def state; end + + # Sets the attribute state + # + # @param value the value to set the attribute state to. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def state=(_arg0); end + + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:101 + def to_a; end + + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:82 + def to_s; end + + # Returns the value of attribute tok. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def tok; end + + # Sets the attribute tok + # + # @param value the value to set the attribute tok to. + # + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:51 + def tok=(_arg0); end +end # :stopdoc: # @@ -38845,28 +38970,38 @@ class Prism::Translation::Ripper::Lexer::State # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:37 def |(i); end + + class << self + # pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:45 + def cached(i); end + end end +# Instances are frozen and there are only a handful of them so we cache them here. +# +# pkg:gem/prism#lib/prism/translation/ripper/lexer.rb:43 +Prism::Translation::Ripper::Lexer::State::STATES = T.let(T.unsafe(nil), Hash) + # This array contains name of parser events. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:282 +# pkg:gem/prism#lib/prism/translation/ripper.rb:295 Prism::Translation::Ripper::PARSER_EVENTS = T.let(T.unsafe(nil), Array) # This contains a table of all of the parser events and their # corresponding arity. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:83 +# pkg:gem/prism#lib/prism/translation/ripper.rb:96 Prism::Translation::Ripper::PARSER_EVENT_TABLE = T.let(T.unsafe(nil), Hash) # This array contains name of scanner events. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:285 +# pkg:gem/prism#lib/prism/translation/ripper.rb:298 Prism::Translation::Ripper::SCANNER_EVENTS = T.let(T.unsafe(nil), Array) # This contains a table of all of the scanner events and their # corresponding arity. # -# pkg:gem/prism#lib/prism/translation/ripper.rb:226 +# pkg:gem/prism#lib/prism/translation/ripper.rb:239 Prism::Translation::Ripper::SCANNER_EVENT_TABLE = T.let(T.unsafe(nil), Hash) # This class mirrors the ::Ripper::SexpBuilder subclass of ::Ripper that @@ -40961,68 +41096,68 @@ end # true # ^^^^ # -# pkg:gem/prism#lib/prism/node.rb:18622 +# pkg:gem/prism#lib/prism/node.rb:18630 class Prism::TrueNode < ::Prism::Node # Initialize a new TrueNode node. # # @return [TrueNode] a new instance of TrueNode # - # pkg:gem/prism#lib/prism/node.rb:18624 + # pkg:gem/prism#lib/prism/node.rb:18632 sig { params(source: Prism::Source, node_id: Integer, location: Prism::Location, flags: Integer).void } def initialize(source, node_id, location, flags); end # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18687 + # pkg:gem/prism#lib/prism/node.rb:18695 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:18632 + # pkg:gem/prism#lib/prism/node.rb:18640 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18637 + # pkg:gem/prism#lib/prism/node.rb:18645 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:18653 + # pkg:gem/prism#lib/prism/node.rb:18661 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:18648 + # pkg:gem/prism#lib/prism/node.rb:18656 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer) -> TrueNode # - # pkg:gem/prism#lib/prism/node.rb:18658 + # pkg:gem/prism#lib/prism/node.rb:18666 sig { params(node_id: Integer, location: Prism::Location, flags: Integer).returns(Prism::TrueNode) } def copy(node_id: T.unsafe(nil), location: T.unsafe(nil), flags: T.unsafe(nil)); end # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18663 + # pkg:gem/prism#lib/prism/node.rb:18671 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location } # - # pkg:gem/prism#lib/prism/node.rb:18666 + # pkg:gem/prism#lib/prism/node.rb:18674 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:18642 + # pkg:gem/prism#lib/prism/node.rb:18650 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -41030,20 +41165,20 @@ class Prism::TrueNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:18671 + # pkg:gem/prism#lib/prism/node.rb:18679 sig { override.returns(String) } def inspect; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:18676 + # pkg:gem/prism#lib/prism/node.rb:18684 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18681 + # pkg:gem/prism#lib/prism/node.rb:18689 def type; end end end @@ -41053,13 +41188,13 @@ end # undef :foo, :bar, :baz # ^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:18696 +# pkg:gem/prism#lib/prism/node.rb:18704 class Prism::UndefNode < ::Prism::Node # Initialize a new UndefNode node. # # @return [UndefNode] a new instance of UndefNode # - # pkg:gem/prism#lib/prism/node.rb:18698 + # pkg:gem/prism#lib/prism/node.rb:18706 sig do params( source: Prism::Source, @@ -41075,36 +41210,36 @@ class Prism::UndefNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18785 + # pkg:gem/prism#lib/prism/node.rb:18793 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:18708 + # pkg:gem/prism#lib/prism/node.rb:18716 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18713 + # pkg:gem/prism#lib/prism/node.rb:18721 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:18730 + # pkg:gem/prism#lib/prism/node.rb:18738 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:18725 + # pkg:gem/prism#lib/prism/node.rb:18733 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?names: Array[SymbolNode | InterpolatedSymbolNode], ?keyword_loc: Location) -> UndefNode # - # pkg:gem/prism#lib/prism/node.rb:18735 + # pkg:gem/prism#lib/prism/node.rb:18743 sig do params( node_id: Integer, @@ -41119,19 +41254,19 @@ class Prism::UndefNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18740 + # pkg:gem/prism#lib/prism/node.rb:18748 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, names: Array[SymbolNode | InterpolatedSymbolNode], keyword_loc: Location } # - # pkg:gem/prism#lib/prism/node.rb:18743 + # pkg:gem/prism#lib/prism/node.rb:18751 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:18718 + # pkg:gem/prism#lib/prism/node.rb:18726 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -41139,44 +41274,44 @@ class Prism::UndefNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:18769 + # pkg:gem/prism#lib/prism/node.rb:18777 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:18764 + # pkg:gem/prism#lib/prism/node.rb:18772 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:18751 + # pkg:gem/prism#lib/prism/node.rb:18759 sig { returns(Prism::Location) } def keyword_loc; end # attr_reader names: Array[SymbolNode | InterpolatedSymbolNode] # - # pkg:gem/prism#lib/prism/node.rb:18748 + # pkg:gem/prism#lib/prism/node.rb:18756 sig { returns(T::Array[T.any(Prism::SymbolNode, Prism::InterpolatedSymbolNode)]) } def names; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18759 + # pkg:gem/prism#lib/prism/node.rb:18767 def save_keyword_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:18774 + # pkg:gem/prism#lib/prism/node.rb:18782 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18779 + # pkg:gem/prism#lib/prism/node.rb:18787 def type; end end end @@ -41189,13 +41324,13 @@ end # unless foo then bar end # ^^^^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:18800 +# pkg:gem/prism#lib/prism/node.rb:18808 class Prism::UnlessNode < ::Prism::Node # Initialize a new UnlessNode node. # # @return [UnlessNode] a new instance of UnlessNode # - # pkg:gem/prism#lib/prism/node.rb:18802 + # pkg:gem/prism#lib/prism/node.rb:18810 sig do params( source: Prism::Source, @@ -41215,30 +41350,30 @@ class Prism::UnlessNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:18978 + # pkg:gem/prism#lib/prism/node.rb:18986 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:18816 + # pkg:gem/prism#lib/prism/node.rb:18824 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18821 + # pkg:gem/prism#lib/prism/node.rb:18829 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:18844 + # pkg:gem/prism#lib/prism/node.rb:18852 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:18835 + # pkg:gem/prism#lib/prism/node.rb:18843 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end @@ -41250,7 +41385,7 @@ class Prism::UnlessNode < ::Prism::Node # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?predicate: Prism::node, ?then_keyword_loc: Location?, ?statements: StatementsNode?, ?else_clause: ElseNode?, ?end_keyword_loc: Location?) -> UnlessNode # - # pkg:gem/prism#lib/prism/node.rb:18849 + # pkg:gem/prism#lib/prism/node.rb:18857 sig do params( node_id: Integer, @@ -41269,13 +41404,13 @@ class Prism::UnlessNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:18854 + # pkg:gem/prism#lib/prism/node.rb:18862 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, predicate: Prism::node, then_keyword_loc: Location?, statements: StatementsNode?, else_clause: ElseNode?, end_keyword_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:18857 + # pkg:gem/prism#lib/prism/node.rb:18865 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -41283,7 +41418,7 @@ class Prism::UnlessNode < ::Prism::Node # # @yield [predicate] # - # pkg:gem/prism#lib/prism/node.rb:18826 + # pkg:gem/prism#lib/prism/node.rb:18834 def each_child_node; end # The else clause of the unless expression, if present. @@ -41291,13 +41426,13 @@ class Prism::UnlessNode < ::Prism::Node # unless cond then bar else baz end # ^^^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:18922 + # pkg:gem/prism#lib/prism/node.rb:18930 sig { returns(T.nilable(Prism::ElseNode)) } def else_clause; end # def end_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18957 + # pkg:gem/prism#lib/prism/node.rb:18965 sig { returns(T.nilable(String)) } def end_keyword; end @@ -41306,7 +41441,7 @@ class Prism::UnlessNode < ::Prism::Node # unless cond then bar end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:18928 + # pkg:gem/prism#lib/prism/node.rb:18936 sig { returns(T.nilable(Prism::Location)) } def end_keyword_loc; end @@ -41315,13 +41450,13 @@ class Prism::UnlessNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:18962 + # pkg:gem/prism#lib/prism/node.rb:18970 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:18947 + # pkg:gem/prism#lib/prism/node.rb:18955 sig { returns(String) } def keyword; end @@ -41333,7 +41468,7 @@ class Prism::UnlessNode < ::Prism::Node # bar unless cond # ^^^^^^ # - # pkg:gem/prism#lib/prism/node.rb:18868 + # pkg:gem/prism#lib/prism/node.rb:18876 sig { returns(Prism::Location) } def keyword_loc; end @@ -41348,26 +41483,26 @@ class Prism::UnlessNode < ::Prism::Node # bar unless cond # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:18887 + # pkg:gem/prism#lib/prism/node.rb:18895 sig { returns(Prism::Node) } def predicate; end # Save the end_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18942 + # pkg:gem/prism#lib/prism/node.rb:18950 def save_end_keyword_loc(repository); end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18876 + # pkg:gem/prism#lib/prism/node.rb:18884 def save_keyword_loc(repository); end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:18907 + # pkg:gem/prism#lib/prism/node.rb:18915 def save_then_keyword_loc(repository); end # The body of statements that will executed if the unless condition is @@ -41376,13 +41511,13 @@ class Prism::UnlessNode < ::Prism::Node # unless cond then bar end # ^^^ # - # pkg:gem/prism#lib/prism/node.rb:18916 + # pkg:gem/prism#lib/prism/node.rb:18924 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # def then_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:18952 + # pkg:gem/prism#lib/prism/node.rb:18960 sig { returns(T.nilable(String)) } def then_keyword; end @@ -41391,20 +41526,20 @@ class Prism::UnlessNode < ::Prism::Node # unless cond then bar end # ^^^^ # - # pkg:gem/prism#lib/prism/node.rb:18893 + # pkg:gem/prism#lib/prism/node.rb:18901 sig { returns(T.nilable(Prism::Location)) } def then_keyword_loc; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:18967 + # pkg:gem/prism#lib/prism/node.rb:18975 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:18972 + # pkg:gem/prism#lib/prism/node.rb:18980 def type; end end end @@ -41417,13 +41552,13 @@ end # until foo do bar end # ^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:18996 +# pkg:gem/prism#lib/prism/node.rb:19004 class Prism::UntilNode < ::Prism::Node # Initialize a new UntilNode node. # # @return [UntilNode] a new instance of UntilNode # - # pkg:gem/prism#lib/prism/node.rb:18998 + # pkg:gem/prism#lib/prism/node.rb:19006 sig do params( source: Prism::Source, @@ -41442,12 +41577,12 @@ class Prism::UntilNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:19148 + # pkg:gem/prism#lib/prism/node.rb:19156 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:19011 + # pkg:gem/prism#lib/prism/node.rb:19019 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -41455,43 +41590,43 @@ class Prism::UntilNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:19055 + # pkg:gem/prism#lib/prism/node.rb:19063 sig { returns(T::Boolean) } def begin_modifier?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19016 + # pkg:gem/prism#lib/prism/node.rb:19024 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:19127 + # pkg:gem/prism#lib/prism/node.rb:19135 sig { returns(T.nilable(String)) } def closing; end # attr_reader closing_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:19092 + # pkg:gem/prism#lib/prism/node.rb:19100 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:19037 + # pkg:gem/prism#lib/prism/node.rb:19045 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:19029 + # pkg:gem/prism#lib/prism/node.rb:19037 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> UntilNode # - # pkg:gem/prism#lib/prism/node.rb:19042 + # pkg:gem/prism#lib/prism/node.rb:19050 sig do params( node_id: Integer, @@ -41509,25 +41644,25 @@ class Prism::UntilNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19047 + # pkg:gem/prism#lib/prism/node.rb:19055 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? } # - # pkg:gem/prism#lib/prism/node.rb:19050 + # pkg:gem/prism#lib/prism/node.rb:19058 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def do_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:19122 + # pkg:gem/prism#lib/prism/node.rb:19130 sig { returns(T.nilable(String)) } def do_keyword; end # attr_reader do_keyword_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:19073 + # pkg:gem/prism#lib/prism/node.rb:19081 sig { returns(T.nilable(Prism::Location)) } def do_keyword_loc; end @@ -41535,7 +41670,7 @@ class Prism::UntilNode < ::Prism::Node # # @yield [predicate] # - # pkg:gem/prism#lib/prism/node.rb:19021 + # pkg:gem/prism#lib/prism/node.rb:19029 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -41543,19 +41678,19 @@ class Prism::UntilNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:19132 + # pkg:gem/prism#lib/prism/node.rb:19140 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:19117 + # pkg:gem/prism#lib/prism/node.rb:19125 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:19060 + # pkg:gem/prism#lib/prism/node.rb:19068 sig { returns(Prism::Location) } def keyword_loc; end @@ -41564,44 +41699,44 @@ class Prism::UntilNode < ::Prism::Node # attr_reader predicate: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:19111 + # pkg:gem/prism#lib/prism/node.rb:19119 sig { returns(Prism::Node) } def predicate; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19106 + # pkg:gem/prism#lib/prism/node.rb:19114 def save_closing_loc(repository); end # Save the do_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19087 + # pkg:gem/prism#lib/prism/node.rb:19095 def save_do_keyword_loc(repository); end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19068 + # pkg:gem/prism#lib/prism/node.rb:19076 def save_keyword_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:19114 + # pkg:gem/prism#lib/prism/node.rb:19122 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:19137 + # pkg:gem/prism#lib/prism/node.rb:19145 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:19142 + # pkg:gem/prism#lib/prism/node.rb:19150 def type; end end end @@ -42544,13 +42679,13 @@ end # ^^^^^^^^^ # end # -# pkg:gem/prism#lib/prism/node.rb:19165 +# pkg:gem/prism#lib/prism/node.rb:19173 class Prism::WhenNode < ::Prism::Node # Initialize a new WhenNode node. # # @return [WhenNode] a new instance of WhenNode # - # pkg:gem/prism#lib/prism/node.rb:19167 + # pkg:gem/prism#lib/prism/node.rb:19175 sig do params( source: Prism::Source, @@ -42568,42 +42703,42 @@ class Prism::WhenNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:19287 + # pkg:gem/prism#lib/prism/node.rb:19295 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:19179 + # pkg:gem/prism#lib/prism/node.rb:19187 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19184 + # pkg:gem/prism#lib/prism/node.rb:19192 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:19205 + # pkg:gem/prism#lib/prism/node.rb:19213 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:19197 + # pkg:gem/prism#lib/prism/node.rb:19205 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # attr_reader conditions: Array[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:19236 + # pkg:gem/prism#lib/prism/node.rb:19244 sig { returns(T::Array[Prism::Node]) } def conditions; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?conditions: Array[Prism::node], ?then_keyword_loc: Location?, ?statements: StatementsNode?) -> WhenNode # - # pkg:gem/prism#lib/prism/node.rb:19210 + # pkg:gem/prism#lib/prism/node.rb:19218 sig do params( node_id: Integer, @@ -42620,13 +42755,13 @@ class Prism::WhenNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19215 + # pkg:gem/prism#lib/prism/node.rb:19223 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, conditions: Array[Prism::node], then_keyword_loc: Location?, statements: StatementsNode? } # - # pkg:gem/prism#lib/prism/node.rb:19218 + # pkg:gem/prism#lib/prism/node.rb:19226 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -42634,7 +42769,7 @@ class Prism::WhenNode < ::Prism::Node # # @yield [statements] # - # pkg:gem/prism#lib/prism/node.rb:19189 + # pkg:gem/prism#lib/prism/node.rb:19197 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -42642,62 +42777,62 @@ class Prism::WhenNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:19271 + # pkg:gem/prism#lib/prism/node.rb:19279 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:19261 + # pkg:gem/prism#lib/prism/node.rb:19269 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:19223 + # pkg:gem/prism#lib/prism/node.rb:19231 sig { returns(Prism::Location) } def keyword_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19231 + # pkg:gem/prism#lib/prism/node.rb:19239 def save_keyword_loc(repository); end # Save the then_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19253 + # pkg:gem/prism#lib/prism/node.rb:19261 def save_then_keyword_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:19258 + # pkg:gem/prism#lib/prism/node.rb:19266 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # def then_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:19266 + # pkg:gem/prism#lib/prism/node.rb:19274 sig { returns(T.nilable(String)) } def then_keyword; end # attr_reader then_keyword_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:19239 + # pkg:gem/prism#lib/prism/node.rb:19247 sig { returns(T.nilable(Prism::Location)) } def then_keyword_loc; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:19276 + # pkg:gem/prism#lib/prism/node.rb:19284 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:19281 + # pkg:gem/prism#lib/prism/node.rb:19289 def type; end end end @@ -42710,13 +42845,13 @@ end # while foo do bar end # ^^^^^^^^^^^^^^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:19304 +# pkg:gem/prism#lib/prism/node.rb:19312 class Prism::WhileNode < ::Prism::Node # Initialize a new WhileNode node. # # @return [WhileNode] a new instance of WhileNode # - # pkg:gem/prism#lib/prism/node.rb:19306 + # pkg:gem/prism#lib/prism/node.rb:19314 sig do params( source: Prism::Source, @@ -42735,12 +42870,12 @@ class Prism::WhileNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:19456 + # pkg:gem/prism#lib/prism/node.rb:19464 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:19319 + # pkg:gem/prism#lib/prism/node.rb:19327 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end @@ -42748,43 +42883,43 @@ class Prism::WhileNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:19363 + # pkg:gem/prism#lib/prism/node.rb:19371 sig { returns(T::Boolean) } def begin_modifier?; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19324 + # pkg:gem/prism#lib/prism/node.rb:19332 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:19435 + # pkg:gem/prism#lib/prism/node.rb:19443 sig { returns(T.nilable(String)) } def closing; end # attr_reader closing_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:19400 + # pkg:gem/prism#lib/prism/node.rb:19408 sig { returns(T.nilable(Prism::Location)) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:19345 + # pkg:gem/prism#lib/prism/node.rb:19353 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:19337 + # pkg:gem/prism#lib/prism/node.rb:19345 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?do_keyword_loc: Location?, ?closing_loc: Location?, ?predicate: Prism::node, ?statements: StatementsNode?) -> WhileNode # - # pkg:gem/prism#lib/prism/node.rb:19350 + # pkg:gem/prism#lib/prism/node.rb:19358 sig do params( node_id: Integer, @@ -42802,25 +42937,25 @@ class Prism::WhileNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19355 + # pkg:gem/prism#lib/prism/node.rb:19363 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, do_keyword_loc: Location?, closing_loc: Location?, predicate: Prism::node, statements: StatementsNode? } # - # pkg:gem/prism#lib/prism/node.rb:19358 + # pkg:gem/prism#lib/prism/node.rb:19366 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def do_keyword: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:19430 + # pkg:gem/prism#lib/prism/node.rb:19438 sig { returns(T.nilable(String)) } def do_keyword; end # attr_reader do_keyword_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:19381 + # pkg:gem/prism#lib/prism/node.rb:19389 sig { returns(T.nilable(Prism::Location)) } def do_keyword_loc; end @@ -42828,7 +42963,7 @@ class Prism::WhileNode < ::Prism::Node # # @yield [predicate] # - # pkg:gem/prism#lib/prism/node.rb:19329 + # pkg:gem/prism#lib/prism/node.rb:19337 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -42836,19 +42971,19 @@ class Prism::WhileNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:19440 + # pkg:gem/prism#lib/prism/node.rb:19448 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:19425 + # pkg:gem/prism#lib/prism/node.rb:19433 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:19368 + # pkg:gem/prism#lib/prism/node.rb:19376 sig { returns(Prism::Location) } def keyword_loc; end @@ -42857,44 +42992,44 @@ class Prism::WhileNode < ::Prism::Node # attr_reader predicate: Prism::node # - # pkg:gem/prism#lib/prism/node.rb:19419 + # pkg:gem/prism#lib/prism/node.rb:19427 sig { returns(Prism::Node) } def predicate; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19414 + # pkg:gem/prism#lib/prism/node.rb:19422 def save_closing_loc(repository); end # Save the do_keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19395 + # pkg:gem/prism#lib/prism/node.rb:19403 def save_do_keyword_loc(repository); end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19376 + # pkg:gem/prism#lib/prism/node.rb:19384 def save_keyword_loc(repository); end # attr_reader statements: StatementsNode? # - # pkg:gem/prism#lib/prism/node.rb:19422 + # pkg:gem/prism#lib/prism/node.rb:19430 sig { returns(T.nilable(Prism::StatementsNode)) } def statements; end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:19445 + # pkg:gem/prism#lib/prism/node.rb:19453 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:19450 + # pkg:gem/prism#lib/prism/node.rb:19458 def type; end end end @@ -42904,7 +43039,7 @@ end # `foo` # ^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:19471 +# pkg:gem/prism#lib/prism/node.rb:19479 class Prism::XStringNode < ::Prism::Node include ::Prism::HeredocQuery @@ -42912,7 +43047,7 @@ class Prism::XStringNode < ::Prism::Node # # @return [XStringNode] a new instance of XStringNode # - # pkg:gem/prism#lib/prism/node.rb:19473 + # pkg:gem/prism#lib/prism/node.rb:19481 sig do params( source: Prism::Source, @@ -42930,60 +43065,60 @@ class Prism::XStringNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:19607 + # pkg:gem/prism#lib/prism/node.rb:19615 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:19485 + # pkg:gem/prism#lib/prism/node.rb:19493 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19490 + # pkg:gem/prism#lib/prism/node.rb:19498 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def closing: () -> String # - # pkg:gem/prism#lib/prism/node.rb:19586 + # pkg:gem/prism#lib/prism/node.rb:19594 sig { returns(String) } def closing; end # attr_reader closing_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:19560 + # pkg:gem/prism#lib/prism/node.rb:19568 sig { returns(Prism::Location) } def closing_loc; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:19506 + # pkg:gem/prism#lib/prism/node.rb:19514 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:19501 + # pkg:gem/prism#lib/prism/node.rb:19509 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def content: () -> String # - # pkg:gem/prism#lib/prism/node.rb:19581 + # pkg:gem/prism#lib/prism/node.rb:19589 sig { returns(String) } def content; end # attr_reader content_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:19547 + # pkg:gem/prism#lib/prism/node.rb:19555 sig { returns(Prism::Location) } def content_loc; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?opening_loc: Location, ?content_loc: Location, ?closing_loc: Location, ?unescaped: String) -> XStringNode # - # pkg:gem/prism#lib/prism/node.rb:19511 + # pkg:gem/prism#lib/prism/node.rb:19519 sig do params( node_id: Integer, @@ -43000,19 +43135,19 @@ class Prism::XStringNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19516 + # pkg:gem/prism#lib/prism/node.rb:19524 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, opening_loc: Location, content_loc: Location, closing_loc: Location, unescaped: String } # - # pkg:gem/prism#lib/prism/node.rb:19519 + # pkg:gem/prism#lib/prism/node.rb:19527 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end # def each_child_node: () { (Prism::node) -> void } -> void | () -> Enumerator[Prism::node] # - # pkg:gem/prism#lib/prism/node.rb:19495 + # pkg:gem/prism#lib/prism/node.rb:19503 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -43022,7 +43157,7 @@ class Prism::XStringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:19529 + # pkg:gem/prism#lib/prism/node.rb:19537 sig { returns(T::Boolean) } def forced_binary_encoding?; end @@ -43030,7 +43165,7 @@ class Prism::XStringNode < ::Prism::Node # # @return [Boolean] # - # pkg:gem/prism#lib/prism/node.rb:19524 + # pkg:gem/prism#lib/prism/node.rb:19532 sig { returns(T::Boolean) } def forced_utf8_encoding?; end @@ -43039,38 +43174,38 @@ class Prism::XStringNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:19591 + # pkg:gem/prism#lib/prism/node.rb:19599 sig { override.returns(String) } def inspect; end # def opening: () -> String # - # pkg:gem/prism#lib/prism/node.rb:19576 + # pkg:gem/prism#lib/prism/node.rb:19584 sig { returns(String) } def opening; end # attr_reader opening_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:19534 + # pkg:gem/prism#lib/prism/node.rb:19542 sig { returns(Prism::Location) } def opening_loc; end # Save the closing_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19568 + # pkg:gem/prism#lib/prism/node.rb:19576 def save_closing_loc(repository); end # Save the content_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19555 + # pkg:gem/prism#lib/prism/node.rb:19563 def save_content_loc(repository); end # Save the opening_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19542 + # pkg:gem/prism#lib/prism/node.rb:19550 def save_opening_loc(repository); end # Occasionally it's helpful to treat a string as if it were interpolated so @@ -43082,20 +43217,20 @@ class Prism::XStringNode < ::Prism::Node # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:19596 + # pkg:gem/prism#lib/prism/node.rb:19604 sig { override.returns(Symbol) } def type; end # attr_reader unescaped: String # - # pkg:gem/prism#lib/prism/node.rb:19573 + # pkg:gem/prism#lib/prism/node.rb:19581 sig { returns(String) } def unescaped; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:19601 + # pkg:gem/prism#lib/prism/node.rb:19609 def type; end end end @@ -43105,13 +43240,13 @@ end # yield 1 # ^^^^^^^ # -# pkg:gem/prism#lib/prism/node.rb:19621 +# pkg:gem/prism#lib/prism/node.rb:19629 class Prism::YieldNode < ::Prism::Node # Initialize a new YieldNode node. # # @return [YieldNode] a new instance of YieldNode # - # pkg:gem/prism#lib/prism/node.rb:19623 + # pkg:gem/prism#lib/prism/node.rb:19631 sig do params( source: Prism::Source, @@ -43129,42 +43264,42 @@ class Prism::YieldNode < ::Prism::Node # Implements case-equality for the node. This is effectively == but without # comparing the value of locations. Locations are checked only for presence. # - # pkg:gem/prism#lib/prism/node.rb:19762 + # pkg:gem/prism#lib/prism/node.rb:19770 def ===(other); end # def accept: (Visitor visitor) -> void # - # pkg:gem/prism#lib/prism/node.rb:19635 + # pkg:gem/prism#lib/prism/node.rb:19643 sig { override.params(visitor: Prism::Visitor).returns(T.untyped) } def accept(visitor); end # attr_reader arguments: ArgumentsNode? # - # pkg:gem/prism#lib/prism/node.rb:19709 + # pkg:gem/prism#lib/prism/node.rb:19717 sig { returns(T.nilable(Prism::ArgumentsNode)) } def arguments; end # def child_nodes: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19640 + # pkg:gem/prism#lib/prism/node.rb:19648 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def child_nodes; end # def comment_targets: () -> Array[Node | Location] # - # pkg:gem/prism#lib/prism/node.rb:19659 + # pkg:gem/prism#lib/prism/node.rb:19667 sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) } def comment_targets; end # def compact_child_nodes: () -> Array[Node] # - # pkg:gem/prism#lib/prism/node.rb:19652 + # pkg:gem/prism#lib/prism/node.rb:19660 sig { override.returns(T::Array[Prism::Node]) } def compact_child_nodes; end # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?) -> YieldNode # - # pkg:gem/prism#lib/prism/node.rb:19664 + # pkg:gem/prism#lib/prism/node.rb:19672 sig do params( node_id: Integer, @@ -43181,13 +43316,13 @@ class Prism::YieldNode < ::Prism::Node # def child_nodes: () -> Array[Node?] # def deconstruct: () -> Array[Node?] # - # pkg:gem/prism#lib/prism/node.rb:19669 + # pkg:gem/prism#lib/prism/node.rb:19677 sig { override.returns(T::Array[T.nilable(Prism::Node)]) } def deconstruct; end # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location? } # - # pkg:gem/prism#lib/prism/node.rb:19672 + # pkg:gem/prism#lib/prism/node.rb:19680 sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) } def deconstruct_keys(keys); end @@ -43195,7 +43330,7 @@ class Prism::YieldNode < ::Prism::Node # # @yield [arguments] # - # pkg:gem/prism#lib/prism/node.rb:19645 + # pkg:gem/prism#lib/prism/node.rb:19653 def each_child_node; end sig { override.returns(T::Array[Prism::Reflection::Field]) } @@ -43203,74 +43338,74 @@ class Prism::YieldNode < ::Prism::Node # def inspect -> String # - # pkg:gem/prism#lib/prism/node.rb:19746 + # pkg:gem/prism#lib/prism/node.rb:19754 sig { override.returns(String) } def inspect; end # def keyword: () -> String # - # pkg:gem/prism#lib/prism/node.rb:19731 + # pkg:gem/prism#lib/prism/node.rb:19739 sig { returns(String) } def keyword; end # attr_reader keyword_loc: Location # - # pkg:gem/prism#lib/prism/node.rb:19677 + # pkg:gem/prism#lib/prism/node.rb:19685 sig { returns(Prism::Location) } def keyword_loc; end # def lparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:19736 + # pkg:gem/prism#lib/prism/node.rb:19744 sig { returns(T.nilable(String)) } def lparen; end # attr_reader lparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:19690 + # pkg:gem/prism#lib/prism/node.rb:19698 sig { returns(T.nilable(Prism::Location)) } def lparen_loc; end # def rparen: () -> String? # - # pkg:gem/prism#lib/prism/node.rb:19741 + # pkg:gem/prism#lib/prism/node.rb:19749 sig { returns(T.nilable(String)) } def rparen; end # attr_reader rparen_loc: Location? # - # pkg:gem/prism#lib/prism/node.rb:19712 + # pkg:gem/prism#lib/prism/node.rb:19720 sig { returns(T.nilable(Prism::Location)) } def rparen_loc; end # Save the keyword_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19685 + # pkg:gem/prism#lib/prism/node.rb:19693 def save_keyword_loc(repository); end # Save the lparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19704 + # pkg:gem/prism#lib/prism/node.rb:19712 def save_lparen_loc(repository); end # Save the rparen_loc location using the given saved source so that # it can be retrieved later. # - # pkg:gem/prism#lib/prism/node.rb:19726 + # pkg:gem/prism#lib/prism/node.rb:19734 def save_rparen_loc(repository); end # Return a symbol representation of this node type. See `Node#type`. # - # pkg:gem/prism#lib/prism/node.rb:19751 + # pkg:gem/prism#lib/prism/node.rb:19759 sig { override.returns(Symbol) } def type; end class << self # Return a symbol representation of this node type. See `Node::type`. # - # pkg:gem/prism#lib/prism/node.rb:19756 + # pkg:gem/prism#lib/prism/node.rb:19764 def type; end end end diff --git a/sorbet/rbi/gems/rbs@4.0.0.dev.4.rbi b/sorbet/rbi/gems/rbs@4.0.0.dev.5.rbi similarity index 85% rename from sorbet/rbi/gems/rbs@4.0.0.dev.4.rbi rename to sorbet/rbi/gems/rbs@4.0.0.dev.5.rbi index 2c1c07a39..88cfd592c 100644 --- a/sorbet/rbi/gems/rbs@4.0.0.dev.4.rbi +++ b/sorbet/rbi/gems/rbs@4.0.0.dev.5.rbi @@ -1072,6 +1072,32 @@ module RBS::AST::Ruby; end # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:6 module RBS::AST::Ruby::Annotations; end +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:43 +class RBS::AST::Ruby::Annotations::AliasAnnotation < ::RBS::AST::Ruby::Annotations::Base + # @return [AliasAnnotation] a new instance of AliasAnnotation + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:46 + def initialize(location:, prefix_location:, keyword_location:, type_name:, type_name_location:); end + + # Returns the value of attribute keyword_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:44 + def keyword_location; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:53 + def map_type_name; end + + # Returns the value of attribute type_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:44 + def type_name; end + + # Returns the value of attribute type_name_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:44 + def type_name_location; end +end + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:7 class RBS::AST::Ruby::Annotations::Base # @return [Base] a new instance of Base @@ -1093,51 +1119,108 @@ class RBS::AST::Ruby::Annotations::Base def prefix_location; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:36 +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:64 +class RBS::AST::Ruby::Annotations::ClassAliasAnnotation < ::RBS::AST::Ruby::Annotations::AliasAnnotation + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:65 + def type_fingerprint; end +end + +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:82 class RBS::AST::Ruby::Annotations::ColonMethodTypeAnnotation < ::RBS::AST::Ruby::Annotations::Base # @return [ColonMethodTypeAnnotation] a new instance of ColonMethodTypeAnnotation # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:39 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:85 def initialize(location:, prefix_location:, annotations:, method_type:); end # Returns the value of attribute annotations. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:37 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:83 def annotations; end - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:45 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:91 def map_type_name; end # Returns the value of attribute method_type. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:37 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:83 def method_type; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:100 + def type_fingerprint; end +end + +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:220 +class RBS::AST::Ruby::Annotations::InstanceVariableAnnotation < ::RBS::AST::Ruby::Annotations::Base + # @return [InstanceVariableAnnotation] a new instance of InstanceVariableAnnotation + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:223 + def initialize(location:, prefix_location:, ivar_name:, ivar_name_location:, colon_location:, type:, comment_location:); end + + # Returns the value of attribute colon_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:221 + def colon_location; end + + # Returns the value of attribute comment_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:221 + def comment_location; end + + # Returns the value of attribute ivar_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:221 + def ivar_name; end + + # Returns the value of attribute ivar_name_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:221 + def ivar_name_location; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:232 + def map_type_name(&block); end + + # Returns the value of attribute type. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:221 + def type; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:244 + def type_fingerprint; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:55 +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:109 class RBS::AST::Ruby::Annotations::MethodTypesAnnotation < ::RBS::AST::Ruby::Annotations::Base # @return [MethodTypesAnnotation] a new instance of MethodTypesAnnotation # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:60 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:114 def initialize(location:, prefix_location:, overloads:, vertical_bar_locations:); end - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:66 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:120 def map_type_name(&block); end # Returns the value of attribute overloads. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:58 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:112 def overloads; end + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:131 + def type_fingerprint; end + # Returns the value of attribute vertical_bar_locations. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:58 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:112 def vertical_bar_locations; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:56 +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:110 RBS::AST::Ruby::Annotations::MethodTypesAnnotation::Overload = RBS::AST::Members::MethodDefinition::Overload +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:73 +class RBS::AST::Ruby::Annotations::ModuleAliasAnnotation < ::RBS::AST::Ruby::Annotations::AliasAnnotation + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:74 + def type_fingerprint; end +end + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:20 class RBS::AST::Ruby::Annotations::NodeTypeAssertion < ::RBS::AST::Ruby::Annotations::Base # @return [NodeTypeAssertion] a new instance of NodeTypeAssertion @@ -1152,55 +1235,93 @@ class RBS::AST::Ruby::Annotations::NodeTypeAssertion < ::RBS::AST::Ruby::Annotat # # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:21 def type; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:35 + def type_fingerprint; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:88 +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:153 class RBS::AST::Ruby::Annotations::ReturnTypeAnnotation < ::RBS::AST::Ruby::Annotations::Base # @return [ReturnTypeAnnotation] a new instance of ReturnTypeAnnotation # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:97 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:162 def initialize(location:, prefix_location:, return_location:, colon_location:, return_type:, comment_location:); end # Returns the value of attribute colon_location. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:91 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:156 def colon_location; end # Returns the value of attribute comment_location. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:95 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:160 def comment_location; end - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:105 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:170 def map_type_name(&block); end # Returns the value of attribute return_location. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:89 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:154 def return_location; end # Returns the value of attribute return_type. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:93 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:158 def return_type; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:181 + def type_fingerprint; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:78 +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:139 class RBS::AST::Ruby::Annotations::SkipAnnotation < ::RBS::AST::Ruby::Annotations::Base # @return [SkipAnnotation] a new instance of SkipAnnotation # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:81 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:142 def initialize(location:, prefix_location:, skip_location:, comment_location:); end # Returns the value of attribute comment_location. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:79 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:140 def comment_location; end # Returns the value of attribute skip_location. # - # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:79 + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:140 def skip_location; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:148 + def type_fingerprint; end +end + +# pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:190 +class RBS::AST::Ruby::Annotations::TypeApplicationAnnotation < ::RBS::AST::Ruby::Annotations::Base + # @return [TypeApplicationAnnotation] a new instance of TypeApplicationAnnotation + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:193 + def initialize(location:, prefix_location:, type_args:, close_bracket_location:, comma_locations:); end + + # Returns the value of attribute close_bracket_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:191 + def close_bracket_location; end + + # Returns the value of attribute comma_locations. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:191 + def comma_locations; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:200 + def map_type_name(&block); end + + # Returns the value of attribute type_args. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:191 + def type_args; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/annotations.rb:212 + def type_fingerprint; end end # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:6 @@ -1210,12 +1331,15 @@ class RBS::AST::Ruby::CommentBlock # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:9 def initialize(source_buffer, comments); end + # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:226 + def as_comment; end + # Returns the value of attribute comment_buffer. # # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:7 def comment_buffer; end - # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:204 + # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:211 def comments; end # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:98 @@ -1231,7 +1355,7 @@ class RBS::AST::Ruby::CommentBlock # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:208 + # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:215 def leading_annotation?(index); end # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:174 @@ -1240,6 +1364,9 @@ class RBS::AST::Ruby::CommentBlock # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:54 def line_starts; end + # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:180 + def location; end + # Returns the value of attribute name. # # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:7 @@ -1250,7 +1377,7 @@ class RBS::AST::Ruby::CommentBlock # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:7 def offsets; end - # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:180 + # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:187 def parse_annotation_lines(start_line, end_line, variables); end # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:46 @@ -1264,7 +1391,7 @@ class RBS::AST::Ruby::CommentBlock # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:41 def trailing?; end - # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:190 + # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:197 def trailing_annotation(variables); end # pkg:gem/rbs#lib/rbs/ast/ruby/comment_block.rb:130 @@ -1334,69 +1461,219 @@ end class RBS::AST::Ruby::Declarations::ClassDecl < ::RBS::AST::Ruby::Declarations::Base # @return [ClassDecl] a new instance of ClassDecl # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:25 - def initialize(buffer, name, node); end + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:74 + def initialize(buffer, name, node, super_class); end # Returns the value of attribute class_name. # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:19 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:66 def class_name; end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:32 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:82 def each_decl(&block); end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:46 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:94 def location; end # Returns the value of attribute members. # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:21 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:68 def members; end + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:98 + def name_location; end + # Returns the value of attribute node. # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:23 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:70 def node; end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:42 + # Returns the value of attribute super_class. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:72 def super_class; end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:44 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:102 + def type_fingerprint; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:92 def type_params; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:51 +# pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:19 +class RBS::AST::Ruby::Declarations::ClassDecl::SuperClass + # @return [SuperClass] a new instance of SuperClass + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:28 + def initialize(type_name_location, operator_location, type_name, type_annotation); end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:56 + def args; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:43 + def location; end + + # Returns the value of attribute type_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:55 + def name; end + + # Returns the value of attribute operator_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:22 + def operator_location; end + + # Returns the value of attribute type_annotation. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:26 + def type_annotation; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:35 + def type_args; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:58 + def type_fingerprint; end + + # Returns the value of attribute type_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:24 + def type_name; end + + # Returns the value of attribute type_name_location. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:20 + def type_name_location; end +end + +# pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:223 +class RBS::AST::Ruby::Declarations::ClassModuleAliasDecl < ::RBS::AST::Ruby::Declarations::Base + # @return [ClassModuleAliasDecl] a new instance of ClassModuleAliasDecl + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:230 + def initialize(buffer, node, new_name, infered_old_name, leading_comment, annotation); end + + # Returns the value of attribute annotation. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:228 + def annotation; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:264 + def comment; end + + # Returns the value of attribute infered_old_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:227 + def infered_old_name; end + + # Returns the value of attribute leading_comment. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:225 + def leading_comment; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:239 + def location; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:243 + def name_location; end + + # Returns the value of attribute new_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:226 + def new_name; end + + # Returns the value of attribute node. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:224 + def node; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:252 + def old_name; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:268 + def type_fingerprint; end +end + +# pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:161 +class RBS::AST::Ruby::Declarations::ConstantDecl < ::RBS::AST::Ruby::Declarations::Base + # @return [ConstantDecl] a new instance of ConstantDecl + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:167 + def initialize(buffer, constant_name, node, leading_comment, type_annotation); end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:209 + def comment; end + + # Returns the value of attribute constant_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:163 + def constant_name; end + + # Returns the value of attribute leading_comment. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:162 + def leading_comment; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:175 + def location; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:179 + def name_location; end + + # Returns the value of attribute node. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:164 + def node; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:188 + def type; end + + # Returns the value of attribute type_annotation. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:165 + def type_annotation; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:213 + def type_fingerprint; end +end + +# pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:114 class RBS::AST::Ruby::Declarations::ModuleDecl < ::RBS::AST::Ruby::Declarations::Base # @return [ModuleDecl] a new instance of ModuleDecl # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:58 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:121 def initialize(buffer, name, node); end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:65 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:128 def each_decl(&block); end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:79 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:142 def location; end # Returns the value of attribute members. # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:54 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:117 def members; end # Returns the value of attribute module_name. # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:52 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:115 def module_name; end + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:146 + def name_location; end + # Returns the value of attribute node. # - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:56 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:119 def node; end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:77 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:140 def self_types; end - # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:75 + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:150 + def type_fingerprint; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/declarations.rb:138 def type_params; end end @@ -1425,6 +1702,58 @@ end # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:6 module RBS::AST::Ruby::Members; end +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:338 +class RBS::AST::Ruby::Members::AttrAccessorMember < ::RBS::AST::Ruby::Members::AttributeMember; end + +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:332 +class RBS::AST::Ruby::Members::AttrReaderMember < ::RBS::AST::Ruby::Members::AttributeMember; end + +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:335 +class RBS::AST::Ruby::Members::AttrWriterMember < ::RBS::AST::Ruby::Members::AttributeMember; end + +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:287 +class RBS::AST::Ruby::Members::AttributeMember < ::RBS::AST::Ruby::Members::Base + # @return [AttributeMember] a new instance of AttributeMember + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:293 + def initialize(buffer, node, name_nodes, leading_comment, type_annotation); end + + # Returns the value of attribute leading_comment. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:291 + def leading_comment; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:307 + def location; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:311 + def name_locations; end + + # Returns the value of attribute name_nodes. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:289 + def name_nodes; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:301 + def names; end + + # Returns the value of attribute node. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:288 + def node; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:317 + def type; end + + # Returns the value of attribute type_annotation. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:290 + def type_annotation; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:321 + def type_fingerprint; end +end + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:7 class RBS::AST::Ruby::Members::Base include ::RBS::AST::Ruby::Helpers::LocationHelper @@ -1440,71 +1769,116 @@ class RBS::AST::Ruby::Members::Base def buffer; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:180 +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:195 class RBS::AST::Ruby::Members::DefMember < ::RBS::AST::Ruby::Members::Base # @return [DefMember] a new instance of DefMember # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:187 - def initialize(buffer, name, node, method_type); end + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:203 + def initialize(buffer, name, node, method_type, leading_comment); end - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:206 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:223 def annotations; end - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:194 + # Returns the value of attribute leading_comment. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:201 + def leading_comment; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:211 def location; end # Returns the value of attribute method_type. # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:185 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:200 def method_type; end # Returns the value of attribute name. # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:183 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:198 def name; end + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:227 + def name_location; end + # Returns the value of attribute node. # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:184 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:199 def node; end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:202 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:219 def overloading?; end - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:198 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:215 def overloads; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:231 + def type_fingerprint; end end -# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:181 +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:196 RBS::AST::Ruby::Members::DefMember::Overload = RBS::AST::Members::MethodDefinition::Overload +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:281 +class RBS::AST::Ruby::Members::ExtendMember < ::RBS::AST::Ruby::Members::MixinMember; end + +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:278 +class RBS::AST::Ruby::Members::IncludeMember < ::RBS::AST::Ruby::Members::MixinMember; end + +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:341 +class RBS::AST::Ruby::Members::InstanceVariableMember < ::RBS::AST::Ruby::Members::Base + # @return [InstanceVariableMember] a new instance of InstanceVariableMember + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:344 + def initialize(buffer, annotation); end + + # Returns the value of attribute annotation. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:342 + def annotation; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:357 + def location; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:349 + def name; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:353 + def type; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:361 + def type_fingerprint; end +end + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:17 class RBS::AST::Ruby::Members::MethodTypeAnnotation # @return [MethodTypeAnnotation] a new instance of MethodTypeAnnotation # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:64 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:68 def initialize(type_annotations:); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:139 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:143 def empty?; end - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:68 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:72 def map_type_name(&block); end - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:143 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:147 def overloads; end # Returns the value of attribute type_annotations. # - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:62 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:66 def type_annotations; end + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:183 + def type_fingerprint; end + class << self - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:81 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:85 def build(leading_block, trailing_block, variables); end end end @@ -1519,7 +1893,7 @@ class RBS::AST::Ruby::Members::MethodTypeAnnotation::DocStyle # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:25 def map_type_name(&block); end - # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:31 + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:35 def method_type; end # Returns the value of attribute return_type_annotation. @@ -1533,16 +1907,57 @@ class RBS::AST::Ruby::Members::MethodTypeAnnotation::DocStyle # # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:19 def return_type_annotation=(_arg0); end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:31 + def type_fingerprint; end +end + +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:241 +class RBS::AST::Ruby::Members::MixinMember < ::RBS::AST::Ruby::Members::Base + # @return [MixinMember] a new instance of MixinMember + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:246 + def initialize(buffer, node, module_name, annotation); end + + # Returns the value of attribute annotation. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:244 + def annotation; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:253 + def location; end + + # Returns the value of attribute module_name. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:243 + def module_name; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:257 + def name_location; end + + # Returns the value of attribute node. + # + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:242 + def node; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:264 + def type_args; end + + # pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:268 + def type_fingerprint; end end +# pkg:gem/rbs#lib/rbs/ast/ruby/members.rb:284 +class RBS::AST::Ruby::Members::PrependMember < ::RBS::AST::Ruby::Members::MixinMember; end + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:5 class RBS::AST::TypeParam # @return [TypeParam] a new instance of TypeParam # # pkg:gem/rbs#lib/rbs/ast/type_param.rb:8 - def initialize(name:, variance:, upper_bound:, location:, default_type: T.unsafe(nil), unchecked: T.unsafe(nil)); end + def initialize(name:, variance:, upper_bound:, lower_bound:, location:, default_type: T.unsafe(nil), unchecked: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:33 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:41 def ==(other); end # Returns the value of attribute default_type. @@ -1550,10 +1965,10 @@ class RBS::AST::TypeParam # pkg:gem/rbs#lib/rbs/ast/type_param.rb:6 def default_type; end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:42 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:51 def eql?(other); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:44 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:53 def hash; end # Returns the value of attribute location. @@ -1561,7 +1976,15 @@ class RBS::AST::TypeParam # pkg:gem/rbs#lib/rbs/ast/type_param.rb:6 def location; end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:59 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:25 + def lower_bound; end + + # Returns the value of attribute lower_bound_type. + # + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:6 + def lower_bound_type; end + + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:69 def map_type(&block); end # Returns the value of attribute name. @@ -1569,21 +1992,21 @@ class RBS::AST::TypeParam # pkg:gem/rbs#lib/rbs/ast/type_param.rb:6 def name; end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:48 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:57 def to_json(state = T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:117 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:133 def to_s; end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:24 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:32 def unchecked!(value = T.unsafe(nil)); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:29 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:37 def unchecked?; end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:17 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:18 def upper_bound; end # Returns the value of attribute upper_bound_type. @@ -1597,22 +2020,22 @@ class RBS::AST::TypeParam def variance; end class << self - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:146 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:166 def application(params, args); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:178 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:198 def normalize_args(params, args); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:99 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:114 def rename(params, new_names:); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:77 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:92 def resolve_variables(params); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:87 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:102 def subst_var(vars, type); end - # pkg:gem/rbs#lib/rbs/ast/type_param.rb:199 + # pkg:gem/rbs#lib/rbs/ast/type_param.rb:219 def validate(type_params); end end end @@ -1816,7 +2239,7 @@ class RBS::Buffer # pkg:gem/rbs#lib/rbs/buffer.rb:9 def initialize(content:, name: T.unsafe(nil), parent: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/buffer.rb:126 + # pkg:gem/rbs#lib/rbs/buffer.rb:131 def absolute_position(position); end # Returns the value of attribute content. @@ -1824,13 +2247,13 @@ class RBS::Buffer # pkg:gem/rbs#lib/rbs/buffer.rb:6 def content; end - # pkg:gem/rbs#lib/rbs/buffer.rb:143 + # pkg:gem/rbs#lib/rbs/buffer.rb:148 def detach; end - # pkg:gem/rbs#lib/rbs/buffer.rb:81 + # pkg:gem/rbs#lib/rbs/buffer.rb:86 def inspect; end - # pkg:gem/rbs#lib/rbs/buffer.rb:73 + # pkg:gem/rbs#lib/rbs/buffer.rb:78 def last_position; end # pkg:gem/rbs#lib/rbs/buffer.rb:26 @@ -1839,7 +2262,7 @@ class RBS::Buffer # pkg:gem/rbs#lib/rbs/buffer.rb:22 def lines; end - # pkg:gem/rbs#lib/rbs/buffer.rb:63 + # pkg:gem/rbs#lib/rbs/buffer.rb:68 def loc_to_pos(loc); end # Returns the value of attribute name. @@ -1852,25 +2275,25 @@ class RBS::Buffer # pkg:gem/rbs#lib/rbs/buffer.rb:7 def parent; end - # pkg:gem/rbs#lib/rbs/buffer.rb:111 + # pkg:gem/rbs#lib/rbs/buffer.rb:116 def parent_buffer; end - # pkg:gem/rbs#lib/rbs/buffer.rb:117 + # pkg:gem/rbs#lib/rbs/buffer.rb:122 def parent_position(position); end - # pkg:gem/rbs#lib/rbs/buffer.rb:51 + # pkg:gem/rbs#lib/rbs/buffer.rb:56 def pos_to_loc(pos); end # pkg:gem/rbs#lib/rbs/buffer.rb:30 def ranges; end - # pkg:gem/rbs#lib/rbs/buffer.rb:85 + # pkg:gem/rbs#lib/rbs/buffer.rb:90 def rbs_location(location, loc2 = T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/buffer.rb:93 + # pkg:gem/rbs#lib/rbs/buffer.rb:98 def sub_buffer(lines:); end - # pkg:gem/rbs#lib/rbs/buffer.rb:135 + # pkg:gem/rbs#lib/rbs/buffer.rb:140 def top_buffer; end end @@ -2172,61 +2595,61 @@ end class RBS::Collection::Config::LockfileGenerator # @return [LockfileGenerator] a new instance of LockfileGenerator # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:43 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:44 def initialize(config:, definition:, with_lockfile:); end # Returns the value of attribute config. # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:35 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:36 def config; end # Returns the value of attribute definition. # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:35 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:36 def definition; end # Returns the value of attribute existing_lockfile. # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:35 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:36 def existing_lockfile; end # Returns the value of attribute gem_entries. # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:35 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:36 def gem_entries; end # Returns the value of attribute gem_hash. # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:35 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:36 def gem_hash; end - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:71 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:72 def generate; end # Returns the value of attribute lockfile. # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:35 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:36 def lockfile; end private - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:104 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:105 def assign_gem(name:, version:, skip: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:170 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:171 def assign_stdlib(name:, from_gem: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:234 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:242 def find_best_version(version:, versions:); end - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:228 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:236 def find_source(name:); end - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:96 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:97 def validate_gemfile_lock_path!(lock:, gemfile_lock_path:); end class << self - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:37 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:38 def generate(config:, definition:, with_lockfile: T.unsafe(nil)); end end end @@ -2234,14 +2657,14 @@ end # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:7 RBS::Collection::Config::LockfileGenerator::ALUMNI_STDLIBS = T.let(T.unsafe(nil), Hash) -# pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:19 +# pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:20 class RBS::Collection::Config::LockfileGenerator::GemfileLockMismatchError < ::StandardError # @return [GemfileLockMismatchError] a new instance of GemfileLockMismatchError # - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:20 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:21 def initialize(expected:, actual:); end - # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:25 + # pkg:gem/rbs#lib/rbs/collection/config/lockfile_generator.rb:26 def message; end end @@ -2283,113 +2706,113 @@ module RBS::Collection::Sources::Base def dependencies_of(name, version); end end -# pkg:gem/rbs#lib/rbs/collection/sources/git.rb:10 +# pkg:gem/rbs#lib/rbs/collection/sources/git.rb:11 class RBS::Collection::Sources::Git include ::RBS::Collection::Sources::Base # @return [Git] a new instance of Git # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:18 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:19 def initialize(name:, revision:, remote:, repo_dir:); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:26 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:27 def has?(name, version); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:43 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:44 def install(dest:, name:, version:, stdout:); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:223 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:224 def load_metadata(dir:); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:73 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:74 def manifest_of(name, version); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:207 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:208 def metadata_content(name:, version:); end # Returns the value of attribute name. # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:16 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:17 def name; end # Returns the value of attribute remote. # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:16 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:17 def remote; end # Returns the value of attribute repo_dir. # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:16 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:17 def repo_dir; end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:172 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:173 def resolved_revision; end # Returns the value of attribute revision. # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:16 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:17 def revision; end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:113 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:114 def to_lockfile; end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:36 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:37 def versions(name); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:215 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:216 def write_metadata(dir:, name:, version:); end private - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:87 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:88 def _install(dest:, name:, version:); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:183 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:184 def commit_hash?; end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:99 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:100 def cp_r(src, dest); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:123 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:124 def format_config_entry(name, version); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:168 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:169 def gem_repo_dir; end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:229 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:230 def gems_versions; end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:187 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:188 def git(*cmd, **opt); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:191 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:192 def git?(*cmd, **opt); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:158 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:159 def git_dir; end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:152 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:153 def need_to_fetch?(revision); end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:130 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:131 def setup!; end - # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:197 + # pkg:gem/rbs#lib/rbs/collection/sources/git.rb:198 def sh!(*cmd, **opt); end end -# pkg:gem/rbs#lib/rbs/collection/sources/git.rb:14 +# pkg:gem/rbs#lib/rbs/collection/sources/git.rb:15 class RBS::Collection::Sources::Git::CommandError < ::StandardError; end -# pkg:gem/rbs#lib/rbs/collection/sources/git.rb:12 +# pkg:gem/rbs#lib/rbs/collection/sources/git.rb:13 RBS::Collection::Sources::Git::METADATA_FILENAME = T.let(T.unsafe(nil), String) # pkg:gem/rbs#lib/rbs/collection/sources/local.rb:6 @@ -2557,51 +2980,51 @@ class RBS::Constant def type; end end -# pkg:gem/rbs#lib/rbs/errors.rb:578 +# pkg:gem/rbs#lib/rbs/errors.rb:598 class RBS::CyclicClassAliasDefinitionError < ::RBS::BaseError include ::RBS::DetailedMessageable # @return [CyclicClassAliasDefinitionError] a new instance of CyclicClassAliasDefinitionError # - # pkg:gem/rbs#lib/rbs/errors.rb:583 + # pkg:gem/rbs#lib/rbs/errors.rb:603 def initialize(entry); end # Returns the value of attribute alias_entry. # - # pkg:gem/rbs#lib/rbs/errors.rb:581 + # pkg:gem/rbs#lib/rbs/errors.rb:601 def alias_entry; end - # pkg:gem/rbs#lib/rbs/errors.rb:589 + # pkg:gem/rbs#lib/rbs/errors.rb:609 def location; end end -# pkg:gem/rbs#lib/rbs/errors.rb:539 +# pkg:gem/rbs#lib/rbs/errors.rb:559 class RBS::CyclicTypeParameterBound < ::RBS::BaseError include ::RBS::DetailedMessageable # @return [CyclicTypeParameterBound] a new instance of CyclicTypeParameterBound # - # pkg:gem/rbs#lib/rbs/errors.rb:544 + # pkg:gem/rbs#lib/rbs/errors.rb:564 def initialize(type_name:, method_name:, params:, location:); end # Returns the value of attribute location. # - # pkg:gem/rbs#lib/rbs/errors.rb:542 + # pkg:gem/rbs#lib/rbs/errors.rb:562 def location; end # Returns the value of attribute method_name. # - # pkg:gem/rbs#lib/rbs/errors.rb:542 + # pkg:gem/rbs#lib/rbs/errors.rb:562 def method_name; end # Returns the value of attribute params. # - # pkg:gem/rbs#lib/rbs/errors.rb:542 + # pkg:gem/rbs#lib/rbs/errors.rb:562 def params; end # Returns the value of attribute type_name. # - # pkg:gem/rbs#lib/rbs/errors.rb:542 + # pkg:gem/rbs#lib/rbs/errors.rb:562 def type_name; end end @@ -2995,18 +3418,18 @@ class RBS::DefinitionBuilder # pkg:gem/rbs#lib/rbs/definition_builder.rb:6 def ancestor_builder; end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:172 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:195 def build_instance(type_name); end # pkg:gem/rbs#lib/rbs/definition_builder.rb:43 def build_interface(type_name); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:304 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:327 def build_singleton(type_name); end # Builds a definition for singleton without .new method. # - # pkg:gem/rbs#lib/rbs/definition_builder.rb:234 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:257 def build_singleton0(type_name); end # pkg:gem/rbs#lib/rbs/definition_builder.rb:85 @@ -3015,7 +3438,7 @@ class RBS::DefinitionBuilder # pkg:gem/rbs#lib/rbs/definition_builder.rb:33 def define_interface(definition, type_name, subst); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:646 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:682 def define_method(methods, definition, method, subst, self_type_methods, defined_in:, implemented_in: T.unsafe(nil)); end # pkg:gem/rbs#lib/rbs/definition_builder.rb:25 @@ -3026,19 +3449,19 @@ class RBS::DefinitionBuilder # pkg:gem/rbs#lib/rbs/definition_builder.rb:5 def env; end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:861 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:950 def expand_alias(type_name); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:865 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:954 def expand_alias1(type_name); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:872 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:961 def expand_alias2(type_name, args); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:585 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:621 def import_methods(definition, module_name, module_methods, interfaces_methods, subst, self_type_methods); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:547 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:570 def insert_variable(type_name, variables, name:, type:, source:); end # Returns the value of attribute instance_cache. @@ -3051,7 +3474,7 @@ class RBS::DefinitionBuilder # pkg:gem/rbs#lib/rbs/definition_builder.rb:12 def interface_cache; end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:417 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:440 def interface_methods(interface_ancestors); end # Returns the value of attribute method_builder. @@ -3069,33 +3492,33 @@ class RBS::DefinitionBuilder # pkg:gem/rbs#lib/rbs/definition_builder.rb:10 def singleton_cache; end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:447 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:470 def source_location(source, decl); end # pkg:gem/rbs#lib/rbs/definition_builder.rb:66 def tapp_subst(name, args); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:857 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:946 def try_cache(type_name, cache:); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:896 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:985 def update(env:, except:, ancestor_builder:); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:437 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:460 def validate_params_with(type_params, result:); end # @raise [NoTypeFoundError] # - # pkg:gem/rbs#lib/rbs/definition_builder.rb:925 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:1014 def validate_type_name(name, location); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:465 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:488 def validate_type_params(definition, ancestors:, methods:); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:914 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:1003 def validate_type_presence(type); end - # pkg:gem/rbs#lib/rbs/definition_builder.rb:557 + # pkg:gem/rbs#lib/rbs/definition_builder.rb:581 def validate_variable(var); end end @@ -3111,10 +3534,10 @@ class RBS::DefinitionBuilder::AncestorBuilder # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:151 def env; end - # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:611 + # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:664 def fill_ancestor_source(ancestor, name:, source:, &block); end - # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:439 + # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:492 def instance_ancestors(type_name, building_ancestors: T.unsafe(nil)); end # Returns the value of attribute instance_ancestors_cache. @@ -3122,7 +3545,7 @@ class RBS::DefinitionBuilder::AncestorBuilder # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:154 def instance_ancestors_cache; end - # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:575 + # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:628 def interface_ancestors(type_name, building_ancestors: T.unsafe(nil)); end # Returns the value of attribute interface_ancestors_cache. @@ -3130,7 +3553,7 @@ class RBS::DefinitionBuilder::AncestorBuilder # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:160 def interface_ancestors_cache; end - # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:421 + # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:474 def mixin_ancestors(entry, type_name, included_modules:, included_interfaces:, extended_modules:, prepended_modules:, extended_interfaces:); end # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:350 @@ -3160,7 +3583,7 @@ class RBS::DefinitionBuilder::AncestorBuilder # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:156 def one_singleton_ancestors_cache; end - # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:520 + # pkg:gem/rbs#lib/rbs/definition_builder/ancestor_builder.rb:573 def singleton_ancestors(type_name, building_ancestors: T.unsafe(nil)); end # Returns the value of attribute singleton_ancestors_cache. @@ -3269,25 +3692,28 @@ class RBS::DefinitionBuilder::MethodBuilder # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:91 def initialize(env:); end - # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:209 + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:211 def build_alias(methods, type, member:); end - # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:214 + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:216 def build_attribute(methods, type, member:, accessibility:); end # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:99 def build_instance(type_name); end - # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:189 + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:191 def build_interface(type_name); end - # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:230 + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:250 def build_method(methods, type, member:, accessibility:); end - # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:160 + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:232 + def build_ruby_attribute(methods, type, member:, accessibility:); end + + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:162 def build_singleton(type_name); end - # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:241 + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:261 def each_rbs_member_with_accessibility(members, accessibility: T.unsafe(nil)); end # Returns the value of attribute env. @@ -3310,7 +3736,7 @@ class RBS::DefinitionBuilder::MethodBuilder # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:88 def singleton_methods; end - # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:254 + # pkg:gem/rbs#lib/rbs/definition_builder/method_builder.rb:274 def update(env:, except:); end end @@ -3403,7 +3829,7 @@ class RBS::Diff # pkg:gem/rbs#lib/rbs/diff.rb:49 def build_methods(path); end - # pkg:gem/rbs#lib/rbs/diff.rb:116 + # pkg:gem/rbs#lib/rbs/diff.rb:122 def constant_to_s(constant); end # pkg:gem/rbs#lib/rbs/diff.rb:100 @@ -3512,19 +3938,19 @@ class RBS::Environment # pkg:gem/rbs#lib/rbs/environment.rb:48 def initialize; end - # pkg:gem/rbs#lib/rbs/environment.rb:841 + # pkg:gem/rbs#lib/rbs/environment.rb:981 def absolute_type(resolver, map, type, context:); end - # pkg:gem/rbs#lib/rbs/environment.rb:836 + # pkg:gem/rbs#lib/rbs/environment.rb:976 def absolute_type_name(resolver, map, type_name, context:); end - # pkg:gem/rbs#lib/rbs/environment.rb:417 + # pkg:gem/rbs#lib/rbs/environment.rb:455 def add_source(source); end - # pkg:gem/rbs#lib/rbs/environment.rb:522 + # pkg:gem/rbs#lib/rbs/environment.rb:568 def append_context(context, decl); end - # pkg:gem/rbs#lib/rbs/environment.rb:852 + # pkg:gem/rbs#lib/rbs/environment.rb:992 def buffers; end # @return [Boolean] @@ -3548,7 +3974,7 @@ class RBS::Environment def class_decls; end # pkg:gem/rbs#lib/rbs/environment.rb:125 - def class_entry(type_name); end + def class_entry(type_name, normalized: T.unsafe(nil)); end # @return [Boolean] # @@ -3560,8 +3986,8 @@ class RBS::Environment # pkg:gem/rbs#lib/rbs/environment.rb:8 def constant_decls; end - # pkg:gem/rbs#lib/rbs/environment.rb:173 - def constant_entry(type_name); end + # pkg:gem/rbs#lib/rbs/environment.rb:167 + def constant_entry(type_name, normalized: T.unsafe(nil)); end # @return [Boolean] # @@ -3571,10 +3997,10 @@ class RBS::Environment # pkg:gem/rbs#lib/rbs/environment.rb:14 def declarations; end - # pkg:gem/rbs#lib/rbs/environment.rb:432 + # pkg:gem/rbs#lib/rbs/environment.rb:470 def each_rbs_source(&block); end - # pkg:gem/rbs#lib/rbs/environment.rb:444 + # pkg:gem/rbs#lib/rbs/environment.rb:482 def each_ruby_source(&block); end # Returns the value of attribute global_decls. @@ -3582,13 +4008,13 @@ class RBS::Environment # pkg:gem/rbs#lib/rbs/environment.rb:9 def global_decls; end - # pkg:gem/rbs#lib/rbs/environment.rb:272 + # pkg:gem/rbs#lib/rbs/environment.rb:277 def insert_rbs_decl(decl, context:, namespace:); end - # pkg:gem/rbs#lib/rbs/environment.rb:369 + # pkg:gem/rbs#lib/rbs/environment.rb:374 def insert_ruby_decl(decl, context:, namespace:); end - # pkg:gem/rbs#lib/rbs/environment.rb:847 + # pkg:gem/rbs#lib/rbs/environment.rb:987 def inspect; end # Returns the value of attribute interface_decls. @@ -3606,83 +4032,86 @@ class RBS::Environment # pkg:gem/rbs#lib/rbs/environment.rb:109 def module_alias?(name); end - # pkg:gem/rbs#lib/rbs/environment.rb:165 - def module_class_entry(type_name); end + # pkg:gem/rbs#lib/rbs/environment.rb:154 + def module_class_entry(type_name, normalized: T.unsafe(nil)); end # @return [Boolean] # # pkg:gem/rbs#lib/rbs/environment.rb:105 def module_decl?(name); end - # pkg:gem/rbs#lib/rbs/environment.rb:134 - def module_entry(type_name); end + # pkg:gem/rbs#lib/rbs/environment.rb:132 + def module_entry(type_name, normalized: T.unsafe(nil)); end # @return [Boolean] # # pkg:gem/rbs#lib/rbs/environment.rb:83 def module_name?(name); end - # pkg:gem/rbs#lib/rbs/environment.rb:231 + # pkg:gem/rbs#lib/rbs/environment.rb:269 def normalize_module_name(name); end + # pkg:gem/rbs#lib/rbs/environment.rb:273 + def normalize_module_name!(name); end + # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/environment.rb:235 + # pkg:gem/rbs#lib/rbs/environment.rb:241 def normalize_module_name?(name); end - # pkg:gem/rbs#lib/rbs/environment.rb:227 + # pkg:gem/rbs#lib/rbs/environment.rb:219 def normalize_type_name(name); end - # pkg:gem/rbs#lib/rbs/environment.rb:196 + # pkg:gem/rbs#lib/rbs/environment.rb:206 def normalize_type_name!(name); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/environment.rb:177 + # pkg:gem/rbs#lib/rbs/environment.rb:187 def normalize_type_name?(name); end - # pkg:gem/rbs#lib/rbs/environment.rb:143 + # pkg:gem/rbs#lib/rbs/environment.rb:139 def normalized_class_entry(type_name); end - # pkg:gem/rbs#lib/rbs/environment.rb:169 + # pkg:gem/rbs#lib/rbs/environment.rb:163 def normalized_module_class_entry(type_name); end - # pkg:gem/rbs#lib/rbs/environment.rb:154 + # pkg:gem/rbs#lib/rbs/environment.rb:150 def normalized_module_entry(type_name); end - # pkg:gem/rbs#lib/rbs/environment.rb:222 + # pkg:gem/rbs#lib/rbs/environment.rb:236 def normalized_type_name!(name); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/environment.rb:209 + # pkg:gem/rbs#lib/rbs/environment.rb:223 def normalized_type_name?(type_name); end - # pkg:gem/rbs#lib/rbs/environment.rb:531 + # pkg:gem/rbs#lib/rbs/environment.rb:577 def resolve_declaration(resolver, map, decl, context:, prefix:); end - # pkg:gem/rbs#lib/rbs/environment.rb:722 + # pkg:gem/rbs#lib/rbs/environment.rb:862 def resolve_member(resolver, map, member, context:); end - # pkg:gem/rbs#lib/rbs/environment.rb:822 + # pkg:gem/rbs#lib/rbs/environment.rb:962 def resolve_method_type(resolver, map, type, context:); end - # pkg:gem/rbs#lib/rbs/environment.rb:667 + # pkg:gem/rbs#lib/rbs/environment.rb:713 def resolve_ruby_decl(resolver, decl, context:, prefix:); end - # pkg:gem/rbs#lib/rbs/environment.rb:708 + # pkg:gem/rbs#lib/rbs/environment.rb:790 def resolve_ruby_member(resolver, member, context:); end - # pkg:gem/rbs#lib/rbs/environment.rb:462 + # pkg:gem/rbs#lib/rbs/environment.rb:500 def resolve_signature(resolver, table, dirs, decls, only: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/environment.rb:484 + # pkg:gem/rbs#lib/rbs/environment.rb:522 def resolve_type_names(only: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/environment.rb:830 + # pkg:gem/rbs#lib/rbs/environment.rb:970 def resolve_type_params(resolver, map, params, context:); end - # pkg:gem/rbs#lib/rbs/environment.rb:516 + # pkg:gem/rbs#lib/rbs/environment.rb:562 def resolver_context(*nesting); end # Returns the value of attribute sources. @@ -3705,10 +4134,10 @@ class RBS::Environment # pkg:gem/rbs#lib/rbs/environment.rb:87 def type_name?(name); end - # pkg:gem/rbs#lib/rbs/environment.rb:856 - def unload(buffers); end + # pkg:gem/rbs#lib/rbs/environment.rb:996 + def unload(paths); end - # pkg:gem/rbs#lib/rbs/environment.rb:456 + # pkg:gem/rbs#lib/rbs/environment.rb:494 def validate_type_params; end private @@ -3899,7 +4328,7 @@ class RBS::EnvironmentLoader # pkg:gem/rbs#lib/rbs/environment_loader.rb:48 def add(path: T.unsafe(nil), library: T.unsafe(nil), version: T.unsafe(nil), resolve_dependencies: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/environment_loader.rb:80 + # pkg:gem/rbs#lib/rbs/environment_loader.rb:74 def add_collection(lockfile); end # Returns the value of attribute core_root. @@ -3912,15 +4341,15 @@ class RBS::EnvironmentLoader # pkg:gem/rbs#lib/rbs/environment_loader.rb:24 def dirs; end - # pkg:gem/rbs#lib/rbs/environment_loader.rb:131 + # pkg:gem/rbs#lib/rbs/environment_loader.rb:125 def each_dir; end - # pkg:gem/rbs#lib/rbs/environment_loader.rb:154 + # pkg:gem/rbs#lib/rbs/environment_loader.rb:148 def each_signature; end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/environment_loader.rb:104 + # pkg:gem/rbs#lib/rbs/environment_loader.rb:98 def has_library?(library:, version:); end # Returns the value of attribute libs. @@ -3928,7 +4357,7 @@ class RBS::EnvironmentLoader # pkg:gem/rbs#lib/rbs/environment_loader.rb:23 def libs; end - # pkg:gem/rbs#lib/rbs/environment_loader.rb:112 + # pkg:gem/rbs#lib/rbs/environment_loader.rb:106 def load(env:); end # Returns the value of attribute repository. @@ -3936,7 +4365,7 @@ class RBS::EnvironmentLoader # pkg:gem/rbs#lib/rbs/environment_loader.rb:21 def repository; end - # pkg:gem/rbs#lib/rbs/environment_loader.rb:65 + # pkg:gem/rbs#lib/rbs/environment_loader.rb:59 def resolve_dependencies(library:, version:); end class << self @@ -4112,21 +4541,21 @@ class RBS::GenericParameterMismatchError < ::RBS::LoadingError def name; end end -# pkg:gem/rbs#lib/rbs/errors.rb:554 +# pkg:gem/rbs#lib/rbs/errors.rb:574 class RBS::InconsistentClassModuleAliasError < ::RBS::BaseError include ::RBS::DetailedMessageable # @return [InconsistentClassModuleAliasError] a new instance of InconsistentClassModuleAliasError # - # pkg:gem/rbs#lib/rbs/errors.rb:559 + # pkg:gem/rbs#lib/rbs/errors.rb:579 def initialize(entry); end # Returns the value of attribute alias_entry. # - # pkg:gem/rbs#lib/rbs/errors.rb:557 + # pkg:gem/rbs#lib/rbs/errors.rb:577 def alias_entry; end - # pkg:gem/rbs#lib/rbs/errors.rb:573 + # pkg:gem/rbs#lib/rbs/errors.rb:593 def location; end end @@ -4156,7 +4585,7 @@ end # pkg:gem/rbs#lib/rbs/inline_parser.rb:4 class RBS::InlineParser class << self - # pkg:gem/rbs#lib/rbs/inline_parser.rb:34 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:45 def parse(buffer, prism); end end end @@ -4233,106 +4662,148 @@ class RBS::InlineParser::CommentAssociation::Reference def block; end end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:16 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:20 module RBS::InlineParser::Diagnostic; end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:31 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:38 class RBS::InlineParser::Diagnostic::AnnotationSyntaxError < ::RBS::InlineParser::Diagnostic::Base; end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:17 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:41 +class RBS::InlineParser::Diagnostic::AttributeNonSymbolName < ::RBS::InlineParser::Diagnostic::Base; end + +# pkg:gem/rbs#lib/rbs/inline_parser.rb:21 class RBS::InlineParser::Diagnostic::Base # @return [Base] a new instance of Base # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:20 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:24 def initialize(location, message); end # Returns the value of attribute location. # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:18 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:22 def location; end # Returns the value of attribute message. # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:18 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:22 def message; end end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:27 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:42 +class RBS::InlineParser::Diagnostic::ClassModuleAliasDeclarationMissingTypeName < ::RBS::InlineParser::Diagnostic::Base; end + +# pkg:gem/rbs#lib/rbs/inline_parser.rb:39 +class RBS::InlineParser::Diagnostic::MixinMultipleArguments < ::RBS::InlineParser::Diagnostic::Base; end + +# pkg:gem/rbs#lib/rbs/inline_parser.rb:40 +class RBS::InlineParser::Diagnostic::MixinNonConstantModule < ::RBS::InlineParser::Diagnostic::Base; end + +# pkg:gem/rbs#lib/rbs/inline_parser.rb:31 class RBS::InlineParser::Diagnostic::NonConstantClassName < ::RBS::InlineParser::Diagnostic::Base; end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:28 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:36 +class RBS::InlineParser::Diagnostic::NonConstantConstantDeclaration < ::RBS::InlineParser::Diagnostic::Base; end + +# pkg:gem/rbs#lib/rbs/inline_parser.rb:32 class RBS::InlineParser::Diagnostic::NonConstantModuleName < ::RBS::InlineParser::Diagnostic::Base; end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:26 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:33 +class RBS::InlineParser::Diagnostic::NonConstantSuperClassName < ::RBS::InlineParser::Diagnostic::Base; end + +# pkg:gem/rbs#lib/rbs/inline_parser.rb:30 class RBS::InlineParser::Diagnostic::NotImplementedYet < ::RBS::InlineParser::Diagnostic::Base; end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:29 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:35 +class RBS::InlineParser::Diagnostic::TopLevelAttributeDefinition < ::RBS::InlineParser::Diagnostic::Base; end + +# pkg:gem/rbs#lib/rbs/inline_parser.rb:34 class RBS::InlineParser::Diagnostic::TopLevelMethodDefinition < ::RBS::InlineParser::Diagnostic::Base; end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:30 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:37 class RBS::InlineParser::Diagnostic::UnusedInlineAnnotation < ::RBS::InlineParser::Diagnostic::Base; end -# pkg:gem/rbs#lib/rbs/inline_parser.rb:42 +# pkg:gem/rbs#lib/rbs/inline_parser.rb:57 class RBS::InlineParser::Parser < ::Prism::Visitor include ::RBS::AST::Ruby::Helpers::ConstantHelper include ::RBS::AST::Ruby::Helpers::LocationHelper # @return [Parser] a new instance of Parser # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:48 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:63 def initialize(result); end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:54 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:69 def buffer; end # Returns the value of attribute comments. # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:43 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:58 def comments; end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:58 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:73 def current_module; end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:62 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:77 def current_module!; end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:66 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:81 def diagnostics; end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:171 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:472 def insert_declaration(decl); end # Returns the value of attribute module_nesting. # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:43 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:58 def module_nesting; end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:70 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:315 + def parse_attribute_call(node); end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:375 + def parse_constant_declaration(node); end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:259 + def parse_mixin_call(node); end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:508 + def parse_super_class(super_class_expr, inheritance_operator_loc); end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:85 def push_module_nesting(mod); end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:179 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:480 def report_unused_annotation(*annotations); end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:194 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:495 def report_unused_block(block); end # Returns the value of attribute result. # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:43 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:58 def result; end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/inline_parser.rb:77 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:92 def skip_node?(node); end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:88 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:217 + def visit_call_node(node); end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:103 def visit_class_node(node); end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:132 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:253 + def visit_constant_path_write_node(node); end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:246 + def visit_constant_write_node(node); end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:178 def visit_def_node(node); end - # pkg:gem/rbs#lib/rbs/inline_parser.rb:110 + # pkg:gem/rbs#lib/rbs/inline_parser.rb:156 def visit_module_node(node); end end @@ -4362,6 +4833,9 @@ class RBS::InlineParser::Result # # pkg:gem/rbs#lib/rbs/inline_parser.rb:6 def prism_result; end + + # pkg:gem/rbs#lib/rbs/inline_parser.rb:15 + def type_fingerprint; end end # pkg:gem/rbs#lib/rbs/errors.rb:341 @@ -4636,7 +5110,7 @@ class RBS::Locator # pkg:gem/rbs#lib/rbs/locator.rb:42 def find_in_directive(pos, dir, array); end - # pkg:gem/rbs#lib/rbs/locator.rb:208 + # pkg:gem/rbs#lib/rbs/locator.rb:212 def find_in_loc(pos, location:, array:); end # pkg:gem/rbs#lib/rbs/locator.rb:131 @@ -4645,13 +5119,13 @@ class RBS::Locator # pkg:gem/rbs#lib/rbs/locator.rb:154 def find_in_method_type(pos, method_type:, array:); end - # pkg:gem/rbs#lib/rbs/locator.rb:192 + # pkg:gem/rbs#lib/rbs/locator.rb:196 def find_in_type(pos, type:, array:); end # pkg:gem/rbs#lib/rbs/locator.rb:172 def find_in_type_param(pos, type_param:, array:); end - # pkg:gem/rbs#lib/rbs/locator.rb:235 + # pkg:gem/rbs#lib/rbs/locator.rb:239 def test_loc(pos, location:); end end @@ -4758,7 +5232,10 @@ class RBS::MixinClassError < ::RBS::DefinitionError private - # pkg:gem/rbs#lib/rbs/errors.rb:493 + # pkg:gem/rbs#lib/rbs/errors.rb:502 + def member_name(member); end + + # pkg:gem/rbs#lib/rbs/errors.rb:513 def mixin_name; end class << self @@ -4943,23 +5420,23 @@ class RBS::NoTypeFoundError < ::RBS::DefinitionError end end -# pkg:gem/rbs#lib/rbs/errors.rb:525 +# pkg:gem/rbs#lib/rbs/errors.rb:545 class RBS::NonregularTypeAliasError < ::RBS::BaseError include ::RBS::DetailedMessageable # @return [NonregularTypeAliasError] a new instance of NonregularTypeAliasError # - # pkg:gem/rbs#lib/rbs/errors.rb:531 + # pkg:gem/rbs#lib/rbs/errors.rb:551 def initialize(diagnostic:, location:); end # Returns the value of attribute diagnostic. # - # pkg:gem/rbs#lib/rbs/errors.rb:528 + # pkg:gem/rbs#lib/rbs/errors.rb:548 def diagnostic; end # Returns the value of attribute location. # - # pkg:gem/rbs#lib/rbs/errors.rb:529 + # pkg:gem/rbs#lib/rbs/errors.rb:549 def location; end end @@ -4982,7 +5459,7 @@ class RBS::Parser def _parse_signature(_arg0, _arg1, _arg2); end # pkg:gem/rbs#lib/rbs.rb:72 - def _parse_type(_arg0, _arg1, _arg2, _arg3, _arg4); end + def _parse_type(_arg0, _arg1, _arg2, _arg3, _arg4, _arg5, _arg6); end # pkg:gem/rbs#lib/rbs.rb:72 def _parse_type_params(_arg0, _arg1, _arg2, _arg3); end @@ -5009,7 +5486,7 @@ class RBS::Parser def parse_signature(source); end # pkg:gem/rbs#lib/rbs/parser_aux.rb:8 - def parse_type(source, range: T.unsafe(nil), variables: T.unsafe(nil), require_eof: T.unsafe(nil)); end + def parse_type(source, range: T.unsafe(nil), variables: T.unsafe(nil), require_eof: T.unsafe(nil), void_allowed: T.unsafe(nil), self_allowed: T.unsafe(nil)); end # pkg:gem/rbs#lib/rbs/parser_aux.rb:38 def parse_type_params(source, module_type_params: T.unsafe(nil)); end @@ -5277,10 +5754,10 @@ class RBS::Prototype::RBI # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:562 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:564 def call_node?(node, name:, receiver: T.unsafe(nil), args: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:566 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:568 def const_to_name(node); end # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:90 @@ -5297,10 +5774,10 @@ class RBS::Prototype::RBI # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:8 def decls; end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:602 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:604 def each_arg(array, &block); end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:616 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:618 def each_child(node); end # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:112 @@ -5311,7 +5788,7 @@ class RBS::Prototype::RBI # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:10 def last_sig; end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:280 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:281 def method_type(args_node, type_node, variables:, overloads:); end # Returns the value of attribute modules. @@ -5322,13 +5799,13 @@ class RBS::Prototype::RBI # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:42 def nested_name(name); end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:624 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:626 def node_to_hash(node); end # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:18 def parse(string); end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:352 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:354 def parse_params(args_node, args, method_type, variables:, overloads:); end # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:106 @@ -5336,7 +5813,7 @@ class RBS::Prototype::RBI # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:554 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:556 def proc_type?(type_node); end # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:117 @@ -5351,10 +5828,10 @@ class RBS::Prototype::RBI # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:98 def push_sig(node); end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:477 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:479 def type_of(type_node, variables:); end - # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:490 + # pkg:gem/rbs#lib/rbs/prototype/rbi.rb:492 def type_of0(type_node, variables:); end end @@ -5365,119 +5842,119 @@ class RBS::Prototype::Runtime # @return [Runtime] a new instance of Runtime # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:71 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:79 def initialize(patterns:, env:, merge:, todo: T.unsafe(nil), owners_included: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:654 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:662 def block_from_ast_of(method); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:101 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:109 def builder; end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:109 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:117 def decls; end # Generate/find outer module declarations # This is broken down into another method to comply with `DRY` # This generates/finds declarations in nested form & returns the last array of declarations # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:583 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:591 def ensure_outer_module_declarations(mod); end # Returns the value of attribute env. # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:65 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:73 def env; end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:488 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:496 def generate_class(mod); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:425 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:433 def generate_constants(mod, decls); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:301 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:309 def generate_methods(mod, module_name, members); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:565 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:573 def generate_mixin(mod, decl, type_name, type_name_absolute); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:527 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:535 def generate_module(mod); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:473 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:481 def generate_super_class(mod); end # Returns the value of attribute merge. # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:66 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:74 def merge; end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:240 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:248 def merge_rbs(module_name, members, instance: T.unsafe(nil), singleton: T.unsafe(nil)); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:171 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:179 def method_type(method); end # Returns the value of attribute outline. # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:69 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:77 def outline; end # Sets the attribute outline # # @param value the value to set the attribute outline to. # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:69 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:77 def outline=(_arg0); end # Returns the value of attribute owners_included. # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:68 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:76 def owners_included; end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:105 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:113 def parse(file); end # Returns the value of attribute patterns. # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:64 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:72 def patterns; end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:84 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:92 def target?(const); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:288 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:296 def target_method?(mod, instance: T.unsafe(nil), singleton: T.unsafe(nil)); end # Returns the value of attribute todo. # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:67 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:75 def todo; end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:97 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:105 def todo_object; end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:637 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:645 def type_args(type_name); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:645 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:653 def type_params(mod); end private # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:415 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:423 def can_alias?(mod, method); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:129 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:137 def each_mixined_module(type_name, mod); end - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:138 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:146 def each_mixined_module_one(type_name, mod); end end @@ -5585,12 +6062,12 @@ class RBS::Prototype::Runtime::Todo # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:42 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:50 def skip_constant?(module_name:, name:); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:33 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:37 def skip_instance_method?(module_name:, method:, accessibility:); end # @return [Boolean] @@ -5605,7 +6082,7 @@ class RBS::Prototype::Runtime::Todo private - # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:49 + # pkg:gem/rbs#lib/rbs/prototype/runtime.rb:57 def mixin_decls(type_name); end end @@ -5635,6 +6112,82 @@ class RBS::Prototype::Runtime::ValueObjectBase def build_s_members; end end +# pkg:gem/rbs#lib/rdoc_plugin/parser.rb:6 +module RBS::RDocPlugin; end + +# pkg:gem/rbs#lib/rdoc_plugin/parser.rb:7 +class RBS::RDocPlugin::Parser + # @return [Parser] a new instance of Parser + # + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:11 + def initialize(top_level, content); end + + # Returns the value of attribute content. + # + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:9 + def content; end + + # Sets the attribute content + # + # @param value the value to set the attribute content to. + # + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:9 + def content=(_arg0); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:94 + def parse_attr_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:53 + def parse_class_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:67 + def parse_constant_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:125 + def parse_extend_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:109 + def parse_include_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:24 + def parse_member(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:88 + def parse_method_alias_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:73 + def parse_method_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:60 + def parse_module_decl(decl:, context:, outer_name: T.unsafe(nil)); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:16 + def scan; end + + # Returns the value of attribute top_level. + # + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:9 + def top_level; end + + # Sets the attribute top_level + # + # @param value the value to set the attribute top_level to. + # + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:9 + def top_level=(_arg0); end + + private + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:149 + def comment_string(with_comment); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:143 + def construct_comment(context:, comment:); end + + # pkg:gem/rbs#lib/rdoc_plugin/parser.rb:154 + def fully_qualified_name(outer_name:, decl:); end +end + # pkg:gem/rbs#lib/rbs/errors.rb:448 class RBS::RecursiveAliasDefinitionError < ::RBS::DefinitionError include ::RBS::DetailedMessageable @@ -5681,26 +6234,26 @@ class RBS::RecursiveAncestorError < ::RBS::DefinitionError end end -# pkg:gem/rbs#lib/rbs/errors.rb:507 +# pkg:gem/rbs#lib/rbs/errors.rb:527 class RBS::RecursiveTypeAliasError < ::RBS::BaseError include ::RBS::DetailedMessageable # @return [RecursiveTypeAliasError] a new instance of RecursiveTypeAliasError # - # pkg:gem/rbs#lib/rbs/errors.rb:513 + # pkg:gem/rbs#lib/rbs/errors.rb:533 def initialize(alias_names:, location:); end # Returns the value of attribute alias_names. # - # pkg:gem/rbs#lib/rbs/errors.rb:510 + # pkg:gem/rbs#lib/rbs/errors.rb:530 def alias_names; end # Returns the value of attribute location. # - # pkg:gem/rbs#lib/rbs/errors.rb:511 + # pkg:gem/rbs#lib/rbs/errors.rb:531 def location; end - # pkg:gem/rbs#lib/rbs/errors.rb:520 + # pkg:gem/rbs#lib/rbs/errors.rb:540 def name; end end @@ -5919,7 +6472,17 @@ class RBS::Resolver::TypeNameResolver # @return [TypeNameResolver] a new instance of TypeNameResolver # # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:10 - def initialize(env); end + def initialize(all_names, aliases); end + + # @return [Boolean] + # + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:82 + def aliased_name?(type_name); end + + # Returns the value of attribute aliases. + # + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:8 + def aliases; end # Returns the value of attribute all_names. # @@ -5931,27 +6494,36 @@ class RBS::Resolver::TypeNameResolver # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:7 def cache; end - # Returns the value of attribute env. - # - # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:8 - def env; end - # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:84 - def has_name?(full_name); end + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:76 + def has_type_name?(full_name); end - # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:51 - def partition(type_name); end + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:121 + def normalize_namespace(type_name, rhs, context, visited); end - # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:28 + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:39 def resolve(type_name, context:); end - # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:69 - def resolve_in(head, context); end + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:104 + def resolve_head_namespace(head, context); end - # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:21 + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:62 + def resolve_namespace(type_name, context:); end + + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:136 + def resolve_namespace0(type_name, context, visited); end + + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:88 + def resolve_type_name(type_name, context); end + + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:32 def try_cache(query); end + + class << self + # pkg:gem/rbs#lib/rbs/resolver/type_name_resolver.rb:16 + def build(env); end + end end # pkg:gem/rbs#lib/rbs/source.rb:4 @@ -6082,26 +6654,26 @@ class RBS::Subtractor private - # pkg:gem/rbs#lib/rbs/subtractor.rb:178 + # pkg:gem/rbs#lib/rbs/subtractor.rb:180 def absolute_typename(name, context:); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/subtractor.rb:161 + # pkg:gem/rbs#lib/rbs/subtractor.rb:163 def access_modifier?(decl); end # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/subtractor.rb:118 + # pkg:gem/rbs#lib/rbs/subtractor.rb:120 def cvar_exist?(owner, name); end - # pkg:gem/rbs#lib/rbs/subtractor.rb:127 + # pkg:gem/rbs#lib/rbs/subtractor.rb:129 def each_member(owner, &block); end # pkg:gem/rbs#lib/rbs/subtractor.rb:48 def filter_members(decl, context:); end - # pkg:gem/rbs#lib/rbs/subtractor.rb:149 + # pkg:gem/rbs#lib/rbs/subtractor.rb:151 def filter_redundant_access_modifiers(decls); end # @return [Boolean] @@ -6121,13 +6693,13 @@ class RBS::Subtractor # @return [Boolean] # - # pkg:gem/rbs#lib/rbs/subtractor.rb:138 + # pkg:gem/rbs#lib/rbs/subtractor.rb:140 def mixin_exist?(owner, mixin, context:); end - # pkg:gem/rbs#lib/rbs/subtractor.rb:187 + # pkg:gem/rbs#lib/rbs/subtractor.rb:189 def typename_candidates(name, context:); end - # pkg:gem/rbs#lib/rbs/subtractor.rb:165 + # pkg:gem/rbs#lib/rbs/subtractor.rb:167 def update_decl(decl, members:); end end @@ -6357,27 +6929,27 @@ class RBS::TypeName end end -# pkg:gem/rbs#lib/rbs/errors.rb:605 +# pkg:gem/rbs#lib/rbs/errors.rb:625 class RBS::TypeParamDefaultReferenceError < ::RBS::DefinitionError include ::RBS::DetailedMessageable # @return [TypeParamDefaultReferenceError] a new instance of TypeParamDefaultReferenceError # - # pkg:gem/rbs#lib/rbs/errors.rb:611 + # pkg:gem/rbs#lib/rbs/errors.rb:631 def initialize(type_param, location:); end # Returns the value of attribute location. # - # pkg:gem/rbs#lib/rbs/errors.rb:609 + # pkg:gem/rbs#lib/rbs/errors.rb:629 def location; end # Returns the value of attribute type_param. # - # pkg:gem/rbs#lib/rbs/errors.rb:608 + # pkg:gem/rbs#lib/rbs/errors.rb:628 def type_param; end class << self - # pkg:gem/rbs#lib/rbs/errors.rb:617 + # pkg:gem/rbs#lib/rbs/errors.rb:637 def check!(type_params); end end end @@ -7719,18 +8291,18 @@ class RBS::Vendorer def vendor_dir; end end -# pkg:gem/rbs#lib/rbs/errors.rb:594 +# pkg:gem/rbs#lib/rbs/errors.rb:614 class RBS::WillSyntaxError < ::RBS::DefinitionError include ::RBS::DetailedMessageable # @return [WillSyntaxError] a new instance of WillSyntaxError # - # pkg:gem/rbs#lib/rbs/errors.rb:599 + # pkg:gem/rbs#lib/rbs/errors.rb:619 def initialize(message, location:); end # Returns the value of attribute location. # - # pkg:gem/rbs#lib/rbs/errors.rb:597 + # pkg:gem/rbs#lib/rbs/errors.rb:617 def location; end end @@ -7813,3 +8385,9 @@ class RBS::Writer # pkg:gem/rbs#lib/rbs/writer.rb:102 def write_use_directive(dir); end end + +# pkg:gem/rbs#lib/rdoc/discover.rb:8 +class RDoc::Parser::RBS < ::RDoc::Parser + # pkg:gem/rbs#lib/rdoc/discover.rb:10 + def scan; end +end diff --git a/sorbet/rbi/gems/rdoc@7.0.3.rbi b/sorbet/rbi/gems/rdoc@7.2.0.rbi similarity index 87% rename from sorbet/rbi/gems/rdoc@7.0.3.rbi rename to sorbet/rbi/gems/rdoc@7.2.0.rbi index fb4956a5a..c0dd0a2aa 100644 --- a/sorbet/rbi/gems/rdoc@7.0.3.rbi +++ b/sorbet/rbi/gems/rdoc@7.2.0.rbi @@ -350,7 +350,7 @@ class RDoc::Attr < ::RDoc::MethodAttr # The #aref prefix for attributes # - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:58 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:59 def aref_prefix; end # Attributes never call super. See RDoc::AnyMethod#calls_super @@ -358,20 +358,20 @@ class RDoc::Attr < ::RDoc::MethodAttr # An RDoc::Attr can show up in the method list in some situations (see # Gem::ConfigFile) # - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:68 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:69 def calls_super; end # Returns attr_reader, attr_writer or attr_accessor as appropriate. # - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:75 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:76 def definition; end - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:83 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:84 def inspect; end # Dumps this Attr for use by ri. See also #marshal_load # - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:99 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:100 def marshal_dump; end # Loads this Attr from +array+. For a loaded Attr the following @@ -380,10 +380,10 @@ class RDoc::Attr < ::RDoc::MethodAttr # * #full_name # * #parent_name # - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:121 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:122 def marshal_load(array); end - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:148 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:149 def pretty_print(q); end # Is the attribute readable ('R'), writable ('W') or both ('RW')? @@ -396,7 +396,7 @@ class RDoc::Attr < ::RDoc::MethodAttr # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:19 def rw=(_arg0); end - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:159 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:160 def to_s; end # Attributes do not have token streams. @@ -404,7 +404,7 @@ class RDoc::Attr < ::RDoc::MethodAttr # An RDoc::Attr can show up in the method list in some situations (see # Gem::ConfigFile) # - # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:169 + # pkg:gem/rdoc#lib/rdoc/code_object/attr.rb:170 def token_stream; end end @@ -446,10 +446,14 @@ class RDoc::ClassModule < ::RDoc::Context # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:182 def ancestors; end - # HTML fragment reference for this module or class. See - # RDoc::NormalClass#aref and RDoc::NormalModule#aref + # HTML fragment reference for this module or class using GitHub-style + # anchor format (lowercase, :: replaced with -). # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:194 + # Examples: + # Foo -> class-foo + # Foo::Bar -> class-foo-bar + # + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:198 def aref; end # @raise [NotImplementedError] @@ -459,7 +463,7 @@ class RDoc::ClassModule < ::RDoc::Context # Clears the comment. Used by the Ruby parser. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:206 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:222 def clear_comment; end # This method is deprecated, use #add_comment instead. @@ -467,7 +471,7 @@ class RDoc::ClassModule < ::RDoc::Context # Appends +comment+ to the current comment, but separated by a rule. Works # more like +=. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:216 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:232 def comment=(comment); end # An array of `[comment, location]` pairs documenting this class/module. @@ -514,7 +518,7 @@ class RDoc::ClassModule < ::RDoc::Context # # See RDoc::Store#complete # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:234 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:250 def complete(min_visibility); end # Constants that are aliases for this class or module @@ -545,12 +549,12 @@ class RDoc::ClassModule < ::RDoc::Context # # Ancestors of this class or module only # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:201 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:217 def direct_ancestors; end # Does this ClassModule or any of its methods have document_self set? # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:246 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:262 def document_self_or_methods; end # Does this class or module have a comment with content or is @@ -558,38 +562,38 @@ class RDoc::ClassModule < ::RDoc::Context # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:254 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:270 def documented?; end # Iterates the ancestors of this class or module for which an # RDoc::ClassModule exists. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:264 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:280 def each_ancestor; end - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:879 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:900 def embed_mixins; end # Looks for a symbol in the #ancestors. See Context#find_local_symbol. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:277 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:293 def find_ancestor_local_symbol(symbol); end # Finds a class or module with +name+ in this namespace or its descendants # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:289 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:305 def find_class_named(name); end # Return the fully qualified name of this class or module # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:302 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:318 def full_name; end # Return array of fully qualified nesting namespaces. # # For example, if full_name is +A::B::C+, this method returns ["A", "A::B", "A::B::C"] # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:322 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:338 def fully_qualified_nesting_namespaces; end # Class or module this constant is an alias for @@ -602,19 +606,29 @@ class RDoc::ClassModule < ::RDoc::Context # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:55 def is_alias_for=(_arg0); end + # Legacy HTML fragment reference for backward compatibility. + # Returns the old RDoc-style anchor format. + # + # Examples: + # Foo -> class-Foo + # Foo::Bar -> class-Foo::Bar + # + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:210 + def legacy_aref; end + # TODO: filter included items by #display? # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:332 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:348 def marshal_dump; end - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:378 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:394 def marshal_load(array); end # Merges +class_module+ into this ClassModule. # # The data in +class_module+ is preferred over the receiver. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:468 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:484 def merge(class_module); end # Merges collection +mine+ with +other+ preferring other. +other_files+ is @@ -631,57 +645,57 @@ class RDoc::ClassModule < ::RDoc::Context # end # end # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:553 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:574 def merge_collections(mine, other, other_files, &block); end # Merges the comments in this ClassModule with the comments in the other # ClassModule +cm+. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:565 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:586 def merge_sections(cm); end # Does this object represent a module? # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:604 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:625 def module?; end # Allows overriding the initial name. # # Used for modules and classes that are constant aliases. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:613 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:634 def name=(new_name); end # Name to use to generate the url: # modules and classes that are aliases for another # module or class return the name of the latter. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:658 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:679 def name_for_path; end # Return array of full_name splitted by +::+. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:313 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:329 def nesting_namespaces; end # Returns the classes and modules that are not constants # aliasing another class or module. For use by formatters # only (caches its result). # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:667 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:688 def non_aliases; end # Parses +comment_location+ into an RDoc::Markup::Document composed of # multiple RDoc::Markup::Documents with their file set. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:621 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:642 def parse(comment_location); end # Path to this class or module for use with HTML generator output. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:647 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:668 def path; end # Updates the child modules or classes of class/module +parent+ by @@ -691,10 +705,10 @@ class RDoc::ClassModule < ::RDoc::Context # parent.classes_hash and +all_hash+ is ::all_modules_hash or # ::all_classes_hash. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:679 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:700 def remove_nodoc_children; end - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:693 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:714 def remove_things(my_things, other_files); end # Search record used by RDoc::Generator::JsonIndex @@ -702,29 +716,29 @@ class RDoc::ClassModule < ::RDoc::Context # TODO: Remove this method after dropping the darkfish theme and JsonIndex generator. # Use #search_snippet instead for getting documentation snippets. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:711 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:732 def search_record; end # Returns an HTML snippet of the first comment for search results. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:726 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:747 def search_snippet; end # Sets the store for this class or module and its contained code objects. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:736 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:757 def store=(store); end # Get all super classes of this class in an array. The last element might be # a string if the name is unknown. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:779 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:800 def super_classes; end # Get the superclass of this class. Attempts to retrieve the superclass # object, returns the name if it is not known. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:750 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:771 def superclass; end # Set the superclass of this class to +superclass+ @@ -737,15 +751,15 @@ class RDoc::ClassModule < ::RDoc::Context # # @raise [NoMethodError] # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:763 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:784 def superclass=(superclass); end - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:789 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:810 def to_s; end # 'module' or 'class' # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:800 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:821 def type; end # Updates the child modules & classes by replacing the ones that are @@ -762,7 +776,7 @@ class RDoc::ClassModule < ::RDoc::Context # the aliased modules are included in the constants of the class/module, # that are listed separately. # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:819 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:840 def update_aliases; end # Deletes from #extends those whose module has been removed from the @@ -770,7 +784,7 @@ class RDoc::ClassModule < ::RDoc::Context # -- # FIXME: like update_includes, extends are not reliably removed # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:869 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:890 def update_extends; end # Deletes from #includes those whose module has been removed from the @@ -778,12 +792,12 @@ class RDoc::ClassModule < ::RDoc::Context # -- # FIXME: includes are not reliably removed, see _possible_bug test case # - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:854 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:875 def update_includes; end private - # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:908 + # pkg:gem/rdoc#lib/rdoc/code_object/class_module.rb:929 def prepare_to_embed(code_object, singleton = T.unsafe(nil)); end class << self @@ -1683,60 +1697,64 @@ class RDoc::Context < ::RDoc::CodeObject # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:781 def find_constant_named(name); end - # Find a module at a higher scope + # Tries to find a module at a higher scope. + # But parent is not always a higher module nesting scope, so the result is not correct. + # Parent chain can only represent last-opened nesting, and may be broken in some cases. + # PrismRuby parser stopped representing module nesting with parent chain at all. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:790 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:793 def find_enclosing_module_named(name); end # Finds an external alias +name+ with singleton value +singleton+. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:797 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:800 def find_external_alias(name, singleton); end # Finds an external alias with +name+ in this context # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:804 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:807 def find_external_alias_named(name); end # Finds an instance method with +name+ in this context # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:818 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:821 def find_instance_method_named(name); end # Finds a method, constant, attribute, external alias, module or file # named +symbol+ in this context. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:826 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:829 def find_local_symbol(symbol); end # Finds a method named +name+ with singleton value +singleton+. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:838 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:841 def find_method(name, singleton); end # Finds a instance or module method with +name+ in this context # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:851 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:854 def find_method_named(name); end - # Find a module with +name+ using ruby's scoping rules + # Find a module with +name+ trying to using ruby's scoping rules. + # find_enclosing_module_named cannot use ruby's scoping so the result is not correct. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:865 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:869 def find_module_named(name); end # Look up +symbol+, first as a module, then as a local symbol. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:875 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:886 def find_symbol(symbol); end # Look up a module named +symbol+. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:882 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:893 def find_symbol_module(symbol); end # The full name for this context. This method is overridden by subclasses. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:915 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:926 def full_name; end # Does this context and its methods and constants all have documentation? @@ -1745,12 +1763,18 @@ class RDoc::Context < ::RDoc::CodeObject # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:924 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:935 def fully_documented?; end + # Get a module named +name+ in this context + # Don't look up for higher module nesting scopes. RDoc::Context doesn't have that information. + # + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:879 + def get_module_named(name); end + # URL for this with a +prefix+ # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:934 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:945 def http_url; end # Files this context is found in @@ -1770,19 +1794,19 @@ class RDoc::Context < ::RDoc::CodeObject # Instance attributes # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:945 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:956 def instance_attributes; end # Instance methods # -- # TODO remove this later # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:961 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:972 def instance_method_list; end # Instance methods # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:952 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:963 def instance_methods; end # Methods defined in this context @@ -1796,7 +1820,7 @@ class RDoc::Context < ::RDoc::CodeObject # If +section+ is provided only methods in that RDoc::Context::Section will # be returned. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:973 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:984 def methods_by_type(section = T.unsafe(nil)); end # Hash of registered methods. Attributes are also registered here, @@ -1807,17 +1831,17 @@ class RDoc::Context < ::RDoc::CodeObject # Yields AnyMethod and Attr entries matching the list of names in +methods+. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:996 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1007 def methods_matching(methods, singleton = T.unsafe(nil), &block); end # Array of modules in this context # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1009 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1020 def modules; end # Hash of modules keyed by module name # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1016 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1027 def modules_hash; end # Name of this class excluding namespace. See also full_name @@ -1828,12 +1852,12 @@ class RDoc::Context < ::RDoc::CodeObject # Name to use to generate the url. # #full_name by default. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1024 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1035 def name_for_path; end # Changes the visibility for new methods to +visibility+ # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1031 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1042 def ongoing_visibility=(visibility); end # Params to be used in the next MethodAttr parsed under this context @@ -1848,7 +1872,7 @@ class RDoc::Context < ::RDoc::CodeObject # Record +top_level+ as a file +self+ is in. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1038 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1049 def record_location(top_level); end # Should we remove this context from the documentation? @@ -1862,19 +1886,19 @@ class RDoc::Context < ::RDoc::CodeObject # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1052 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1063 def remove_from_documentation?; end # Removes methods and attributes with a visibility less than +min_visibility+. # -- # TODO mark the visibility of attributes in the template (if not public?) # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1065 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1076 def remove_invisible(min_visibility); end # Only called when min_visibility == :public or :private # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1075 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1086 def remove_invisible_in(array, min_visibility); end # Files this context requires @@ -1885,44 +1909,44 @@ class RDoc::Context < ::RDoc::CodeObject # Tries to resolve unmatched aliases when a method or attribute has just # been added. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1091 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1102 def resolve_aliases(added); end # Returns RDoc::Context::Section objects referenced in this context for use # in a table of contents. # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1107 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1118 def section_contents; end # Sections in this context # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1131 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1142 def sections; end - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1135 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1146 def sections_hash; end # Given an array +names+ of constants, set the visibility of each constant to # +visibility+ # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1160 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1171 def set_constant_visibility_for(names, visibility); end # Sets the current section to a section with +title+. See also #add_section # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1142 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1153 def set_current_section(title, comment); end # Given an array +methods+ of method names, set the visibility of each to # +visibility+ # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1150 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1161 def set_visibility_for(methods, visibility, singleton = T.unsafe(nil)); end # Sorts sections alphabetically (default) or in TomDoc fashion (none, # Public, Internal, Deprecated) # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1171 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1182 def sort_sections; end # Use this section for the next method, attribute or constant added. @@ -1935,7 +1959,7 @@ class RDoc::Context < ::RDoc::CodeObject # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:80 def temporary_section=(_arg0); end - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1187 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1198 def to_s; end # Return the TopLevel that owns us @@ -1943,7 +1967,7 @@ class RDoc::Context < ::RDoc::CodeObject # FIXME we can be 'owned' by several TopLevel (see #record_location & # #in_files) # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1197 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1208 def top_level; end # Hash old_name => [aliases], for aliases @@ -1962,7 +1986,7 @@ class RDoc::Context < ::RDoc::CodeObject # Upgrades NormalModule +mod+ in +enclosing+ to a +class_type+ # - # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1207 + # pkg:gem/rdoc#lib/rdoc/code_object/context.rb:1218 def upgrade_to_class(mod, class_type, enclosing); end # Current visibility of this context @@ -1994,36 +2018,44 @@ class RDoc::Context::Section # @return [Section] a new instance of Section # # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:43 - def initialize(parent, title, comment); end + def initialize(parent, title, comment, store = T.unsafe(nil)); end # Sections are equal when they have the same #title # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:55 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:56 def ==(other); end # Adds +comment+ to this section # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:64 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:65 def add_comment(comment); end - # Anchor reference for linking to this section + # Anchor reference for linking to this section using GitHub-style format. # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:75 + # Examples: + # "Section" -> "section" + # "One Two" -> "one-two" + # "[untitled]" -> "untitled" + # + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:81 def aref; end # Section comment # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:23 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:189 def comment; end # Section comments # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:28 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:23 def comments; end + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:194 + def description; end + # Sections are equal when they have the same #title # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:59 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:60 def eql?(other); end # Extracts the comment for this section from the original comment block. @@ -2034,71 +2066,89 @@ class RDoc::Context::Section # # :section: The title # # The body # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:90 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:110 def extract_comment(comment); end - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:116 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:136 def hash; end # The files comments in this section come from # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:123 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:143 def in_files; end - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:112 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:132 def inspect; end + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:199 + def language; end + + # Legacy anchor reference for backward compatibility. + # + # Examples: + # "Section" -> "section" + # "One Two" -> "one+two" + # "[untitled]" -> "5Buntitled-5D" + # + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:95 + def legacy_aref; end + # Serializes this Section. The title and parsed comment are saved, but not # the section parent which must be restored manually. # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:131 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:151 def marshal_dump; end # De-serializes this Section. The section parent must be restored manually. # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:142 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:162 def marshal_load(array); end # Context this Section lives in # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:33 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:28 def parent; end - # Parses +comment_location+ into an RDoc::Markup::Document composed of - # multiple RDoc::Markup::Documents with their file set. - # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:153 - def parse; end - # The section's title, or 'Top Section' if the title is nil. # # This is used by the table of contents template so the name is silly. # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:162 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:182 def plain_html; end # Removes a comment from this section if it is from the same file as # +comment+ # - # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:170 + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:207 def remove_comment(target_comment); end - # Section title + # The RDoc::Store for this object. # # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:38 + def store; end + + # Section title + # + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:33 def title; end + + # Parses +comment_location+ into an RDoc::Markup::Document composed of + # multiple RDoc::Markup::Documents with their file set. + # + # pkg:gem/rdoc#lib/rdoc/code_object/context/section.rb:173 + def to_document; end end # RDoc::CrossReference is a reusable way to create cross references for names. # -# pkg:gem/rdoc#lib/rdoc/cross_reference.rb:8 +# pkg:gem/rdoc#lib/rdoc/cross_reference.rb:6 class RDoc::CrossReference # Allows cross-references to be created based on the given +context+ # (RDoc::Context). # # @return [CrossReference] a new instance of CrossReference # - # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:127 + # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:125 def initialize(context); end # Returns a reference to +name+. @@ -2107,33 +2157,39 @@ class RDoc::CrossReference # returned. If +name+ is escaped +name+ is returned. If +name+ is not # found +text+ is returned. # - # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:190 + # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:197 def resolve(name, text); end - # Returns a method reference to +name+. + # Returns a method, attribute or constant reference to +name+ + # if it exists in the containing context object. It returns + # nil otherwise. + # + # For example, this method would decompose name = 'A::CONSTANT' into a + # container object A and a symbol 'CONSTANT', and it would try to find + # 'CONSTANT' in A. # - # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:137 - def resolve_method(name); end + # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:141 + def resolve_local_symbol(name); end # Hash of references that have been looked-up to their replacements # - # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:121 + # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:119 def seen; end # Hash of references that have been looked-up to their replacements # - # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:121 + # pkg:gem/rdoc#lib/rdoc/cross_reference.rb:119 def seen=(_arg0); end end # Regular expression to match method arguments. # -# pkg:gem/rdoc#lib/rdoc/cross_reference.rb:28 +# pkg:gem/rdoc#lib/rdoc/cross_reference.rb:26 RDoc::CrossReference::METHOD_ARGS_REGEXP_STR = T.let(T.unsafe(nil), String) # Regular expression to match a single method argument. # -# pkg:gem/rdoc#lib/rdoc/cross_reference.rb:23 +# pkg:gem/rdoc#lib/rdoc/cross_reference.rb:21 RDoc::CrossReference::METHOD_ARG_REGEXP_STR = T.let(T.unsafe(nil), String) # A subclass of ERB that writes directly to an IO. Credit to Aaron Patterson @@ -2980,1242 +3036,1242 @@ class RDoc::Markdown # Alphanumeric = %literals.Alphanumeric # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14588 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14598 def _Alphanumeric; end # AlphanumericAscii = %literals.AlphanumericAscii # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14595 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14605 def _AlphanumericAscii; end # AtxHeading = AtxStart:s @Spacechar+ AtxInline+:a (@Sp /#*/ @Sp)? @Newline { RDoc::Markup::Heading.new(s, a.join) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1213 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1223 def _AtxHeading; end # AtxInline = !@Newline !(@Sp /#*/ @Sp @Newline) Inline # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1131 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1141 def _AtxInline; end # AtxStart = < /\#{1,6}/ > { text.length } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1187 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1197 def _AtxStart; end # AutoLink = (AutoLinkUrl | AutoLinkEmail) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11647 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11657 def _AutoLink; end # AutoLinkEmail = "<" "mailto:"? < /[\w+.\/!%~$-]+/i "@" (!@Newline !">" .)+ > ">" { "mailto:#{text}" } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11780 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11790 def _AutoLinkEmail; end # AutoLinkUrl = "<" < /[A-Za-z]+/ "://" (!@Newline !">" .)+ > ">" { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11665 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11675 def _AutoLinkUrl; end # BOM = %literals.BOM # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14602 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14612 def _BOM; end # BlankLine = @Sp @Newline { "\n" } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14031 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14041 def _BlankLine; end # Block = @BlankLine* (BlockQuote | Verbatim | CodeFence | Table | Note | Reference | HorizontalRule | Heading | OrderedList | BulletList | DefinitionList | HtmlBlock | StyleBlock | Para | Plain) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:990 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1000 def _Block; end # BlockQuote = BlockQuoteRaw:a { RDoc::Markup::BlockQuote.new(*a) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1627 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1637 def _BlockQuote; end # BlockQuoteRaw = @StartList:a (">" " "? Line:l { a << l } (!">" !@BlankLine Line:c { a << c })* (@BlankLine:n { a << n })*)+ { inner_parse a.join } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1650 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1660 def _BlockQuoteRaw; end # Bullet = !HorizontalRule @NonindentSpace /[+*-]/ @Spacechar+ # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2215 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2225 def _Bullet; end # BulletList = &Bullet (ListTight | ListLoose):a { RDoc::Markup::List.new(:BULLET, *a) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2259 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2269 def _BulletList; end - # CharEntity = "&" < /[A-Za-z0-9]+/ > ";" { if entity = HTML_ENTITIES[text] then entity.pack 'U*' else "&#{text};" end } + # CharEntity = "&" < /[A-Za-z0-9]+/ > ";" { if entity = HTML_ENTITIES[text] then rdoc_escape(entity.pack('U*')) else "&#{text};" end } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14695 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14705 def _CharEntity; end # Code = (Ticks1 < ((!"`" Nonspacechar)+ | !Ticks1 /`+/ | !Ticks1 (@Spacechar | @Newline !@BlankLine))+ > Ticks1 | Ticks2 < ((!"`" Nonspacechar)+ | !Ticks2 /`+/ | !Ticks2 (@Spacechar | @Newline !@BlankLine))+ > Ticks2 | Ticks3 < ((!"`" Nonspacechar)+ | !Ticks3 /`+/ | !Ticks3 (@Spacechar | @Newline !@BlankLine))+ > Ticks3 | Ticks4 < ((!"`" Nonspacechar)+ | !Ticks4 /`+/ | !Ticks4 (@Spacechar | @Newline !@BlankLine))+ > Ticks4 | Ticks5 < ((!"`" Nonspacechar)+ | !Ticks5 /`+/ | !Ticks5 (@Spacechar | @Newline !@BlankLine))+ > Ticks5) { code text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12584 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12594 def _Code; end # CodeFence = &{ github? } Ticks3 (@Sp StrChunk:format)? Spnl < ((!"`" Nonspacechar)+ | !Ticks3 /`+/ | Spacechar | @Newline)+ > Ticks3 @Sp @Newline* { verbatim = RDoc::Markup::Verbatim.new text verbatim.format = format.intern if format.instance_of?(String) verbatim } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15564 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15574 def _CodeFence; end - # DecEntity = "&#" < /[0-9]+/ > ";" { [text.to_i].pack 'U' } + # DecEntity = "&#" < /[0-9]+/ > ";" { rdoc_escape([text.to_i].pack('U')) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14659 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14669 def _DecEntity; end # DefinitionList = &{ definition_lists? } DefinitionListItem+:list { RDoc::Markup::List.new :NOTE, *list.flatten } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16225 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16235 def _DefinitionList; end # DefinitionListDefinition = @NonindentSpace ":" @Space Inlines:a @BlankLine+ { paragraph a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16368 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16378 def _DefinitionListDefinition; end # DefinitionListItem = DefinitionListLabel+:label DefinitionListDefinition+:defns { list_items = [] list_items << RDoc::Markup::ListItem.new(label, defns.shift) list_items.concat defns.map { |defn| RDoc::Markup::ListItem.new nil, defn } unless list_items.empty? list_items } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16269 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16279 def _DefinitionListItem; end # DefinitionListLabel = Inline:label @Sp @Newline { label } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16335 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16345 def _DefinitionListLabel; end # Digit = [0-9] # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14574 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14584 def _Digit; end # Doc = BOM? Block*:a { RDoc::Markup::Document.new(*a.compact) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:950 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:960 def _Doc; end # Emph = (EmphStar | EmphUl) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10344 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10354 def _Emph; end # EmphStar = "*" !@Whitespace @StartList:a (!"*" Inline:b { a << b } | StrongStar:b { a << b })+ "*" { emphasis a.join } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10380 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10390 def _EmphStar; end # EmphUl = "_" !@Whitespace @StartList:a (!"_" Inline:b { a << b } | StrongUl:b { a << b })+ "_" { emphasis a.join } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10538 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10548 def _EmphUl; end # EmptyTitle = "" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12159 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12169 def _EmptyTitle; end # Endline = (@LineBreak | @TerminalEndline | @NormalEndline) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9978 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9988 def _Endline; end # Entity = (HexEntity | DecEntity | CharEntity):a { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9941 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9951 def _Entity; end # Enumerator = @NonindentSpace [0-9]+ "." @Spacechar+ # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2748 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2758 def _Enumerator; end # Eof = !. # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14425 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14435 def _Eof; end - # EscapedChar = "\\" !@Newline < /[:\\`|*_{}\[\]()#+.!><-]/ > { text } + # EscapedChar = "\\" !@Newline < /[:\\`|*_{}\[\]()#+.!><-]/ > { rdoc_escape(text) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9902 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9912 def _EscapedChar; end - # ExplicitLink = ExplicitLinkWithLabel:a { "{#{a[:label]}}[#{a[:link]}]" } + # ExplicitLink = ExplicitLinkWithLabel:a { "{#{a[:label]}}[#{rdoc_link_url_escape(a[:link])}]" } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11197 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11207 def _ExplicitLink; end # ExplicitLinkWithLabel = Label:label "(" @Sp Source:link Spnl Title @Sp ")" { { label: label, link: link } } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11220 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11230 def _ExplicitLinkWithLabel; end # ExtendedSpecialChar = &{ notes? } "^" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15067 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15077 def _ExtendedSpecialChar; end # Heading = (SetextHeading | AtxHeading) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1609 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1619 def _Heading; end - # HexEntity = /&#x/i < /[0-9a-fA-F]+/ > ";" { [text.to_i(16)].pack 'U' } + # HexEntity = /&#x/i < /[0-9a-fA-F]+/ > ";" { rdoc_escape([text.to_i(16)].pack('U')) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14623 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14633 def _HexEntity; end # HorizontalRule = @NonindentSpace ("*" @Sp "*" @Sp "*" (@Sp "*")* | "-" @Sp "-" @Sp "-" (@Sp "-")* | "_" @Sp "_" @Sp "_" (@Sp "_")*) @Sp @Newline @BlankLine+ { RDoc::Markup::Rule.new 1 } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1993 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2003 def _HorizontalRule; end # HtmlAnchor = HtmlOpenAnchor (HtmlAnchor | !HtmlCloseAnchor .)* HtmlCloseAnchor # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3032 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3042 def _HtmlAnchor; end # HtmlAttribute = (AlphanumericAscii | "-")+ Spnl ("=" Spnl (Quoted | (!">" Nonspacechar)+))? Spnl # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14156 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14166 def _HtmlAttribute; end # HtmlBlock = < (HtmlBlockInTags | HtmlComment | HtmlBlockSelfClosing | HtmlUnclosed) > @BlankLine+ { if html? then RDoc::Markup::Raw.new text end } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8829 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8839 def _HtmlBlock; end # HtmlBlockAddress = HtmlBlockOpenAddress (HtmlBlockAddress | !HtmlBlockCloseAddress .)* HtmlBlockCloseAddress # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3198 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3208 def _HtmlBlockAddress; end # HtmlBlockBlockquote = HtmlBlockOpenBlockquote (HtmlBlockBlockquote | !HtmlBlockCloseBlockquote .)* HtmlBlockCloseBlockquote # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3364 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3374 def _HtmlBlockBlockquote; end # HtmlBlockCenter = HtmlBlockOpenCenter (HtmlBlockCenter | !HtmlBlockCloseCenter .)* HtmlBlockCloseCenter # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3530 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3540 def _HtmlBlockCenter; end # HtmlBlockCloseAddress = "<" Spnl "/" ("address" | "ADDRESS") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3146 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3156 def _HtmlBlockCloseAddress; end # HtmlBlockCloseBlockquote = "<" Spnl "/" ("blockquote" | "BLOCKQUOTE") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3312 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3322 def _HtmlBlockCloseBlockquote; end # HtmlBlockCloseCenter = "<" Spnl "/" ("center" | "CENTER") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3478 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3488 def _HtmlBlockCloseCenter; end # HtmlBlockCloseDd = "<" Spnl "/" ("dd" | "DD") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6798 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6808 def _HtmlBlockCloseDd; end # HtmlBlockCloseDir = "<" Spnl "/" ("dir" | "DIR") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3644 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3654 def _HtmlBlockCloseDir; end # HtmlBlockCloseDiv = "<" Spnl "/" ("div" | "DIV") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3810 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3820 def _HtmlBlockCloseDiv; end # HtmlBlockCloseDl = "<" Spnl "/" ("dl" | "DL") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3976 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3986 def _HtmlBlockCloseDl; end # HtmlBlockCloseDt = "<" Spnl "/" ("dt" | "DT") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6964 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6974 def _HtmlBlockCloseDt; end # HtmlBlockCloseFieldset = "<" Spnl "/" ("fieldset" | "FIELDSET") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4142 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4152 def _HtmlBlockCloseFieldset; end # HtmlBlockCloseForm = "<" Spnl "/" ("form" | "FORM") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4308 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4318 def _HtmlBlockCloseForm; end # HtmlBlockCloseFrameset = "<" Spnl "/" ("frameset" | "FRAMESET") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7130 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7140 def _HtmlBlockCloseFrameset; end # HtmlBlockCloseH1 = "<" Spnl "/" ("h1" | "H1") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4474 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4484 def _HtmlBlockCloseH1; end # HtmlBlockCloseH2 = "<" Spnl "/" ("h2" | "H2") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4640 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4650 def _HtmlBlockCloseH2; end # HtmlBlockCloseH3 = "<" Spnl "/" ("h3" | "H3") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4806 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4816 def _HtmlBlockCloseH3; end # HtmlBlockCloseH4 = "<" Spnl "/" ("h4" | "H4") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4972 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4982 def _HtmlBlockCloseH4; end # HtmlBlockCloseH5 = "<" Spnl "/" ("h5" | "H5") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5138 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5148 def _HtmlBlockCloseH5; end # HtmlBlockCloseH6 = "<" Spnl "/" ("h6" | "H6") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5304 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5314 def _HtmlBlockCloseH6; end # HtmlBlockCloseHead = "<" Spnl "/" ("head" | "HEAD") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8613 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8623 def _HtmlBlockCloseHead; end # HtmlBlockCloseLi = "<" Spnl "/" ("li" | "LI") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7296 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7306 def _HtmlBlockCloseLi; end # HtmlBlockCloseMenu = "<" Spnl "/" ("menu" | "MENU") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5470 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5480 def _HtmlBlockCloseMenu; end # HtmlBlockCloseNoframes = "<" Spnl "/" ("noframes" | "NOFRAMES") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5636 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5646 def _HtmlBlockCloseNoframes; end # HtmlBlockCloseNoscript = "<" Spnl "/" ("noscript" | "NOSCRIPT") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5802 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5812 def _HtmlBlockCloseNoscript; end # HtmlBlockCloseOl = "<" Spnl "/" ("ol" | "OL") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5968 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5978 def _HtmlBlockCloseOl; end # HtmlBlockCloseP = "<" Spnl "/" ("p" | "P") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6134 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6144 def _HtmlBlockCloseP; end # HtmlBlockClosePre = "<" Spnl "/" ("pre" | "PRE") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6300 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6310 def _HtmlBlockClosePre; end # HtmlBlockCloseScript = "<" Spnl "/" ("script" | "SCRIPT") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8458 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8468 def _HtmlBlockCloseScript; end # HtmlBlockCloseTable = "<" Spnl "/" ("table" | "TABLE") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6466 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6476 def _HtmlBlockCloseTable; end # HtmlBlockCloseTbody = "<" Spnl "/" ("tbody" | "TBODY") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7462 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7472 def _HtmlBlockCloseTbody; end # HtmlBlockCloseTd = "<" Spnl "/" ("td" | "TD") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7628 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7638 def _HtmlBlockCloseTd; end # HtmlBlockCloseTfoot = "<" Spnl "/" ("tfoot" | "TFOOT") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7794 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7804 def _HtmlBlockCloseTfoot; end # HtmlBlockCloseTh = "<" Spnl "/" ("th" | "TH") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7960 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7970 def _HtmlBlockCloseTh; end # HtmlBlockCloseThead = "<" Spnl "/" ("thead" | "THEAD") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8126 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8136 def _HtmlBlockCloseThead; end # HtmlBlockCloseTr = "<" Spnl "/" ("tr" | "TR") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8292 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8302 def _HtmlBlockCloseTr; end # HtmlBlockCloseUl = "<" Spnl "/" ("ul" | "UL") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6632 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6642 def _HtmlBlockCloseUl; end # HtmlBlockDd = HtmlBlockOpenDd (HtmlBlockDd | !HtmlBlockCloseDd .)* HtmlBlockCloseDd # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6850 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6860 def _HtmlBlockDd; end # HtmlBlockDir = HtmlBlockOpenDir (HtmlBlockDir | !HtmlBlockCloseDir .)* HtmlBlockCloseDir # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3696 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3706 def _HtmlBlockDir; end # HtmlBlockDiv = HtmlBlockOpenDiv (HtmlBlockDiv | !HtmlBlockCloseDiv .)* HtmlBlockCloseDiv # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3862 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3872 def _HtmlBlockDiv; end # HtmlBlockDl = HtmlBlockOpenDl (HtmlBlockDl | !HtmlBlockCloseDl .)* HtmlBlockCloseDl # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4028 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4038 def _HtmlBlockDl; end # HtmlBlockDt = HtmlBlockOpenDt (HtmlBlockDt | !HtmlBlockCloseDt .)* HtmlBlockCloseDt # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7016 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7026 def _HtmlBlockDt; end # HtmlBlockFieldset = HtmlBlockOpenFieldset (HtmlBlockFieldset | !HtmlBlockCloseFieldset .)* HtmlBlockCloseFieldset # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4194 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4204 def _HtmlBlockFieldset; end # HtmlBlockForm = HtmlBlockOpenForm (HtmlBlockForm | !HtmlBlockCloseForm .)* HtmlBlockCloseForm # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4360 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4370 def _HtmlBlockForm; end # HtmlBlockFrameset = HtmlBlockOpenFrameset (HtmlBlockFrameset | !HtmlBlockCloseFrameset .)* HtmlBlockCloseFrameset # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7182 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7192 def _HtmlBlockFrameset; end # HtmlBlockH1 = HtmlBlockOpenH1 (HtmlBlockH1 | !HtmlBlockCloseH1 .)* HtmlBlockCloseH1 # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4526 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4536 def _HtmlBlockH1; end # HtmlBlockH2 = HtmlBlockOpenH2 (HtmlBlockH2 | !HtmlBlockCloseH2 .)* HtmlBlockCloseH2 # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4692 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4702 def _HtmlBlockH2; end # HtmlBlockH3 = HtmlBlockOpenH3 (HtmlBlockH3 | !HtmlBlockCloseH3 .)* HtmlBlockCloseH3 # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4858 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4868 def _HtmlBlockH3; end # HtmlBlockH4 = HtmlBlockOpenH4 (HtmlBlockH4 | !HtmlBlockCloseH4 .)* HtmlBlockCloseH4 # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5024 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5034 def _HtmlBlockH4; end # HtmlBlockH5 = HtmlBlockOpenH5 (HtmlBlockH5 | !HtmlBlockCloseH5 .)* HtmlBlockCloseH5 # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5190 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5200 def _HtmlBlockH5; end # HtmlBlockH6 = HtmlBlockOpenH6 (HtmlBlockH6 | !HtmlBlockCloseH6 .)* HtmlBlockCloseH6 # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5356 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5366 def _HtmlBlockH6; end # HtmlBlockHead = HtmlBlockOpenHead (!HtmlBlockCloseHead .)* HtmlBlockCloseHead # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8665 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8675 def _HtmlBlockHead; end # HtmlBlockInTags = (HtmlAnchor | HtmlBlockAddress | HtmlBlockBlockquote | HtmlBlockCenter | HtmlBlockDir | HtmlBlockDiv | HtmlBlockDl | HtmlBlockFieldset | HtmlBlockForm | HtmlBlockH1 | HtmlBlockH2 | HtmlBlockH3 | HtmlBlockH4 | HtmlBlockH5 | HtmlBlockH6 | HtmlBlockMenu | HtmlBlockNoframes | HtmlBlockNoscript | HtmlBlockOl | HtmlBlockP | HtmlBlockPre | HtmlBlockTable | HtmlBlockUl | HtmlBlockDd | HtmlBlockDt | HtmlBlockFrameset | HtmlBlockLi | HtmlBlockTbody | HtmlBlockTd | HtmlBlockTfoot | HtmlBlockTh | HtmlBlockThead | HtmlBlockTr | HtmlBlockScript | HtmlBlockHead) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8712 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8722 def _HtmlBlockInTags; end # HtmlBlockLi = HtmlBlockOpenLi (HtmlBlockLi | !HtmlBlockCloseLi .)* HtmlBlockCloseLi # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7348 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7358 def _HtmlBlockLi; end # HtmlBlockMenu = HtmlBlockOpenMenu (HtmlBlockMenu | !HtmlBlockCloseMenu .)* HtmlBlockCloseMenu # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5522 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5532 def _HtmlBlockMenu; end # HtmlBlockNoframes = HtmlBlockOpenNoframes (HtmlBlockNoframes | !HtmlBlockCloseNoframes .)* HtmlBlockCloseNoframes # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5688 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5698 def _HtmlBlockNoframes; end # HtmlBlockNoscript = HtmlBlockOpenNoscript (HtmlBlockNoscript | !HtmlBlockCloseNoscript .)* HtmlBlockCloseNoscript # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5854 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5864 def _HtmlBlockNoscript; end # HtmlBlockOl = HtmlBlockOpenOl (HtmlBlockOl | !HtmlBlockCloseOl .)* HtmlBlockCloseOl # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6020 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6030 def _HtmlBlockOl; end # HtmlBlockOpenAddress = "<" Spnl ("address" | "ADDRESS") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3090 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3100 def _HtmlBlockOpenAddress; end # HtmlBlockOpenBlockquote = "<" Spnl ("blockquote" | "BLOCKQUOTE") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3256 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3266 def _HtmlBlockOpenBlockquote; end # HtmlBlockOpenCenter = "<" Spnl ("center" | "CENTER") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3422 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3432 def _HtmlBlockOpenCenter; end # HtmlBlockOpenDd = "<" Spnl ("dd" | "DD") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6742 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6752 def _HtmlBlockOpenDd; end # HtmlBlockOpenDir = "<" Spnl ("dir" | "DIR") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3588 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3598 def _HtmlBlockOpenDir; end # HtmlBlockOpenDiv = "<" Spnl ("div" | "DIV") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3754 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3764 def _HtmlBlockOpenDiv; end # HtmlBlockOpenDl = "<" Spnl ("dl" | "DL") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:3920 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:3930 def _HtmlBlockOpenDl; end # HtmlBlockOpenDt = "<" Spnl ("dt" | "DT") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6908 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6918 def _HtmlBlockOpenDt; end # HtmlBlockOpenFieldset = "<" Spnl ("fieldset" | "FIELDSET") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4086 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4096 def _HtmlBlockOpenFieldset; end # HtmlBlockOpenForm = "<" Spnl ("form" | "FORM") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4252 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4262 def _HtmlBlockOpenForm; end # HtmlBlockOpenFrameset = "<" Spnl ("frameset" | "FRAMESET") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7074 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7084 def _HtmlBlockOpenFrameset; end # HtmlBlockOpenH1 = "<" Spnl ("h1" | "H1") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4418 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4428 def _HtmlBlockOpenH1; end # HtmlBlockOpenH2 = "<" Spnl ("h2" | "H2") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4584 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4594 def _HtmlBlockOpenH2; end # HtmlBlockOpenH3 = "<" Spnl ("h3" | "H3") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4750 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4760 def _HtmlBlockOpenH3; end # HtmlBlockOpenH4 = "<" Spnl ("h4" | "H4") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:4916 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:4926 def _HtmlBlockOpenH4; end # HtmlBlockOpenH5 = "<" Spnl ("h5" | "H5") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5082 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5092 def _HtmlBlockOpenH5; end # HtmlBlockOpenH6 = "<" Spnl ("h6" | "H6") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5248 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5258 def _HtmlBlockOpenH6; end # HtmlBlockOpenHead = "<" Spnl ("head" | "HEAD") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8557 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8567 def _HtmlBlockOpenHead; end # HtmlBlockOpenLi = "<" Spnl ("li" | "LI") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7240 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7250 def _HtmlBlockOpenLi; end # HtmlBlockOpenMenu = "<" Spnl ("menu" | "MENU") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5414 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5424 def _HtmlBlockOpenMenu; end # HtmlBlockOpenNoframes = "<" Spnl ("noframes" | "NOFRAMES") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5580 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5590 def _HtmlBlockOpenNoframes; end # HtmlBlockOpenNoscript = "<" Spnl ("noscript" | "NOSCRIPT") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5746 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5756 def _HtmlBlockOpenNoscript; end # HtmlBlockOpenOl = "<" Spnl ("ol" | "OL") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:5912 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:5922 def _HtmlBlockOpenOl; end # HtmlBlockOpenP = "<" Spnl ("p" | "P") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6078 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6088 def _HtmlBlockOpenP; end # HtmlBlockOpenPre = "<" Spnl ("pre" | "PRE") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6244 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6254 def _HtmlBlockOpenPre; end # HtmlBlockOpenScript = "<" Spnl ("script" | "SCRIPT") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8402 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8412 def _HtmlBlockOpenScript; end # HtmlBlockOpenTable = "<" Spnl ("table" | "TABLE") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6410 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6420 def _HtmlBlockOpenTable; end # HtmlBlockOpenTbody = "<" Spnl ("tbody" | "TBODY") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7406 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7416 def _HtmlBlockOpenTbody; end # HtmlBlockOpenTd = "<" Spnl ("td" | "TD") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7572 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7582 def _HtmlBlockOpenTd; end # HtmlBlockOpenTfoot = "<" Spnl ("tfoot" | "TFOOT") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7738 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7748 def _HtmlBlockOpenTfoot; end # HtmlBlockOpenTh = "<" Spnl ("th" | "TH") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7904 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7914 def _HtmlBlockOpenTh; end # HtmlBlockOpenThead = "<" Spnl ("thead" | "THEAD") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8070 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8080 def _HtmlBlockOpenThead; end # HtmlBlockOpenTr = "<" Spnl ("tr" | "TR") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8236 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8246 def _HtmlBlockOpenTr; end # HtmlBlockOpenUl = "<" Spnl ("ul" | "UL") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6576 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6586 def _HtmlBlockOpenUl; end # HtmlBlockP = HtmlBlockOpenP (HtmlBlockP | !HtmlBlockCloseP .)* HtmlBlockCloseP # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6186 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6196 def _HtmlBlockP; end # HtmlBlockPre = HtmlBlockOpenPre (HtmlBlockPre | !HtmlBlockClosePre .)* HtmlBlockClosePre # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6352 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6362 def _HtmlBlockPre; end # HtmlBlockScript = HtmlBlockOpenScript (!HtmlBlockCloseScript .)* HtmlBlockCloseScript # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8510 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8520 def _HtmlBlockScript; end # HtmlBlockSelfClosing = "<" Spnl HtmlBlockType Spnl HtmlAttribute* "/" Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8957 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8967 def _HtmlBlockSelfClosing; end # HtmlBlockTable = HtmlBlockOpenTable (HtmlBlockTable | !HtmlBlockCloseTable .)* HtmlBlockCloseTable # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6518 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6528 def _HtmlBlockTable; end # HtmlBlockTbody = HtmlBlockOpenTbody (HtmlBlockTbody | !HtmlBlockCloseTbody .)* HtmlBlockCloseTbody # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7514 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7524 def _HtmlBlockTbody; end # HtmlBlockTd = HtmlBlockOpenTd (HtmlBlockTd | !HtmlBlockCloseTd .)* HtmlBlockCloseTd # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7680 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7690 def _HtmlBlockTd; end # HtmlBlockTfoot = HtmlBlockOpenTfoot (HtmlBlockTfoot | !HtmlBlockCloseTfoot .)* HtmlBlockCloseTfoot # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:7846 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:7856 def _HtmlBlockTfoot; end # HtmlBlockTh = HtmlBlockOpenTh (HtmlBlockTh | !HtmlBlockCloseTh .)* HtmlBlockCloseTh # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8012 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8022 def _HtmlBlockTh; end # HtmlBlockThead = HtmlBlockOpenThead (HtmlBlockThead | !HtmlBlockCloseThead .)* HtmlBlockCloseThead # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8178 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8188 def _HtmlBlockThead; end # HtmlBlockTr = HtmlBlockOpenTr (HtmlBlockTr | !HtmlBlockCloseTr .)* HtmlBlockCloseTr # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8344 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8354 def _HtmlBlockTr; end # HtmlBlockType = ("ADDRESS" | "BLOCKQUOTE" | "CENTER" | "DD" | "DIR" | "DIV" | "DL" | "DT" | "FIELDSET" | "FORM" | "FRAMESET" | "H1" | "H2" | "H3" | "H4" | "H5" | "H6" | "HR" | "ISINDEX" | "LI" | "MENU" | "NOFRAMES" | "NOSCRIPT" | "OL" | "P" | "PRE" | "SCRIPT" | "TABLE" | "TBODY" | "TD" | "TFOOT" | "TH" | "THEAD" | "TR" | "UL" | "address" | "blockquote" | "center" | "dd" | "dir" | "div" | "dl" | "dt" | "fieldset" | "form" | "frameset" | "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "hr" | "isindex" | "li" | "menu" | "noframes" | "noscript" | "ol" | "p" | "pre" | "script" | "table" | "tbody" | "td" | "tfoot" | "th" | "thead" | "tr" | "ul") # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9012 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9022 def _HtmlBlockType; end # HtmlBlockUl = HtmlBlockOpenUl (HtmlBlockUl | !HtmlBlockCloseUl .)* HtmlBlockCloseUl # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:6684 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:6694 def _HtmlBlockUl; end # HtmlCloseAnchor = "<" Spnl "/" ("a" | "A") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2980 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2990 def _HtmlCloseAnchor; end # HtmlComment = "" .)* "-->" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14298 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14308 def _HtmlComment; end # HtmlOpenAnchor = "<" Spnl ("a" | "A") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2924 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2934 def _HtmlOpenAnchor; end # HtmlTag = "<" Spnl "/"? AlphanumericAscii+ Spnl HtmlAttribute* "/"? Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14345 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14355 def _HtmlTag; end # HtmlUnclosed = "<" Spnl HtmlUnclosedType Spnl HtmlAttribute* Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8889 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8899 def _HtmlUnclosed; end # HtmlUnclosedType = ("HR" | "hr") # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:8939 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:8949 def _HtmlUnclosedType; end # Image = "!" ExplicitLinkWithLabel:a { "rdoc-image:#{a[:link]}:#{a[:label]}" } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11033 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11043 def _Image; end # InStyleTags = StyleOpen (!StyleClose .)* StyleClose # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9342 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9352 def _InStyleTags; end # Indent = /\t| / # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14743 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14753 def _Indent; end # IndentedLine = Indent Line # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14750 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14760 def _IndentedLine; end # Inline = (Str | @Endline | UlOrStarLine | @Space | Strong | Emph | Strike | Image | Link | NoteReference | InlineNote | Code | RawHtml | Entity | EscapedChar | Symbol) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9647 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9657 def _Inline; end # InlineNote = &{ notes? } "^[" @StartList:a (!"]" Inline:l { a << l })+ "]" { ref = [:inline, @note_order.length] @footnotes[ref] = paragraph a note_for ref } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15314 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15324 def _InlineNote; end # Inlines = (!@Endline Inline:i { i } | @Endline:c !(&{ github? } Ticks3 /[^`\n]*$/) &Inline { c })+:chunks @Endline? { chunks } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9426 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9436 def _Inlines; end # Label = "[" (!"^" &{ notes? } | &. &{ !notes? }) @StartList:a (!"]" Inline:l { a << l })* "]" { a.join.gsub(/\s+/, ' ') } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11980 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11990 def _Label; end # Line = @RawLine:a { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14821 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14831 def _Line; end # LineBreak = " " @NormalEndline { RDoc::Markup::HardBreak.new } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10103 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10113 def _LineBreak; end # Link = (ExplicitLink | ReferenceLink | AutoLink) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11061 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11071 def _Link; end # ListBlock = !@BlankLine Line:a ListBlockLine*:c { [a, *c] } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2609 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2619 def _ListBlock; end # ListBlockLine = !@BlankLine !(Indent? (Bullet | Enumerator)) !HorizontalRule OptionallyIndentedLine # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2854 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2864 def _ListBlockLine; end # ListContinuationBlock = @StartList:a @BlankLine* { a << "\n" } (Indent ListBlock:b { a.concat b })+ { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2653 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2663 def _ListContinuationBlock; end # ListItem = (Bullet | Enumerator) @StartList:a ListBlock:b { a << b } (ListContinuationBlock:c { a.push(*c) })* { list_item_from a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2453 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2463 def _ListItem; end # ListItemTight = (Bullet | Enumerator) ListBlock:a (!@BlankLine ListContinuationBlock:b { a.push(*b) })* !ListContinuationBlock { list_item_from a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2529 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2539 def _ListItemTight; end # ListLoose = @StartList:a (ListItem:b @BlankLine* { a << b })+ { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2365 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2375 def _ListLoose; end # ListTight = ListItemTight+:a @BlankLine* !(Bullet | Enumerator) { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2300 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2310 def _ListTight; end # Newline = %literals.Newline # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14609 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14619 def _Newline; end # NonblankIndentedLine = !@BlankLine IndentedLine # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1882 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1892 def _NonblankIndentedLine; end # NonindentSpace = / {0,3}/ # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14736 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14746 def _NonindentSpace; end # Nonspacechar = !@Spacechar !@Newline . # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14435 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14445 def _Nonspacechar; end # NormalChar = !(@SpecialChar | @Spacechar | @Newline) . # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14536 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14546 def _NormalChar; end # NormalEndline = @Sp @Newline !@BlankLine !">" !AtxStart !(Line /={1,}|-{1,}/ @Newline) { "\n" } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9999 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10009 def _NormalEndline; end # Note = &{ notes? } @NonindentSpace RawNoteReference:ref ":" @Sp @StartList:a RawNoteBlock:i { a.concat i } (&Indent RawNoteBlock:i { a.concat i })* { @footnotes[ref] = paragraph a nil } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15216 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15226 def _Note; end # NoteReference = &{ notes? } RawNoteReference:ref { note_for ref } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15090 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15100 def _NoteReference; end # Notes = (Note | SkipBlock)* # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15421 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15431 def _Notes; end # OptionallyIndentedLine = Indent? Line # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14771 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14781 def _OptionallyIndentedLine; end # OrderedList = &Enumerator (ListTight | ListLoose):a { RDoc::Markup::List.new(:NUMBER, *a) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:2813 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:2823 def _OrderedList; end # Para = @NonindentSpace Inlines:a @BlankLine+ { paragraph a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1065 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1075 def _Para; end # Plain = Inlines:a { paragraph a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1108 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1118 def _Plain; end # Quoted = ("\"" (!"\"" .)* "\"" | "'" (!"'" .)* "'") # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14058 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14068 def _Quoted; end # RawHtml = < (HtmlComment | HtmlBlockScript | HtmlTag) > { if html? then text else '' end } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:13991 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14001 def _RawHtml; end # RawLine = (< /[^\r\n]*/ @Newline > | < .+ > @Eof) { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14844 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14854 def _RawLine; end # RawNoteBlock = @StartList:a (!@BlankLine !RawNoteReference OptionallyIndentedLine:l { a << l })+ < @BlankLine* > { a << text } { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15443 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15453 def _RawNoteBlock; end # RawNoteReference = "[^" < (!@Newline !"]" .)+ > "]" { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15120 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15130 def _RawNoteReference; end # RefSrc = < Nonspacechar+ > { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12099 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12109 def _RefSrc; end # RefTitle = (RefTitleSingle | RefTitleDouble | RefTitleParens | EmptyTitle) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12135 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12145 def _RefTitle; end # RefTitleDouble = Spnl "\"" < (!("\"" @Sp @Newline | @Newline) .)* > "\"" { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12258 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12268 def _RefTitleDouble; end # RefTitleParens = Spnl "(" < (!(")" @Sp @Newline | @Newline) .)* > ")" { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12350 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12360 def _RefTitleParens; end # RefTitleSingle = Spnl "'" < (!("'" @Sp @Newline | @Newline) .)* > "'" { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12166 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12176 def _RefTitleSingle; end # Reference = @NonindentSpace !"[]" Label:label ":" Spnl RefSrc:link RefTitle @BlankLine+ { # TODO use title reference label, link nil } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11905 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11915 def _Reference; end # ReferenceLink = (ReferenceLinkDouble | ReferenceLinkSingle) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11082 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11092 def _ReferenceLink; end # ReferenceLinkDouble = Label:content < Spnl > !"[]" Label:label { link_to content, label, text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11100 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11110 def _ReferenceLinkDouble; end # ReferenceLinkSingle = Label:content < (Spnl "[]")? > { link_to content, content, text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11146 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11156 def _ReferenceLinkSingle; end # References = (Reference | SkipBlock)* # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12442 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12452 def _References; end # SetextBottom1 = /={1,}/ @Newline # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1323 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1333 def _SetextBottom1; end # SetextBottom2 = /-{1,}/ @Newline # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1344 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1354 def _SetextBottom2; end # SetextHeading = (SetextHeading1 | SetextHeading2) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1305 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1315 def _SetextHeading; end # SetextHeading1 = &(@RawLine SetextBottom1) @StartList:a (!@Endline Inline:b { a << b })+ @Sp @Newline SetextBottom1 { RDoc::Markup::Heading.new(1, a.join) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1365 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1375 def _SetextHeading1; end # SetextHeading2 = &(@RawLine SetextBottom2) @StartList:a (!@Endline Inline:b { a << b })+ @Sp @Newline SetextBottom2 { RDoc::Markup::Heading.new(2, a.join) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1487 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1497 def _SetextHeading2; end # SkipBlock = (HtmlBlock | (!"#" !SetextBottom1 !SetextBottom2 !@BlankLine @RawLine)+ @BlankLine* | @BlankLine+ | @RawLine) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14923 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14933 def _SkipBlock; end # Source = ("<" < SourceContents > ">" | < SourceContents >) { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11279 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11289 def _Source; end # SourceContents = ((!"(" !")" !">" Nonspacechar)+ | "(" SourceContents ")")* # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11339 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11349 def _SourceContents; end # Sp = @Spacechar* # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14467 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14477 def _Sp; end # Space = @Spacechar+ { " " } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9707 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9717 def _Space; end # Spacechar = %literals.Spacechar # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14616 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14626 def _Spacechar; end # SpecialChar = (/[~*_`&\[\]() { text } | < @Spacechar /\*+/ &@Spacechar > { text }) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10190 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10200 def _StarLine; end # StartList = &. { [] } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:14797 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:14807 def _StartList; end - # Str = @StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { a } + # Str = @StartList:a < @NormalChar+ > { a = text } (StrChunk:c { a << c })* { rdoc_escape(a) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9739 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9749 def _Str; end # StrChunk = < (@NormalChar | /_+/ &Alphanumeric)+ > { text } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9812 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9822 def _StrChunk; end # Strike = &{ strike? } "~~" !@Whitespace @StartList:a (!"~~" Inline:b { a << b })+ "~~" { strike a.join } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10922 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10932 def _Strike; end # Strong = (StrongStar | StrongUl) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10696 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10706 def _Strong; end # StrongStar = "**" !@Whitespace @StartList:a (!"**" Inline:b { a << b })+ "**" { strong a.join } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10714 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10724 def _StrongStar; end # StrongUl = "__" !@Whitespace @StartList:a (!"__" Inline:b { a << b })+ "__" { strong a.join } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10818 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10828 def _StrongUl; end # StyleBlock = < InStyleTags > @BlankLine* { if css? then RDoc::Markup::Raw.new text end } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9389 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9399 def _StyleBlock; end # StyleClose = "<" Spnl "/" ("style" | "STYLE") Spnl ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9290 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9300 def _StyleClose; end # StyleOpen = "<" Spnl ("style" | "STYLE") Spnl HtmlAttribute* ">" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:9234 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:9244 def _StyleOpen; end - # Symbol = < @SpecialChar > { text } + # Symbol = < @SpecialChar > { rdoc_escape(text) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10130 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10140 def _Symbol; end # Table = &{ github? } TableHead:header TableLine:line TableRow+:body { table = RDoc::Markup::Table.new(header, line, body) parse_table_cells(table) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15820 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15830 def _Table; end # TableAlign = < /:?-+:?/ > @Sp { text.start_with?(":") ? (text.end_with?(":") ? :center : :left) : (text.end_with?(":") ? :right : nil) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16190 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16200 def _TableAlign; end # TableAlign2 = "|" @Sp TableAlign # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16164 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16174 def _TableAlign2; end # TableHead = TableItem2+:items "|"? @Newline { items } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15879 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15889 def _TableHead; end # TableItem = < /(?:\\.|[^|\n])+/ > { text.strip.gsub(/\\([|])/, '\1') } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16045 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16055 def _TableItem; end # TableItem2 = "|" TableItem # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16024 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16034 def _TableItem2; end # TableLine = ((TableAlign:align1 TableAlign2*:aligns {[align1, *aligns] }):line | TableAlign2+:line) "|"? @Newline { line } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:16071 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:16081 def _TableLine; end # TableRow = ((TableItem:item1 TableItem2*:items { [item1, *items] }):row | TableItem2+:row) "|"? @Newline { row } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:15931 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:15941 def _TableRow; end # TerminalEndline = @Sp @Newline @Eof # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10077 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10087 def _TerminalEndline; end # Ticks1 = "`" !"`" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12464 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12474 def _Ticks1; end # Ticks2 = "``" !"`" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12488 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12498 def _Ticks2; end # Ticks3 = "```" !"`" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12512 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12522 def _Ticks3; end # Ticks4 = "````" !"`" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12536 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12546 def _Ticks4; end # Ticks5 = "`````" !"`" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:12560 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:12570 def _Ticks5; end # Title = (TitleSingle | TitleDouble | ""):a { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11456 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11466 def _Title; end # TitleDouble = "\"" (!("\"" @Sp (")" | @Newline)) .)* "\"" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11570 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11580 def _TitleDouble; end # TitleSingle = "'" (!("'" @Sp (")" | @Newline)) .)* "'" # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:11493 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:11503 def _TitleSingle; end # UlLine = (< /_{4,}/ > { text } | < @Spacechar /_+/ &@Spacechar > { text }) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10267 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10277 def _UlLine; end # UlOrStarLine = (UlLine | StarLine):a { a } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10156 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10166 def _UlOrStarLine; end # Verbatim = VerbatimChunk+:a { RDoc::Markup::Verbatim.new(*a.flatten) } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1956 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1966 def _Verbatim; end # VerbatimChunk = @BlankLine*:a NonblankIndentedLine+:b { a.concat b } # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:1906 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:1916 def _VerbatimChunk; end # Whitespace = (@Spacechar | @Newline) # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:10362 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:10372 def _Whitespace; end # root = Doc # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:943 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:953 def _root; end # pkg:gem/rdoc#lib/rdoc/markdown.rb:502 @@ -4232,7 +4288,7 @@ class RDoc::Markdown # Wraps `text` in code markup for rdoc inline formatting # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:888 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:898 def code(text); end # pkg:gem/rdoc#lib/rdoc/markdown.rb:610 @@ -4268,7 +4324,7 @@ class RDoc::Markdown # # Enables or disables the extension with `name` # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:705 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:719 def extension(name, enable); end # :category: Extensions @@ -4277,7 +4333,7 @@ class RDoc::Markdown # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:696 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:710 def extension?(name); end # pkg:gem/rdoc#lib/rdoc/markdown.rb:449 @@ -4332,7 +4388,7 @@ class RDoc::Markdown # Parses `text` in a clone of this parser. This is used for handling nested # lists the same way as markdown_parser. # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:717 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:731 def inner_parse(text); end # pkg:gem/rdoc#lib/rdoc/markdown.rb:267 @@ -4345,13 +4401,13 @@ class RDoc::Markdown # # @raise [ParseError] # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:737 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:751 def link_to(content, label = T.unsafe(nil), text = T.unsafe(nil)); end # Creates an RDoc::Markup::ListItem by parsing the `unparsed` content from # the first parsing pass. # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:754 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:768 def list_item_from(unparsed); end # pkg:gem/rdoc#lib/rdoc/markdown.rb:373 @@ -4359,13 +4415,13 @@ class RDoc::Markdown # Stores `label` as a note and fills in previously unknown note references. # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:762 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:776 def note(label); end # Creates a new link for the footnote `reference` and adds the reference to # the note order list for proper display at the end of the document. # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:776 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:790 def note_for(ref); end # pkg:gem/rdoc#lib/rdoc/markdown.rb:610 @@ -4377,7 +4433,7 @@ class RDoc::Markdown # Creates an RDoc::Markup::Paragraph from `parts` and including # extension-specific behavior # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:793 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:807 def paragraph(parts); end # Parses `markdown` into an RDoc::Document @@ -4387,17 +4443,17 @@ class RDoc::Markdown # Parses inline markdown in a single table cell # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:914 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:924 def parse_cell_inline(text); end # Parses inline markdown in table cells # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:899 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:909 def parse_table_cells(table); end # The internal kpeg parse method # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:787 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:801 def peg_parse(rule = T.unsafe(nil)); end # Returns the value of attribute pos. @@ -4420,10 +4476,22 @@ class RDoc::Markdown # pkg:gem/rdoc#lib/rdoc/markdown.rb:341 def raise_error; end + # Escape character that has special meaning in RDoc format. + # To allow rdoc-styled link used in markdown format for now, bracket and brace are not escaped. + # + # pkg:gem/rdoc#lib/rdoc/markdown.rb:694 + def rdoc_escape(text); end + + # Escape link url that contains brackets. + # Brackets needs escape because link url will be surrounded by `[]` in RDoc format. + # + # pkg:gem/rdoc#lib/rdoc/markdown.rb:701 + def rdoc_link_url_escape(text); end + # Stores `label` as a reference to `link` and fills in previously unknown # link references. # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:855 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:869 def reference(label, link); end # Returns the value of attribute result. @@ -4451,7 +4519,7 @@ class RDoc::Markdown # :stopdoc: # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:938 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:948 def setup_foreign_grammar; end # Prepares for parsing +str+. If you define a custom initialize you must @@ -4468,7 +4536,7 @@ class RDoc::Markdown # Wraps `text` in strike markup for rdoc inline formatting # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:877 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:891 def strike(text); end # pkg:gem/rdoc#lib/rdoc/markdown.rb:610 @@ -4484,7 +4552,7 @@ class RDoc::Markdown # Wraps `text` in strong markup for rdoc inline formatting # - # pkg:gem/rdoc#lib/rdoc/markdown.rb:866 + # pkg:gem/rdoc#lib/rdoc/markdown.rb:880 def strong(text); end private @@ -5021,12 +5089,7 @@ class RDoc::Markup # @return [Markup] a new instance of Markup # # pkg:gem/rdoc#lib/rdoc/markup.rb:151 - def initialize(attribute_manager = T.unsafe(nil)); end - - # Add to the sequences recognized as general markup. - # - # pkg:gem/rdoc#lib/rdoc/markup.rb:168 - def add_html(tag, name); end + def initialize; end # Add to other inline sequences. For example, we could add WikiWords using # something like: @@ -5035,27 +5098,21 @@ class RDoc::Markup # # Each wiki word will be presented to the output formatter. # - # pkg:gem/rdoc#lib/rdoc/markup.rb:180 + # pkg:gem/rdoc#lib/rdoc/markup.rb:164 def add_regexp_handling(pattern, name); end - # Add to the sequences used to add formatting to an individual word (such - # as *bold*). Matching entries will generate attributes that the output - # formatters can recognize by their +name+. - # - # pkg:gem/rdoc#lib/rdoc/markup.rb:161 - def add_word_pair(start, stop, name); end - - # An AttributeManager which handles inline markup. - # - # pkg:gem/rdoc#lib/rdoc/markup.rb:116 - def attribute_manager; end - # We take +input+, parse it if necessary, then invoke the output +formatter+ # using a Visitor to render the result. # - # pkg:gem/rdoc#lib/rdoc/markup.rb:188 + # pkg:gem/rdoc#lib/rdoc/markup.rb:172 def convert(input, formatter); end + # Array of regexp handling pattern and its name. A regexp handling + # sequence is something like a WikiWord + # + # pkg:gem/rdoc#lib/rdoc/markup.rb:116 + def regexp_handlings; end + class << self # Parses +str+ into an RDoc::Markup::Document. # @@ -5064,279 +5121,6 @@ class RDoc::Markup end end -# An AttrChanger records a change in attributes. It contains a bitmap of the -# attributes to turn on, and a bitmap of those to turn off. -# -# pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 -class RDoc::Markup::AttrChanger < ::Struct - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:18 - def inspect; end - - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:14 - def to_s; end - - # Returns the value of attribute turn_off - # - # @return [Object] the current value of turn_off - # - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def turn_off; end - - # Sets the attribute turn_off - # - # @param value [Object] the value to set the attribute turn_off to. - # @return [Object] the newly set value - # - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def turn_off=(_); end - - # Returns the value of attribute turn_on - # - # @return [Object] the current value of turn_on - # - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def turn_on; end - - # Sets the attribute turn_on - # - # @param value [Object] the value to set the attribute turn_on to. - # @return [Object] the newly set value - # - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def turn_on=(_); end - - class << self - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def [](*_arg0); end - - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def inspect; end - - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def keyword_init?; end - - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def members; end - - # pkg:gem/rdoc#lib/rdoc/markup/attr_changer.rb:4 - def new(*_arg0); end - end -end - -# An array of attributes which parallels the characters in a string. -# -# pkg:gem/rdoc#lib/rdoc/markup/attr_span.rb:5 -class RDoc::Markup::AttrSpan - # Creates a new AttrSpan for +length+ characters - # - # @return [AttrSpan] a new instance of AttrSpan - # - # pkg:gem/rdoc#lib/rdoc/markup/attr_span.rb:10 - def initialize(length, exclusive); end - - # Accesses flags for character +n+ - # - # pkg:gem/rdoc#lib/rdoc/markup/attr_span.rb:31 - def [](n); end - - # Toggles +bits+ from +start+ to +length+ - # - # pkg:gem/rdoc#lib/rdoc/markup/attr_span.rb:17 - def set_attrs(start, length, bits); end -end - -# Manages changes of attributes in a block of text -# -# pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:6 -class RDoc::Markup::AttributeManager - # Creates a new attribute manager that understands bold, emphasized and - # teletype text. - # - # @return [AttributeManager] a new instance of AttributeManager - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:80 - def initialize; end - - # Adds a markup class with +name+ for words surrounded by HTML tag +tag+. - # To process emphasis tags: - # - # am.add_html 'em', :EM - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:286 - def add_html(tag, name, exclusive = T.unsafe(nil)); end - - # Adds a regexp handling for +pattern+ with +name+. A simple URL handler - # would be: - # - # @am.add_regexp_handling(/((https?:)\S+\w)/, :HYPERLINK) - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:298 - def add_regexp_handling(pattern, name, exclusive = T.unsafe(nil)); end - - # Adds a markup class with +name+ for words wrapped in the +start+ and - # +stop+ character. To make words wrapped with "*" bold: - # - # am.add_word_pair '*', '*', :BOLD - # - # @raise [ArgumentError] - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:261 - def add_word_pair(start, stop, name, exclusive = T.unsafe(nil)); end - - # Return an attribute object with the given turn_on and turn_off bits set - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:103 - def attribute(turn_on, turn_off); end - - # The attributes enabled for this markup object. - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:40 - def attributes; end - - # Changes the current attribute from +current+ to +new+ - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:110 - def change_attribute(current, new); end - - # Used by the tests to change attributes by name from +current_set+ to - # +new_set+ - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:119 - def changed_attribute_by_name(current_set, new_set); end - - # Map attributes like textto the sequence - # \001\002\001\003, where is a per-attribute specific - # character - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:154 - def convert_attrs(str, attrs, exclusive = T.unsafe(nil)); end - - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:160 - def convert_attrs_matching_word_pairs(str, attrs, exclusive); end - - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:185 - def convert_attrs_word_pair_map(str, attrs, exclusive); end - - # Converts HTML tags to RDoc attributes - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:206 - def convert_html(str, attrs, exclusive = T.unsafe(nil)); end - - # Converts regexp handling sequences to RDoc attributes - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:223 - def convert_regexp_handlings(str, attrs, exclusive = T.unsafe(nil)); end - - # Copies +start_pos+ to +end_pos+ from the current string - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:135 - def copy_string(start_pos, end_pos); end - - # Debug method that prints a string along with its attributes - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:329 - def display_attributes; end - - # @return [Boolean] - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:142 - def exclusive?(attr); end - - # A bits of exclusive maps - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:74 - def exclusive_bitmap; end - - # Processes +str+ converting attributes, HTML and regexp handlings - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:307 - def flow(str); end - - # This maps HTML tags to the corresponding attribute char - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:58 - def html_tags; end - - # Escapes regexp handling sequences of text to prevent conversion to RDoc - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:239 - def mask_protected_sequences; end - - # This maps delimiters that occur around words (such as *bold* or +tt+) - # where the start and end delimiters and the same. This lets us optimize - # the regexp - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:47 - def matching_word_pairs; end - - # A \ in front of a character that would normally be processed turns off - # processing. We do this by turning \< into <#{PROTECT} - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:64 - def protectable; end - - # And this maps _regexp handling_ sequences to a name. A regexp handling - # sequence is something like a WikiWord - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:70 - def regexp_handlings; end - - # Splits the string into chunks by attribute change - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:354 - def split_into_flow; end - - # Unescapes regexp handling sequences of text - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:251 - def unmask_protected_sequences; end - - # And this is used when the delimiters aren't the same. In this case the - # hash maps a pattern to the attribute character - # - # pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:53 - def word_pair_map; end -end - -# pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:147 -RDoc::Markup::AttributeManager::NON_PRINTING_END = T.let(T.unsafe(nil), String) - -# pkg:gem/rdoc#lib/rdoc/markup/attribute_manager.rb:146 -RDoc::Markup::AttributeManager::NON_PRINTING_START = T.let(T.unsafe(nil), String) - -# We manage a set of attributes. Each attribute has a symbol name and a bit -# value. -# -# pkg:gem/rdoc#lib/rdoc/markup/attributes.rb:6 -class RDoc::Markup::Attributes - # Creates a new attributes set. - # - # @return [Attributes] a new instance of Attributes - # - # pkg:gem/rdoc#lib/rdoc/markup/attributes.rb:16 - def initialize; end - - # Returns a string representation of +bitmap+ - # - # pkg:gem/rdoc#lib/rdoc/markup/attributes.rb:46 - def as_string(bitmap); end - - # Returns a unique bit for +name+ - # - # pkg:gem/rdoc#lib/rdoc/markup/attributes.rb:29 - def bitmap_for(name); end - - # yields each attribute name in +bitmap+ - # - # pkg:gem/rdoc#lib/rdoc/markup/attributes.rb:60 - def each_name_of(bitmap); end - - # The regexp handling attribute type. See RDoc::Markup#add_regexp_handling - # - # pkg:gem/rdoc#lib/rdoc/markup/attributes.rb:11 - def regexp_handling; end -end - # An empty line # # pkg:gem/rdoc#lib/rdoc/markup/blank_line.rb:6 @@ -5490,123 +5274,149 @@ class RDoc::Markup::Element def pretty_print(q); end end -# Base class for RDoc markup formatters -# -# Formatters are a visitor that converts an RDoc::Markup tree (from a comment) -# into some kind of output. RDoc ships with formatters for converting back to -# rdoc, ANSI text, HTML, a Table of Contents and other formats. -# -# If you'd like to write your own Formatter use -# RDoc::Markup::FormatterTestCase. If you're writing a text-output formatter -# use RDoc::Markup::TextFormatterTestCase which provides extra test cases. -# -# pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:13 +# pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:15 class RDoc::Markup::Formatter # Creates a new Formatter # # @return [Formatter] a new instance of Formatter # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:48 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:51 def initialize(options, markup = T.unsafe(nil)); end # Adds +document+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:69 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:62 def accept_document(document); end # Adds a regexp handling for links of the form rdoc-...: # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:83 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:76 def add_regexp_handling_RDOCLINK; end - # Adds a regexp handling for links of the form {}[] and - # [] - # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:91 - def add_regexp_handling_TIDYLINK; end - - # Add a new set of tags for an attribute. We allow separate start and end - # tags for flexibility - # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:105 - def add_tag(name, start, stop); end - # Allows +tag+ to be decorated with additional information. # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:113 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:83 def annotate(tag); end + # Applies regexp handling to +text+ and returns an array of [text, converted?] pairs. + # + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:96 + def apply_regexp_handling(text); end + # Marks up +content+ # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:120 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:90 def convert(content); end - # Converts flow items +flow+ + # Converts a string to be fancier if desired # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:127 - def convert_flow(flow); end + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:243 + def convert_string(string); end - # Converts added regexp handlings. See RDoc::Markup#add_regexp_handling + # Called when processing bold nodes while traversing inline nodes from handle_inline. + # Traverse the children nodes and dispatch to the appropriate handlers. # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:150 - def convert_regexp_handling(target); end + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:158 + def handle_BOLD(nodes); end - # Converts a string to be fancier if desired + # Called when processing bold word nodes while traversing inline nodes from handle_inline. + # +word+ may need proper escaping. # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:176 - def convert_string(string); end + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:172 + def handle_BOLD_WORD(word); end - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:225 - def each_attr_tag(attr_mask, reverse = T.unsafe(nil)); end + # Called when processing emphasis nodes while traversing inline nodes from handle_inline. + # Traverse the children nodes and dispatch to the appropriate handlers. + # + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:165 + def handle_EM(nodes); end - # Use ignore in your subclass to ignore the content of a node. + # Called when processing emphasis word nodes while traversing inline nodes from handle_inline. + # +word+ may need proper escaping. # - # ## - # # We don't support raw nodes in ToNoRaw + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:179 + def handle_EM_WORD(word); end + + # Called when processing a hard break while traversing inline nodes from handle_inline. # - # alias accept_raw ignore + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:152 + def handle_HARD_BREAK; end + + # Called when processing plain text while traversing inline nodes from handle_inline. + # +text+ may need proper escaping. # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:188 - def ignore(*node); end + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:128 + def handle_PLAIN_TEXT(text); end - # Are we currently inside tt tags? + # Called when processing regexp-handling-processed text while traversing inline nodes from handle_inline. + # +text+ may contain markup tags. # - # @return [Boolean] + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:134 + def handle_REGEXP_HANDLING_TEXT(text); end + + # Called when processing strike nodes while traversing inline nodes from handle_inline. + # Traverse the children nodes and dispatch to the appropriate handlers. + # + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:193 + def handle_STRIKE(nodes); end + + # Called when processing text node while traversing inline nodes from handle_inline. + # Apply regexp handling and dispatch to the appropriate handler: handle_REGEXP_HANDLING_TEXT or handle_PLAIN_TEXT. # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:194 - def in_tt?; end + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:140 + def handle_TEXT(text); end - # Turns off tags for +item+ on +res+ + # Called when processing tidylink nodes while traversing inline nodes from handle_inline. + # +label_part+ is an array of strings or nodes representing the link label. + # +url+ is the link URL. + # Traverse the label_part nodes and dispatch to the appropriate handlers. # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:218 - def off_tags(res, item); end + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:202 + def handle_TIDYLINK(label_part, url); end - # Turns on tags for +item+ on +res+ + # Called when processing tt nodes while traversing inline nodes from handle_inline. + # +code+ may need proper escaping. + # + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:186 + def handle_TT(code); end + + # Parses inline +text+, traverse the resulting nodes, and calls the appropriate handler methods. # # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:208 - def on_tags(res, item); end + def handle_inline(text); end + + # Use ignore in your subclass to ignore the content of a node. + # + # ## + # # We don't support raw nodes in ToNoRaw + # + # alias accept_raw ignore + # + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:255 + def ignore(*node); end # Extracts and a scheme, url and an anchor id from +url+ and returns them. # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:238 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:261 def parse_url(url); end + # Traverses +nodes+ and calls the appropriate handler methods + # Nodes formats are described in RDoc::Markup::InlineParser#parse + # + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:216 + def traverse_inline_nodes(nodes); end + # Is +tag+ a tt tag? # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:268 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:291 def tt?(tag); end - # @return [Boolean] - # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:198 - def tt_tag?(attr_mask, reverse = T.unsafe(nil)); end - class << self # Converts a target url to one that is relative to a given path # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:24 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:27 def gen_relative_url(path, target); end end end @@ -5614,13 +5424,13 @@ end # Tag for inline markup containing a +bit+ for the bitmask and the +on+ and # +off+ triggers. # -# pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 +# pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 class RDoc::Markup::Formatter::InlineTag < ::Struct # Returns the value of attribute bit # # @return [Object] the current value of bit # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def bit; end # Sets the attribute bit @@ -5628,14 +5438,14 @@ class RDoc::Markup::Formatter::InlineTag < ::Struct # @param value [Object] the value to set the attribute bit to. # @return [Object] the newly set value # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def bit=(_); end # Returns the value of attribute off # # @return [Object] the current value of off # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def off; end # Sets the attribute off @@ -5643,14 +5453,14 @@ class RDoc::Markup::Formatter::InlineTag < ::Struct # @param value [Object] the value to set the attribute off to. # @return [Object] the newly set value # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def off=(_); end # Returns the value of attribute on # # @return [Object] the current value of on # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def on; end # Sets the attribute on @@ -5658,23 +5468,23 @@ class RDoc::Markup::Formatter::InlineTag < ::Struct # @param value [Object] the value to set the attribute on to. # @return [Object] the newly set value # - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def on=(_); end class << self - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def [](*_arg0); end - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def inspect; end - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def keyword_init?; end - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def members; end - # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:19 + # pkg:gem/rdoc#lib/rdoc/markup/formatter.rb:21 def new(*_arg0); end end end @@ -5714,55 +5524,109 @@ end # ## Heading 2 # ### Heading 3 # -# pkg:gem/rdoc#lib/rdoc/markup/heading.rb:16 +# pkg:gem/rdoc#lib/rdoc/markup/heading.rb:8 class RDoc::Markup::Heading < ::RDoc::Markup::Element # @return [Heading] a new instance of Heading # - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:47 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:16 def initialize(level, text); end - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:55 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:24 def ==(other); end - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:61 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:70 def accept(visitor); end - # An HTML-safe anchor reference for this header. + # An HTML-safe anchor reference for this header using GitHub-style formatting: + # - Lowercase + # - Spaces converted to hyphens + # - Special characters removed (except hyphens) # - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:67 + # Examples: + # "Hello" -> "hello" + # "Hello World" -> "hello-world" + # "Foo Bar Baz" -> "foo-bar-baz" + # + # + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:85 def aref; end - # Creates a fully-qualified label which will include the label from +context+. This helps keep ids unique in HTML. + # Creates a fully-qualified label (GitHub-style) which includes the context's aref prefix. + # This helps keep IDs unique in HTML when headings appear within class/method documentation. + # + # Examples (without context): + # "Hello World" -> "hello-world" + # + # Examples (with context being class Foo): + # "Hello World" -> "class-foo-hello-world" # - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:73 + # Examples (with context being method #bar): + # "Hello World" -> "method-i-bar-hello-world" + # + # + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:121 def label(context = T.unsafe(nil)); end - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:21 + # An HTML-safe anchor reference using legacy RDoc formatting: + # - Prefixed with "label-" + # - Original case preserved + # - Spaces converted to + (URL encoding style) + # - Special characters percent-encoded + # + # Returns nil if it would be the same as the GitHub-style aref (no alias needed). + # + # Examples: + # "hello" -> "label-hello" (different due to label- prefix) + # "Hello" -> "label-Hello" + # "Hello World" -> "label-Hello+World" + # "Foo Bar Baz" -> "label-Foo+Bar+Baz" + # + # + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:104 + def legacy_aref; end + + # Creates a fully-qualified legacy label for backward compatibility. + # This is used to generate a secondary ID attribute on the heading's inner anchor, + # allowing old-style links (e.g., #label-Hello+World) to continue working. + # + # Examples (without context): + # "hello" -> "label-hello" + # "Hello World" -> "label-Hello+World" + # + # Examples (with context being class Foo): + # "hello" -> "class-Foo-label-hello" + # "Hello World" -> "class-Foo-label-Hello+World" + # + # + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:141 + def legacy_label(context = T.unsafe(nil)); end + + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:13 def level; end - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:21 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:13 def level=(_arg0); end # HTML markup of the text of this label without the surrounding header element. # - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:82 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:154 def plain_html; end - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:94 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:166 def pretty_print(q); end - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:18 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:10 def text; end class << self # A singleton plain HTML formatter for headings. Used for creating labels for the Table of Contents # - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:31 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:53 def to_html; end # A singleton RDoc::Markup::ToLabel formatter for headings. # - # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:25 + # pkg:gem/rdoc#lib/rdoc/markup/heading.rb:47 def to_label; end end end @@ -5830,18 +5694,129 @@ class RDoc::Markup::IndentedParagraph < ::RDoc::Markup::Raw def text(hard_break = T.unsafe(nil)); end end +# Parses inline markup in RDoc text. +# This parser handles em, bold, strike, tt, hard break, and tidylink. +# Block-level constructs are handled in RDoc::Markup::Parser. +# +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:10 +class RDoc::Markup::InlineParser + # @return [InlineParser] a new instance of InlineParser + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:82 + def initialize(string); end + + # Return the current parsing node on @stack. + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:92 + def current; end + + # Parse and return an array of nodes. + # Node format: + # { + # type: :EM | :BOLD | :BOLD_WORD | :EM_WORD | :TT | :STRIKE | :HARD_BREAK | :TIDYLINK, + # url: string # only for :TIDYLINK + # children: [string_or_node, ...] + # } + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:104 + def parse; end + + private + + # Compacts adjacent strings in +nodes+ into a single string. + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:208 + def compact_string(nodes); end + + # When a valid tidylink node is encountered, invalidate all nested tidylinks. + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:178 + def invalidate_open_tidylinks; end + + # Read the URL part of a tidylink from the current position. + # Returns nil if no valid URL part is found. + # URL part is enclosed in square brackets and may contain escaped brackets. + # Example: [http://example.com/?q=\[\]] represents http://example.com/?q=[]. + # If we're accepting rdoc-style links in markdown, url may include *+<_ with backslash escape. + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:308 + def read_tidylink_url; end + + # Scan and return the next token for parsing. + # Returns [token_type, token_string_or_nil, extra_info] + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:230 + def scan_token; end + + # Pop the top node off the stack when node is closed by a closing delimiter or an error. + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:191 + def stack_pop; end + + # Push a new node onto the stack when encountering an opening delimiter. + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:200 + def stack_push(delimiter, token); end + + # Scan from StringScanner with +pattern+ + # If +negative_cache+ is true, caches scan failure result. scan(pattern, negative_cache: true) return nil when it is called again after a failure. + # Be careful to use +negative_cache+ with a pattern and position that does not match after previous failure. + # + # pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:218 + def strscan(pattern, negative_cache: T.unsafe(nil)); end +end + +# Pattern to match code block content until or . +# +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:63 +RDoc::Markup::InlineParser::CODEBLOCK_REGEXPS = T.let(T.unsafe(nil), Hash) + +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:35 +RDoc::Markup::InlineParser::CODEBLOCK_TAGS = T.let(T.unsafe(nil), Array) + +# Characters that can be escaped with backslash. +# +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:60 +RDoc::Markup::InlineParser::ESCAPING_CHARS = T.let(T.unsafe(nil), String) + +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:52 +RDoc::Markup::InlineParser::SCANNER_REGEXP = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:33 +RDoc::Markup::InlineParser::STANDALONE_TAGS = T.let(T.unsafe(nil), Hash) + +# Other types: regexp-handling(example: crossref) is enabled +# +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:25 +RDoc::Markup::InlineParser::TAGS = T.let(T.unsafe(nil), Hash) + +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:37 +RDoc::Markup::InlineParser::TOKENS = T.let(T.unsafe(nil), Hash) + +# TT, BOLD_WORD, EM_WORD: regexp-handling(example: crossref) is disabled +# +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:13 +RDoc::Markup::InlineParser::WORD_PAIRS = T.let(T.unsafe(nil), Hash) + +# Word contains alphanumeric and _./:[]- characters. +# Word may start with # and may end with any non-space character. (e.g. #eql?). +# Underscore delimiter have special rules. +# +# pkg:gem/rdoc#lib/rdoc/markup/inline_parser.rb:68 +RDoc::Markup::InlineParser::WORD_REGEXPS = T.let(T.unsafe(nil), Hash) + # Formatter dedicated to rendering tidy link labels without mutating the # calling formatter's state. # -# pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:599 +# pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:594 class RDoc::Markup::LinkLabelToHtml < ::RDoc::Markup::ToHtml # @return [LinkLabelToHtml] a new instance of LinkLabelToHtml # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:604 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:599 def initialize(options, from_path = T.unsafe(nil)); end class << self - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:600 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:595 def render(label, options, from_path); end end end @@ -6018,7 +5993,7 @@ end # The parser only handles the block-level constructs Paragraph, List, # ListItem, Heading, Verbatim, BlankLine, Rule and BlockQuote. # Inline markup such as \+blah\+ is handled separately by -# RDoc::Markup::AttributeManager. +# RDoc::Markup::InlineParser. # # To see what markup the Parser implements read RDoc. To see how to use # RDoc markup to format text in your program read RDoc::Markup. @@ -6367,44 +6342,6 @@ class RDoc::Markup::Raw def text; end end -# Hold details of a regexp handling sequence -# -# pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:5 -class RDoc::Markup::RegexpHandling - # Creates a new regexp handling sequence of +type+ with +text+ - # - # @return [RegexpHandling] a new instance of RegexpHandling - # - # pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:20 - def initialize(type, text); end - - # Regexp handlings are equal when the have the same text and type - # - # pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:27 - def ==(o); end - - # pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:31 - def inspect; end - - # Regexp handling text - # - # pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:15 - def text; end - - # Regexp handling text - # - # pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:15 - def text=(_arg0); end - - # pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:36 - def to_s; end - - # Regexp handling type - # - # pkg:gem/rdoc#lib/rdoc/markup/regexp_handling.rb:10 - def type; end -end - # A horizontal rule with a weight # # pkg:gem/rdoc#lib/rdoc/markup/rule.rb:5 @@ -6480,28 +6417,45 @@ class RDoc::Markup::ToAnsi < ::RDoc::Markup::ToRdoc # Overrides indent width to ensure output lines up correctly. # - # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:31 + # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:78 def accept_list_item_end(list_item); end # Adds coloring to note and label list items # - # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:55 + # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:102 def accept_list_item_start(list_item); end - # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:84 - def calculate_text_width(text); end + # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:59 + def add_text(text); end - # Maps attributes to ANSI sequences + # Apply the given attributes by emitting ANSI sequences. + # Emitting attribute changes are deferred until new text is added and applied in batch. + # This method computes the necessary ANSI codes to transition from the + # current set of applied attributes to the new set of +attributes+. # - # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:22 - def init_tags; end + # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:41 + def apply_attributes(attributes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:131 + def calculate_text_width(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:67 + def handle_inline(text); end # Starts accepting with a reset screen # - # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:91 + # pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:138 def start_accepting; end end +# pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:29 +RDoc::Markup::ToAnsi::ANSI_STYLE_CODES_OFF = T.let(T.unsafe(nil), Hash) + +# Maps attributes to ANSI sequences +# +# pkg:gem/rdoc#lib/rdoc/markup/to_ansi.rb:22 +RDoc::Markup::ToAnsi::ANSI_STYLE_CODES_ON = T.let(T.unsafe(nil), Hash) + # Outputs RDoc markup with hot backspace action! You will probably need a # pager to use this output format. # @@ -6518,37 +6472,22 @@ class RDoc::Markup::ToBs < ::RDoc::Markup::ToRdoc # Makes heading text bold. # - # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:33 + # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:48 def accept_heading(heading); end # Prepares the visitor for consuming +list_item+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:46 + # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:61 def accept_list_item_start(list_item); end - # Turns on or off regexp handling for +convert_string+ - # - # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:75 - def annotate(tag); end + # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:27 + def add_text(text); end - # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:68 + # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:83 def calculate_text_width(text); end - # Calls convert_string on the result of convert_regexp_handling - # - # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:88 - def convert_regexp_handling(target); end - - # Adds bold or underline mixed with backspaces - # - # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:95 - def convert_string(string); end - - # Sets a flag that is picked up by #annotate to do the right thing in - # #convert_string - # - # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:24 - def init_tags; end + # pkg:gem/rdoc#lib/rdoc/markup/to_bs.rb:20 + def handle_inline(text); end end # Outputs RDoc markup as HTML. @@ -6566,65 +6505,75 @@ class RDoc::Markup::ToHtml < ::RDoc::Markup::Formatter # Adds +blank_line+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:297 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:405 def accept_blank_line(blank_line); end # Adds +block_quote+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:196 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:298 def accept_block_quote(block_quote); end # Adds +heading+ to the output. The headings greater than 6 are trimmed to # level 6. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:305 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:413 def accept_heading(heading); end # Finishes consumption of +list+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:268 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:376 def accept_list_end(list); end # Finishes consumption of +list_item+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:290 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:398 def accept_list_item_end(list_item); end # Prepares the visitor for consuming +list_item+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:279 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:387 def accept_list_item_start(list_item); end # Prepares the visitor for consuming +list+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:259 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:367 def accept_list_start(list); end # Adds +paragraph+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:209 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:311 def accept_paragraph(paragraph); end # Adds +raw+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:328 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:443 def accept_raw(raw); end # Adds +rule+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:252 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:360 def accept_rule(rule); end # Adds +table+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:335 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:450 def accept_table(header, body, aligns); end # Adds +verbatim+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:222 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:324 def accept_verbatim(verbatim); end + # Special handling for tidy link labels. + # When a tidy link is {rdoc-image:path/to/image.jpg:alt text}[http://example.com], + # label part is normally considered RDOCLINK rdoc-image:path/to/image.jpg:alt and a text " text" + # but RDoc's test code expects the whole label part to be treated as RDOCLINK only in tidy link label. + # When a tidy link is {^1}[url] or {*1}[url], the label part needs to drop leading * or ^. + # TODO: reconsider this workaround. + # + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:184 + def apply_tidylink_label_special_handling(label, url); end + # The RDoc::CodeObject HTML is being generated for. This is used to # generate namespaced URI fragments # @@ -6639,12 +6588,21 @@ class RDoc::Markup::ToHtml < ::RDoc::Markup::Formatter # CGI-escapes +text+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:360 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:489 def convert_string(text); end + # Returns a unique heading ID, appending -1, -2, etc. for duplicates. + # Matches GitHub's behavior for duplicate heading anchors. + # + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:476 + def deduplicate_heading_id(id); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:167 + def emit_inline(text); end + # Returns the generated output # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:189 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:291 def end_accepting; end # Path to this document for relative links @@ -6657,19 +6615,52 @@ class RDoc::Markup::ToHtml < ::RDoc::Markup::Formatter # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:39 def from_path=(_arg0); end - # Generate a link to +url+ with content +text+. Handles the special cases - # for img: and link: described under handle_regexp_HYPERLINK + # Generates an HTML link or image tag for the given +url+ and +text+. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:368 + # - Image URLs (http/https/link ending in .gif, .png, .jpg, .jpeg, .bmp) + # become tags + # - File references (.rb, .rdoc, .md) are converted to .html paths + # - Anchor URLs (#foo) pass through unchanged for GitHub-style header linking + # - Footnote links get wrapped in tags + # + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:502 def gen_url(url, text); end - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:86 - def handle_RDOCLINK(url); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:127 + def handle_BOLD(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:139 + def handle_BOLD_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:133 + def handle_EM(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:145 + def handle_EM_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:163 + def handle_HARD_BREAK; end - # +target+ is a
- # # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:119 - def handle_regexp_HARD_BREAK(target); end + def handle_PLAIN_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:88 + def handle_RDOCLINK(url); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:123 + def handle_REGEXP_HANDLING_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:157 + def handle_STRIKE(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:192 + def handle_TIDYLINK(label_part, url); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:151 + def handle_TT(code); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:228 + def handle_inline(text); end # +target+ is a potential link. The following schemes are handled: # @@ -6682,8 +6673,8 @@ class RDoc::Markup::ToHtml < ::RDoc::Markup::Formatter # link::: # Reference to a local file relative to the output directory. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:135 - def handle_regexp_HYPERLINK(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:254 + def handle_regexp_HYPERLINK(text); end # +target+ is an rdoc-schemed link that will be converted into a hyperlink. # @@ -6693,59 +6684,60 @@ class RDoc::Markup::ToHtml < ::RDoc::Markup::Formatter # For the +rdoc-label+ scheme the footnote and label prefixes are stripped # when creating a link. All other contents will be linked verbatim. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:150 - def handle_regexp_RDOCLINK(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:270 + def handle_regexp_RDOCLINK(text); end - # This +target+ is a link where the label is different from the URL - # label[url] or {long label}[url] + # Converts suppressed cross-reference +text+ to HTML by removing the leading backslash. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:158 - def handle_regexp_TIDYLINK(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:238 + def handle_regexp_SUPPRESSED_CROSSREF(text); end # Determines the HTML list element for +list_type+ and +open_tag+ # # @raise [RDoc::Error] # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:393 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:528 def html_list_name(list_type, open_tag); end # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:27 def in_list_entry; end + # Returns true if we are processing inside a tidy link label. + # + # @return [Boolean] + # + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:173 + def in_tidylink_label?; end + # Adds regexp handlings about link notations. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:81 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:84 def init_link_notation_regexp_handlings; end # Adds regexp handlings. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:71 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:70 def init_regexp_handlings; end - # Maps attributes to HTML tags - # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:402 - def init_tags; end - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:28 def list; end # Returns the HTML end-tag for +list_type+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:428 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:554 def list_end_for(list_type); end # Returns the HTML tag for +list_type+, possible using a label from # +list_item+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:412 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:538 def list_item_start(list_item, list_type); end # Returns true if text is valid ruby syntax # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:442 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:568 def parseable?(text); end # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:26 @@ -6753,83 +6745,16 @@ class RDoc::Markup::ToHtml < ::RDoc::Markup::Formatter # Prepares the visitor for HTML generation # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:180 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:281 def start_accepting; end # Converts +item+ to HTML using RDoc::Text#to_html # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:456 + # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:582 def to_html(item); end - - private - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:482 - def append_flow_fragment(res, fragment); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:488 - def append_to_tidy_label(fragment); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:516 - def convert_complete_tidy_link(text); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:462 - def convert_flow(flow_items); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:532 - def emit_tidy_link_fragment(res, fragment); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:555 - def extract_tidy_link_parts(text); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:540 - def finish_tidy_link(text); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:574 - def off_tags(res, item); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:567 - def on_tags(res, item); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:590 - def render_tidy_link_label(label); end - - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:581 - def start_tidy_link(text); end - - # @return [Boolean] - # - # pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:586 - def tidy_link_capturing?; end end -# Matches a tidy link with a single-word label "label[url]". -# -# Capture 1: the single-word label (no whitespace). -# Capture 2: URL text between the brackets. -# -# pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:514 -RDoc::Markup::ToHtml::TIDY_LINK_SINGLE_WORD = T.let(T.unsafe(nil), Regexp) - -# Matches an entire tidy link with a braced label "{label}[url]". -# -# Capture 1: label contents. -# Capture 2: URL text. -# Capture 3: trailing content. -# -# pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:498 -RDoc::Markup::ToHtml::TIDY_LINK_WITH_BRACES = T.let(T.unsafe(nil), Regexp) - -# Matches the tail of a braced tidy link when the opening brace was -# consumed earlier while accumulating the label text. -# -# Capture 1: remaining label content. -# Capture 2: URL text. -# Capture 3: trailing content. -# -# pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:507 -RDoc::Markup::ToHtml::TIDY_LINK_WITH_BRACES_TAIL = T.let(T.unsafe(nil), Regexp) - -# pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:66 +# pkg:gem/rdoc#lib/rdoc/markup/to_html.rb:65 RDoc::Markup::ToHtml::URL_CHARACTERS_REGEXP_STR = T.let(T.unsafe(nil), String) # Subclass of the RDoc::Markup::ToHtml class that supports looking up method @@ -6849,6 +6774,13 @@ class RDoc::Markup::ToHtmlCrossref < ::RDoc::Markup::ToHtml # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:32 def initialize(options, from_path, context, markup = T.unsafe(nil)); end + # Applies additional special handling on top of the one defined in ToHtml. + # When a tidy link is {Foo}[rdoc-ref:Foo], the label part is surrounded by . + # TODO: reconsider this workaround. + # + # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:216 + def apply_tidylink_label_special_handling(label, url); end + # RDoc::CodeObject for generating references # # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:19 @@ -6859,35 +6791,35 @@ class RDoc::Markup::ToHtmlCrossref < ::RDoc::Markup::ToHtml # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:19 def context=(_arg0); end - # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:187 - def convert_flow(flow_items, &block); end - # Creates a link to the reference +name+ if the name exists. If +text+ is # given it is used as the link text, otherwise +name+ is used. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:61 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:59 def cross_reference(name, text = T.unsafe(nil), code = T.unsafe(nil), rdoc_ref: T.unsafe(nil)); end # Generates links for rdoc-ref: scheme URLs and allows # RDoc::Markup::ToHtml to handle other schemes. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:138 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:140 def gen_url(url, text); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:209 + def handle_TT(code); end + # We're invoked when any text matches the CROSSREF pattern. If we find the # corresponding reference, generate a link. If the name we're looking for # contains no punctuation, we look for it up the module/class chain. For # example, ToHtml is found, even without the RDoc::Markup:: prefix, # because we look for it in module Markup first. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:83 - def handle_regexp_CROSSREF(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:84 + def handle_regexp_CROSSREF(name); end # Handles rdoc-ref: scheme links and allows RDoc::Markup::ToHtml to # handle other schemes. # # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:104 - def handle_regexp_HYPERLINK(target); end + def handle_regexp_HYPERLINK(url); end # +target+ is an rdoc-schemed link that will be converted into a hyperlink. # For the rdoc-ref scheme the cross-reference will be looked up and the @@ -6897,14 +6829,14 @@ class RDoc::Markup::ToHtmlCrossref < ::RDoc::Markup::ToHtml # {the superclass}[rdoc-ref:RDoc::Markup::ToHtml#handle_regexp_RDOCLINK] # # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:123 - def handle_regexp_RDOCLINK(target); end + def handle_regexp_RDOCLINK(url); end # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:46 def init_link_notation_regexp_handlings; end # Creates an HTML link to +name+ with the given +text+. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:150 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:152 def link(name, text, code = T.unsafe(nil), rdoc_ref: T.unsafe(nil)); end # Should we show '#' characters on method references? @@ -6917,14 +6849,8 @@ class RDoc::Markup::ToHtmlCrossref < ::RDoc::Markup::ToHtml # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:24 def show_hash=(_arg0); end - private - - # Detects ... spans that contain a single cross-reference candidate. - # When the candidate occupies the whole span (aside from trailing - # punctuation), the tt markup is replaced by the resolved cross-reference. - # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:231 - def convert_tt_crossref(flow_items, index); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html_crossref.rb:224 + def tt_cross_reference(code); end end # Outputs RDoc markup as paragraphs with inline markup only. @@ -6982,7 +6908,7 @@ class RDoc::Markup::ToHtmlSnippet < ::RDoc::Markup::ToHtml # Throws +:done+ when paragraph_limit paragraphs have been encountered # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:198 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:190 def add_paragraph; end # After this many characters the input will be cut off. @@ -6997,38 +6923,66 @@ class RDoc::Markup::ToHtmlSnippet < ::RDoc::Markup::ToHtml # Marks up +content+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:207 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:199 def convert(content); end - # Converts flow items +flow+ - # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:218 - def convert_flow(flow); end - # Returns just the text of +link+, +url+ is only used to determine the link # type. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:171 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:163 def gen_url(url, text); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:224 + def handle_BOLD(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:228 + def handle_BOLD_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:232 + def handle_EM(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:236 + def handle_EM_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:248 + def handle_HARD_BREAK; end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:207 + def handle_PLAIN_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:215 + def handle_REGEXP_HANDLING_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:244 + def handle_STRIKE(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:252 + def handle_TIDYLINK(label_part, url); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:240 + def handle_TT(code); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:260 + def handle_inline(text); end + # Removes escaping from the cross-references in +target+ # # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:131 - def handle_regexp_CROSSREF(target); end - - # +target+ is a
- # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:138 - def handle_regexp_HARD_BREAK(target); end + def handle_regexp_CROSSREF(text); end # In snippets, there are no lists # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:191 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:183 def html_list_name(list_type, open_tag); end + # @return [Boolean] + # + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:256 + def inline_limit_reached?; end + # Lists are paragraphs, but notes and labels have a separator # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:146 + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:138 def list_item_start(list_item, list_type); end # The attribute bitmask @@ -7036,18 +6990,6 @@ class RDoc::Markup::ToHtmlSnippet < ::RDoc::Markup::ToHtml # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:20 def mask; end - # Maintains a bitmask to allow HTML elements to be closed properly. See - # RDoc::Markup::Formatter. - # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:264 - def off_tags(res, item); end - - # Maintains a bitmask to allow HTML elements to be closed properly. See - # RDoc::Markup::Formatter. - # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:254 - def on_tags(res, item); end - # After this many paragraphs the input will be cut off. # # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:25 @@ -7063,10 +7005,13 @@ class RDoc::Markup::ToHtmlSnippet < ::RDoc::Markup::ToHtml # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:122 def start_accepting; end - # Truncates +text+ at the end of the first word after the character_limit. + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:270 + def to_html(item); end + + # Truncates +text+ at the end of the first word after the limit. # - # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:273 - def truncate(text); end + # pkg:gem/rdoc#lib/rdoc/markup/to_html_snippet.rb:278 + def truncate(text, limit); end end # Joins the parts of an RDoc::Markup::Paragraph into a single String. @@ -7138,65 +7083,75 @@ class RDoc::Markup::ToLabel < ::RDoc::Markup::Formatter # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:17 def initialize(markup = T.unsafe(nil)); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:60 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:70 def accept_blank_line(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:61 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:71 def accept_block_quote(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:62 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:72 def accept_heading(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:63 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:73 def accept_list_end(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:64 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:74 def accept_list_item_end(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:65 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:75 def accept_list_item_start(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:66 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:76 def accept_list_start(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:67 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:77 def accept_paragraph(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:68 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:78 def accept_raw(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:69 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:79 def accept_rule(*node); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:70 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:80 def accept_verbatim(*node); end - # Converts +text+ to an HTML-safe label + # Converts +text+ to an HTML-safe label using GitHub-style anchor formatting. # - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:33 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:46 def convert(text); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:71 + # Converts +text+ to an HTML-safe label using legacy RDoc formatting. + # Used for generating backward-compatible anchor aliases. + # + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:56 + def convert_legacy(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:81 def end_accepting(*node); end - # Converts the CROSSREF +target+ to plain text, removing the suppression - # marker, if any - # - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:43 - def handle_regexp_CROSSREF(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:37 + def extract_plaintext(text); end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:72 - def handle_regexp_HARD_BREAK(*node); end + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:25 + def handle_PLAIN_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:29 + def handle_REGEXP_HANDLING_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:33 + def handle_TT(text); end - # Converts the TIDYLINK +target+ to just the text part + # Converts the CROSSREF +target+ to plain text, removing the suppression + # marker, if any # - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:52 - def handle_regexp_TIDYLINK(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:66 + def handle_regexp_CROSSREF(text); end # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:12 def res; end - # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:73 + # pkg:gem/rdoc#lib/rdoc/markup/to_label.rb:82 def start_accepting(*node); end end @@ -7213,63 +7168,78 @@ class RDoc::Markup::ToMarkdown < ::RDoc::Markup::ToRdoc # Finishes consumption of `list` # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:47 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:30 def accept_list_end(list); end # Finishes consumption of `list_item` # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:54 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:37 def accept_list_item_end(list_item); end # Prepares the visitor for consuming `list_item` # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:75 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:58 def accept_list_item_start(list_item); end # Prepares the visitor for consuming `list` # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:100 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:142 def accept_list_start(list); end # Adds `rule` to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:117 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:159 def accept_rule(rule); end # Outputs `verbatim` indented 4 columns # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:126 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:168 def accept_verbatim(verbatim); end + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:80 + def add_tag(tag, simple_tag, content); end + # Creates a Markdown-style URL from +url+ with +text+. # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:140 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:182 def gen_url(url, text); end + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:111 + def handle_BOLD(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:119 + def handle_BOLD_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:115 + def handle_EM(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:123 + def handle_EM_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:135 + def handle_HARD_BREAK; end + + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:131 + def handle_STRIKE(nodes); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:101 + def handle_TIDYLINK(label_part, url); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:127 + def handle_TT(text); end + # Handles rdoc- type links for footnotes. # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:149 + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:191 def handle_rdoc_link(url); end - # Adds a newline to the output - # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:40 - def handle_regexp_HARD_BREAK(target); end - # Converts the rdoc-...: links into a Markdown.style links. # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:187 - def handle_regexp_RDOCLINK(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:211 + def handle_regexp_RDOCLINK(text); end - # Converts the RDoc markup tidylink into a Markdown.style link. - # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:169 - def handle_regexp_TIDYLINK(target); end - - # Maps attributes to HTML sequences - # - # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:31 - def init_tags; end + # pkg:gem/rdoc#lib/rdoc/markup/to_markdown.rb:88 + def handle_tag(nodes, simple_tag, tag); end end # Outputs RDoc markup as RDoc markup! (mostly) @@ -7285,91 +7255,125 @@ class RDoc::Markup::ToRdoc < ::RDoc::Markup::Formatter # Adds +blank_line+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:78 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:68 def accept_blank_line(blank_line); end # Adds +paragraph+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:85 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:75 def accept_block_quote(block_quote); end # Adds +heading+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:100 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:90 def accept_heading(heading); end # Adds +paragraph+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:212 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:202 def accept_indented_paragraph(paragraph); end # Finishes consumption of +list+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:111 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:101 def accept_list_end(list); end # Finishes consumption of +list_item+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:120 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:110 def accept_list_item_end(list_item); end # Prepares the visitor for consuming +list_item+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:144 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:134 def accept_list_item_start(list_item); end # Prepares the visitor for consuming +list+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:177 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:167 def accept_list_start(list); end # Adds +paragraph+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:204 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:194 def accept_paragraph(paragraph); end # Adds +raw+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:222 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:212 def accept_raw(raw); end # Adds +rule+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:229 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:219 def accept_rule(rule); end # Adds +table+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:252 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:242 def accept_table(header, body, aligns); end # Outputs +verbatim+ indented 2 columns # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:238 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:228 def accept_verbatim(verbatim); end - # Applies attribute-specific markup to +text+ using RDoc::AttributeManager + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:347 + def add_text(text); end + + # Applies attribute-specific markup to +text+ using RDoc::Markup::InlineParser # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:288 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:358 def attributes(text); end - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:281 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:272 def calculate_text_width(text); end + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:351 + def emit_inline(text); end + # Returns the generated output # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:296 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:365 def end_accepting; end - # Adds a newline to the output - # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:312 - def handle_regexp_HARD_BREAK(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:284 + def handle_BOLD(target); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:296 + def handle_BOLD_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:290 + def handle_EM(target); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:302 + def handle_EM_WORD(word); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:320 + def handle_HARD_BREAK; end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:276 + def handle_PLAIN_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:280 + def handle_REGEXP_HANDLING_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:314 + def handle_STRIKE(target); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:324 + def handle_TIDYLINK(label_part, url); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:308 + def handle_TT(code); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:329 + def handle_inline(text, initial_attributes = T.unsafe(nil)); end # Removes preceding \\ from the suppressed crossref +target+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:303 - def handle_regexp_SUPPRESSED_CROSSREF(target); end + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:372 + def handle_regexp_SUPPRESSED_CROSSREF(text); end # Current indent amount for output in characters # @@ -7381,11 +7385,6 @@ class RDoc::Markup::ToRdoc < ::RDoc::Markup::Formatter # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:20 def indent=(_arg0); end - # Maps attributes to HTML sequences - # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:69 - def init_tags; end - # Stack of current list indexes for alphabetic and numeric lists # # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:30 @@ -7401,6 +7400,12 @@ class RDoc::Markup::ToRdoc < ::RDoc::Markup::Formatter # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:40 def list_width; end + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:342 + def off(attr); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:338 + def on(attr); end + # Prefix for the next list item. See #use_prefix # # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:45 @@ -7413,13 +7418,13 @@ class RDoc::Markup::ToRdoc < ::RDoc::Markup::Formatter # Prepares the visitor for text generation # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:319 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:379 def start_accepting; end # Adds the stored #prefix to the output and clears it. Lists generate a # prefix for later consumption. # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:333 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:393 def use_prefix; end # Output width in characters @@ -7434,7 +7439,7 @@ class RDoc::Markup::ToRdoc < ::RDoc::Markup::Formatter # Wraps +text+ to #width # - # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:343 + # pkg:gem/rdoc#lib/rdoc/markup/to_rdoc.rb:403 def wrap(text); end end @@ -7543,39 +7548,45 @@ end # # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:5 class RDoc::Markup::ToTest < ::RDoc::Markup::Formatter - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:55 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:63 def accept_blank_line(blank_line); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:59 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:67 def accept_heading(heading); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:44 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:52 def accept_list_end(list); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:52 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:60 def accept_list_item_end(list_item); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:48 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:56 def accept_list_item_start(list_item); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:33 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:41 def accept_list_start(list); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:21 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:29 def accept_paragraph(paragraph); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:25 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:33 def accept_raw(raw); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:63 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:71 def accept_rule(rule); end - # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:29 + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:37 def accept_verbatim(verbatim); end # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:17 def end_accepting; end + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:21 + def handle_PLAIN_TEXT(text); end + + # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:25 + def handle_REGEXP_HANDLING_TEXT(text); end + # :section: Visitor # # pkg:gem/rdoc#lib/rdoc/markup/to_test.rb:12 @@ -7597,73 +7608,73 @@ class RDoc::Markup::ToTtOnly < ::RDoc::Markup::Formatter # Does nothing to +markup_item+ because it doesn't have any user-built # content # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:74 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:72 def accept_blank_line(markup_item); end # Adds tts from +block_quote+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:30 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:28 def accept_block_quote(block_quote); end # Does nothing to +markup_item+ because it doesn't have any user-built # content # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:75 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:73 def accept_heading(markup_item); end # Pops the list type for +list+ from #list_type # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:37 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:35 def accept_list_end(list); end # Does nothing to +markup_item+ because it doesn't have any user-built # content # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:76 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:74 def accept_list_item_end(markup_item); end # Prepares the visitor for consuming +list_item+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:51 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:49 def accept_list_item_start(list_item); end # Pushes the list type for +list+ onto #list_type # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:44 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:42 def accept_list_start(list); end # Adds +paragraph+ to the output # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:63 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:61 def accept_paragraph(paragraph); end # Does nothing to +markup_item+ because it doesn't have any user-built # content # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:77 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:75 def accept_raw(markup_item); end # Does nothing to +markup_item+ because it doesn't have any user-built # content # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:78 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:76 def accept_rule(markup_item); end # Does nothing to +markup_item+ because it doesn't have any user-built # content # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:79 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:77 def accept_verbatim(markup_item); end # Does nothing to +markup_item+ because it doesn't have any user-built # content # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:71 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:69 def do_nothing(markup_item); end # Returns an Array of items that were wrapped in plus, tt or code. # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:107 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:101 def end_accepting; end # Stack of list types @@ -7678,12 +7689,12 @@ class RDoc::Markup::ToTtOnly < ::RDoc::Markup::Formatter # Prepares the visitor for gathering tt sections # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:114 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:108 def start_accepting; end # Extracts tt sections from +text+ # - # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:84 + # pkg:gem/rdoc#lib/rdoc/markup/to_tt_only.rb:82 def tt_sections(text); end end @@ -8047,7 +8058,9 @@ class RDoc::Mixin < ::RDoc::CodeObject # # As of the beginning of October, 2011, no gem includes nonexistent modules. # - # pkg:gem/rdoc#lib/rdoc/code_object/mixin.rb:75 + # When mixin is created from RDoc::Parser::PrismRuby, module name is already a resolved full-path name. + # + # pkg:gem/rdoc#lib/rdoc/code_object/mixin.rb:78 def module; end # Name of included module @@ -8062,10 +8075,10 @@ class RDoc::Mixin < ::RDoc::CodeObject # Sets the store for this class or module and its contained code objects. # - # pkg:gem/rdoc#lib/rdoc/code_object/mixin.rb:110 + # pkg:gem/rdoc#lib/rdoc/code_object/mixin.rb:113 def store=(store); end - # pkg:gem/rdoc#lib/rdoc/code_object/mixin.rb:116 + # pkg:gem/rdoc#lib/rdoc/code_object/mixin.rb:119 def to_s; end end @@ -9451,10 +9464,10 @@ class RDoc::Parser::ChangeLog::Git::LogEntry < ::Struct # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:274 def initialize(base, commit, author, email, date, contents); end - # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:314 + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:343 def accept(visitor); end - # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:295 + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:316 def aref; end # Returns the value of attribute author @@ -9547,16 +9560,22 @@ class RDoc::Parser::ChangeLog::Git::LogEntry < ::Struct # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:271 def email=(_); end - # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:299 + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:324 def label(context = T.unsafe(nil)); end - # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:291 + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:320 + def legacy_aref; end + + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:328 + def legacy_label(context = T.unsafe(nil)); end + + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:312 def level; end - # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:331 + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:360 def pretty_print(q); end - # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:303 + # pkg:gem/rdoc#lib/rdoc/parser/changelog.rb:332 def text; end class << self @@ -9863,7 +9882,7 @@ end # # The parser looks at the token after the identifier to determine the name, in # this example, :meta_method. If a name cannot be found, a warning is printed -# and 'unknown is used. +# and 'unknown' is used. # # You can force the name of a method using the :method: directive: # @@ -12854,22 +12873,70 @@ module RDoc::Text # pkg:gem/rdoc#lib/rdoc/text.rb:177 def strip_stars(text); end - # pkg:gem/rdoc#lib/rdoc/text.rb:200 + # pkg:gem/rdoc#lib/rdoc/text.rb:196 def to_html(text); end + # pkg:gem/rdoc#lib/rdoc/text.rb:204 + def to_html_characters(text); end + # Wraps +txt+ to +line_len+ # - # pkg:gem/rdoc#lib/rdoc/text.rb:287 + # pkg:gem/rdoc#lib/rdoc/text.rb:288 def wrap(txt, line_len = T.unsafe(nil)); end private + # Decodes a label that may be in legacy RDoc format where CGI.escape was + # applied and then '%' was replaced with '-'. Converts '+' to space, + # then reverses -XX hex encoding for non-alphanumeric characters. + # + # Labels in new format pass through unchanged because -XX patterns that + # decode to alphanumeric characters are left as-is (CGI.escape never + # encodes alphanumerics). + # + # Examples: + # "What-27s+Here" -> "What's Here" (legacy: -27 is apostrophe) + # "Foo-3A-3ABar" -> "Foo::Bar" (legacy: -3A is colon) + # "Whats-Here" -> "Whats-Here" (new format, unchanged) + # + # pkg:gem/rdoc#lib/rdoc/text.rb:352 + def decode_legacy_label(label); end + # Expands tab characters in +text+ to eight spaces # # pkg:gem/rdoc#lib/rdoc/text.rb:63 def expand_tabs(text); end + # Converts +text+ to a GitHub-style anchor ID: + # - Lowercase + # - Remove characters that aren't alphanumeric, space, or hyphen + # - Replace spaces with hyphens + # + # Examples: + # "Hello World" -> "hello-world" + # "Foo::Bar" -> "foobar" + # "What's New?" -> "whats-new" + # + # pkg:gem/rdoc#lib/rdoc/text.rb:334 + def to_anchor(text); end + class << self + # Decodes a label that may be in legacy RDoc format where CGI.escape was + # applied and then '%' was replaced with '-'. Converts '+' to space, + # then reverses -XX hex encoding for non-alphanumeric characters. + # + # Labels in new format pass through unchanged because -XX patterns that + # decode to alphanumeric characters are left as-is (CGI.escape never + # encodes alphanumerics). + # + # Examples: + # "What-27s+Here" -> "What's Here" (legacy: -27 is apostrophe) + # "Foo-3A-3ABar" -> "Foo::Bar" (legacy: -3A is colon) + # "Whats-Here" -> "Whats-Here" (new format, unchanged) + # + # pkg:gem/rdoc#lib/rdoc/text.rb:352 + def decode_legacy_label(label); end + # Transcodes +character+ to +encoding+ with a +fallback+ character. # # pkg:gem/rdoc#lib/rdoc/text.rb:55 @@ -12879,13 +12946,26 @@ module RDoc::Text # # pkg:gem/rdoc#lib/rdoc/text.rb:63 def expand_tabs(text); end + + # Converts +text+ to a GitHub-style anchor ID: + # - Lowercase + # - Remove characters that aren't alphanumeric, space, or hyphen + # - Replace spaces with hyphens + # + # Examples: + # "Hello World" -> "hello-world" + # "Foo::Bar" -> "foobar" + # "What's New?" -> "whats-new" + # + # pkg:gem/rdoc#lib/rdoc/text.rb:334 + def to_anchor(text); end end end # Character class to be separated by a space when concatenating # lines. # -# pkg:gem/rdoc#lib/rdoc/text.rb:320 +# pkg:gem/rdoc#lib/rdoc/text.rb:321 RDoc::Text::SPACE_SEPARATED_LETTER_CLASS = T.let(T.unsafe(nil), Regexp) # A TokenStream is a list of tokens, gathered during the parse of some entity @@ -12898,44 +12978,44 @@ RDoc::Text::SPACE_SEPARATED_LETTER_CLASS = T.let(T.unsafe(nil), Regexp) module RDoc::TokenStream # Adds one +token+ to the collected tokens # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:85 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:81 def add_token(token); end # Adds +tokens+ to the collected tokens # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:78 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:74 def add_tokens(tokens); end # Starts collecting tokens # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:93 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:89 def collect_tokens(language); end # Remove the last token from the collected tokens # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:103 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:99 def pop_token; end # Returns the source language of the token stream as a string # # Returns 'c' or 'ruby' # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:126 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:122 def source_language; end # Starts collecting tokens # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:98 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:94 def start_collecting_tokens(language); end # Current token stream # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:110 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:106 def token_stream; end # Returns a string representation of the token stream # - # pkg:gem/rdoc#lib/rdoc/token_stream.rb:117 + # pkg:gem/rdoc#lib/rdoc/token_stream.rb:113 def tokens_to_s; end class << self @@ -13173,31 +13253,36 @@ class RDoc::TopLevel < ::RDoc::Context # Returns the relative name of this file # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:155 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:157 def full_name; end + # Finds a module or class with +name+ + # + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:152 + def get_module_named(name); end + # An RDoc::TopLevel has the same hash as another with the same # relative_name # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:163 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:165 def hash; end # URL for this with a +prefix+ # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:170 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:172 def http_url; end - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:174 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:176 def inspect; end # Dumps this TopLevel for use by ri. See also #marshal_load # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:186 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:188 def marshal_dump; end # Loads this TopLevel from +array+. # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:198 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:200 def marshal_load(array); end # Base name of this file @@ -13209,7 +13294,7 @@ class RDoc::TopLevel < ::RDoc::Context # # Records +self+ as a location in "Object". # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:210 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:212 def object_class; end # Base name of this file without the extension @@ -13229,10 +13314,10 @@ class RDoc::TopLevel < ::RDoc::Context # Path to this file for use with HTML generator output. # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:221 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:223 def path; end - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:227 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:229 def pretty_print(q); end # Relative name of this file @@ -13250,22 +13335,22 @@ class RDoc::TopLevel < ::RDoc::Context # TODO: Remove this method after dropping the darkfish theme and JsonIndex generator. # Use #search_snippet instead for getting documentation snippets. # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:244 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:246 def search_record; end # Returns an HTML snippet of the comment for search results. # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:261 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:263 def search_snippet; end # Is this TopLevel from a text file instead of a source code file? # # @return [Boolean] # - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:270 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:272 def text?; end - # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:274 + # pkg:gem/rdoc#lib/rdoc/code_object/top_level.rb:276 def to_s; end end diff --git a/sorbet/rbi/gems/rubocop-sorbet@0.11.0.rbi b/sorbet/rbi/gems/rubocop-sorbet@0.12.0.rbi similarity index 98% rename from sorbet/rbi/gems/rubocop-sorbet@0.11.0.rbi rename to sorbet/rbi/gems/rubocop-sorbet@0.12.0.rbi index 47e1c7696..bad9a57ad 100644 --- a/sorbet/rbi/gems/rubocop-sorbet@0.11.0.rbi +++ b/sorbet/rbi/gems/rubocop-sorbet@0.12.0.rbi @@ -2046,6 +2046,39 @@ RuboCop::Cop::Sorbet::Refinement::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/refinement.rb:36 RuboCop::Cop::Sorbet::Refinement::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Checks that `on_failure` is not used without `checked(:tests)` or `checked(:always)`. +# +# @example +# +# # bad +# sig { params(x: Integer).returns(Integer).on_failure(:raise) } +# def plus_one(x) +# x + 1 +# end +# +# # good +# sig { params(x: Integer).returns(Integer).checked(:always).on_failure(:raise) } +# def plus_one(x) +# x + 1 +# end +# +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/runtime_on_failure_depends_on_checked.rb:22 +class RuboCop::Cop::Sorbet::RuntimeOnFailureDependsOnChecked < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Sorbet::SignatureHelp + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/runtime_on_failure_depends_on_checked.rb:33 + def checked_tests_or_always?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/runtime_on_failure_depends_on_checked.rb:28 + def on_failure_call?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/runtime_on_failure_depends_on_checked.rb:37 + def on_signature(node); end +end + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/runtime_on_failure_depends_on_checked.rb:25 +RuboCop::Cop::Sorbet::RuntimeOnFailureDependsOnChecked::MSG = T.let(T.unsafe(nil), String) + # Suggests using `grep` over `select` when using it only for type narrowing. # # @example diff --git a/sorbet/rbi/gems/rubocop@1.82.1.rbi b/sorbet/rbi/gems/rubocop@1.84.1.rbi similarity index 98% rename from sorbet/rbi/gems/rubocop@1.82.1.rbi rename to sorbet/rbi/gems/rubocop@1.84.1.rbi index 039839b57..6ba9cb2a3 100644 --- a/sorbet/rbi/gems/rubocop@1.82.1.rbi +++ b/sorbet/rbi/gems/rubocop@1.84.1.rbi @@ -102,18 +102,18 @@ class RuboCop::CLI # pkg:gem/rubocop#lib/rubocop/cli.rb:162 def act_on_options; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:210 + # pkg:gem/rubocop#lib/rubocop/cli.rb:211 def apply_default_formatter; end # pkg:gem/rubocop#lib/rubocop/cli.rb:131 def execute_runners; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:194 + # pkg:gem/rubocop#lib/rubocop/cli.rb:195 def handle_editor_mode; end # @raise [Finished] # - # pkg:gem/rubocop#lib/rubocop/cli.rb:199 + # pkg:gem/rubocop#lib/rubocop/cli.rb:200 def handle_exiting_options; end # pkg:gem/rubocop#lib/rubocop/cli.rb:150 @@ -122,7 +122,7 @@ class RuboCop::CLI # pkg:gem/rubocop#lib/rubocop/cli.rb:86 def profile_if_needed; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:224 + # pkg:gem/rubocop#lib/rubocop/cli.rb:225 def report_pending_cops; end # pkg:gem/rubocop#lib/rubocop/cli.rb:119 @@ -131,10 +131,10 @@ class RuboCop::CLI # pkg:gem/rubocop#lib/rubocop/cli.rb:127 def run_command(name); end - # pkg:gem/rubocop#lib/rubocop/cli.rb:180 + # pkg:gem/rubocop#lib/rubocop/cli.rb:182 def set_options_to_config_loader; end - # pkg:gem/rubocop#lib/rubocop/cli.rb:189 + # pkg:gem/rubocop#lib/rubocop/cli.rb:190 def set_options_to_pending_cops_reporter; end # pkg:gem/rubocop#lib/rubocop/cli.rb:139 @@ -902,7 +902,7 @@ class RuboCop::CommentConfig private - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:97 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:98 def analyze; end # pkg:gem/rubocop#lib/rubocop/comment_config.rb:177 @@ -917,11 +917,11 @@ class RuboCop::CommentConfig # pkg:gem/rubocop#lib/rubocop/comment_config.rb:188 def analyze_single_line(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:152 - def apply_cop_operation(analyses, operation, cop_name, line); end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:147 + def apply_cop_op(analyses, operation, cop, line); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:143 - def apply_push_args(analyses, directive); end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:141 + def apply_push(analyses, resolved_cops, line); end # pkg:gem/rubocop#lib/rubocop/comment_config.rb:209 def cop_line_ranges(analysis); end @@ -929,6 +929,9 @@ class RuboCop::CommentConfig # pkg:gem/rubocop#lib/rubocop/comment_config.rb:215 def each_directive; end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:135 + def expand_cop_name(name); end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:70 def extra_enabled_comments_with_names(extras:, names:); end @@ -947,17 +950,20 @@ class RuboCop::CommentConfig # pkg:gem/rubocop#lib/rubocop/comment_config.rb:228 def non_comment_token_line_numbers; end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:84 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:85 def opt_in_cops; end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:127 - def pop_state(analyses, pop_line); end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:157 + def pop_state(analyses, line); end # pkg:gem/rubocop#lib/rubocop/comment_config.rb:224 def qualified_cop_name(cop_name); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:123 - def snapshot_analyses(analyses); end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:129 + def resolve_push_cops(directive); end + + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:125 + def snapshot_cops(analyses, cop_names); end end # pkg:gem/rubocop#lib/rubocop/comment_config.rb:9 @@ -1540,7 +1546,7 @@ class RuboCop::ConfigLoader # # @api private # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:207 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:198 def add_loaded_features(loaded_features); end # Used to add plugins that were required inside a config or from @@ -1548,7 +1554,7 @@ class RuboCop::ConfigLoader # # @api private # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:200 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:191 def add_loaded_plugins(loaded_plugins); end # pkg:gem/rubocop#lib/rubocop/config_loader.rb:86 @@ -1666,7 +1672,7 @@ class RuboCop::ConfigLoader # so this API is usually not needed. It is intended to be used only when implementing tests # that do not use `rubocop/rspec/support`. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:155 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:154 def inject_defaults!(config_yml_path); end # pkg:gem/rubocop#lib/rubocop/config_loader.rb:46 @@ -1694,7 +1700,7 @@ class RuboCop::ConfigLoader # Merges the given configuration with the default one. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:193 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:184 def merge_with_default(config, config_file, unset_nil: T.unsafe(nil)); end # Returns the path RuboCop inferred as the root of the project. No file @@ -1702,31 +1708,31 @@ class RuboCop::ConfigLoader # # @deprecated Use `RuboCop::ConfigFinder.project_root` instead. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:183 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:174 def project_root; end private - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:221 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:212 def check_duplication(yaml_code, absolute_path); end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:213 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:204 def file_path(file); end # Read the specified file, or exit with a friendly, concise message on # stderr. Care is taken to use the standard OS exit code for a "file not # found" error. # - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:241 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:232 def read_file(absolute_path); end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:217 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:208 def resolver; end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:247 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:238 def yaml_tree_to_hash(yaml_tree); end - # pkg:gem/rubocop#lib/rubocop/config_loader.rb:257 + # pkg:gem/rubocop#lib/rubocop/config_loader.rb:248 def yaml_tree_to_hash!(yaml_tree); end end end @@ -2721,7 +2727,7 @@ class RuboCop::Cop::AlignmentCorrector extend ::RuboCop::Cop::Alignment class << self - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:29 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:32 def align_end(corrector, processed_source, node, align_to); end # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:15 @@ -2734,18 +2740,18 @@ class RuboCop::Cop::AlignmentCorrector private - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:118 def alignment_column(align_to); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:43 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:47 def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:86 def block_comment_within?(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:92 def calculate_range(expr, line_begin_pos, column_delta); end # Some special kinds of string literals are not composed of literal @@ -2756,19 +2762,27 @@ class RuboCop::Cop::AlignmentCorrector # # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:82 def delimited_string_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:100 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:104 def each_line(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:128 + def indentation_string(column); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:67 def inside_string_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:61 def inside_string_ranges(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:108 + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:136 + def using_tabs?; end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:112 def whitespace_range(node); end end end @@ -7311,11 +7325,6 @@ module RuboCop::Cop::HashShorthandSyntax # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:159 def last_expression?(node); end - # @return [Boolean] - # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:167 - def method_dispatch_as_argument?(method_dispatch_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:207 def mixed_shorthand_syntax_check(hash_value_type_breakdown); end @@ -7335,6 +7344,11 @@ module RuboCop::Cop::HashShorthandSyntax # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:112 def require_hash_value_for_around_hash_literal?(node); end + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:167 + def requires_parentheses_context?(node); end + # @return [Boolean] # # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_shorthand_syntax.rb:148 @@ -8662,40 +8676,40 @@ class RuboCop::Cop::Layout::CaseIndentation < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:193 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:195 def base_column(case_node, base); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:152 def check_when(when_node, branch_type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:184 def detect_incorrect_style(when_node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:138 def end_and_last_conditional_same_line?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:148 def enforced_style_end?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:171 def incorrect_style(when_node, branch_type); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:163 def indent_one_step?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:167 def indentation_width; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:209 def replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/layout/case_indentation.rb:202 def whitespace_range(node); end end @@ -8891,19 +8905,19 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:209 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:340 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:347 def begin_pos_with_comment(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:363 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:370 def buffer; end # Setting categories hash allow you to group methods in group to match # in the {expected_order}. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:375 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:382 def categories; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:269 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:276 def class_elements(class_node); end # Classifies a node to match with something in the {expected_order} @@ -8911,7 +8925,7 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # @param node to be analysed # @return String when the node type is a `:block` then # {classify} recursively with the first children - # @return String when the node type is a `:send` then {find_category} + # @return String when the node type is a `:send` then {find_send_node_category} # by method name # @return String otherwise trying to {humanize_node} of the current node # @@ -8920,18 +8934,24 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:313 def dynamic_constant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:330 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:337 def end_position_for(node); end # Load expected order from `ExpectedOrder` config. # Define new terms in the expected order by adding new {categories}. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:369 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:376 def expected_order; end + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:261 + def find_category(name); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:366 + def find_heredoc(node); end + # Categorize a node according to the {expected_order} # Try to match {categories} values against the node's method_name given # also its visibility. @@ -8939,44 +8959,41 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # @param node to be analysed. # @return [String] with the key category or the `method_name` as string # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:247 - def find_category(node); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:248 + def find_send_node_category(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:359 - def find_heredoc(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:297 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:304 def humanize_node(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:281 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:288 def ignore?(node, classification); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:288 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:295 def ignore_for_autocorrect?(node, sibling); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:324 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:331 def marked_as_private_constant?(node, name); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:314 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:321 def private_constant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:355 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:362 def start_line_position(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:267 def walk_over_nested_class_definition(class_node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:351 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:358 def whole_line_comment_at_line?(line); end end @@ -11520,7 +11537,7 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:222 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:254 def eligible_method_call?(param0 = T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:165 @@ -11539,45 +11556,53 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:210 def bare_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:230 def base_indentation(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:258 def base_range(send_node, arg_node); end # Returns the column of the given range. For single line ranges, this # is simple. For ranges with line breaks, we look a the last code line. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:238 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:270 def column_of(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:291 def comment_lines; end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:308 def enable_layout_first_method_argument_line_break?; end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:271 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:303 def enforce_first_argument_with_fixed_indentation?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:200 + def find_top_level_send(send_node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:194 + def inner_call?(top_level_send); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:214 def message(arg_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:299 def on_new_investigation; end # Takes the line number of a given code line and returns a string # containing the previous line that's not a comment line or a blank # line. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:282 def previous_code_line(line_number); end # @return [Boolean] @@ -11587,7 +11612,12 @@ class RuboCop::Cop::Layout::FirstArgumentIndentation < ::RuboCop::Cop::Base # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:206 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:187 + def should_correct_entire_chain?(send_node, top_level_send); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_argument_indentation.rb:238 def special_inner_call_indentation?(node); end end @@ -11735,6 +11765,25 @@ RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), S # # # good # [:a, :b] +# @example AllowImplicitArrayLiterals: false (default) +# +# # bad +# a = b, +# c +# +# # good +# a = +# b, +# c +# @example AllowImplicitArrayLiterals: true +# +# # good +# a = b, +# c +# +# a = +# b, +# c # @example AllowMultilineFinalElement: false (default) # # # bad @@ -11754,28 +11803,33 @@ RuboCop::Cop::Layout::FirstArrayElementIndentation::MSG = T.let(T.unsafe(nil), S # :b => :c # }] # -# pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:43 +# pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:64 class RuboCop::Cop::Layout::FirstArrayElementLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::FirstElementLineBreak extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:49 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:70 def on_array(node); end private # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:84 + def allow_implicit_array_brackets?; end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:79 def assignment_on_same_line?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:88 def ignore_last_element?; end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:47 +# pkg:gem/rubocop#lib/rubocop/cop/layout/first_array_element_line_break.rb:68 RuboCop::Cop::Layout::FirstArrayElementLineBreak::MSG = T.let(T.unsafe(nil), String) # Checks the indentation of the first key in a hash literal @@ -12735,75 +12789,101 @@ RuboCop::Cop::Layout::HeredocArgumentClosingParenthesis::MSG = T.let(T.unsafe(ni # <<~RUBY # something # RUBY +# @example AllCops:ActiveSupportExtensionsEnabled: false (default) +# # good +# <<-RUBY.squish +# something +# RUBY +# @example AllCops:ActiveSupportExtensionsEnabled: true +# # bad +# <<-RUBY.squish +# something +# RUBY # -# pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:24 +# # good +# <<~RUBY.squish +# something +# RUBY +# +# pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:41 class RuboCop::Cop::Layout::HeredocIndentation < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::Heredoc extend ::RuboCop::Cop::AutoCorrector extend ::RuboCop::Cop::TargetRubyVersion - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:36 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:58 def on_heredoc(node); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:54 + def squish_method?(param0 = T.unsafe(nil)); end + private - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:136 + def adjust_heredoc_squish(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:146 def adjust_minus(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:141 def adjust_squiggly(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:170 def base_indent_level(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:181 def heredoc_body(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:185 def heredoc_end(node); end # Returns '~', '-' or nil # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:177 def heredoc_indent_type(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:123 + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:189 + def heredoc_squish?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:152 def indented_body(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:130 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:159 def indented_end(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:115 def line_too_long?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:128 def longest_line(lines); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:93 def message(heredoc_indent_type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:79 def register_offense(node, heredoc_indent_type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:103 def type_message(indentation_width, current_indent_type); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:132 def unlimited_heredoc_length?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:111 def width_message(indentation_width); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:32 +# pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:49 RuboCop::Cop::Layout::HeredocIndentation::TYPE_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:34 +# pkg:gem/rubocop#lib/rubocop/cop/layout/heredoc_indentation.rb:51 RuboCop::Cop::Layout::HeredocIndentation::WIDTH_MSG = T.let(T.unsafe(nil), String) # Checks for inconsistent indentation. @@ -13036,6 +13116,8 @@ RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String) # Checks for indentation that doesn't use the specified number of spaces. # The indentation width can be configured using the `Width` setting. The default width is 2. +# The block body indentation for method chain blocks can be configured using the +# `EnforcedStyleAlignWith` setting. # # See also the `Layout/IndentationConsistency` cop which is the companion to this one. # @@ -13057,6 +13139,18 @@ RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String) # end # end # end +# @example EnforcedStyleAlignWith: relative_to_receiver +# # good +# records.uniq { |el| el[:profile_id] } +# .map do |message| +# SomeJob.perform_later(message[:id]) +# end +# @example EnforcedStyleAlignWith: start_of_line (default) +# # good +# records.uniq { |el| el[:profile_id] } +# .map do |message| +# SomeJob.perform_later(message[:id]) +# end # @example Width: 2 (default) # # bad # class A @@ -13072,7 +13166,7 @@ RuboCop::Cop::Layout::IndentationStyle::MSG = T.let(T.unsafe(nil), String) # end # end # -# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:44 +# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:60 class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::RangeHelp @@ -13082,134 +13176,159 @@ class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedPattern extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:73 def access_modifier?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:98 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:158 def on_case(case_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:166 def on_case_match(case_match); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:115 def on_class(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:139 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:141 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:130 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:146 def on_defs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:86 def on_ensure(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:84 def on_for(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:160 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:176 def on_if(node, base = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:113 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:90 def on_kwbegin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:122 def on_module(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:112 def on_numblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:81 def on_resbody(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:77 def on_rescue(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:121 def on_sclass(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:124 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:140 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:156 def on_until(node, base = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:148 def on_while(node, base = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:231 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:249 def access_modifier_indentation_style; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:185 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:239 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:475 + def block_body_indentation_base(node, end_loc); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:257 def check_assignment(node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:277 def check_if(node, body, else_clause, base_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:290 def check_indentation(base_loc, body_node, style = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:191 def check_members(base, members); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:215 def check_members_for_indented_internal_methods_style(members); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:203 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:221 def check_members_for_normal_style(base, members); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:344 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:384 def check_rescue?(rescue_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:380 - def configured_indentation_width; end + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:440 + def column_offset_between(base_range, range); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:426 + def contains_access_modifier?(body_node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:390 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:483 def dot_on_new_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:229 def each_member(members); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:253 def indentation_consistency_style; end + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:432 + def indentation_style; end + # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:327 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:367 def indentation_to_check?(base_loc, body_node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:223 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:241 def indented_internal_methods_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:384 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:469 def leftmost_modifier_of(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:451 + def line_indentation(range); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:456 + def line_uses_tabs?(range); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:324 def message(configured_indentation_width, indentation, name); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:363 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:345 + def message_for_spaces(configured_indentation_width, indentation, name); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:332 + def message_for_tabs(configured_indentation_width, indentation, name); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:403 def offending_range(body_node, indentation); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:282 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:300 def offense(body_node, indentation, style); end # Returns true if the given node is within another node that has @@ -13217,29 +13336,37 @@ class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base # # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:317 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:357 def other_offense_in_same_range?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:203 def select_check_member(member); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:348 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:388 def skip_check?(base_loc, body_node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:227 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:245 def special_modifier?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:371 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:417 def starts_with_access_modifier?(body_node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:436 + def using_tabs?; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:460 + def visual_column(range); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:52 +# pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:69 RuboCop::Cop::Layout::IndentationWidth::MSG = T.let(T.unsafe(nil), String) # Checks for indentation of the first non-blank non-comment @@ -14834,102 +14961,165 @@ RuboCop::Cop::Layout::MultilineMethodCallBraceLayout::SAME_LINE_MESSAGE = T.let( # .b # .c # -# pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:49 +# pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:50 class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::MultilineExpressionIndentation + include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector # @raise [ValidationError] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:55 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:57 def validate_config; end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:140 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:219 def align_with_base_message(rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:241 def alignment_base(node, rhs, given_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:67 + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:300 + def alignment_base_for_chained_receiver?(receiver_chain, base_receiver); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:83 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:223 def base_source; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:181 + def calculate_column_delta_offense(rhs, correct_column); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:154 + def check_hash_pair_indentation(node, lhs, rhs); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:145 + def check_hash_pair_indented_style(rhs, pair_ancestor); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:168 + def check_regular_indentation(node, lhs, rhs, given_style); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:98 + def correct_block(corrector, block_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:92 + def correct_selector_only(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:186 def extra_indentation(given_style, parent); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:230 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:69 + def find_base_receiver(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:345 + def find_continuation_receiver(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:288 + def find_hash_method_base_in_receiver_chain(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:160 + def find_hash_pair_alignment_base(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:339 def find_multiline_block_chain_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:75 + def find_pair_ancestor(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:313 + def first_call_alignment_node(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:360 def first_call_has_a_dot(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:221 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:330 def get_dot_right_above(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:353 + def handle_descendant_block(node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:137 + def hash_pair_aligned?(pair_ancestor, given_style); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:141 + def hash_pair_indented?(node, pair_ancestor, given_style); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:196 def message(node, lhs, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:148 + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:324 + def method_on_receiver_last_line?(node, base_receiver, type); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:227 def no_base_message(lhs, rhs, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:120 def offending_range(node, lhs, rhs, given_style); end # @yield [operation_rhs.first_argument] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:251 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:367 def operation_rhs(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:261 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:377 def operator_rhs?(node, receiver); end # a # .b # .c # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:280 def receiver_alignment_base(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:214 def relative_to_receiver_message(rhs); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:104 def relevant_node?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:108 def right_hand_side(send_node); end # a.b # .c # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:268 def semantic_alignment_base(node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:205 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:305 def semantic_alignment_node(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:131 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:210 def should_align_with_base?; end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:206 def should_indent_relative_to_receiver?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:250 def syntactic_alignment_base(lhs, rhs); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:79 + def unwrap_block_node(node); end end # Checks that the closing brace in a method definition is either @@ -19667,6 +19857,27 @@ RuboCop::Cop::Lint::DuplicateMatchPattern::MSG = T.let(T.unsafe(nil), String) # def foo # 1 # end +# +# # bad +# class MyClass +# extend Forwardable +# +# # or with: `def_instance_delegator`, `def_delegators`, `def_instance_delegators` +# def_delegator :delegation_target, :delegated_method_name +# +# def delegated_method_name +# end +# end +# +# # good +# class MyClass +# extend Forwardable +# +# def_delegator :delegation_target, :delegated_method_name +# +# def non_duplicated_delegated_method_name +# end +# end # @example AllCops:ActiveSupportExtensionsEnabled: false (default) # # # good @@ -19707,92 +19918,103 @@ RuboCop::Cop::Lint::DuplicateMatchPattern::MSG = T.let(T.unsafe(nil), String) # delegate :foo, to: :bar # end # -# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:100 +# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:121 class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Base # @return [DuplicateMethods] a new instance of DuplicateMethods # - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:127 def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:145 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:167 def alias_method?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:172 def delegate_method?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:131 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:180 + def delegator?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:190 + def delegators?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:153 def method_alias?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:157 def on_alias(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:133 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:141 def on_defs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:160 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:200 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:198 def sym_name(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:179 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:227 def check_const_receiver(node, name, const_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:234 def check_self_receiver(node, name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:260 def delegate_prefix(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:296 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:348 def found_attr(node, args, readable: T.unsafe(nil), writable: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:276 def found_instance_method(node, name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:247 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:299 def found_method(node, method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:237 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:289 def found_sclass_method(node, name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:272 def hash_value(node, key); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:274 + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:241 + def inside_condition?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:326 def location(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:358 def lookup_constant(node, const_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:193 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:245 def message_for_dup(node, method_name, key); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:266 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:318 def method_key(node, method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:282 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:334 def on_attr(node, attr_name, args); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:250 def on_delegate(node, method_names); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:324 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:376 def qualified_name(enclosing, namespace, mod_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:338 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:390 def source_location(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:101 +# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:122 RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:102 +# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:123 RuboCop::Cop::Lint::DuplicateMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for duplicate elements in `Regexp` character classes. @@ -25757,10 +25979,10 @@ RuboCop::Cop::Lint::SharedMutableDefault::RESTRICT_ON_SEND = T.let(T.unsafe(nil) # # pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:24 class RuboCop::Cop::Lint::StructNewOverride < ::RuboCop::Cop::Base - # pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:38 + # pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:54 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:33 + # pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:49 def struct_new(param0 = T.unsafe(nil)); end end @@ -25770,10 +25992,12 @@ RuboCop::Cop::Lint::StructNewOverride::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:27 RuboCop::Cop::Lint::StructNewOverride::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:30 +# pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:46 RuboCop::Cop::Lint::StructNewOverride::STRUCT_MEMBER_NAME_TYPES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:29 +# This is based on `Struct.instance_methods.sort` in Ruby 4.0.0. +# +# pkg:gem/rubocop#lib/rubocop/cop/lint/struct_new_override.rb:30 RuboCop::Cop::Lint::StructNewOverride::STRUCT_METHOD_NAMES = T.let(T.unsafe(nil), Array) # Checks for `rescue` blocks with no body. @@ -26149,38 +26373,34 @@ RuboCop::Cop::Lint::ToEnumArguments::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr # Checks to make sure `#to_json` includes an optional argument. # When overriding `#to_json`, callers may invoke JSON -# generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows +# generation via `JSON.generate(your_obj)`. Since `JSON#generate` allows # for an optional argument, your method should too. # # @example -# class Point -# attr_reader :x, :y -# -# # bad, incorrect arity +# # bad - incorrect arity # def to_json # JSON.generate([x, y]) # end # -# # good, preserving args +# # good - preserving args # def to_json(*args) # JSON.generate([x, y], *args) # end # -# # good, discarding args +# # good - discarding args # def to_json(*_args) # JSON.generate([x, y]) # end -# end # -# pkg:gem/rubocop#lib/rubocop/cop/lint/to_json.rb:31 +# pkg:gem/rubocop#lib/rubocop/cop/lint/to_json.rb:27 class RuboCop::Cop::Lint::ToJSON < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_json.rb:36 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_json.rb:32 def on_def(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/to_json.rb:34 +# pkg:gem/rubocop#lib/rubocop/cop/lint/to_json.rb:30 RuboCop::Cop::Lint::ToJSON::MSG = T.let(T.unsafe(nil), String) # Checks for top level return with arguments. If there is a @@ -31538,91 +31758,101 @@ end # def foo # bar? # end +# @example WaywardPredicates: ['infinite?', 'nonzero?'] (default) +# # good +# def non_predicate_method(num) +# num.infinite? +# end # -# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:140 +# # good +# def non_predicate_method(num) +# num.nonzero? +# end +# +# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:151 class RuboCop::Cop::Naming::PredicateMethod < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::AllowedPattern - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:158 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:170 def on_defs(node); end private # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:183 def acceptable?(return_values); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:201 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:212 def all_return_values_boolean?(return_values); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:302 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:313 def allow_bang_methods?; end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:174 def allowed?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:296 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:307 def allowed_bang_method?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:266 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:277 def and_or?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:219 def boolean_return?(value); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:292 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:303 def conservative?; end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:270 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:281 def extract_and_or_clauses(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:277 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:288 def extract_conditional_branches(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:246 def extract_return_value(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:259 def last_value(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:225 def method_returning_boolean?(value); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:221 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:232 def potential_non_predicate?(return_values); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:265 def process_return_values(return_values); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:199 def return_values(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:193 def unknown_method_call?(value); end # If a method ending in `?` is known to not return a boolean value, @@ -31631,17 +31861,17 @@ class RuboCop::Cop::Naming::PredicateMethod < ::RuboCop::Cop::Base # # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:309 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:320 def wayward_predicate?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:313 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:324 def wayward_predicates; end end -# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:145 +# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:156 RuboCop::Cop::Naming::PredicateMethod::MSG_NON_PREDICATE = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:144 +# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_method.rb:155 RuboCop::Cop::Naming::PredicateMethod::MSG_PREDICATE = T.let(T.unsafe(nil), String) # Checks that predicate method names end with a question mark and @@ -32200,28 +32430,28 @@ class RuboCop::Cop::Offense # @api public # @return [Integer] comparison result # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:229 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:230 def <=>(other); end # @api public # @return [Boolean] returns `true` if two offenses contain same attributes # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:211 def ==(other); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:160 def column; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:170 def column_length; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:193 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:194 def column_range; end # @api public @@ -32268,15 +32498,15 @@ class RuboCop::Cop::Offense # @api public # @return [Boolean] returns `true` if two offenses contain same attributes # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:217 def eql?(other); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:179 def first_line; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:218 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:219 def hash; end # @api public @@ -32287,17 +32517,17 @@ class RuboCop::Cop::Offense # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:189 def last_column; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:183 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:184 def last_line; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:155 def line; end # @api public @@ -32321,7 +32551,7 @@ class RuboCop::Cop::Offense # # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:203 def real_column; end # @api public @@ -32332,7 +32562,7 @@ class RuboCop::Cop::Offense # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:165 def source_line; end # @api private @@ -32344,7 +32574,7 @@ class RuboCop::Cop::Offense # # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:148 def to_s; end end @@ -34141,7 +34371,7 @@ class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:248 def correctable_group_offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:356 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:355 def def_source(node, def_nodes); end # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:310 @@ -34160,7 +34390,7 @@ class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:259 def inline_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:340 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:339 def insert_inline_modifier(corrector, node, modifier_name); end # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:281 @@ -34176,10 +34406,10 @@ class RuboCop::Cop::Style::AccessModifierDeclarations < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:222 def percent_symbol_array?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:350 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:349 def remove_modifier_node_within_begin(corrector, modifier_node, begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:344 + # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:343 def remove_nodes(corrector, *nodes); end # pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:324 @@ -39274,6 +39504,89 @@ RuboCop::Cop::Style::EmptyCaseCondition::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/cop/style/empty_case_condition.rb:43 RuboCop::Cop::Style::EmptyCaseCondition::NOT_SUPPORTED_PARENT_TYPES = T.let(T.unsafe(nil), Array) +# Enforces consistent style for empty class definitions. +# +# This cop can enforce either a two-line class definition or `Class.new` +# for classes with no body. +# +# The supported styles are: +# +# * class_definition (default) - prefer two-line class definition over `Class.new` +# * class_new - prefer `Class.new` over class definition +# +# @example EnforcedStyle: class_definition (default) +# # bad +# FooError = Class.new(StandardError) +# +# # okish +# class FooError < StandardError; end +# +# # good +# class FooError < StandardError +# end +# @example EnforcedStyle: class_new +# # bad +# class FooError < StandardError +# end +# +# # bad +# class FooError < StandardError; end +# +# # good +# FooError = Class.new(StandardError) +# +# pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:38 +class RuboCop::Cop::Style::EmptyClassDefinition < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::Alignment + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:49 + def class_new_assignment?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:53 + def on_casgn(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:66 + def on_class(node); end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:92 + def autocorrect_class_definition(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:77 + def autocorrect_class_new(corrector, node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:129 + def chained_with_any_method?(expression_node, class_new_node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:135 + def empty_class?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:108 + def extract_parent_class(class_new_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:120 + def find_class_new_node(node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:113 + def variable_parent_class?(class_new_node); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:44 +RuboCop::Cop::Style::EmptyClassDefinition::MSG_CLASS_DEFINITION = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/empty_class_definition.rb:46 +RuboCop::Cop::Style::EmptyClassDefinition::MSG_CLASS_NEW = T.let(T.unsafe(nil), String) + # Checks for empty else-clauses, possibly including comments and/or an # explicit `nil` depending on the EnforcedStyle. # @@ -41801,34 +42114,34 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:265 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:278 def accepted_form?(node, ending: T.unsafe(nil)); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:275 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:288 def accepted_if?(node, ending); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:302 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:315 def allowed_consecutive_conditionals?; end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:268 def and_or_guard_clause?(guard_clause); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:299 def assigned_lvar_used_in_if_branch?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:200 def autocorrect(corrector, node, condition, replacement, guard); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:226 - def autocorrect_heredoc_argument(corrector, node, heredoc_branch, leave_branch, guard); end + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:238 + def autocorrect_heredoc_argument(corrector, node, heredoc_node, leave_branch, guard); end # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:149 def check_ending_body(body); end @@ -41841,7 +42154,10 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:170 def consecutive_conditionals?(parent, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:247 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:226 + def find_heredoc_argument(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:260 def guard_clause_source(guard_clause); end # @return [Boolean] @@ -41849,23 +42165,23 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:222 def heredoc?(argument); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:238 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:251 def range_of_branch_to_remove(node, guard); end # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:178 def register_offense(node, scope_exiting_keyword, conditional_keyword, guard = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:298 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:311 def remove_whole_lines(corrector, range); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:273 def too_long_for_single_line?(node, example); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:269 + # pkg:gem/rubocop#lib/rubocop/cop/style/guard_clause.rb:282 def trivial?(node); end end @@ -42327,6 +42643,73 @@ end # pkg:gem/rubocop#lib/rubocop/cop/style/hash_like_case.rb:42 RuboCop::Cop::Style::HashLikeCase::MSG = T.let(T.unsafe(nil), String) +# Enforces the use of either `Hash#[]` or `Hash#fetch` for hash lookup. +# +# This cop can be configured to prefer either bracket-style (`[]`) +# or fetch-style lookup. It is disabled by default. +# +# When enforcing `fetch` style, only single-argument bracket access is flagged. +# When enforcing `brackets` style, only `fetch` calls with a single key +# argument are flagged (not those with default values or blocks). +# +# @example EnforcedStyle: brackets (default) +# # bad +# hash.fetch(key) +# +# # good +# hash[key] +# +# # good - fetch with default value is allowed +# hash.fetch(key, default) +# +# # good - fetch with block is allowed +# hash.fetch(key) { default } +# @example EnforcedStyle: fetch +# # bad +# hash[key] +# +# # good +# hash.fetch(key) +# +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:44 +class RuboCop::Cop::Style::HashLookupMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ConfigurableEnforcedStyle + extend ::RuboCop::Cop::AutoCorrector + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:64 + def on_csend(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:53 + def on_send(node); end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:85 + def correct_brackets_to_fetch(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:77 + def correct_fetch_to_brackets(corrector, node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:68 + def offense_for_brackets?(node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:73 + def offense_for_fetch?(node); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:48 +RuboCop::Cop::Style::HashLookupMethod::BRACKET_MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:49 +RuboCop::Cop::Style::HashLookupMethod::FETCH_MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/hash_lookup_method.rb:51 +RuboCop::Cop::Style::HashLookupMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Checks for usages of `Hash#reject`, `Hash#select`, and `Hash#filter` methods # that can be replaced with `Hash#slice` method. # @@ -43028,7 +43411,7 @@ RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) # do_something # end # -# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:74 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:75 class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp @@ -43038,130 +43421,149 @@ class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::CommentsHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:93 def on_if(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:190 def allowed_patterns; end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:258 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:287 def another_statement_on_same_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:150 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:151 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:312 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:277 + def collection_from_ancestor(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:341 def comment_on_node_line(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:125 def defined_argument_is_undefined?(if_node, defined_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:117 def defined_nodes(condition); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:113 def endless_method?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:299 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:328 def extract_heredoc_from(last_argument); end + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:270 + def find_containing_collection(node); end + # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:242 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:234 def line_length_enabled_at_line?(line); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:143 def message(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:246 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:247 + def multiline_inside_collection?(node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:238 def named_capture_in_condition?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:250 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:242 def non_eligible_node?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:283 def non_simple_if_unless?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:135 def pattern_matching_nodes(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:316 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:345 def remove_comment(corrector, _node, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:335 def remove_heredoc(corrector, heredoc); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:160 def replacement_for_modifier_form(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:292 + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:266 + def shares_line_with?(inner, node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:254 + def sibling_if_shares_line?(child, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:321 def to_modifier_form_with_move_comment(node, indentation, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:301 def to_normal_form(node, indentation); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:280 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:309 def to_normal_form_with_heredoc(node, indentation, heredoc); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:183 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:184 def too_long_due_to_comment_after_modifier?(node, comment); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:179 def too_long_due_to_modifier?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:217 def too_long_line_based_on_allow_cop_directives?(range, line); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:233 - def too_long_line_based_on_allow_qualified_name?(line); end - - # @return [Boolean] - # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:225 def too_long_line_based_on_allow_uri?(line); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:208 def too_long_line_based_on_config?(range, line); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:195 def too_long_single_line?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:259 + def unwrap_begin(node); end + class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:88 def autocorrect_incompatible_with; end end end -# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:82 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:83 RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:85 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:86 RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String) # Checks for if and unless statements used as modifiers of other if or @@ -43244,65 +43646,68 @@ RuboCop::Cop::Style::IfUnlessModifierOfIfUnless::MSG = T.let(T.unsafe(nil), Stri # # # good (but potentially an unsafe correction) # foo.do_something? -# @example AllowedMethods: ['nonzero?'] (default) +# @example AllowedMethods: ['infinite?', 'nonzero?'] (default) +# # good +# num.infinite? ? true : false +# # # good # num.nonzero? ? true : false # -# pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:61 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:64 class RuboCop::Cop::Style::IfWithBooleanLiteralBranches < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:76 def double_negative?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:69 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:72 def if_with_boolean_literal_branches?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:78 def on_if(node); end private # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:138 def assume_boolean_value?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:116 def message(node, keyword); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:98 def multiple_elsif?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:104 def offense_range_with_keyword(node, condition); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:155 def opposite_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:145 def replacement_condition(node, condition); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:160 def require_parentheses?(condition); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:124 def return_boolean_value?(condition); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:65 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:68 RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:66 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_with_boolean_literal_branches.rb:69 RuboCop::Cop::Style::IfWithBooleanLiteralBranches::MSG_FOR_ELSIF = T.let(T.unsafe(nil), String) # Checks for uses of semicolon in if statements. @@ -46213,31 +46618,64 @@ RuboCop::Cop::Style::ModuleFunction::MODULE_FUNCTION_MSG = T.let(T.unsafe(nil), # # Array.method_defined?(:find, false) # -# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:29 +# # bad +# Array.class_variables.include?(:foo) +# Array.constants.include?(:foo) +# Array.private_instance_methods.include?(:foo) +# Array.protected_instance_methods.include?(:foo) +# Array.public_instance_methods.include?(:foo) +# Array.included_modules.include?(:foo) +# +# # good +# Array.class_variable_defined?(:foo) +# Array.const_defined?(:foo) +# Array.private_method_defined?(:foo) +# Array.protected_method_defined?(:foo) +# Array.public_method_defined?(:foo) +# Array.include?(:foo) +# @example AllowedMethods: [included_modules] +# +# # good +# Array.included_modules.include?(:foo) +# +# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:50 class RuboCop::Cop::Style::ModuleMemberExistenceCheck < ::RuboCop::Cop::Base + include ::RuboCop::Cop::AllowedMethods extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:37 - def instance_methods_inclusion?(param0 = T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:57 + def module_member_inclusion?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:93 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:44 + # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:80 def on_send(node); end private + # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:97 + def replacement_for(node, parent); end + # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:108 def simple_method_argument?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:32 +# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:74 +RuboCop::Cop::Style::ModuleMemberExistenceCheck::METHODS_WITHOUT_INHERIT_PARAM = T.let(T.unsafe(nil), Set) + +# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:75 +RuboCop::Cop::Style::ModuleMemberExistenceCheck::METHODS_WITH_INHERIT_PARAM = T.let(T.unsafe(nil), Set) + +# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:64 +RuboCop::Cop::Style::ModuleMemberExistenceCheck::METHOD_REPLACEMENTS = T.let(T.unsafe(nil), Hash) + +# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:54 RuboCop::Cop::Style::ModuleMemberExistenceCheck::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:34 +# pkg:gem/rubocop#lib/rubocop/cop/style/module_member_existence_check.rb:78 RuboCop::Cop::Style::ModuleMemberExistenceCheck::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for chaining of a block after another block that spans @@ -47182,6 +47620,117 @@ class RuboCop::Cop::Style::NegatedWhile < ::RuboCop::Cop::Base def on_while(node); end end +# Identifies usages of `arr[arr.length - n]`, `arr[arr.size - n]`, or +# `arr[arr.count - n]` and suggests to change them to use `arr[-n]` instead. +# Also handles range patterns like `arr[0..(arr.length - n)]`. +# +# The cop recognizes preserving methods (`sort`, `reverse`, `shuffle`, `rotate`) +# and their combinations, allowing safe replacement when the receiver matches. +# It works with variables, instance variables, class variables, and constants. +# +# @example +# # bad +# arr[arr.count - 2] +# arr[0..(arr.length - 2)] +# arr[0...(arr.length - 4)] +# arr.sort[arr.reverse.length - 2] +# arr.sort.reverse[arr.sort.size - 2] +# +# # good +# arr[-2] +# arr[0..-2] +# arr[0...-4] +# arr.sort[-2] +# arr.sort.reverse[-2] +# +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:29 +class RuboCop::Cop::Style::NegativeArrayIndex < ::RuboCop::Cop::Base + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:42 + def length_subtraction?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:61 + def on_csend(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:48 + def on_send(node); end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:82 + def add_offense_for_subtraction(node, index_arg, negative_index); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:168 + def build_current_source(receiver, range_without_parens, index_arg); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:151 + def build_message_for_range(receiver, start, range_op, index, current); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:126 + def build_range_offense_data(receiver, range_node, range_end, inner_end, negative_index, index_arg); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:178 + def build_range_without_parens(range_start, range_op, range_end, inner_end); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:158 + def build_replacement_string(range_start, range_op, negative_index, index_arg); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:200 + def extract_base_receiver(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:78 + def extract_inner_end(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:74 + def extract_range_from_begin(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:143 + def format_range_message_parts(range_start, negative_index, index_arg); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:111 + def handle_range_pattern(receiver, range_node, index_arg); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:65 + def handle_simple_index_pattern(node, index_arg); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:209 + def preserving_method?(node); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:94 + def range_with_length_subtraction?(range_node, array_receiver); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:184 + def receivers_match?(length_receiver, array_receiver); end + + # @return [Boolean] + # + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:195 + def receivers_match_strict?(length_receiver, array_receiver); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:37 +RuboCop::Cop::Style::NegativeArrayIndex::LENGTH_METHODS = T.let(T.unsafe(nil), Array) + +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:33 +RuboCop::Cop::Style::NegativeArrayIndex::MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:34 +RuboCop::Cop::Style::NegativeArrayIndex::MSG_RANGE = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:39 +RuboCop::Cop::Style::NegativeArrayIndex::PRESERVING_METHODS = T.let(T.unsafe(nil), Array) + +# pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:35 +RuboCop::Cop::Style::NegativeArrayIndex::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Checks for nested `File.dirname`. # It replaces nested `File.dirname` with the level argument introduced in Ruby 3.1. # @@ -50024,18 +50573,21 @@ RuboCop::Cop::Style::RedundantCapitalW::MSG = T.let(T.unsafe(nil), String) # # # good # a.nil? || a -# @example AllowedMethods: ['nonzero?'] (default) +# @example AllowedMethods: ['infinite?', 'nonzero?'] (default) +# # good +# num.infinite? ? true : false +# # # good # num.nonzero? ? true : false # -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:65 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:68 class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::CommentsHelp include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:80 def on_if(node); end private @@ -50045,127 +50597,127 @@ class RuboCop::Cop::Style::RedundantCondition < ::RuboCop::Cop::Base # # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:225 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:228 def argument_with_operator?(argument); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:205 def asgn_type?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:100 def autocorrect(corrector, node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:192 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:195 def branches_have_assignment?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:206 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:209 def branches_have_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:312 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:315 def correct_ternary(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:262 def else_source(else_branch, arithmetic_operation); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:288 def else_source_if_has_assignment(else_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:275 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:278 def else_source_if_has_method(else_branch); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:184 def if_branch_is_true_type_and_else_is_not?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:244 def if_source(if_branch, arithmetic_operation); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:295 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:298 def make_ternary_form(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:92 def message(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:121 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:114 def range_of_offense(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:129 def redundant_condition?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:327 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:330 def require_braces?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:320 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:323 def require_parentheses?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:219 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:222 def same_method?(if_branch, else_branch); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:213 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:216 def single_argument_method?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:145 def synonymous_condition_and_branch?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:331 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:334 def use_arithmetic_operation?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:141 def use_hash_key_access?(node); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:137 def use_hash_key_assignment?(else_branch); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:130 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:133 def use_if_branch?(else_branch); end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:335 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:338 def without_argument_parentheses_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:233 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:236 def wrap_arguments_with_parens(condition); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:73 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:76 RuboCop::Cop::Style::RedundantCondition::ARGUMENT_WITH_OPERATOR_TYPES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:71 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:74 RuboCop::Cop::Style::RedundantCondition::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:72 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_condition.rb:75 RuboCop::Cop::Style::RedundantCondition::REDUNDANT_CONDITION = T.let(T.unsafe(nil), String) # Checks for redundant returning of true/false in conditionals. @@ -53246,6 +53798,39 @@ end # pkg:gem/rubocop#lib/rubocop/cop/style/return_nil_in_predicate_method_definition.rb:74 RuboCop::Cop::Style::ReturnNilInPredicateMethodDefinition::MSG = T.let(T.unsafe(nil), String) +# Identifies places where `array.reverse.find` can be replaced by `array.rfind`. +# +# @example +# # bad +# array.reverse.find { |item| item.even? } +# array.reverse.detect { |item| item.even? } +# array.reverse_each.find { |item| item.even? } +# array.reverse_each.detect { |item| item.even? } +# +# # good +# array.rfind { |item| item.even? } +# +# pkg:gem/rubocop#lib/rubocop/cop/style/reverse_find.rb:22 +class RuboCop::Cop::Style::ReverseFind < ::RuboCop::Cop::Base + extend ::RuboCop::Cop::AutoCorrector + extend ::RuboCop::Cop::TargetRubyVersion + + # pkg:gem/rubocop#lib/rubocop/cop/style/reverse_find.rb:47 + def on_csend(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/reverse_find.rb:38 + def on_send(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/reverse_find.rb:32 + def reverse_find?(param0 = T.unsafe(nil)); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/style/reverse_find.rb:26 +RuboCop::Cop::Style::ReverseFind::MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/reverse_find.rb:27 +RuboCop::Cop::Style::ReverseFind::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) + # Transforms usages of a method call safeguarded by a non `nil` # check for the variable whose method is being called to # safe navigation (`&.`). If there is a method chain, all of the methods @@ -59060,7 +59645,20 @@ end # # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:265 class RuboCop::Cop::VariableForce::Branch::And < ::RuboCop::Cop::VariableForce::Branch::Base - include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + include ::RuboCop::Cop::VariableForce::Branch::Operator + + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 + def left_body?; end + + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 + def right_body?; end +end + +# left_body &&= right_body +# +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:273 +class RuboCop::Cop::VariableForce::Branch::AndAsgn < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::Operator # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 def left_body?; end @@ -59205,7 +59803,7 @@ class RuboCop::Cop::VariableForce::Branch::Base < ::Struct end end -# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:325 +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:349 RuboCop::Cop::VariableForce::Branch::CLASSES_BY_TYPE = T.let(T.unsafe(nil), Hash) # case target @@ -59260,13 +59858,13 @@ end # ensure_body # end # -# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:314 +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:338 class RuboCop::Cop::VariableForce::Branch::Ensure < ::RuboCop::Cop::VariableForce::Branch::Base include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:320 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:344 def always_run?; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 @@ -59278,16 +59876,16 @@ end # Mix-in module for exception handling control structures. # -# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:281 +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:305 module RuboCop::Cop::VariableForce::Branch::ExceptionHandler # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:282 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:306 def may_jump_to_other_branch?; end # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:310 def may_run_incompletely?; end end @@ -59338,10 +59936,23 @@ class RuboCop::Cop::VariableForce::Branch::If < ::RuboCop::Cop::VariableForce::B def truthy_body?; end end -# Mix-in module for logical operator control structures. +# e.g. left_body += right_body +# +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:297 +class RuboCop::Cop::VariableForce::Branch::OpAsgn < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::Operator + + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 + def left_body?; end + + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 + def right_body?; end +end + +# Mix-in module for operator control structures. # # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:258 -module RuboCop::Cop::VariableForce::Branch::LogicalOperator +module RuboCop::Cop::VariableForce::Branch::Operator # @return [Boolean] # # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:259 @@ -59350,9 +59961,22 @@ end # left_body || right_body # -# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:273 +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:281 class RuboCop::Cop::VariableForce::Branch::Or < ::RuboCop::Cop::VariableForce::Branch::Base - include ::RuboCop::Cop::VariableForce::Branch::LogicalOperator + include ::RuboCop::Cop::VariableForce::Branch::Operator + + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 + def left_body?; end + + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 + def right_body?; end +end + +# left_body ||= right_body +# +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:289 +class RuboCop::Cop::VariableForce::Branch::OrAsgn < ::RuboCop::Cop::VariableForce::Branch::Base + include ::RuboCop::Cop::VariableForce::Branch::Operator # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 def left_body?; end @@ -59368,13 +59992,13 @@ end # else_body # end # -# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:297 +# pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:321 class RuboCop::Cop::VariableForce::Branch::Rescue < ::RuboCop::Cop::VariableForce::Branch::Base include ::RuboCop::Cop::VariableForce::Branch::ExceptionHandler # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:304 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:328 def always_run?; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/branch.rb:57 @@ -60736,6 +61360,9 @@ class RuboCop::Formatter::ClangStyleFormatter < ::RuboCop::Formatter::SimpleText # pkg:gem/rubocop#lib/rubocop/formatter/clang_style_formatter.rb:17 def report_offense(file, offense); end + # pkg:gem/rubocop#lib/rubocop/formatter/clang_style_formatter.rb:53 + def to_whitespace(string); end + # @return [Boolean] # # pkg:gem/rubocop#lib/rubocop/formatter/clang_style_formatter.rb:33 @@ -61807,10 +62434,10 @@ class RuboCop::Formatter::TapFormatter < ::RuboCop::Formatter::ClangStyleFormatt private - # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:62 + # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:65 def annotate_message(msg); end - # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:66 + # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:69 def message(offense); end # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:39 @@ -61819,8 +62446,11 @@ class RuboCop::Formatter::TapFormatter < ::RuboCop::Formatter::ClangStyleFormatt # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:29 def report_line(location); end - # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:46 + # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:49 def report_offense(file, offense); end + + # pkg:gem/rubocop#lib/rubocop/formatter/tap_formatter.rb:45 + def to_whitespace(string); end end # Common logic for UI texts. @@ -63208,7 +63838,7 @@ class RuboCop::RemoteConfig # @api private # - # pkg:gem/rubocop#lib/rubocop/remote_config.rb:104 + # pkg:gem/rubocop#lib/rubocop/remote_config.rb:107 def cloned_url; end # @api private @@ -63848,34 +64478,34 @@ class RuboCop::TargetRuby # @api private # @return [TargetRuby] a new instance of TargetRuby # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:282 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:284 def initialize(config); end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:298 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:300 def rubocop_version_with_support; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:286 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:288 def source; end # @api private # @return [Boolean] # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:294 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:296 def supported?; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:290 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:292 def version; end class << self # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:267 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:269 def supported_versions; end end end @@ -63884,47 +64514,47 @@ end # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:214 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:216 class RuboCop::TargetRuby::BundlerLockFile < ::RuboCop::TargetRuby::Source # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:215 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:217 def name; end private # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:248 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:250 def bundler_lock_file_path; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:221 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:223 def find_version; end end # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:8 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:10 RuboCop::TargetRuby::DEFAULT_VERSION = T.let(T.unsafe(nil), Float) # If all else fails, a default version will be picked. # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:255 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:257 class RuboCop::TargetRuby::Default < ::RuboCop::TargetRuby::Source # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:256 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:258 def name; end private # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:262 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:264 def find_version; end end @@ -63932,51 +64562,51 @@ end # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:67 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:69 class RuboCop::TargetRuby::GemspecFile < ::RuboCop::TargetRuby::Source extend ::RuboCop::AST::NodePattern::Macros - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:76 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:78 def gem_requirement_versions(param0 = T.unsafe(nil)); end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:82 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:84 def name; end - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:71 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:73 def required_ruby_version(param0); end private # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:146 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:148 def find_minimal_known_ruby(right_hand_side); end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:88 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:90 def find_version; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:98 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:100 def gemspec_filepath; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:142 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:144 def version_from_array(array); end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:112 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:114 def version_from_gemspec_file(file); end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:130 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:132 def version_from_right_hand_side(right_hand_side); end end @@ -63987,25 +64617,25 @@ RuboCop::TargetRuby::KNOWN_RUBIES = T.let(T.unsafe(nil), Array) # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:10 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:12 RuboCop::TargetRuby::OBSOLETE_RUBIES = T.let(T.unsafe(nil), Hash) # The target ruby version may be configured in RuboCop's config. # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:53 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:55 class RuboCop::TargetRuby::RuboCopConfig < ::RuboCop::TargetRuby::Source # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:54 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:56 def name; end private # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:60 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:62 def find_version; end end @@ -64014,18 +64644,18 @@ end # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:39 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:41 class RuboCop::TargetRuby::RuboCopEnvVar < ::RuboCop::TargetRuby::Source # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:40 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:42 def name; end private # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:46 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:48 def find_version; end end @@ -64033,76 +64663,76 @@ end # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:160 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:162 class RuboCop::TargetRuby::RubyVersionFile < ::RuboCop::TargetRuby::Source # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:164 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:166 def name; end private # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:170 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:172 def filename; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:178 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:180 def find_version; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:174 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:176 def pattern; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:185 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:187 def version_file; end end # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:161 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:163 RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_FILENAME = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:162 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:164 RuboCop::TargetRuby::RubyVersionFile::RUBY_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:271 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:273 RuboCop::TargetRuby::SOURCES = T.let(T.unsafe(nil), Array) # A place where information about a target ruby version is found. # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:24 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:26 class RuboCop::TargetRuby::Source # @api private # @return [Source] a new instance of Source # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:27 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:29 def initialize(config); end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:25 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:27 def name; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:32 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:34 def to_s; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:25 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:27 def version; end end @@ -64111,34 +64741,34 @@ end # # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:193 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:195 class RuboCop::TargetRuby::ToolVersionsFile < ::RuboCop::TargetRuby::RubyVersionFile # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:197 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:199 def name; end private # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:203 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:205 def filename; end # @api private # - # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:207 + # pkg:gem/rubocop#lib/rubocop/target_ruby.rb:209 def pattern; end end # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:194 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:196 RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_FILENAME = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:195 +# pkg:gem/rubocop#lib/rubocop/target_ruby.rb:197 RuboCop::TargetRuby::ToolVersionsFile::TOOL_VERSIONS_PATTERN = T.let(T.unsafe(nil), Regexp) # pkg:gem/rubocop#lib/rubocop/ast_aliases.rb:7 diff --git a/sorbet/rbi/gems/ruby-lsp@0.26.4.rbi b/sorbet/rbi/gems/ruby-lsp@0.26.6.rbi similarity index 96% rename from sorbet/rbi/gems/ruby-lsp@0.26.4.rbi rename to sorbet/rbi/gems/ruby-lsp@0.26.6.rbi index eff785f71..0897cd16a 100644 --- a/sorbet/rbi/gems/ruby-lsp@0.26.4.rbi +++ b/sorbet/rbi/gems/ruby-lsp@0.26.6.rbi @@ -47,11 +47,11 @@ class RubyIndexer::Configuration # `test_helper.rb` or `test_case.rb`. Also takes into consideration the possibility of finding these files under # fixtures or inside gem source code if the bundle path points to a directory inside the workspace # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/configuration.rb:257 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/configuration.rb:258 sig { params(path: ::String, bundle_path: T.nilable(::String)).returns(T::Boolean) } def test_files_ignored_from_exclusion?(path, bundle_path); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/configuration.rb:264 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/configuration.rb:265 sig { returns(T::Array[::String]) } def top_level_directories; end @@ -79,7 +79,7 @@ class RubyIndexer::DeclarationListener end def initialize(index, dispatcher, parse_result, uri, collect_comments: T.unsafe(nil)); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:504 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:511 sig do params( name_or_nesting: T.any(::String, T::Array[::String]), @@ -91,7 +91,7 @@ class RubyIndexer::DeclarationListener end def add_class(name_or_nesting, full_location, name_location, parent_class_name: T.unsafe(nil), comments: T.unsafe(nil)); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:472 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:477 sig do params( name: ::String, @@ -103,7 +103,7 @@ class RubyIndexer::DeclarationListener end def add_method(name, node_location, signatures, visibility: T.unsafe(nil), comments: T.unsafe(nil)); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:488 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:494 sig do params( name: ::String, @@ -114,7 +114,7 @@ class RubyIndexer::DeclarationListener end def add_module(name, full_location, name_location, comments: T.unsafe(nil)); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:539 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:547 sig { returns(T.nilable(::RubyIndexer::Entry::Namespace)) } def current_owner; end @@ -122,15 +122,15 @@ class RubyIndexer::DeclarationListener sig { returns(T::Array[::String]) } def indexing_errors; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:431 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:435 sig { params(node: ::Prism::AliasMethodNode).void } def on_alias_method_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:251 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:252 sig { params(node: ::Prism::CallNode).void } def on_call_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:292 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:293 sig { params(node: ::Prism::CallNode).void } def on_call_node_leave(node); end @@ -142,103 +142,103 @@ class RubyIndexer::DeclarationListener sig { params(node: ::Prism::ClassNode).void } def on_class_node_leave(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:447 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:452 sig { params(node: ::Prism::ClassVariableAndWriteNode).void } def on_class_variable_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:452 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:457 sig { params(node: ::Prism::ClassVariableOperatorWriteNode).void } def on_class_variable_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:457 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:462 sig { params(node: ::Prism::ClassVariableOrWriteNode).void } def on_class_variable_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:462 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:467 sig { params(node: ::Prism::ClassVariableTargetNode).void } def on_class_variable_target_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:467 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:472 sig { params(node: ::Prism::ClassVariableWriteNode).void } def on_class_variable_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:239 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:240 sig { params(node: ::Prism::ConstantAndWriteNode).void } def on_constant_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:245 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:246 sig { params(node: ::Prism::ConstantOperatorWriteNode).void } def on_constant_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:233 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:234 sig { params(node: ::Prism::ConstantOrWriteNode).void } def on_constant_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:217 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:218 sig { params(node: ::Prism::ConstantPathAndWriteNode).void } def on_constant_path_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:207 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:208 sig { params(node: ::Prism::ConstantPathOperatorWriteNode).void } def on_constant_path_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:197 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:198 sig { params(node: ::Prism::ConstantPathOrWriteNode).void } def on_constant_path_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:187 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:188 sig { params(node: ::Prism::ConstantPathWriteNode).void } def on_constant_path_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:227 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:228 sig { params(node: ::Prism::ConstantWriteNode).void } def on_constant_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:313 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:314 sig { params(node: ::Prism::DefNode).void } def on_def_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:372 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:376 sig { params(node: ::Prism::DefNode).void } def on_def_node_leave(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:381 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:385 sig { params(node: ::Prism::GlobalVariableAndWriteNode).void } def on_global_variable_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:386 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:390 sig { params(node: ::Prism::GlobalVariableOperatorWriteNode).void } def on_global_variable_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:391 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:395 sig { params(node: ::Prism::GlobalVariableOrWriteNode).void } def on_global_variable_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:396 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:400 sig { params(node: ::Prism::GlobalVariableTargetNode).void } def on_global_variable_target_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:401 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:405 sig { params(node: ::Prism::GlobalVariableWriteNode).void } def on_global_variable_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:411 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:415 sig { params(node: ::Prism::InstanceVariableAndWriteNode).void } def on_instance_variable_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:416 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:420 sig { params(node: ::Prism::InstanceVariableOperatorWriteNode).void } def on_instance_variable_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:421 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:425 sig { params(node: ::Prism::InstanceVariableOrWriteNode).void } def on_instance_variable_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:426 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:430 sig { params(node: ::Prism::InstanceVariableTargetNode).void } def on_instance_variable_target_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:406 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:410 sig { params(node: ::Prism::InstanceVariableWriteNode).void } def on_instance_variable_write_node_enter(node); end @@ -250,7 +250,7 @@ class RubyIndexer::DeclarationListener sig { params(node: ::Prism::ModuleNode).void } def on_module_node_leave(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:167 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:168 sig { params(node: ::Prism::MultiWriteNode).void } def on_multi_write_node_enter(node); end @@ -258,21 +258,21 @@ class RubyIndexer::DeclarationListener sig { params(node: ::Prism::SingletonClassNode).void } def on_singleton_class_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:162 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:163 sig { params(node: ::Prism::SingletonClassNode).void } def on_singleton_class_node_leave(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:532 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:540 sig { void } def pop_namespace_stack; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:522 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:530 sig { params(block: T.proc.params(index: ::RubyIndexer::Index, base: ::RubyIndexer::Entry::Namespace).void).void } def register_included_hook(&block); end private - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:670 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:682 sig do params( node: T.any(::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathTargetNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantTargetNode, ::Prism::ConstantWriteNode), @@ -282,35 +282,35 @@ class RubyIndexer::DeclarationListener end def add_constant(node, name, value = T.unsafe(nil)); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1027 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1046 sig { params(short_name: ::String, entry: ::RubyIndexer::Entry::Namespace).void } def advance_namespace_stack(short_name, entry); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:721 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:737 sig { params(node: ::Prism::Node).returns(T.nilable(::String)) } def collect_comments(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:752 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:768 sig { params(line: ::Integer).returns(T::Boolean) } def comment_exists_at?(line); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:935 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:954 sig { returns(::RubyIndexer::VisibilityScope) } def current_visibility_scope; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:757 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:773 sig { params(name: ::String).returns(::String) } def fully_qualify_name(name); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:631 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:642 sig { params(node: ::Prism::CallNode).void } def handle_alias_method(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:766 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:782 sig { params(node: ::Prism::CallNode, reader: T::Boolean, writer: T::Boolean).void } def handle_attribute(node, reader:, writer:); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:559 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:568 sig do params( node: T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableTargetNode, ::Prism::ClassVariableWriteNode), @@ -319,7 +319,7 @@ class RubyIndexer::DeclarationListener end def handle_class_variable(node, loc); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:546 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:554 sig do params( node: T.any(::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableTargetNode, ::Prism::GlobalVariableWriteNode), @@ -328,7 +328,7 @@ class RubyIndexer::DeclarationListener end def handle_global_variable(node, loc); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:584 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:594 sig do params( node: T.any(::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableTargetNode, ::Prism::InstanceVariableWriteNode), @@ -337,34 +337,34 @@ class RubyIndexer::DeclarationListener end def handle_instance_variable(node, loc); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:845 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:863 sig { params(node: ::Prism::CallNode).void } def handle_module_function(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:811 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:829 sig { params(node: ::Prism::CallNode, operation: ::Symbol).void } def handle_module_operation(node, operation); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:896 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:915 sig { params(node: ::Prism::CallNode).void } def handle_private_class_method(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:606 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:617 sig { params(node: ::Prism::CallNode).void } def handle_private_constant(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1045 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1064 sig { params(node: ::Prism::CallNode, visibility: ::Symbol).void } def handle_visibility_change(node, visibility); end # Returns the last name in the stack not as we found it, but in terms of declared constants. For example, if the # last entry in the stack is a compact namespace like `Foo::Bar`, then the last name is `Bar` # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1037 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1056 sig { returns(T.nilable(::String)) } def last_name_in_stack; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:940 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:959 sig do params( parameters_node: T.nilable(::Prism::ParametersNode) @@ -372,11 +372,11 @@ class RubyIndexer::DeclarationListener end def list_params(parameters_node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1002 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1021 sig { params(node: T.nilable(::Prism::Node)).returns(T.nilable(::Symbol)) } def parameter_name(node); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1068 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/declaration_listener.rb:1087 sig { params(node: ::Prism::CallNode).returns(T::Array[::String]) } def string_or_symbol_argument_values(node); end end @@ -428,94 +428,100 @@ end # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:5 class RubyIndexer::Entry - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:21 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:24 sig do params( + configuration: ::RubyIndexer::Configuration, name: ::String, uri: ::URI::Generic, location: ::RubyIndexer::Location, comments: T.nilable(::String) ).void end - def initialize(name, uri, location, comments); end + def initialize(configuration, name, uri, location, comments); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:61 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:65 sig { returns(::String) } def comments; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:45 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:7 + sig { returns(::RubyIndexer::Configuration) } + def configuration; end + + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:49 sig { returns(::String) } def file_name; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:56 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:60 sig { returns(T.nilable(::String)) } def file_path; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:13 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:16 sig { returns(::RubyIndexer::Location) } def location; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:7 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:10 sig { returns(::String) } def name; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:15 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:18 def name_location(*args, **_arg1, &blk); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:40 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:44 sig { returns(T::Boolean) } def private?; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:35 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:39 sig { returns(T::Boolean) } def protected?; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:30 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:34 sig { returns(T::Boolean) } def public?; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:10 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:13 sig { returns(::URI::Generic) } def uri; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:18 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:21 sig { returns(::Symbol) } def visibility; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:18 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:21 def visibility=(_arg0); end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:335 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:339 class RubyIndexer::Entry::Accessor < ::RubyIndexer::Entry::Member - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:338 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:342 sig { override.returns(T::Array[::RubyIndexer::Entry::Signature]) } def signatures; end end # A block method parameter, e.g. `def foo(&block)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:266 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:270 class RubyIndexer::Entry::BlockParameter < ::RubyIndexer::Entry::Parameter - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:278 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:282 sig { override.returns(::Symbol) } def decorated_name; end class << self - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:271 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:275 sig { returns(::RubyIndexer::Entry::BlockParameter) } def anonymous; end end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:267 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:271 RubyIndexer::Entry::BlockParameter::DEFAULT_NAME = T.let(T.unsafe(nil), Symbol) -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:163 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:167 class RubyIndexer::Entry::Class < ::RubyIndexer::Entry::Namespace - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:170 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:174 sig do params( + configuration: ::RubyIndexer::Configuration, nesting: T::Array[::String], uri: ::URI::Generic, location: ::RubyIndexer::Location, @@ -524,27 +530,28 @@ class RubyIndexer::Entry::Class < ::RubyIndexer::Entry::Namespace parent_class: T.nilable(::String) ).void end - def initialize(nesting, uri, location, name_location, comments, parent_class); end + def initialize(configuration, nesting, uri, location, name_location, comments, parent_class); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:177 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:181 sig { override.returns(::Integer) } def ancestor_hash; end # The unresolved name of the parent class. This may return `nil`, which indicates the lack of an explicit parent # and therefore ::Object is the correct parent class # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:167 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:171 sig { returns(T.nilable(::String)) } def parent_class; end end # Represents a class variable e.g.: @@a = 1 # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:413 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:418 class RubyIndexer::Entry::ClassVariable < ::RubyIndexer::Entry - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:418 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:423 sig do params( + configuration: ::RubyIndexer::Configuration, name: ::String, uri: ::URI::Generic, location: ::RubyIndexer::Location, @@ -552,53 +559,54 @@ class RubyIndexer::Entry::ClassVariable < ::RubyIndexer::Entry owner: T.nilable(::RubyIndexer::Entry::Namespace) ).void end - def initialize(name, uri, location, comments, owner); end + def initialize(configuration, name, uri, location, comments, owner); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:415 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:420 sig { returns(T.nilable(::RubyIndexer::Entry::Namespace)) } def owner; end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:191 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:195 class RubyIndexer::Entry::Constant < ::RubyIndexer::Entry; end # Alias represents a resolved alias, which points to an existing constant target # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:391 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:395 class RubyIndexer::Entry::ConstantAlias < ::RubyIndexer::Entry - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:396 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:400 sig { params(target: ::String, unresolved_alias: ::RubyIndexer::Entry::UnresolvedConstantAlias).void } def initialize(target, unresolved_alias); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:393 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:397 sig { returns(::String) } def target; end end # A forwarding method parameter, e.g. `def foo(...)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:284 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:288 class RubyIndexer::Entry::ForwardingParameter < ::RubyIndexer::Entry::Parameter - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:286 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:290 sig { void } def initialize; end end # Represents a global variable e.g.: $DEBUG # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:410 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:415 class RubyIndexer::Entry::GlobalVariable < ::RubyIndexer::Entry; end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:115 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:119 class RubyIndexer::Entry::Include < ::RubyIndexer::Entry::ModuleOperation; end # Represents an instance variable e.g.: @a = 1 # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:425 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:430 class RubyIndexer::Entry::InstanceVariable < ::RubyIndexer::Entry - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:430 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:435 sig do params( + configuration: ::RubyIndexer::Configuration, name: ::String, uri: ::URI::Generic, location: ::RubyIndexer::Location, @@ -606,43 +614,44 @@ class RubyIndexer::Entry::InstanceVariable < ::RubyIndexer::Entry owner: T.nilable(::RubyIndexer::Entry::Namespace) ).void end - def initialize(name, uri, location, comments, owner); end + def initialize(configuration, name, uri, location, comments, owner); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:427 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:432 sig { returns(T.nilable(::RubyIndexer::Entry::Namespace)) } def owner; end end # An required keyword method parameter, e.g. `def foo(a:)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:226 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:230 class RubyIndexer::Entry::KeywordParameter < ::RubyIndexer::Entry::Parameter - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:229 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:233 sig { override.returns(::Symbol) } def decorated_name; end end # A keyword rest method parameter, e.g. `def foo(**a)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:255 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:259 class RubyIndexer::Entry::KeywordRestParameter < ::RubyIndexer::Entry::Parameter - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:260 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:264 sig { override.returns(::Symbol) } def decorated_name; end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:256 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:260 RubyIndexer::Entry::KeywordRestParameter::DEFAULT_NAME = T.let(T.unsafe(nil), Symbol) # @abstract # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:292 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:296 class RubyIndexer::Entry::Member < ::RubyIndexer::Entry abstract! - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:301 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:305 sig do params( + configuration: ::RubyIndexer::Configuration, name: ::String, uri: ::URI::Generic, location: ::RubyIndexer::Location, @@ -651,33 +660,34 @@ class RubyIndexer::Entry::Member < ::RubyIndexer::Entry owner: T.nilable(::RubyIndexer::Entry::Namespace) ).void end - def initialize(name, uri, location, comments, visibility, owner); end + def initialize(configuration, name, uri, location, comments, visibility, owner); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:314 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:318 sig { returns(::String) } def decorated_parameters; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:322 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:326 sig { returns(::String) } def formatted_signatures; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:298 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:302 sig { returns(T.nilable(::RubyIndexer::Entry::Namespace)) } def owner; end # @abstract # @raise [AbstractMethodInvokedError] # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:309 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:313 sig { abstract.returns(T::Array[::RubyIndexer::Entry::Signature]) } def signatures; end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:347 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:351 class RubyIndexer::Entry::Method < ::RubyIndexer::Entry::Member - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:357 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:361 sig do params( + configuration: ::RubyIndexer::Configuration, name: ::String, uri: ::URI::Generic, location: ::RubyIndexer::Location, @@ -688,24 +698,24 @@ class RubyIndexer::Entry::Method < ::RubyIndexer::Entry::Member owner: T.nilable(::RubyIndexer::Entry::Namespace) ).void end - def initialize(name, uri, location, name_location, comments, signatures, visibility, owner); end + def initialize(configuration, name, uri, location, name_location, comments, signatures, visibility, owner); end # Returns the location of the method name, excluding parameters or the body # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:354 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:358 sig { returns(::RubyIndexer::Location) } def name_location; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:350 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:354 sig { override.returns(T::Array[::RubyIndexer::Entry::Signature]) } def signatures; end end # A method alias is a resolved alias entry that points to the exact method target it refers to # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:457 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:462 class RubyIndexer::Entry::MethodAlias < ::RubyIndexer::Entry - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:465 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:470 sig do params( target: T.any(::RubyIndexer::Entry::Member, ::RubyIndexer::Entry::MethodAlias), @@ -714,54 +724,55 @@ class RubyIndexer::Entry::MethodAlias < ::RubyIndexer::Entry end def initialize(target, unresolved_alias); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:482 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:488 sig { returns(::String) } def decorated_parameters; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:487 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:493 sig { returns(::String) } def formatted_signatures; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:462 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:467 sig { returns(T.nilable(::RubyIndexer::Entry::Namespace)) } def owner; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:492 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:498 sig { returns(T::Array[::RubyIndexer::Entry::Signature]) } def signatures; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:459 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:464 sig { returns(T.any(::RubyIndexer::Entry::Member, ::RubyIndexer::Entry::MethodAlias)) } def target; end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:160 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:164 class RubyIndexer::Entry::Module < ::RubyIndexer::Entry::Namespace; end # @abstract # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:101 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:105 class RubyIndexer::Entry::ModuleOperation abstract! - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:110 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:114 sig { params(module_name: ::String).void } def initialize(module_name); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:107 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:111 sig { returns(::String) } def module_name; end end # @abstract # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:118 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:122 class RubyIndexer::Entry::Namespace < ::RubyIndexer::Entry abstract! - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:131 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:135 sig do params( + configuration: ::RubyIndexer::Configuration, nesting: T::Array[::String], uri: ::URI::Generic, location: ::RubyIndexer::Location, @@ -769,13 +780,13 @@ class RubyIndexer::Entry::Namespace < ::RubyIndexer::Entry comments: T.nilable(::String) ).void end - def initialize(nesting, uri, location, name_location, comments); end + def initialize(configuration, nesting, uri, location, name_location, comments); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:155 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:159 sig { returns(::Integer) } def ancestor_hash; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:142 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:146 sig { returns(T::Array[::String]) } def mixin_operation_module_names; end @@ -783,99 +794,99 @@ class RubyIndexer::Entry::Namespace < ::RubyIndexer::Entry # code. Maintaining the order is essential to linearize ancestors the right way when a module is both included # and prepended # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:150 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:154 sig { returns(T::Array[::RubyIndexer::Entry::ModuleOperation]) } def mixin_operations; end # Returns the location of the constant name, excluding the parent class or the body # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:128 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:132 sig { returns(::RubyIndexer::Location) } def name_location; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:124 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:128 sig { returns(T::Array[::String]) } def nesting; end end # An optional keyword method parameter, e.g. `def foo(a: 123)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:235 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:239 class RubyIndexer::Entry::OptionalKeywordParameter < ::RubyIndexer::Entry::Parameter - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:238 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:242 sig { override.returns(::Symbol) } def decorated_name; end end # An optional method parameter, e.g. `def foo(a = 123)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:217 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:221 class RubyIndexer::Entry::OptionalParameter < ::RubyIndexer::Entry::Parameter - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:220 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:224 sig { override.returns(::Symbol) } def decorated_name; end end # @abstract # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:194 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:198 class RubyIndexer::Entry::Parameter abstract! - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:207 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:211 sig { params(name: ::Symbol).void } def initialize(name:); end # Name includes just the name of the parameter, excluding symbols like splats # Decorated name is the parameter name including the splat or block prefix, e.g.: `*foo`, `**foo` or `&block` # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:204 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:208 def decorated_name(*args, **_arg1, &blk); end # Name includes just the name of the parameter, excluding symbols like splats # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:201 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:205 sig { returns(::Symbol) } def name; end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:116 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:120 class RubyIndexer::Entry::Prepend < ::RubyIndexer::Entry::ModuleOperation; end # A required method parameter, e.g. `def foo(a)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:213 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:217 class RubyIndexer::Entry::RequiredParameter < ::RubyIndexer::Entry::Parameter; end # A rest method parameter, e.g. `def foo(*a)` # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:244 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:248 class RubyIndexer::Entry::RestParameter < ::RubyIndexer::Entry::Parameter - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:249 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:253 sig { override.returns(::Symbol) } def decorated_name; end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:245 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:249 RubyIndexer::Entry::RestParameter::DEFAULT_NAME = T.let(T.unsafe(nil), Symbol) # Ruby doesn't support method overloading, so a method will have only one signature. # However RBS can represent the concept of method overloading, with different return types based on the arguments # passed, so we need to store all the signatures. # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:500 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:506 class RubyIndexer::Entry::Signature - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:505 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:511 sig { params(parameters: T::Array[::RubyIndexer::Entry::Parameter]).void } def initialize(parameters); end # Returns a string with the decorated names of the parameters of this member. E.g.: `(a, b = 1, c: 2)` # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:511 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:517 sig { returns(::String) } def format; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:596 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:602 sig { params(args: T.nilable(T::Array[::Prism::Node]), names: T::Array[::Symbol]).returns(T::Boolean) } def keyword_arguments_match?(args, names); end @@ -895,15 +906,15 @@ class RubyIndexer::Entry::Signature # foo(1, 2) # ``` # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:531 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:537 sig { params(arguments: T::Array[::Prism::Node]).returns(T::Boolean) } def matches?(arguments); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:502 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:508 sig { returns(T::Array[::RubyIndexer::Entry::Parameter]) } def parameters; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:583 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:589 sig do params( positional_args: T::Array[::Prism::Node], @@ -916,9 +927,9 @@ class RubyIndexer::Entry::Signature def positional_arguments_match?(positional_args, forwarding_arguments, keyword_args, min_pos, max_pos); end end -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:182 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:186 class RubyIndexer::Entry::SingletonClass < ::RubyIndexer::Entry::Class - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:184 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:188 sig do params( location: ::RubyIndexer::Location, @@ -940,11 +951,12 @@ end # target in [rdoc-ref:Index#resolve]. If the right hand side contains a constant that doesn't exist, then it's not # possible to resolve the alias and it will remain an UnresolvedAlias until the right hand side constant exists # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:374 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:378 class RubyIndexer::Entry::UnresolvedConstantAlias < ::RubyIndexer::Entry - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:382 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:386 sig do params( + configuration: ::RubyIndexer::Configuration, target: ::String, nesting: T::Array[::String], name: ::String, @@ -953,13 +965,13 @@ class RubyIndexer::Entry::UnresolvedConstantAlias < ::RubyIndexer::Entry comments: T.nilable(::String) ).void end - def initialize(target, nesting, name, uri, location, comments); end + def initialize(configuration, target, nesting, name, uri, location, comments); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:379 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:383 sig { returns(T::Array[::String]) } def nesting; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:376 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:380 sig { returns(::String) } def target; end end @@ -968,11 +980,12 @@ end # example, if we have `alias a b`, we create an unresolved alias for `a` because we aren't sure immediate what `b` # is referring to # -# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:439 +# pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:444 class RubyIndexer::Entry::UnresolvedMethodAlias < ::RubyIndexer::Entry - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:447 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:452 sig do params( + configuration: ::RubyIndexer::Configuration, new_name: ::String, old_name: ::String, owner: T.nilable(::RubyIndexer::Entry::Namespace), @@ -981,16 +994,16 @@ class RubyIndexer::Entry::UnresolvedMethodAlias < ::RubyIndexer::Entry comments: T.nilable(::String) ).void end - def initialize(new_name, old_name, owner, uri, location, comments); end + def initialize(configuration, new_name, old_name, owner, uri, location, comments); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:441 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:446 sig { returns(::String) } def new_name; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:441 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:446 def old_name; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:444 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/entry.rb:449 sig { returns(T.nilable(::RubyIndexer::Entry::Namespace)) } def owner; end end @@ -1038,7 +1051,7 @@ class RubyIndexer::Index sig { returns(T::Boolean) } def empty?; end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:731 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:732 sig do type_parameters(:T) .params( @@ -1278,13 +1291,13 @@ class RubyIndexer::Index # with `A::B::A::B::Foo`. This method will remove any redundant parts from the final name based on the reference and # the nesting # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:1016 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:1017 sig { params(name: ::String, nesting: T::Array[::String]).returns(::String) } def build_non_redundant_full_name(name, nesting); end # Tries to return direct entry from index then non seen canonicalized alias or nil # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:1038 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:1039 sig do params( full_name: ::String, @@ -1293,7 +1306,7 @@ class RubyIndexer::Index end def direct_or_aliased_constant(full_name, seen_names); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:974 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:975 sig do params( name: T.nilable(::String), @@ -1305,7 +1318,7 @@ class RubyIndexer::Index # Linearize mixins for an array of namespace entries. This method will mutate the `ancestors` array with the # linearized ancestors of the mixins # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:787 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:788 sig do params( ancestors: T::Array[::String], @@ -1318,7 +1331,7 @@ class RubyIndexer::Index # Linearize the superclass of a given namespace (including modules with the implicit `Module` superclass). This # method will mutate the `ancestors` array with the linearized ancestors of the superclass # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:829 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:830 sig do params( ancestors: T::Array[::String], @@ -1334,11 +1347,11 @@ class RubyIndexer::Index # Always returns the linearized ancestors for the attached class, regardless of whether `name` refers to a singleton # or attached namespace # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:743 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:744 sig { params(name: ::String).returns(T::Array[::String]) } def linearized_attached_ancestors(name); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:952 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:953 sig do params( name: ::String, @@ -1348,7 +1361,7 @@ class RubyIndexer::Index end def lookup_ancestor_chain(name, nesting, seen_names); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:932 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:933 sig do params( name: ::String, @@ -1361,7 +1374,7 @@ class RubyIndexer::Index # Attempts to resolve an UnresolvedAlias into a resolved Alias. If the unresolved alias is pointing to a constant # that doesn't exist, then we return the same UnresolvedAlias # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:905 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:906 sig do params( entry: ::RubyIndexer::Entry::UnresolvedConstantAlias, @@ -1373,7 +1386,7 @@ class RubyIndexer::Index # Attempt to resolve a given unresolved method alias. This method returns the resolved alias if we managed to # identify the target or the same unresolved alias entry if we couldn't # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:1056 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:1057 sig do params( entry: ::RubyIndexer::Entry::UnresolvedMethodAlias, @@ -1385,7 +1398,7 @@ class RubyIndexer::Index # Runs the registered included hooks # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:757 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/index.rb:758 sig { params(fully_qualified_name: ::String, nesting: T::Array[::String]).void } def run_included_hooks(fully_qualified_name, nesting); end @@ -1594,7 +1607,7 @@ class RubyIndexer::RBSIndexer end def add_declaration_mixins_to_entry(declaration, entry); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:286 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:290 sig do params( declaration: T.any(::RBS::AST::Declarations::Class, ::RBS::AST::Declarations::Constant, ::RBS::AST::Declarations::Global, ::RBS::AST::Declarations::Module, ::RBS::AST::Members::Alias, ::RBS::AST::Members::MethodDefinition) @@ -1626,7 +1639,7 @@ class RubyIndexer::RBSIndexer # # And we need to handle their nesting differently. # - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:243 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:244 sig do params( declaration: ::RBS::AST::Declarations::Constant, @@ -1636,7 +1649,7 @@ class RubyIndexer::RBSIndexer end def handle_constant(declaration, nesting, uri); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:254 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:256 sig { params(declaration: ::RBS::AST::Declarations::Global, pathname: ::Pathname).void } def handle_global_variable(declaration, pathname); end @@ -1644,11 +1657,11 @@ class RubyIndexer::RBSIndexer sig { params(member: ::RBS::AST::Members::MethodDefinition, owner: ::RubyIndexer::Entry::Namespace).void } def handle_method(member, owner); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:269 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:272 sig { params(member: ::RBS::AST::Members::Alias, owner_entry: ::RubyIndexer::Entry::Namespace).void } def handle_signature_alias(member, owner_entry); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:154 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:155 sig { params(function: ::RBS::Types::Function).returns(T::Array[::RubyIndexer::Entry::Parameter]) } def parse_arguments(function); end @@ -1656,11 +1669,11 @@ class RubyIndexer::RBSIndexer sig { params(declaration: ::RBS::AST::Declarations::Base, pathname: ::Pathname).void } def process_declaration(declaration, pathname); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:213 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:214 sig { params(function: ::RBS::Types::Function).returns(T::Array[::RubyIndexer::Entry::OptionalKeywordParameter]) } def process_optional_keywords(function); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:133 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:134 sig do params( overload: ::RBS::AST::Members::MethodDefinition::Overload @@ -1668,27 +1681,27 @@ class RubyIndexer::RBSIndexer end def process_overload(overload); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:166 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:167 sig { params(function: ::RBS::Types::Function).returns(T::Array[::RubyIndexer::Entry::RequiredParameter]) } def process_required_and_optional_positionals(function); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:206 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:207 sig { params(function: ::RBS::Types::Function).returns(T::Array[::RubyIndexer::Entry::KeywordParameter]) } def process_required_keywords(function); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:220 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:221 sig { params(function: ::RBS::Types::Function).returns(::RubyIndexer::Entry::KeywordRestParameter) } def process_rest_keywords(function); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:197 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:198 sig { params(function: ::RBS::Types::Function).returns(::RubyIndexer::Entry::RestParameter) } def process_rest_positionals(function); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:190 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:191 sig { params(function: ::RBS::Types::Function).returns(T::Array[::RubyIndexer::Entry::OptionalParameter]) } def process_trailing_positionals(function); end - # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:125 + # pkg:gem/ruby-lsp#lib/ruby_indexer/lib/ruby_indexer/rbs_indexer.rb:126 sig { params(member: ::RBS::AST::Members::MethodDefinition).returns(T::Array[::RubyIndexer::Entry::Signature]) } def signatures(member); end @@ -2337,6 +2350,23 @@ class RubyLsp::DelegateRequestError < ::StandardError; end # pkg:gem/ruby-lsp#lib/ruby_lsp/utils.rb:31 RubyLsp::DelegateRequestError::CODE = T.let(T.unsafe(nil), Integer) +# Holds the detected value and the reason for detection +# +# pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:6 +class RubyLsp::DetectionResult + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:14 + sig { params(value: ::String, reason: ::String).void } + def initialize(value, reason); end + + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:11 + sig { returns(::String) } + def reason; end + + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:8 + sig { returns(::String) } + def value; end +end + # @abstract # # pkg:gem/ruby-lsp#lib/ruby_lsp/document.rb:5 @@ -2676,139 +2706,149 @@ RubyLsp::GEMFILE_NAME = T.let(T.unsafe(nil), String) # pkg:gem/ruby-lsp#lib/ruby_lsp/utils.rb:21 RubyLsp::GUESSED_TYPES_URL = T.let(T.unsafe(nil), String) -# pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:5 +# pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:20 class RubyLsp::GlobalState - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:37 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:52 sig { void } def initialize; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:88 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:103 sig { returns(T.nilable(::RubyLsp::Requests::Support::Formatter)) } def active_formatter; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:93 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:108 sig { returns(T::Array[::RubyLsp::Requests::Support::Formatter]) } def active_linters; end # Applies the options provided by the editor and returns an array of notifications to send back to the client # - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:99 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:114 sig { params(options: T::Hash[::Symbol, T.untyped]).returns(T::Array[::RubyLsp::Notification]) } def apply_options(options); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:28 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:43 sig { returns(::RubyLsp::ClientCapabilities) } def client_capabilities; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:203 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:228 sig { params(flag: ::Symbol).returns(T.nilable(T::Boolean)) } def enabled_feature?(flag); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:19 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:34 sig { returns(::Encoding) } def encoding; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:213 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:238 sig { returns(::String) } def encoding_name; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:198 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:223 sig { params(feature_name: ::Symbol).returns(T.nilable(::RubyLsp::RequestConfig)) } def feature_configuration(feature_name); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:10 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:25 sig { returns(::String) } def formatter; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:10 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:25 def formatter=(_arg0); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:13 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:28 sig { returns(T::Boolean) } def has_type_checker; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:16 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:31 sig { returns(::RubyIndexer::Index) } def index; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:83 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:98 sig { params(identifier: ::String, instance: ::RubyLsp::Requests::Support::Formatter).void } def register_formatter(identifier, instance); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:78 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:93 sig { params(addon_name: ::String).returns(T.nilable(T::Hash[::Symbol, T.untyped])) } def settings_for_addon(addon_name); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:225 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:250 sig { returns(T::Boolean) } def supports_watching_files; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:73 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:88 sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) } def synchronize(&block); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:34 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:49 sig { returns(T.nilable(::String)) } def telemetry_machine_id; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:7 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:22 sig { returns(::String) } def test_library; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:22 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:37 sig { returns(T::Boolean) } def top_level_bundle; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:25 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:40 sig { returns(::RubyLsp::TypeInferrer) } def type_inferrer; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:208 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:233 sig { returns(::String) } def workspace_path; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:31 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:46 sig { returns(::URI::Generic) } def workspace_uri; end private - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:288 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:320 sig { returns(T::Boolean) } def bin_rails_present; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:232 - sig { params(direct_dependencies: T::Array[::String], all_dependencies: T::Array[::String]).returns(::String) } + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:257 + sig do + params( + direct_dependencies: T::Array[::String], + all_dependencies: T::Array[::String] + ).returns(::RubyLsp::DetectionResult) + end def detect_formatter(direct_dependencies, all_dependencies); end # Try to detect if there are linters in the project's dependencies. For auto-detection, we always only consider a # single linter. To have multiple linters running, the user must configure them manually # - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:248 - sig { params(dependencies: T::Array[::String], all_dependencies: T::Array[::String]).returns(T::Array[::String]) } + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:277 + sig do + params( + dependencies: T::Array[::String], + all_dependencies: T::Array[::String] + ).returns(T::Array[::RubyLsp::DetectionResult]) + end def detect_linters(dependencies, all_dependencies); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:259 - sig { params(dependencies: T::Array[::String]).returns(::String) } + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:290 + sig { params(dependencies: T::Array[::String]).returns(::RubyLsp::DetectionResult) } def detect_test_library(dependencies); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:279 - sig { params(dependencies: T::Array[::String]).returns(T::Boolean) } + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:310 + sig { params(dependencies: T::Array[::String]).returns(T.nilable(::RubyLsp::DetectionResult)) } def detect_typechecker(dependencies); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:293 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:325 sig { returns(T::Boolean) } def dot_rubocop_yml_present; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:315 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:347 sig { returns(T::Array[::String]) } def gather_direct_and_indirect_dependencies; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:298 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:330 sig { returns(T::Array[::String]) } def gather_direct_dependencies; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:308 + # pkg:gem/ruby-lsp#lib/ruby_lsp/global_state.rb:340 sig { returns(T::Array[::String]) } def gemspec_dependencies; end end @@ -3128,7 +3168,7 @@ class RubyLsp::Listeners::Definition end def initialize(response_builder, global_state, language_id, uri, node_context, dispatcher, sorbet_level); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:95 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:97 sig { params(node: ::Prism::BlockArgumentNode).void } def on_block_argument_node_enter(node); end @@ -3136,87 +3176,87 @@ class RubyLsp::Listeners::Definition sig { params(node: ::Prism::CallNode).void } def on_call_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:192 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:194 sig { params(node: ::Prism::ClassVariableAndWriteNode).void } def on_class_variable_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:197 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:199 sig { params(node: ::Prism::ClassVariableOperatorWriteNode).void } def on_class_variable_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:202 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:204 sig { params(node: ::Prism::ClassVariableOrWriteNode).void } def on_class_variable_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:212 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:214 sig { params(node: ::Prism::ClassVariableReadNode).void } def on_class_variable_read_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:207 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:209 sig { params(node: ::Prism::ClassVariableTargetNode).void } def on_class_variable_target_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:217 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:219 sig { params(node: ::Prism::ClassVariableWriteNode).void } def on_class_variable_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:106 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:108 sig { params(node: ::Prism::ConstantPathNode).void } def on_constant_path_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:114 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:116 sig { params(node: ::Prism::ConstantReadNode).void } def on_constant_read_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:187 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:189 sig { params(node: ::Prism::ForwardingSuperNode).void } def on_forwarding_super_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:122 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:124 sig { params(node: ::Prism::GlobalVariableAndWriteNode).void } def on_global_variable_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:127 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:129 sig { params(node: ::Prism::GlobalVariableOperatorWriteNode).void } def on_global_variable_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:132 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:134 sig { params(node: ::Prism::GlobalVariableOrWriteNode).void } def on_global_variable_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:137 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:139 sig { params(node: ::Prism::GlobalVariableReadNode).void } def on_global_variable_read_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:142 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:144 sig { params(node: ::Prism::GlobalVariableTargetNode).void } def on_global_variable_target_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:147 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:149 sig { params(node: ::Prism::GlobalVariableWriteNode).void } def on_global_variable_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:162 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:164 sig { params(node: ::Prism::InstanceVariableAndWriteNode).void } def on_instance_variable_and_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:167 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:169 sig { params(node: ::Prism::InstanceVariableOperatorWriteNode).void } def on_instance_variable_operator_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:172 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:174 sig { params(node: ::Prism::InstanceVariableOrWriteNode).void } def on_instance_variable_or_write_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:152 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:154 sig { params(node: ::Prism::InstanceVariableReadNode).void } def on_instance_variable_read_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:177 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:179 sig { params(node: ::Prism::InstanceVariableTargetNode).void } def on_instance_variable_target_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:157 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:159 sig { params(node: ::Prism::InstanceVariableWriteNode).void } def on_instance_variable_write_node_enter(node); end @@ -3224,37 +3264,37 @@ class RubyLsp::Listeners::Definition sig { params(node: ::Prism::StringNode).void } def on_string_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:182 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:184 sig { params(node: ::Prism::SuperNode).void } def on_super_node_enter(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:84 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:85 sig { params(node: ::Prism::SymbolNode).void } def on_symbol_node_enter(node); end private - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:379 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:399 sig { params(value: ::String).void } def find_in_index(value); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:368 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:388 sig { params(node: ::Prism::CallNode).void } def handle_autoload_definition(node); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:258 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:278 sig { params(name: ::String).void } def handle_class_variable_definition(name); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:239 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:259 sig { params(name: ::String).void } def handle_global_variable_definition(name); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:276 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:296 sig { params(name: ::String).void } def handle_instance_variable_definition(name); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:303 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:323 sig do params( message: ::String, @@ -3264,13 +3304,21 @@ class RubyLsp::Listeners::Definition end def handle_method_definition(message, receiver_type, inherited_only: T.unsafe(nil)); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:331 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:351 sig { params(node: ::Prism::StringNode, message: ::Symbol).void } def handle_require_definition(node, message); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:224 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:234 + sig { params(enclosing_call: ::Prism::CallNode, node: ::Prism::Node, block: T.proc.returns(::String)).void } + def handle_send_or_public_send_definition(enclosing_call, node, &block); end + + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:244 sig { void } def handle_super_node_definition; end + + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:226 + sig { params(node: ::Prism::Node, block: T.proc.params(arg0: ::Prism::CallNode, arg1: ::Symbol).void).void } + def with_enclosing_call(node, &block); end end # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/definition.rb:9 @@ -3606,7 +3654,7 @@ class RubyLsp::Listeners::DocumentLink sig { params(uri_string: ::String).returns(T.nilable([::String, ::String])) } def parse_package_url(uri_string); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/document_link.rb:149 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/document_link.rb:147 sig { params(uri_string: ::String).returns(T.nilable([::String, ::String])) } def parse_source_uri(uri_string); end @@ -3615,7 +3663,7 @@ class RubyLsp::Listeners::DocumentLink # 2. The version in the RBI file name # 3. The version from the gemspec # - # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/document_link.rb:177 + # pkg:gem/ruby-lsp#lib/ruby_lsp/listeners/document_link.rb:172 sig { params(version: T.nilable(::String), gem_name: T.nilable(::String)).returns(T.nilable(::String)) } def resolve_version(version, gem_name); end @@ -4909,11 +4957,11 @@ class RubyLsp::Requests::CodeActionResolve < ::RubyLsp::Requests::Request private - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:346 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:368 sig { returns(::LanguageServer::Protocol::Interface::CodeAction) } def create_attribute_accessor; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:277 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:299 sig do params( range: T::Hash[::Symbol, T.untyped], @@ -4922,28 +4970,26 @@ class RubyLsp::Requests::CodeActionResolve < ::RubyLsp::Requests::Request end def create_text_edit(range, new_text); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:288 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:310 sig { params(node: ::Prism::BlockNode, indentation: T.nilable(::String)).returns(::String) } def recursively_switch_nested_block_styles(node, indentation); end # @raise [EmptySelectionError] # - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:201 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:223 sig { returns(::LanguageServer::Protocol::Interface::CodeAction) } def refactor_method; end # @raise [EmptySelectionError] # - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:94 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:116 sig { returns(::LanguageServer::Protocol::Interface::CodeAction) } def refactor_variable; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:317 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:339 sig { params(body: ::Prism::Node, indentation: T.nilable(::String)).returns(::String) } def switch_block_body(body, indentation); end - # @raise [EmptySelectionError] - # # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_action_resolve.rb:52 sig { returns(::LanguageServer::Protocol::Interface::CodeAction) } def switch_block_style; end @@ -4989,10 +5035,14 @@ class RubyLsp::Requests::CodeActions < ::RubyLsp::Requests::Request private - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_actions.rb:80 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_actions.rb:76 sig { returns(T::Array[::LanguageServer::Protocol::Interface::CodeAction]) } def attribute_actions; end + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_actions.rb:114 + sig { returns(T::Array[::LanguageServer::Protocol::Interface::CodeAction]) } + def toggle_block_style_action; end + class << self # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/code_actions.rb:28 sig { returns(::LanguageServer::Protocol::Interface::CodeActionRegistrationOptions) } @@ -5101,7 +5151,7 @@ class RubyLsp::Requests::CompletionResolve < ::RubyLsp::Requests::Request private - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/completion_resolve.rb:82 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/completion_resolve.rb:84 sig { params(item: T::Hash[::Symbol, T.untyped]).returns(T::Hash[::Symbol, T.untyped]) } def keyword_resolve(item); end end @@ -7246,46 +7296,47 @@ end URI::Generic::PARSER = T.let(T.unsafe(nil), URI::RFC2396_Parser) # Must be kept in sync with the one in Tapioca +# https://github.com/Shopify/tapioca/blob/main/lib/tapioca/helpers/source_uri.rb # -# pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:8 +# pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:9 class URI::Source < ::URI::File - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:57 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:56 sig { params(v: T.nilable(::String)).returns(T::Boolean) } def check_host(v); end # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:25 def gem_name; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:30 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:29 sig { returns(T.nilable(::String)) } def gem_version; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:27 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:26 def line_number; end - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:47 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:46 sig { params(v: T.nilable(::String)).void } def set_path(v); end - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:69 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:68 sig { returns(::String) } def to_s; end class << self - # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:34 + # pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:33 sig do params( gem_name: ::String, gem_version: T.nilable(::String), path: ::String, line_number: T.nilable(::String) - ).returns(::URI::Source) + ).returns(T.attached_class) end def build(gem_name:, gem_version:, path:, line_number:); end end end -# pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:9 +# pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:10 URI::Source::COMPONENT = T.let(T.unsafe(nil), Array) # `uri` for Ruby 3.4 switched the default parser from RFC2396 to RFC3986. The new parser emits a deprecation @@ -7294,5 +7345,5 @@ URI::Source::COMPONENT = T.let(T.unsafe(nil), Array) # handling to select a parser that doesn't emit deprecations. While it was backported to Ruby 3.1, users may # have the uri gem in their own bundle and thus not use a compatible version. # -# pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:22 +# pkg:gem/ruby-lsp#lib/ruby_lsp/requests/support/source_uri.rb:23 URI::Source::PARSER = T.let(T.unsafe(nil), URI::RFC2396_Parser) diff --git a/sorbet/rbi/gems/shopify-money@3.2.5.rbi b/sorbet/rbi/gems/shopify-money@3.2.7.rbi similarity index 96% rename from sorbet/rbi/gems/shopify-money@3.2.5.rbi rename to sorbet/rbi/gems/shopify-money@3.2.7.rbi index e9c622470..87c43e365 100644 --- a/sorbet/rbi/gems/shopify-money@3.2.5.rbi +++ b/sorbet/rbi/gems/shopify-money@3.2.7.rbi @@ -34,41 +34,41 @@ class Money # @raise [ArgumentError] # - # pkg:gem/shopify-money#lib/money/money.rb:185 + # pkg:gem/shopify-money#lib/money/money.rb:194 def *(other); end - # pkg:gem/shopify-money#lib/money/money.rb:171 + # pkg:gem/shopify-money#lib/money/money.rb:180 def +(other); end - # pkg:gem/shopify-money#lib/money/money.rb:178 + # pkg:gem/shopify-money#lib/money/money.rb:187 def -(other); end - # pkg:gem/shopify-money#lib/money/money.rb:160 + # pkg:gem/shopify-money#lib/money/money.rb:164 def -@; end - # pkg:gem/shopify-money#lib/money/money.rb:192 + # pkg:gem/shopify-money#lib/money/money.rb:201 def /(other); end - # pkg:gem/shopify-money#lib/money/money.rb:164 + # pkg:gem/shopify-money#lib/money/money.rb:168 def <=>(other); end - # pkg:gem/shopify-money#lib/money/money.rb:200 + # pkg:gem/shopify-money#lib/money/money.rb:209 def ==(other); end - # pkg:gem/shopify-money#lib/money/money.rb:283 + # pkg:gem/shopify-money#lib/money/money.rb:292 def abs; end # @see Money::Allocator#allocate # - # pkg:gem/shopify-money#lib/money/money.rb:309 + # pkg:gem/shopify-money#lib/money/money.rb:318 def allocate(splits, strategy = T.unsafe(nil)); end # @see Money::Allocator#allocate_max_amounts # - # pkg:gem/shopify-money#lib/money/money.rb:314 + # pkg:gem/shopify-money#lib/money/money.rb:323 def allocate_max_amounts(maximums); end - # pkg:gem/shopify-money#lib/money/money.rb:274 + # pkg:gem/shopify-money#lib/money/money.rb:283 def as_json(options = T.unsafe(nil)); end # Calculate the splits evenly without losing pennies. @@ -81,7 +81,7 @@ class Money # @param number [2] of parties. # @return [Hash] # - # pkg:gem/shopify-money#lib/money/money.rb:341 + # pkg:gem/shopify-money#lib/money/money.rb:350 def calculate_splits(num); end # Clamps the value to be within the specified minimum and maximum. Returns @@ -94,15 +94,15 @@ class Money # Money.new(120, "CAD").clamp(0, 100) #=> Money.new(100, "CAD") # @raise [ArgumentError] # - # pkg:gem/shopify-money#lib/money/money.rb:353 + # pkg:gem/shopify-money#lib/money/money.rb:362 def clamp(min, max); end # @raise [TypeError] # - # pkg:gem/shopify-money#lib/money/money.rb:211 + # pkg:gem/shopify-money#lib/money/money.rb:220 def coerce(other); end - # pkg:gem/shopify-money#lib/money/money.rb:216 + # pkg:gem/shopify-money#lib/money/money.rb:225 def convert_currency(exchange_rate, new_currency); end # Returns the value of attribute currency. @@ -110,31 +110,31 @@ class Money # pkg:gem/shopify-money#lib/money/money.rb:12 def currency; end - # pkg:gem/shopify-money#lib/money/money.rb:147 + # pkg:gem/shopify-money#lib/money/money.rb:151 def encode_with(coder); end # TODO: Remove once cross-currency mathematical operations are no longer allowed # # @return [Boolean] # - # pkg:gem/shopify-money#lib/money/money.rb:205 + # pkg:gem/shopify-money#lib/money/money.rb:214 def eql?(other); end - # pkg:gem/shopify-money#lib/money/money.rb:289 + # pkg:gem/shopify-money#lib/money/money.rb:298 def floor; end # @raise [ArgumentError] # - # pkg:gem/shopify-money#lib/money/money.rb:301 + # pkg:gem/shopify-money#lib/money/money.rb:310 def fraction(rate); end # pkg:gem/shopify-money#lib/money/money.rb:14 def hash(*_arg0, **_arg1, &_arg2); end - # pkg:gem/shopify-money#lib/money/money.rb:143 + # pkg:gem/shopify-money#lib/money/money.rb:147 def init_with(coder); end - # pkg:gem/shopify-money#lib/money/money.rb:196 + # pkg:gem/shopify-money#lib/money/money.rb:205 def inspect; end # pkg:gem/shopify-money#lib/money/money.rb:14 @@ -142,7 +142,7 @@ class Money # @return [Boolean] # - # pkg:gem/shopify-money#lib/money/money.rb:156 + # pkg:gem/shopify-money#lib/money/money.rb:160 def no_currency?; end # pkg:gem/shopify-money#lib/money/money.rb:14 @@ -151,7 +151,7 @@ class Money # pkg:gem/shopify-money#lib/money/money.rb:14 def positive?(*_arg0, **_arg1, &_arg2); end - # pkg:gem/shopify-money#lib/money/money.rb:295 + # pkg:gem/shopify-money#lib/money/money.rb:304 def round(ndigits = T.unsafe(nil)); end # Split money amongst parties evenly without losing pennies. @@ -161,37 +161,37 @@ class Money # @param number [2] of parties. # @return [Enumerable] # - # pkg:gem/shopify-money#lib/money/money.rb:326 + # pkg:gem/shopify-money#lib/money/money.rb:335 def split(num); end - # pkg:gem/shopify-money#lib/money/money.rb:152 + # pkg:gem/shopify-money#lib/money/money.rb:156 def subunits(format: T.unsafe(nil)); end - # pkg:gem/shopify-money#lib/money/money.rb:237 + # pkg:gem/shopify-money#lib/money/money.rb:246 def to_d; end # pkg:gem/shopify-money#lib/money/money.rb:14 def to_f(*_arg0, **_arg1, &_arg2); end - # pkg:gem/shopify-money#lib/money/money.rb:264 + # pkg:gem/shopify-money#lib/money/money.rb:273 def to_formatted_s(style = T.unsafe(nil)); end - # pkg:gem/shopify-money#lib/money/money.rb:241 + # pkg:gem/shopify-money#lib/money/money.rb:250 def to_fs(style = T.unsafe(nil)); end - # pkg:gem/shopify-money#lib/money/money.rb:281 + # pkg:gem/shopify-money#lib/money/money.rb:290 def to_h(options = T.unsafe(nil)); end # pkg:gem/shopify-money#lib/money/money.rb:14 def to_i(*_arg0, **_arg1, &_arg2); end - # pkg:gem/shopify-money#lib/money/money.rb:266 + # pkg:gem/shopify-money#lib/money/money.rb:275 def to_json(options = T.unsafe(nil)); end - # pkg:gem/shopify-money#lib/money/money.rb:220 + # pkg:gem/shopify-money#lib/money/money.rb:229 def to_money(new_currency = T.unsafe(nil)); end - # pkg:gem/shopify-money#lib/money/money.rb:263 + # pkg:gem/shopify-money#lib/money/money.rb:272 def to_s(style = T.unsafe(nil)); end # Returns the value of attribute value. @@ -204,13 +204,13 @@ class Money private - # pkg:gem/shopify-money#lib/money/money.rb:368 + # pkg:gem/shopify-money#lib/money/money.rb:377 def arithmetic(other); end - # pkg:gem/shopify-money#lib/money/money.rb:395 + # pkg:gem/shopify-money#lib/money/money.rb:404 def calculated_currency(other); end - # pkg:gem/shopify-money#lib/money/money.rb:385 + # pkg:gem/shopify-money#lib/money/money.rb:394 def ensure_compatible_currency(other_currency, msg); end class << self