From 893ca07d1d4135df5ec10400764057a6edcc05ea Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 26 Jan 2026 23:04:09 +0000 Subject: [PATCH 1/3] Bump the minor-and-patch group with 5 updates Bumps the minor-and-patch group with 5 updates: | Package | From | To | | --- | --- | --- | | [ruby-lsp](https://github.com/Shopify/ruby-lsp) | `0.26.4` | `0.26.5` | | [dalli](https://github.com/petergoldstein/dalli) | `4.0.0` | `4.1.0` | | [graphql](https://github.com/rmosolgo/graphql-ruby) | `2.5.16` | `2.5.18` | | [sorbet-static](https://github.com/sorbet/sorbet) | `0.6.12887` | `0.6.12897` | | [sorbet-static-and-runtime](https://github.com/sorbet/sorbet) | `0.6.12887` | `0.6.12897` | Updates `ruby-lsp` from 0.26.4 to 0.26.5 - [Release notes](https://github.com/Shopify/ruby-lsp/releases) - [Commits](https://github.com/Shopify/ruby-lsp/compare/v0.26.4...v0.26.5) Updates `dalli` from 4.0.0 to 4.1.0 - [Changelog](https://github.com/petergoldstein/dalli/blob/main/CHANGELOG.md) - [Commits](https://github.com/petergoldstein/dalli/compare/v4.0.0...v4.1.0) Updates `graphql` from 2.5.16 to 2.5.18 - [Release notes](https://github.com/rmosolgo/graphql-ruby/releases) - [Changelog](https://github.com/rmosolgo/graphql-ruby/blob/master/CHANGELOG.md) - [Commits](https://github.com/rmosolgo/graphql-ruby/compare/v2.5.16...v2.5.18) Updates `sorbet-static` from 0.6.12887 to 0.6.12897 - [Release notes](https://github.com/sorbet/sorbet/releases) - [Commits](https://github.com/sorbet/sorbet/commits) Updates `sorbet-static-and-runtime` from 0.6.12887 to 0.6.12897 - [Release notes](https://github.com/sorbet/sorbet/releases) - [Commits](https://github.com/sorbet/sorbet/commits) --- updated-dependencies: - dependency-name: ruby-lsp dependency-version: 0.26.5 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: minor-and-patch - dependency-name: dalli dependency-version: 4.1.0 dependency-type: direct:development update-type: version-update:semver-minor dependency-group: minor-and-patch - dependency-name: graphql dependency-version: 2.5.18 dependency-type: direct:development update-type: version-update:semver-patch dependency-group: minor-and-patch - dependency-name: sorbet-static dependency-version: 0.6.12897 dependency-type: direct:development update-type: version-update:semver-patch dependency-group: minor-and-patch - dependency-name: sorbet-static-and-runtime dependency-version: 0.6.12897 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: minor-and-patch ... Signed-off-by: dependabot[bot] --- Gemfile | 2 +- Gemfile.lock | 29 +++++++++++++++-------------- 2 files changed, 16 insertions(+), 15 deletions(-) diff --git a/Gemfile b/Gemfile index 28e3941f0..dad90d6dd 100644 --- a/Gemfile +++ b/Gemfile @@ -64,7 +64,7 @@ group :development, :test do gem "xpath" gem "kredis" # TODO: Unlock when segfault in sorbet-static is fixed - gem "sorbet-static", "< 0.6.12889" + gem "sorbet-static", "< 0.6.12898" end group :test do diff --git a/Gemfile.lock b/Gemfile.lock index cb57474e5..66292c42a 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -137,7 +137,7 @@ GEM bigdecimal rexml crass (1.0.6) - dalli (4.0.0) + dalli (4.1.0) logger date (3.5.1) debug (1.11.1) @@ -180,7 +180,7 @@ GEM google-protobuf (4.33.4-x86_64-linux-musl) bigdecimal rake (>= 13) - graphql (2.5.16) + graphql (2.5.18) base64 fiber-storage logger @@ -309,9 +309,10 @@ 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) + tsort rdoc (7.0.3) erb psych (>= 4.0.0) @@ -347,7 +348,7 @@ GEM rubocop-sorbet (0.11.0) lint_roller rubocop (>= 1.75.2) - ruby-lsp (0.26.4) + ruby-lsp (0.26.5) language_server-protocol (~> 3.17.0) prism (>= 1.2, < 2.0) rbs (>= 3, < 5) @@ -364,15 +365,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.12897) + sorbet-static (= 0.6.12897) + sorbet-runtime (0.6.12897) + sorbet-static (0.6.12897-aarch64-linux) + sorbet-static (0.6.12897-universal-darwin) + sorbet-static (0.6.12897-x86_64-linux) + sorbet-static-and-runtime (0.6.12897) + sorbet (= 0.6.12897) + sorbet-runtime (= 0.6.12897) spoom (1.7.11) erubi (>= 1.10.0) prism (>= 0.28.0) @@ -464,7 +465,7 @@ DEPENDENCIES shopify-money sidekiq smart_properties - sorbet-static (< 0.6.12889) + sorbet-static (< 0.6.12898) sprockets sqlite3 state_machines From 665d4922e5c1efdaa7a0ba3d8e0a203d40f2cad7 Mon Sep 17 00:00:00 2001 From: Stan Lo Date: Fri, 30 Jan 2026 18:28:33 +0000 Subject: [PATCH 2/3] Bump gem rbis --- .../gems/{dalli@4.0.0.rbi => dalli@4.1.0.rbi} | 625 ++++++-- ...{graphql@2.5.16.rbi => graphql@2.5.18.rbi} | 452 +++--- ...bs@4.0.0.dev.4.rbi => rbs@4.0.0.dev.5.rbi} | 1260 ++++++++++++----- ...uby-lsp@0.26.4.rbi => ruby-lsp@0.26.5.rbi} | 615 ++++---- 4 files changed, 2024 insertions(+), 928 deletions(-) rename sorbet/rbi/gems/{dalli@4.0.0.rbi => dalli@4.1.0.rbi} (79%) rename sorbet/rbi/gems/{graphql@2.5.16.rbi => graphql@2.5.18.rbi} (98%) rename sorbet/rbi/gems/{rbs@4.0.0.dev.4.rbi => rbs@4.0.0.dev.5.rbi} (85%) rename sorbet/rbi/gems/{ruby-lsp@0.26.4.rbi => ruby-lsp@0.26.5.rbi} (96%) diff --git a/sorbet/rbi/gems/dalli@4.0.0.rbi b/sorbet/rbi/gems/dalli@4.1.0.rbi similarity index 79% rename from sorbet/rbi/gems/dalli@4.0.0.rbi rename to sorbet/rbi/gems/dalli@4.1.0.rbi index 8813d0288..f756a5b09 100644 --- a/sorbet/rbi/gems/dalli@4.0.0.rbi +++ b/sorbet/rbi/gems/dalli@4.1.0.rbi @@ -29,6 +29,8 @@ end # # pkg:gem/dalli#lib/dalli/client.rb:12 class Dalli::Client + include ::Dalli::ProtocolDeprecations + # Dalli::Client is the main class which developers will use to interact with # the memcached server. Usage: # @@ -59,6 +61,11 @@ class Dalli::Client # - :compressor - defaults to Dalli::Compressor, a Zlib-based implementation # - :cache_nils - defaults to false, if true Dalli will not treat cached nil values as 'not found' for # #fetch operations. + # - :raw - If set, disables serialization and compression entirely at the client level. + # Only String values are supported. This is useful when the caller handles its own + # serialization (e.g., Rails' ActiveSupport::Cache). Note: this is different from + # the per-request :raw option which converts values to strings but still uses the + # serialization pipeline. # - :digest_class - defaults to Digest::MD5, allows you to pass in an object that responds to the hexdigest method, # useful for injecting a FIPS compliant hash object. # - :protocol - one of either :binary or :meta, defaulting to :binary. This sets the protocol that Dalli uses @@ -66,27 +73,27 @@ class Dalli::Client # # @return [Client] a new instance of Client # - # pkg:gem/dalli#lib/dalli/client.rb:49 + # pkg:gem/dalli#lib/dalli/client.rb:54 def initialize(servers = T.unsafe(nil), options = T.unsafe(nil)); end # Conditionally add a key/value pair, if the key does not already exist # on the server. Returns truthy if the operation succeeded. # - # pkg:gem/dalli#lib/dalli/client.rb:214 + # pkg:gem/dalli#lib/dalli/client.rb:346 def add(key, value, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Make sure memcache servers are alive, or raise an Dalli::RingError # - # pkg:gem/dalli#lib/dalli/client.rb:342 + # pkg:gem/dalli#lib/dalli/client.rb:490 def alive!; end # Append value to the value already stored on the server for 'key'. # Appending only works for values stored with :raw => true. # - # pkg:gem/dalli#lib/dalli/client.rb:246 + # pkg:gem/dalli#lib/dalli/client.rb:394 def append(key, value); end - # pkg:gem/dalli#lib/dalli/client.rb:361 + # pkg:gem/dalli#lib/dalli/client.rb:509 def cache_nils; end # compare and swap values using optimistic locking. @@ -100,7 +107,7 @@ class Dalli::Client # - false if the value was changed by someone else. # - true if the value was successfully updated. # - # pkg:gem/dalli#lib/dalli/client.rb:158 + # pkg:gem/dalli#lib/dalli/client.rb:272 def cas(key, ttl = T.unsafe(nil), req_options = T.unsafe(nil), &_arg3); end # like #cas, but will yield to the block whether or not the value @@ -110,13 +117,13 @@ class Dalli::Client # - false if the value was changed by someone else. # - true if the value was successfully updated. # - # pkg:gem/dalli#lib/dalli/client.rb:169 + # pkg:gem/dalli#lib/dalli/client.rb:283 def cas!(key, ttl = T.unsafe(nil), req_options = T.unsafe(nil), &_arg3); end # Close our connection to each server. # If you perform another operation after this, the connections will be re-established. # - # pkg:gem/dalli#lib/dalli/client.rb:349 + # pkg:gem/dalli#lib/dalli/client.rb:497 def close; end # Decr subtracts the given amount from the counter on the memcached server. @@ -135,18 +142,31 @@ class Dalli::Client # # If the value already exists, it must have been set with raw: true # - # pkg:gem/dalli#lib/dalli/client.rb:292 + # pkg:gem/dalli#lib/dalli/client.rb:440 def decr(key, amt = T.unsafe(nil), ttl = T.unsafe(nil), default = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:239 + # pkg:gem/dalli#lib/dalli/client.rb:371 def delete(key); end # Delete a key/value pair, verifying existing CAS. # Returns true if succeeded, and falsy otherwise. # - # pkg:gem/dalli#lib/dalli/client.rb:235 + # pkg:gem/dalli#lib/dalli/client.rb:367 def delete_cas(key, cas = T.unsafe(nil)); end + # Delete multiple keys efficiently using pipelining. + # This method is more efficient than calling delete() in a loop because + # it batches requests by server and uses quiet mode. + # + # Example: + # client.delete_multi(['key1', 'key2', 'key3']) + # + # @param keys [Array] keys to delete + # @return [void] + # + # pkg:gem/dalli#lib/dalli/client.rb:385 + def delete_multi(keys); end + # Fetch the value associated with the key. # If a value is found, then it is returned. # @@ -156,32 +176,64 @@ class Dalli::Client # and a block is given, the block will be invoked and its return value # written to the cache and returned. # - # pkg:gem/dalli#lib/dalli/client.rb:137 + # pkg:gem/dalli#lib/dalli/client.rb:188 def fetch(key, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end + # Fetch the value with thundering herd protection using the meta protocol's + # N (vivify) and R (recache) flags. + # + # This method prevents multiple clients from simultaneously regenerating the same + # cache entry (the "thundering herd" problem). Only one client wins the right to + # regenerate; other clients receive the stale value (if available) or wait. + # + # IMPORTANT: This method requires memcached 1.6+ and the meta protocol (protocol: :meta). + # It will raise an error if used with the binary protocol. + # + # @example Basic usage + # client.fetch_with_lock('expensive_key', ttl: 300, lock_ttl: 30) do + # expensive_database_query + # end + # @example With proactive recaching (recache before expiry) + # client.fetch_with_lock('key', ttl: 300, lock_ttl: 30, recache_threshold: 60) do + # expensive_operation + # end + # @param key [String] the cache key + # @param lock_ttl [Integer] how long the lock/stub lives (default: 30 seconds) + # This is the maximum time other clients will return stale data while + # waiting for regeneration. Should be longer than your expected regeneration time. + # @param recache_threshold [Integer, nil] if set, win the recache race when the + # item's remaining TTL is below this threshold. Useful for proactive recaching. + # @param req_options [Hash] options passed to set operations (e.g., raw: true) + # @param ttl [Integer] time-to-live for the cached value in seconds + # @return [Object] the cached value (may be stale if another client is regenerating) + # @yield Block to regenerate the value (only called if this client won the race) + # + # pkg:gem/dalli#lib/dalli/client.rb:231 + def fetch_with_lock(key, ttl: T.unsafe(nil), lock_ttl: T.unsafe(nil), recache_threshold: T.unsafe(nil), req_options: T.unsafe(nil)); end + # Flush the memcached server, at 'delay' seconds in the future. # Delay defaults to zero seconds, which means an immediate flush. # - # pkg:gem/dalli#lib/dalli/client.rb:302 + # pkg:gem/dalli#lib/dalli/client.rb:450 def flush(delay = T.unsafe(nil)); end # Flush the memcached server, at 'delay' seconds in the future. # Delay defaults to zero seconds, which means an immediate flush. # - # pkg:gem/dalli#lib/dalli/client.rb:305 + # pkg:gem/dalli#lib/dalli/client.rb:453 def flush_all(delay = T.unsafe(nil)); end # Gat (get and touch) fetch an item and simultaneously update its expiration time. # # If a value is not found, then +nil+ is returned. # - # pkg:gem/dalli#lib/dalli/client.rb:71 + # pkg:gem/dalli#lib/dalli/client.rb:77 def gat(key, ttl = T.unsafe(nil)); end # Get the value associated with the key. # If a value is not found, then +nil+ is returned. # - # pkg:gem/dalli#lib/dalli/client.rb:63 + # pkg:gem/dalli#lib/dalli/client.rb:69 def get(key, req_options = T.unsafe(nil)); end # Get the value and CAS ID associated with the key. If a block is provided, @@ -189,14 +241,14 @@ class Dalli::Client # # @yield [value, cas] # - # pkg:gem/dalli#lib/dalli/client.rb:87 + # pkg:gem/dalli#lib/dalli/client.rb:93 def get_cas(key); end # Fetch multiple keys efficiently. # If a block is given, yields key/value pairs one at a time. # Otherwise returns a hash of { 'key' => 'value', 'key2' => 'value1' } # - # pkg:gem/dalli#lib/dalli/client.rb:98 + # pkg:gem/dalli#lib/dalli/client.rb:149 def get_multi(*keys); end # Fetch multiple keys efficiently, including available metadata such as CAS. @@ -205,9 +257,39 @@ class Dalli::Client # If no block is given, returns a hash of # { 'key' => [value, cas_id] } # - # pkg:gem/dalli#lib/dalli/client.rb:119 + # pkg:gem/dalli#lib/dalli/client.rb:170 def get_multi_cas(*keys); end + # Get value with extended metadata using the meta protocol. + # + # IMPORTANT: This method requires memcached 1.6+ and the meta protocol (protocol: :meta). + # It will raise an error if used with the binary protocol. + # + # @example Get with all metadata without affecting LRU + # result = client.get_with_metadata('key', + # return_hit_status: true, + # return_last_access: true, + # skip_lru_bump: true + # ) + # # => { value: "data", cas: 123, hit_before: true, last_access: 42 } + # @example Get with hit status + # result = client.get_with_metadata('key', return_hit_status: true) + # # => { value: "data", cas: 123, hit_before: true } + # @param key [String] the cache key + # @param options [Hash] options controlling what metadata to return + # - :return_cas [Boolean] return the CAS value (default: true) + # - :return_hit_status [Boolean] return whether item was previously accessed + # - :return_last_access [Boolean] return seconds since last access + # - :skip_lru_bump [Boolean] don't bump LRU or update access stats + # @return [Hash] containing: + # - :value - the cached value (or nil on miss) + # - :cas - the CAS value + # - :hit_before - true/false if previously accessed (only if return_hit_status: true) + # - :last_access - seconds since last access (only if return_last_access: true) + # + # pkg:gem/dalli#lib/dalli/client.rb:131 + def get_with_metadata(key, options = T.unsafe(nil)); end + # Incr adds the given amount to the counter on the memcached server. # Amt must be a positive integer value. # @@ -221,7 +303,7 @@ class Dalli::Client # # If the value already exists, it must have been set with raw: true # - # pkg:gem/dalli#lib/dalli/client.rb:270 + # pkg:gem/dalli#lib/dalli/client.rb:418 def incr(key, amt = T.unsafe(nil), ttl = T.unsafe(nil), default = T.unsafe(nil)); end # Turn on quiet aka noreply support for a number of @@ -241,18 +323,18 @@ class Dalli::Client # Dalli client methods invoked inside the block will not # have return values # - # pkg:gem/dalli#lib/dalli/client.rb:198 + # pkg:gem/dalli#lib/dalli/client.rb:312 def multi; end # @return [Boolean] # - # pkg:gem/dalli#lib/dalli/client.rb:357 + # pkg:gem/dalli#lib/dalli/client.rb:505 def not_found?(val); end # Prepend value to the value already stored on the server for 'key'. # Prepending only works for values stored with :raw => true. # - # pkg:gem/dalli#lib/dalli/client.rb:253 + # pkg:gem/dalli#lib/dalli/client.rb:401 def prepend(key, value); end # Turn on quiet aka noreply support for a number of @@ -272,59 +354,74 @@ class Dalli::Client # Dalli client methods invoked inside the block will not # have return values # - # pkg:gem/dalli#lib/dalli/client.rb:190 + # pkg:gem/dalli#lib/dalli/client.rb:304 def quiet; end # Conditionally add a key/value pair, only if the key already exists # on the server. Returns truthy if the operation succeeded. # - # pkg:gem/dalli#lib/dalli/client.rb:221 + # pkg:gem/dalli#lib/dalli/client.rb:353 def replace(key, value, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Conditionally add a key/value pair, verifying existing CAS, only if the # key already exists on the server. Returns the new CAS value if the # operation succeeded, or falsy otherwise. # - # pkg:gem/dalli#lib/dalli/client.rb:229 + # pkg:gem/dalli#lib/dalli/client.rb:361 def replace_cas(key, value, cas, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Close our connection to each server. # If you perform another operation after this, the connections will be re-established. # - # pkg:gem/dalli#lib/dalli/client.rb:353 + # pkg:gem/dalli#lib/dalli/client.rb:501 def reset; end # Reset stats for each server. # - # pkg:gem/dalli#lib/dalli/client.rb:324 + # pkg:gem/dalli#lib/dalli/client.rb:472 def reset_stats; end - # pkg:gem/dalli#lib/dalli/client.rb:200 + # pkg:gem/dalli#lib/dalli/client.rb:314 def set(key, value, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # Set the key-value pair, verifying existing CAS. # Returns the resulting CAS value if succeeded, and falsy otherwise. # - # pkg:gem/dalli#lib/dalli/client.rb:207 + # pkg:gem/dalli#lib/dalli/client.rb:339 def set_cas(key, value, cas, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end + # Set multiple keys and values efficiently using pipelining. + # This method is more efficient than calling set() in a loop because + # it batches requests by server and uses quiet mode. + # + # Example: + # client.set_multi({ 'key1' => 'value1', 'key2' => 'value2' }, 300) + # + # @param hash [Hash] key-value pairs to set + # @param req_options [Hash] options passed to each set operation + # @param ttl [Integer] time-to-live in seconds (optional, uses default if not provided) + # @return [void] + # + # pkg:gem/dalli#lib/dalli/client.rb:330 + def set_multi(hash, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end + # Collect the stats for each server. # You can optionally pass a type including :items, :slabs or :settings to get specific stats # Returns a hash like { 'hostname:port' => { 'stat1' => 'value1', ... }, 'hostname2:port' => { ... } } # - # pkg:gem/dalli#lib/dalli/client.rb:313 + # pkg:gem/dalli#lib/dalli/client.rb:461 def stats(type = T.unsafe(nil)); end # Touch updates expiration time for a given key. # # Returns true if key exists, otherwise nil. # - # pkg:gem/dalli#lib/dalli/client.rb:79 + # pkg:gem/dalli#lib/dalli/client.rb:85 def touch(key, ttl = T.unsafe(nil)); end # Version of the memcache servers. # - # pkg:gem/dalli#lib/dalli/client.rb:332 + # pkg:gem/dalli#lib/dalli/client.rb:480 def version; end # Stub method so a bare Dalli client can pretend to be a connection pool. @@ -332,20 +429,20 @@ class Dalli::Client # @yield [_self] # @yieldparam _self [Dalli::Client] the object that the method was called on # - # pkg:gem/dalli#lib/dalli/client.rb:366 + # pkg:gem/dalli#lib/dalli/client.rb:514 def with; end private - # pkg:gem/dalli#lib/dalli/client.rb:376 + # pkg:gem/dalli#lib/dalli/client.rb:524 def cas_core(key, always_set, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end # @raise [ArgumentError] # - # pkg:gem/dalli#lib/dalli/client.rb:372 + # pkg:gem/dalli#lib/dalli/client.rb:520 def check_positive!(amt); end - # pkg:gem/dalli#lib/dalli/client.rb:433 + # pkg:gem/dalli#lib/dalli/client.rb:581 def normalize_options(opts); end # Chokepoint method for memcached methods with a key argument. @@ -357,29 +454,40 @@ class Dalli::Client # a particular memcached instance becomes unreachable, or the # operational times out. # - # pkg:gem/dalli#lib/dalli/client.rb:417 + # pkg:gem/dalli#lib/dalli/client.rb:565 def perform(*all_args); end - # pkg:gem/dalli#lib/dalli/client.rb:440 + # pkg:gem/dalli#lib/dalli/client.rb:596 + def pipelined_deleter; end + + # pkg:gem/dalli#lib/dalli/client.rb:588 def pipelined_getter; end - # pkg:gem/dalli#lib/dalli/client.rb:398 + # pkg:gem/dalli#lib/dalli/client.rb:592 + def pipelined_setter; end + + # pkg:gem/dalli#lib/dalli/client.rb:546 def protocol_implementation; end - # pkg:gem/dalli#lib/dalli/client.rb:394 + # @raise [Dalli::DalliError] + # + # pkg:gem/dalli#lib/dalli/client.rb:600 + def raise_unless_meta_protocol!; end + + # pkg:gem/dalli#lib/dalli/client.rb:542 def ring; end # Uses the argument TTL or the client-wide default. Ensures # that the value is an integer # - # pkg:gem/dalli#lib/dalli/client.rb:388 + # pkg:gem/dalli#lib/dalli/client.rb:536 def ttl_or_default(ttl); end end -# pkg:gem/dalli#lib/dalli/client.rb:307 +# pkg:gem/dalli#lib/dalli/client.rb:455 Dalli::Client::ALLOWED_STAT_KEYS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/client.rb:355 +# pkg:gem/dalli#lib/dalli/client.rb:503 Dalli::Client::CACHE_NILS = T.let(T.unsafe(nil), Hash) # Default compressor used by Dalli, that uses @@ -556,6 +664,45 @@ module Dalli::PIDCache::CoreExt def _fork; end end +# Contains logic for the pipelined delete operations implemented by the client. +# Efficiently deletes multiple keys by grouping requests by server +# and using quiet mode to minimize round trips. +# +# pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:9 +class Dalli::PipelinedDeleter + # @return [PipelinedDeleter] a new instance of PipelinedDeleter + # + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:10 + def initialize(ring, key_manager); end + + # Deletes multiple keys from memcached. + # + # @param keys [Array] keys to delete + # @return [void] + # + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:21 + def process(keys); end + + private + + # Sends noop to each server to flush responses and ensure all deletes complete. + # + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:60 + def finish_requests(servers); end + + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:69 + def groups_for_keys(keys); end + + # Loop through the server-grouped sets of keys, writing + # the corresponding quiet delete requests to the appropriate servers + # + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:46 + def make_delete_requests(groups); end + + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:36 + def setup_requests(keys); end +end + # Contains logic for the pipelined gets implemented by the client. # # pkg:gem/dalli#lib/dalli/pipelined_getter.rb:7 @@ -621,6 +768,48 @@ class Dalli::PipelinedGetter def setup_requests(keys); end end +# Contains logic for the pipelined set operations implemented by the client. +# Efficiently writes multiple key-value pairs by grouping requests by server +# and using quiet mode to minimize round trips. +# +# pkg:gem/dalli#lib/dalli/pipelined_setter.rb:9 +class Dalli::PipelinedSetter + # @return [PipelinedSetter] a new instance of PipelinedSetter + # + # pkg:gem/dalli#lib/dalli/pipelined_setter.rb:10 + def initialize(ring, key_manager); end + + # Writes multiple key-value pairs to memcached. + # Raises an error if any server is unavailable. + # + # @param hash [Hash] key-value pairs to set + # @param req_options [Hash] options passed to each set operation + # @param ttl [Integer] time-to-live in seconds + # @return [void] + # + # pkg:gem/dalli#lib/dalli/pipelined_setter.rb:24 + def process(hash, ttl, req_options); end + + private + + # Sends noop to each server to flush responses and ensure all writes complete. + # + # pkg:gem/dalli#lib/dalli/pipelined_setter.rb:65 + def finish_requests(servers); end + + # pkg:gem/dalli#lib/dalli/pipelined_setter.rb:74 + def groups_for_keys(keys); end + + # Loop through the server-grouped sets of keys, writing + # the corresponding quiet set requests to the appropriate servers + # + # pkg:gem/dalli#lib/dalli/pipelined_setter.rb:49 + def make_set_requests(groups, hash, ttl, req_options); end + + # pkg:gem/dalli#lib/dalli/pipelined_setter.rb:39 + def setup_requests(hash, ttl, req_options); end +end + # pkg:gem/dalli#lib/dalli/protocol.rb:6 module Dalli::Protocol; end @@ -862,10 +1051,10 @@ class Dalli::Protocol::Binary < ::Dalli::Protocol::Base private - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:59 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:65 def add(key, value, ttl, options); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:82 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:88 def append(key, value); end # TODO: This is confusing, as there's a cas command in memcached @@ -876,20 +1065,20 @@ class Dalli::Protocol::Binary < ::Dalli::Protocol::Base # Arithmetic Commands # - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:106 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:119 def decr(key, count, ttl, initial); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:124 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:137 def decr_incr(opkey, key, count, ttl, initial); end # Delete Commands # - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:98 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:104 def delete(key, cas); end # Other Commands # - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:133 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:146 def flush(ttl = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/protocol/binary.rb:32 @@ -900,25 +1089,37 @@ class Dalli::Protocol::Binary < ::Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/binary.rb:22 def get(key, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:111 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:124 def incr(key, count, ttl, initial); end # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands. # We need to read all the responses at once. # - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:141 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:154 def noop; end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:87 + # Pipelined delete - writes a quiet delete request without reading response. + # Used by PipelinedDeleter for bulk operations. + # + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:113 + def pipelined_delete(key); end + + # Pipelined set - writes a quiet set request without reading response. + # Used by PipelinedSetter for bulk operations. + # + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:61 + def pipelined_set(key, value, ttl, options); end + + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:93 def prepend(key, value); end # pkg:gem/dalli#lib/dalli/protocol/binary.rb:28 def quiet_get_request(key); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:64 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:70 def replace(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:152 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:165 def reset_stats; end # Storage Commands @@ -926,22 +1127,22 @@ class Dalli::Protocol::Binary < ::Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/binary.rb:54 def set(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:146 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:159 def stats(info = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:70 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:76 def storage_req(opkey, key, value, ttl, cas, options); end # pkg:gem/dalli#lib/dalli/protocol/binary.rb:39 def touch(key, ttl); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:157 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:170 def version; end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:92 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:98 def write_append_prepend(opkey, key, value); end - # pkg:gem/dalli#lib/dalli/protocol/binary.rb:162 + # pkg:gem/dalli#lib/dalli/protocol/binary.rb:175 def write_noop; end end @@ -951,7 +1152,7 @@ end # if the key doesn't already exist, rather than # setting the initial value # -# pkg:gem/dalli#lib/dalli/protocol/binary.rb:121 +# pkg:gem/dalli#lib/dalli/protocol/binary.rb:134 Dalli::Protocol::Binary::NOT_FOUND_EXPIRY = T.let(T.unsafe(nil), Integer) # Class that encapsulates logic for formatting binary protocol requests @@ -1385,15 +1586,15 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base private - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:69 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:128 def add(key, value, ttl, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:93 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:152 def append(key, value); end # @raise [Dalli::DalliError] # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:173 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:240 def authenticate_connection; end # TODO: This is confusing, as there's a cas command in memcached @@ -1404,20 +1605,31 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # Arithmetic Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:125 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:192 def decr(key, count, ttl, initial); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:133 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:200 def decr_incr(incr, key, delta, ttl, initial); end # Delete Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:116 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:175 def delete(key, cas); end + # Delete with stale invalidation instead of actual deletion. + # Used with thundering herd protection to mark items as stale rather than removing them. + # + # @note Requires memcached 1.6+ (meta protocol feature) + # @param cas [Integer] optional CAS value for compare-and-swap + # @param key [String] the key to invalidate + # @return [Boolean] true if successful + # + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:109 + def delete_stale(key, cas = T.unsafe(nil)); end + # Other Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:142 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:209 def flush(delay = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/protocol/meta.rb:38 @@ -1428,49 +1640,88 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/meta.rb:26 def get(key, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:129 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:196 def incr(key, count, ttl, initial); end + # Comprehensive meta get with support for all metadata flags. + # This is the full-featured get method that supports: + # - Thundering herd protection (vivify_ttl, recache_ttl) + # - Item metadata (hit_status, last_access) + # - LRU control (skip_lru_bump) + # + # @note Requires memcached 1.6+ (meta protocol feature) + # @param key [String] the key to retrieve + # @param options [Hash] options controlling what metadata to return + # - :vivify_ttl [Integer] creates a stub on miss with this TTL (N flag) + # - :recache_ttl [Integer] wins recache race if remaining TTL is below this (R flag) + # - :return_hit_status [Boolean] return whether item was previously accessed (h flag) + # - :return_last_access [Boolean] return seconds since last access (l flag) + # - :skip_lru_bump [Boolean] don't bump LRU or update access stats (u flag) + # - :cache_nils [Boolean] whether to cache nil values + # @return [Hash] containing: + # - :value - the cached value (or nil on miss) + # - :cas - the CAS value + # - :won_recache - true if client won recache race (W flag) + # - :stale - true if item is stale (X flag) + # - :lost_recache - true if another client is recaching (Z flag) + # - :hit_before - true/false if previously accessed (only if return_hit_status: true) + # - :last_access - seconds since last access (only if return_last_access: true) + # + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:87 + def meta_get(key, options = T.unsafe(nil)); end + # Noop is a keepalive operation but also used to demarcate the end of a set of pipelined commands. # We need to read all the responses at once. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:149 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:216 def noop; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:98 + # Pipelined delete - writes a quiet delete request without reading response. + # Used by PipelinedDeleter for bulk operations. + # + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:185 + def pipelined_delete(key); end + + # Pipelined set - writes a quiet set request without reading response. + # Used by PipelinedSetter for bulk operations. + # + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:124 + def pipelined_set(key, value, ttl, options); end + + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:157 def prepend(key, value); end # pkg:gem/dalli#lib/dalli/protocol/meta.rb:33 def quiet_get_request(key); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:74 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:133 def replace(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:159 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:226 def reset_stats; end # Storage Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:64 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:117 def set(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:154 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:221 def stats(info = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/protocol/meta.rb:46 def touch(key, ttl); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:164 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:231 def version; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:104 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:163 def write_append_prepend_req(mode, key, value, ttl = T.unsafe(nil), cas = T.unsafe(nil), _options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:169 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:236 def write_noop; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:80 - def write_storage_req(mode, key, raw_value, ttl = T.unsafe(nil), cas = T.unsafe(nil), options = T.unsafe(nil)); end + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:139 + def write_storage_req(mode, key, raw_value, ttl = T.unsafe(nil), cas = T.unsafe(nil), options = T.unsafe(nil), quiet: T.unsafe(nil)); end end # The meta protocol requires that keys be ASCII only, so Unicode keys are @@ -1499,49 +1750,73 @@ Dalli::Protocol::Meta::KeyRegularizer::WHITESPACE = T.let(T.unsafe(nil), Regexp) # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:10 class Dalli::Protocol::Meta::RequestFormatter class << self - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:105 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:136 def cas_string(cas); end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:73 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:104 def flush(delay: T.unsafe(nil), quiet: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:49 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:80 def meta_arithmetic(key:, delta:, initial:, incr: T.unsafe(nil), cas: T.unsafe(nil), ttl: T.unsafe(nil), base64: T.unsafe(nil), quiet: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:40 - def meta_delete(key:, cas: T.unsafe(nil), ttl: T.unsafe(nil), base64: T.unsafe(nil), quiet: T.unsafe(nil)); end + # Thundering herd protection flag: + # - stale (I flag): Instead of deleting the item, mark it as stale. Other clients + # using N/R flags will see the X flag and know the item is being regenerated. + # + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:70 + def meta_delete(key:, cas: T.unsafe(nil), ttl: T.unsafe(nil), base64: T.unsafe(nil), quiet: T.unsafe(nil), stale: T.unsafe(nil)); end # Since these are string construction methods, we're going to disable these # Rubocop directives. We really can't make this construction much simpler, # and introducing an intermediate object seems like overkill. # # - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:18 - def meta_get(key:, value: T.unsafe(nil), return_cas: T.unsafe(nil), ttl: T.unsafe(nil), base64: T.unsafe(nil), quiet: T.unsafe(nil)); end + # Meta get flags: + # + # Thundering herd protection: + # - vivify_ttl (N flag): On miss, create a stub item and return W flag. The TTL + # specifies how long the stub lives. Other clients see X (stale) and Z (lost race). + # - recache_ttl (R flag): If item's remaining TTL is below this threshold, return W + # flag to indicate this client should recache. Other clients get Z (lost race). + # + # Metadata flags: + # - return_hit_status (h flag): Return whether item has been hit before (0 or 1) + # - return_last_access (l flag): Return seconds since item was last accessed + # - skip_lru_bump (u flag): Don't bump item in LRU, don't update hit status or last access + # + # Response flags (parsed by response processor): + # - W: Client won the right to recache this item + # - X: Item is stale (another client is regenerating) + # - Z: Client lost the recache race (another client is already regenerating) + # - h0/h1: Hit status (0 = first access, 1 = previously accessed) + # - l: Seconds since last access + # + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:38 + def meta_get(key:, value: T.unsafe(nil), return_cas: T.unsafe(nil), ttl: T.unsafe(nil), base64: T.unsafe(nil), quiet: T.unsafe(nil), vivify_ttl: T.unsafe(nil), recache_ttl: T.unsafe(nil), return_hit_status: T.unsafe(nil), return_last_access: T.unsafe(nil), skip_lru_bump: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:65 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:96 def meta_noop; end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:28 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:55 def meta_set(key:, value:, bitflags: T.unsafe(nil), cas: T.unsafe(nil), ttl: T.unsafe(nil), mode: T.unsafe(nil), base64: T.unsafe(nil), quiet: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:90 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:121 def mode_to_token(mode); end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:110 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:141 def parse_to_64_bit_int(val, default); end # @raise [ArgumentError] # - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:82 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:113 def stats(arg = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:69 + # pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:100 def version; end end end -# pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:80 +# pkg:gem/dalli#lib/dalli/protocol/meta/request_formatter.rb:111 Dalli::Protocol::Meta::RequestFormatter::ALLOWED_STATS_ARGS = T.let(T.unsafe(nil), Array) # Class that encapsulates logic for processing meta protocol responses @@ -1555,35 +1830,38 @@ class Dalli::Protocol::Meta::ResponseProcessor # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:26 def initialize(io_source, value_marshaller); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:179 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:214 def bitflags_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:193 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:243 def body_len_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:183 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:74 + def build_metadata_result(tokens); end + + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:218 def cas_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:108 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:143 def consume_all_responses_until_mn; end # @return [Boolean] # - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:161 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:196 def contains_header?(buf); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:73 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:108 def decr_incr; end # @raise [Dalli::ServerError] # - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:169 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:204 def error_on_unexpected!(expected_codes); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:91 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:126 def flush; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:123 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:158 def full_response_from_buffer(tokens, body, resp_size); end # This method returns an array of values used in a pipelined @@ -1595,18 +1873,45 @@ class Dalli::Protocol::Meta::ResponseProcessor # The remaining three values in the array are the ResponseHeader, # key, and value. # - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:138 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:173 def getk_response_from_buffer(buf); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:165 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:200 def header_from_buffer(buf); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:187 + # Returns true if item was previously hit, false if first access, nil if not requested + # The h flag returns h0 (first access) or h1 (previously accessed) + # + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:230 + def hit_status_from_tokens(tokens); end + + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:222 def key_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:68 + # Returns seconds since last access, or nil if not requested + # The l flag returns l + # + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:239 + def last_access_from_tokens(tokens); end + + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:103 def meta_delete; end + # Returns a hash with all requested metadata: + # - :value - the cached value (or nil if miss) + # - :cas - the CAS value (if return_cas was requested) + # - :won_recache - true if client won the right to recache (W flag) + # - :stale - true if the item is stale (X flag) + # - :lost_recache - true if another client is already recaching (Z flag) + # - :hit_before - true/false if item was previously accessed (h flag, if requested) + # - :last_access - seconds since last access (l flag, if requested) + # + # Used by meta_get for comprehensive metadata retrieval. + # Supports thundering herd protection (N/R flags) and metadata flags (h/l/u). + # + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:65 + def meta_get_with_metadata(cache_nils: T.unsafe(nil), return_hit_status: T.unsafe(nil), return_last_access: T.unsafe(nil)); end + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:31 def meta_get_with_value(cache_nils: T.unsafe(nil)); end @@ -1616,34 +1921,37 @@ class Dalli::Protocol::Meta::ResponseProcessor # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:49 def meta_get_without_value; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:61 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:96 def meta_set_append_prepend; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:54 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:89 def meta_set_with_cas; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:208 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:258 def next_line_to_tokens; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:213 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:82 + def parse_value_from_tokens(tokens, cache_nils); end + + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:263 def read_data(data_size); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:204 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:254 def read_line; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:97 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:132 def reset; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:81 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:116 def stats; end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:115 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:150 def tokens_from_header_buffer(buf); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:197 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:247 def value_from_tokens(tokens, flag); end - # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:103 + # pkg:gem/dalli#lib/dalli/protocol/meta/response_processor.rb:138 def version; end end @@ -1735,6 +2043,13 @@ class Dalli::Protocol::ResponseBuffer def reset; end end +# SSL errors that occur during read/write operations (not during initial +# handshake) should trigger reconnection. These indicate transient network +# issues, not configuration problems. +# +# pkg:gem/dalli#lib/dalli/protocol.rb:22 +Dalli::Protocol::SSL_ERRORS = T.let(T.unsafe(nil), Array) + # Dalli::Protocol::ServerConfigParser parses a server string passed to # a Dalli::Protocol::Binary instance into the hostname, port, weight, and # socket_type. @@ -1794,6 +2109,59 @@ Dalli::Protocol::ServerConfigParser::MEMCACHED_URI_PROTOCOL = T.let(T.unsafe(nil # pkg:gem/dalli#lib/dalli/protocol/server_config_parser.rb:19 Dalli::Protocol::ServerConfigParser::SERVER_CONFIG_REGEXP = T.let(T.unsafe(nil), Regexp) +# Dalli::Protocol::StringMarshaller is a pass-through marshaller for use with +# the :raw client option. It bypasses serialization and compression entirely, +# expecting values to already be strings (e.g., pre-serialized by Rails' +# ActiveSupport::Cache). It still enforces the maximum value size limit. +# +# pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:11 +class Dalli::Protocol::StringMarshaller + # @return [StringMarshaller] a new instance of StringMarshaller + # + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:19 + def initialize(client_options); end + + # @return [Boolean] + # + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:51 + def compress_by_default?; end + + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:47 + def compression_min_size; end + + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:43 + def compressor; end + + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:32 + def retrieve(value, _flags); end + + # Interface compatibility methods - these return nil since + # StringMarshaller bypasses serialization and compression entirely. + # + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:39 + def serializer; end + + # @raise [MarshalError] + # + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:25 + def store(key, value, _options = T.unsafe(nil)); end + + # Returns the value of attribute value_max_bytes. + # + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:17 + def value_max_bytes; end + + private + + # @raise [Dalli::ValueOverMaxSize] + # + # pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:57 + def error_if_over_max_value_bytes(key, value); end +end + +# pkg:gem/dalli#lib/dalli/protocol/string_marshaller.rb:12 +Dalli::Protocol::StringMarshaller::DEFAULTS = T.let(T.unsafe(nil), Hash) + # Ruby 3.2 raises IO::TimeoutError on blocking reads/writes, but # it is not defined in earlier Ruby versions. # @@ -1985,6 +2353,29 @@ Dalli::Protocol::ValueSerializer::FLAG_UTF8 = T.let(T.unsafe(nil), Integer) # pkg:gem/dalli#lib/dalli/protocol/value_serializer.rb:16 Dalli::Protocol::ValueSerializer::OPTIONS = T.let(T.unsafe(nil), Array) +# Handles deprecation warnings for protocol and authentication features +# that will be removed in Dalli 5.0. +# +# pkg:gem/dalli#lib/dalli/protocol_deprecations.rb:8 +module Dalli::ProtocolDeprecations + private + + # pkg:gem/dalli#lib/dalli/protocol_deprecations.rb:28 + def emit_binary_protocol_deprecation_warning; end + + # pkg:gem/dalli#lib/dalli/protocol_deprecations.rb:23 + def emit_deprecation_warnings; end + + # pkg:gem/dalli#lib/dalli/protocol_deprecations.rb:37 + def emit_sasl_auth_deprecation_warning; end +end + +# pkg:gem/dalli#lib/dalli/protocol_deprecations.rb:9 +Dalli::ProtocolDeprecations::BINARY_PROTOCOL_DEPRECATION_MESSAGE = T.let(T.unsafe(nil), String) + +# pkg:gem/dalli#lib/dalli/protocol_deprecations.rb:15 +Dalli::ProtocolDeprecations::SASL_AUTH_DEPRECATION_MESSAGE = T.let(T.unsafe(nil), String) + # pkg:gem/dalli#lib/dalli.rb:35 Dalli::QUIET = T.let(T.unsafe(nil), Symbol) diff --git a/sorbet/rbi/gems/graphql@2.5.16.rbi b/sorbet/rbi/gems/graphql@2.5.18.rbi similarity index 98% rename from sorbet/rbi/gems/graphql@2.5.16.rbi rename to sorbet/rbi/gems/graphql@2.5.18.rbi index b6c239fc9..affa1e423 100644 --- a/sorbet/rbi/gems/graphql@2.5.16.rbi +++ b/sorbet/rbi/gems/graphql@2.5.18.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 @@ -21122,7 +21197,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 +21228,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 +21357,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 +21596,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/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/ruby-lsp@0.26.4.rbi b/sorbet/rbi/gems/ruby-lsp@0.26.5.rbi similarity index 96% rename from sorbet/rbi/gems/ruby-lsp@0.26.4.rbi rename to sorbet/rbi/gems/ruby-lsp@0.26.5.rbi index eff785f71..b309c560a 100644 --- a/sorbet/rbi/gems/ruby-lsp@0.26.4.rbi +++ b/sorbet/rbi/gems/ruby-lsp@0.26.5.rbi @@ -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) From dd95f85b8501b44d49e53240eb5f88e0aa02a1d7 Mon Sep 17 00:00:00 2001 From: Stan Lo Date: Fri, 30 Jan 2026 19:24:57 +0000 Subject: [PATCH 3/3] Pin bundler to 4.0.3 --- .github/workflows/ci.yml | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 5cbc67acd..562a4030c 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -41,7 +41,7 @@ jobs: strategy: fail-fast: false matrix: - ruby: ["3.2", "3.3", "3.4", "4.0","head"] + ruby: ["3.2", "3.3", "3.4", "head"] rails: ["8.0", "current", "main"] rubygems: ["3.6.2"] exclude: @@ -52,6 +52,20 @@ jobs: experimental: true - ruby: "head" experimental: true + # Pin Bundler 4.0.3 for Ruby 4.0 due to regression in 4.0.5 + # See: https://github.com/ruby/rubygems/issues/9258 + - ruby: "4.0" + rails: "8.0" + rubygems: "3.6.2" + bundler: "4.0.3" + - ruby: "4.0" + rails: "current" + rubygems: "3.6.2" + bundler: "4.0.3" + - ruby: "4.0" + rails: "main" + rubygems: "3.6.2" + bundler: "4.0.3" name: Ruby ${{ matrix.ruby }} - Rails ${{ matrix.rails }} - RubyGems ${{ matrix.rubygems }} env: RAILS_VERSION: ${{ matrix.rails }} @@ -72,6 +86,7 @@ jobs: ruby-version: ${{ matrix.ruby }} bundler-cache: true rubygems: ${{ matrix.rubygems }} + bundler: ${{ matrix.bundler }} - name: Run tests run: bin/test continue-on-error: ${{ !!matrix.experimental }}