From 4b25cd1d22f9a558385ca9a2ff880bdaa28b43f9 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 10 Aug 2026 21:44:58 +0000 Subject: [PATCH 1/2] Bump the minor-and-patch group with 6 updates Bumps the minor-and-patch group with 6 updates: | Package | From | To | | --- | --- | --- | | [rubocop-shopify](https://github.com/Shopify/ruby-style-guide) | `3.0.1` | `3.0.2` | | [rubocop-sorbet](https://github.com/shopify/rubocop-sorbet) | `0.13.2` | `0.14.0` | | [dalli](https://github.com/petergoldstein/dalli) | `5.0.5` | `5.0.6` | | [sorbet-static](https://github.com/sorbet/sorbet) | `0.6.13386` | `0.6.13414` | | [sorbet-static-and-runtime](https://github.com/sorbet/sorbet) | `0.6.13386` | `0.6.13414` | | [rbi](https://github.com/Shopify/rbi) | `0.4.2` | `0.4.3` | Updates `rubocop-shopify` from 3.0.1 to 3.0.2 - [Release notes](https://github.com/Shopify/ruby-style-guide/releases) - [Commits](https://github.com/Shopify/ruby-style-guide/compare/v3.0.1...v3.0.2) Updates `rubocop-sorbet` from 0.13.2 to 0.14.0 - [Release notes](https://github.com/shopify/rubocop-sorbet/releases) - [Commits](https://github.com/shopify/rubocop-sorbet/compare/v0.13.2...v0.14.0) Updates `dalli` from 5.0.5 to 5.0.6 - [Release notes](https://github.com/petergoldstein/dalli/releases) - [Changelog](https://github.com/petergoldstein/dalli/blob/main/CHANGELOG.md) - [Commits](https://github.com/petergoldstein/dalli/compare/v5.0.5...v5.0.6) Updates `sorbet-static` from 0.6.13386 to 0.6.13414 - [Release notes](https://github.com/sorbet/sorbet/releases) - [Commits](https://github.com/sorbet/sorbet/commits) Updates `sorbet-static-and-runtime` from 0.6.13386 to 0.6.13414 - [Release notes](https://github.com/sorbet/sorbet/releases) - [Commits](https://github.com/sorbet/sorbet/commits) Updates `rbi` from 0.4.2 to 0.4.3 - [Release notes](https://github.com/Shopify/rbi/releases) - [Commits](https://github.com/Shopify/rbi/compare/v0.4.2...v0.4.3) --- updated-dependencies: - dependency-name: rubocop-shopify dependency-version: 3.0.2 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: minor-and-patch - dependency-name: rubocop-sorbet dependency-version: 0.14.0 dependency-type: direct:production update-type: version-update:semver-minor dependency-group: minor-and-patch - dependency-name: dalli dependency-version: 5.0.6 dependency-type: direct:development update-type: version-update:semver-patch dependency-group: minor-and-patch - dependency-name: sorbet-static dependency-version: 0.6.13414 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.13414 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: minor-and-patch - dependency-name: rbi dependency-version: 0.4.3 dependency-type: direct:production update-type: version-update:semver-patch dependency-group: minor-and-patch ... Signed-off-by: dependabot[bot] --- Gemfile.lock | 54 ++++++++++++++++++++++++++-------------------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/Gemfile.lock b/Gemfile.lock index 34c121530..c368ec6c2 100644 --- a/Gemfile.lock +++ b/Gemfile.lock @@ -137,7 +137,7 @@ GEM bigdecimal rexml crass (1.0.7) - dalli (5.0.5) + dalli (5.0.6) logger date (3.5.1) debug (1.11.1) @@ -307,10 +307,10 @@ GEM zeitwerk (~> 2.6) rainbow (3.1.1) rake (13.4.2) - rbi (0.4.2) + rbi (0.4.3) prism (~> 1.0) rbs (>= 4.0.1) - rbs (4.1.2) + rbs (4.1.3) logger prism (>= 1.6.0) tsort @@ -327,7 +327,7 @@ GEM io-console (~> 0.5) require-hooks (0.4.1) rexml (3.4.4) - rubocop (1.88.2) + rubocop (1.89.0) json (~> 2.3) language_server-protocol (~> 3.17.0.2) lint_roller (~> 1.1.0) @@ -345,10 +345,10 @@ GEM lint_roller (~> 1.1) regexp_parser (>= 2.0) rubocop (~> 1.86, >= 1.86.2) - rubocop-shopify (3.0.1) + rubocop-shopify (3.0.2) lint_roller rubocop (~> 1.72, >= 1.72.1) - rubocop-sorbet (0.13.2) + rubocop-sorbet (0.14.0) lint_roller rubocop (>= 1.75.2) ruby-lsp (0.26.10) @@ -372,15 +372,15 @@ GEM rack (>= 3.2.0) redis-client (>= 0.29.0) smart_properties (1.17.0) - sorbet (0.6.13386) - sorbet-static (= 0.6.13386) - sorbet-runtime (0.6.13386) - sorbet-static (0.6.13386-aarch64-linux) - sorbet-static (0.6.13386-universal-darwin) - sorbet-static (0.6.13386-x86_64-linux) - sorbet-static-and-runtime (0.6.13386) - sorbet (= 0.6.13386) - sorbet-runtime (= 0.6.13386) + sorbet (0.6.13414) + sorbet-static (= 0.6.13414) + sorbet-runtime (0.6.13414) + sorbet-static (0.6.13414-aarch64-linux) + sorbet-static (0.6.13414-universal-darwin) + sorbet-static (0.6.13414-x86_64-linux) + sorbet-static-and-runtime (0.6.13414) + sorbet (= 0.6.13414) + sorbet-runtime (= 0.6.13414) spoom (1.8.7) erubi (>= 1.10.0) prism (>= 0.28.0) @@ -511,7 +511,7 @@ CHECKSUMS connection_pool (3.0.2) sha256=33fff5ba71a12d2aa26cb72b1db8bba2a1a01823559fb01d29eb74c286e62e0a crack (1.0.1) sha256=ff4a10390cd31d66440b7524eb1841874db86201d5b70032028553130b6d4c7e crass (1.0.7) sha256=94868719948664c89ddcaf0a37c65048413dfcb1c869470a5f7a7ceb5390b295 - dalli (5.0.5) sha256=5f51502200999278806654c846054856d6d0b5607cc1d14d06c617042f71e6f9 + dalli (5.0.6) sha256=01887253a3e788124b9e04e90b63dc54ea9ef69f981d6f5fa2a4debc9e62a456 date (3.5.1) sha256=750d06384d7b9c15d562c76291407d89e368dda4d4fff957eb94962d325a0dc0 debug (1.11.1) sha256=2e0b0ac6119f2207a6f8ac7d4a73ca8eb4e440f64da0a3136c30343146e952b6 deep_merge (1.2.2) sha256=83ced3a3d7f95f67de958d2ce41b1874e83c8d94fe2ddbff50c8b4b82323563a @@ -584,8 +584,8 @@ CHECKSUMS railties (8.1.3.1) sha256=2388a232579a00cefea4487de66c8553c3408c1300abdc6cf1799d86ffb04487 rainbow (3.1.1) sha256=039491aa3a89f42efa1d6dec2fc4e62ede96eb6acd95e52f1ad581182b79bc6a rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701 - rbi (0.4.2) sha256=f1da92e338a6d45f9c4c1465b27a878a007fa7a0307f38abd29e6ddcb9f155b9 - rbs (4.1.2) sha256=050eb1d8b508f1233bed929c0f2c7052302f7adf295230d9cb314e9024078f48 + rbi (0.4.3) sha256=cc090ae62c3246412b992954f54077d6046c9b04f1537a4d24bfae8714503eac + rbs (4.1.3) sha256=0c4474a9751cdc14364bfad0b3e53678323bbdc2c31683b0445932867dbab8c4 rdoc (7.2.0) sha256=8650f76cd4009c3b54955eb5d7e3a075c60a57276766ebf36f9085e8c9f23192 redis (5.4.0) sha256=798900d869418a9fc3977f916578375b45c38247a556b61d58cba6bb02f7d06b redis-client (0.29.0) sha256=0c65bf1f8f6dca22063ddb085c0bb2054feef6f03a84869f4161b18a9a15bea3 @@ -593,11 +593,11 @@ CHECKSUMS reline (0.6.3) sha256=1198b04973565b36ec0f11542ab3f5cfeeec34823f4e54cebde90968092b1835 require-hooks (0.4.1) sha256=3a4cd3ed0131b9ec5c2e68f64cb0c5ba56daec6fc363d56e8eef74816c374d7d rexml (3.4.4) sha256=19e0a2c3425dfbf2d4fc1189747bdb2f849b6c5e74180401b15734bc97b5d142 - rubocop (1.88.2) sha256=8def251c90cd955feb4daa3edc0ab56893250c4ce90ef81e6c80c03f9a939bbf + rubocop (1.89.0) sha256=4dee8e3ee9c45e474834efd9e8d6fd031e8331c8dacdff0de4ad65ae0a6faae7 rubocop-ast (1.50.0) sha256=b9ca88300da0803ee222ad20cdb30494c0a784eed06fdc35d254b06d662788db rubocop-rspec (3.10.2) sha256=0b3e2ecc592cd10ecbf0095bb58d1e357905276e069643523cc19eb7495f65e2 - rubocop-shopify (3.0.1) sha256=4adffa6313294bd9da2b0896ae44c5eb8e419336b2413de20c38b7691a7e6774 - rubocop-sorbet (0.13.2) sha256=7901e57b6b8e9e9b970d941dbdbb89f2c9de0183bfd2551460468f8aa9548655 + rubocop-shopify (3.0.2) sha256=c2479c2781550dabbbb5850880f42eb36e37527711f10de89c3d11eb0cb31361 + rubocop-sorbet (0.14.0) sha256=30899556c9d02ab291d8bb761bae1cc025de56f72d909286b6960c1620d67bda ruby-lsp (0.26.10) sha256=e67284af94423531f6b9a583350596421b5a6a4dd93083f1c2ba03da7c23bbed ruby-lsp-rails (0.4.8) sha256=f09d1f926d4063deeb2f3049311925c20dfe6c912371e3bcd04a265a865c44ae ruby-progressbar (1.13.0) sha256=80fc9c47a9b640d6834e0dc7b3c94c9df37f08cb072b7761e4a71e22cff29b33 @@ -609,12 +609,12 @@ CHECKSUMS shopify-money (4.1.1) sha256=523078e44bfde1920f8b3487ddf9144e0fb6af8cdf67e212bed02025c5c5f423 sidekiq (8.1.6) sha256=be20cd051124b1a16cf97ea9157137abbd30a515c16a5ae9312d2eadd045e40f smart_properties (1.17.0) sha256=f9323f8122e932341756ddec8e0ac9ec6e238408a7661508be99439ca6d6384b - sorbet (0.6.13386) sha256=8f9cb0771c0843f1f2610847bf38a976716459fbec87b040ba8897414a286aa3 - sorbet-runtime (0.6.13386) sha256=716aa0a47e75bba1167205d408d59b622db3648109854e9fd309fb901564df48 - sorbet-static (0.6.13386-aarch64-linux) sha256=ebe41ccfbe9659d318cf6c5e28cede1069d4141bdc2f6524d4ba4d7b18440519 - sorbet-static (0.6.13386-universal-darwin) sha256=1d3cfdfd1c57a6108b322fe5d2657da2b4021aa1fed413634762d9c44d4ffea4 - sorbet-static (0.6.13386-x86_64-linux) sha256=29123908d23ca2bfc135c94c2da698934c74e9fbf02d5855274dc91d71071a93 - sorbet-static-and-runtime (0.6.13386) sha256=ca4450fa2ef490fd17526eac9e0067fbf2c2b657b83637a9957135658e6b8207 + sorbet (0.6.13414) sha256=45e76f63d48a59e8ba47d4de17d21c2dee8dfe29d7673a1ea1f509bc225eb87a + sorbet-runtime (0.6.13414) sha256=b0c93dea1cafd776cb37f116df873b9c4ee28df55cab4e454fbe587fc1cc76e5 + sorbet-static (0.6.13414-aarch64-linux) sha256=13f705dffc4760f0b5c647430f1ffc8f4374d3ed5b8fd050cca45cdcbc7aec1e + sorbet-static (0.6.13414-universal-darwin) sha256=6e64c126e572449b0e79734acf497dd15f3756f57990d842c1d48c9ffbd1a2c0 + sorbet-static (0.6.13414-x86_64-linux) sha256=ee2e24fcfb208815af2c915e9c13cd58a573c8b5501df050c3bd521add861b5e + sorbet-static-and-runtime (0.6.13414) sha256=4ef7e6d69f57defd311d4d8ce5f291a9d0d65e9eec8227d352100113cab03de7 spoom (1.8.7) sha256=81960502cdf23aa991f015988aa5dd43325e23ae4318b8e00d541299cbdb70f6 sprockets (4.2.2) sha256=761e5a49f1c288704763f73139763564c845a8f856d52fba013458f8af1b59b1 sqlite3 (2.9.0-aarch64-linux-gnu) sha256=cfe1e0216f46d7483839719bf827129151e6c680317b99d7b8fc1597a3e13473 From 84d9d123cbe1bba9a80f414de569acf13a4cc74c Mon Sep 17 00:00:00 2001 From: Alexandre Terrasa Date: Tue, 11 Aug 2026 09:26:56 -0400 Subject: [PATCH 2/2] Update gem RBIs --- sorbet/rbi/gems/activesupport@8.1.3.1.rbi | 3 +- sorbet/rbi/gems/connection_pool@3.0.2.rbi | 1 - .../gems/{dalli@5.0.5.rbi => dalli@5.0.6.rbi} | 649 +-- .../rbi/gems/{rbi@0.4.2.rbi => rbi@0.4.3.rbi} | 903 ++-- .../rbi/gems/{rbs@4.1.2.rbi => rbs@4.1.3.rbi} | 0 sorbet/rbi/gems/redis-client@0.29.0.rbi | 1 - sorbet/rbi/gems/rubocop-shopify@3.0.1.rbi | 120 - sorbet/rbi/gems/rubocop-shopify@3.0.2.rbi | 207 + ...t@0.13.2.rbi => rubocop-sorbet@0.14.0.rbi} | 389 +- ...{rubocop@1.88.2.rbi => rubocop@1.89.0.rbi} | 4194 +++++++++++------ sorbet/rbi/gems/sqlite3@2.9.0.rbi | 1 - 11 files changed, 4225 insertions(+), 2243 deletions(-) rename sorbet/rbi/gems/{dalli@5.0.5.rbi => dalli@5.0.6.rbi} (84%) rename sorbet/rbi/gems/{rbi@0.4.2.rbi => rbi@0.4.3.rbi} (89%) rename sorbet/rbi/gems/{rbs@4.1.2.rbi => rbs@4.1.3.rbi} (100%) delete mode 100644 sorbet/rbi/gems/rubocop-shopify@3.0.1.rbi create mode 100644 sorbet/rbi/gems/rubocop-shopify@3.0.2.rbi rename sorbet/rbi/gems/{rubocop-sorbet@0.13.2.rbi => rubocop-sorbet@0.14.0.rbi} (89%) rename sorbet/rbi/gems/{rubocop@1.88.2.rbi => rubocop@1.89.0.rbi} (94%) diff --git a/sorbet/rbi/gems/activesupport@8.1.3.1.rbi b/sorbet/rbi/gems/activesupport@8.1.3.1.rbi index 4b03fa3e3..c851ce822 100644 --- a/sorbet/rbi/gems/activesupport@8.1.3.1.rbi +++ b/sorbet/rbi/gems/activesupport@8.1.3.1.rbi @@ -6083,7 +6083,7 @@ end # pkg:gem/activesupport#lib/active_support/core_ext/enumerable.rb:25 ActiveSupport::EnumerableCoreExt::SoleItemExpectedError = Enumerable::SoleItemExpectedError -# pkg:gem/activesupport#lib/active_support/environment_inquirer.rb:7 +# pkg:gem/activesupport#lib/active_support/environment_inquirer.rb:9 class ActiveSupport::EnvironmentInquirer < ::ActiveSupport::StringInquirer # pkg:gem/activesupport#lib/active_support/environment_inquirer.rb:15 def initialize(env); end @@ -19869,7 +19869,6 @@ end module Process extend ::SQLite3::ForkSafety::CoreExt - extend ::Dalli::PIDCache::CoreExt extend ::ConnectionPool::ForkTracker extend ::RedisClient::PIDCache::CoreExt extend ::ActiveSupport::ForkTracker::CoreExt diff --git a/sorbet/rbi/gems/connection_pool@3.0.2.rbi b/sorbet/rbi/gems/connection_pool@3.0.2.rbi index 6128cf53a..f56c21b1e 100644 --- a/sorbet/rbi/gems/connection_pool@3.0.2.rbi +++ b/sorbet/rbi/gems/connection_pool@3.0.2.rbi @@ -336,7 +336,6 @@ ConnectionPool::Wrapper::METHODS = T.let(T.unsafe(nil), Array) module Process extend ::SQLite3::ForkSafety::CoreExt - extend ::Dalli::PIDCache::CoreExt extend ::ConnectionPool::ForkTracker extend ::RedisClient::PIDCache::CoreExt extend ::ActiveSupport::ForkTracker::CoreExt diff --git a/sorbet/rbi/gems/dalli@5.0.5.rbi b/sorbet/rbi/gems/dalli@5.0.6.rbi similarity index 84% rename from sorbet/rbi/gems/dalli@5.0.5.rbi rename to sorbet/rbi/gems/dalli@5.0.6.rbi index c890d47fd..bf8f9551f 100644 --- a/sorbet/rbi/gems/dalli@5.0.5.rbi +++ b/sorbet/rbi/gems/dalli@5.0.6.rbi @@ -82,16 +82,16 @@ class Dalli::Client # Make sure memcache servers are alive, or raise an Dalli::RingError # - # pkg:gem/dalli#lib/dalli/client.rb:482 + # pkg:gem/dalli#lib/dalli/client.rb:485 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:386 + # pkg:gem/dalli#lib/dalli/client.rb:389 def append(key, value); end - # pkg:gem/dalli#lib/dalli/client.rb:501 + # pkg:gem/dalli#lib/dalli/client.rb:504 def cache_nils; end # compare and swap values using optimistic locking. @@ -121,7 +121,7 @@ class Dalli::Client # 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:489 + # pkg:gem/dalli#lib/dalli/client.rb:492 def close; end # Decr subtracts the given amount from the counter on the memcached server. @@ -140,7 +140,7 @@ class Dalli::Client # # If the value already exists, it must have been set with raw: true # - # pkg:gem/dalli#lib/dalli/client.rb:432 + # pkg:gem/dalli#lib/dalli/client.rb:435 def decr(key, amt = T.unsafe(nil), ttl = T.unsafe(nil), default = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/client.rb:357 @@ -157,12 +157,15 @@ class Dalli::Client # it batches requests by server and uses quiet mode. # # @param keys [Array] keys to delete - # @return [void] + # @return [Integer] the number of keys that were found and deleted. This is + # best-effort: on a network error the operation is retried, and keys + # deleted before the error are not recounted, so the result may + # under-report the number actually removed when a failure occurs. # # Example: # client.delete_multi(['key1', 'key2', 'key3']) # - # pkg:gem/dalli#lib/dalli/client.rb:371 + # pkg:gem/dalli#lib/dalli/client.rb:374 def delete_multi(keys); end # Fetch the value associated with the key. @@ -212,10 +215,10 @@ class Dalli::Client # 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:442 + # pkg:gem/dalli#lib/dalli/client.rb:445 def flush(delay = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:445 + # pkg:gem/dalli#lib/dalli/client.rb:448 def flush_all(delay = T.unsafe(nil)); end # Gat (get and touch) fetch an item and simultaneously update its expiration time. @@ -296,19 +299,19 @@ class Dalli::Client # # If the value already exists, it must have been set with raw: true # - # pkg:gem/dalli#lib/dalli/client.rb:410 + # pkg:gem/dalli#lib/dalli/client.rb:413 def incr(key, amt = T.unsafe(nil), ttl = T.unsafe(nil), default = T.unsafe(nil)); end # pkg:gem/dalli#lib/dalli/client.rb:292 def multi; end - # pkg:gem/dalli#lib/dalli/client.rb:497 + # pkg:gem/dalli#lib/dalli/client.rb:500 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:393 + # pkg:gem/dalli#lib/dalli/client.rb:396 def prepend(key, value); end # Turn on quiet aka noreply support for a number of @@ -344,12 +347,12 @@ class Dalli::Client # pkg:gem/dalli#lib/dalli/client.rb:347 def replace_cas(key, value, cas, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:493 + # pkg:gem/dalli#lib/dalli/client.rb:496 def reset; end # Reset stats for each server. # - # pkg:gem/dalli#lib/dalli/client.rb:464 + # pkg:gem/dalli#lib/dalli/client.rb:467 def reset_stats; end # pkg:gem/dalli#lib/dalli/client.rb:294 @@ -380,7 +383,7 @@ class Dalli::Client # 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:453 + # pkg:gem/dalli#lib/dalli/client.rb:456 def stats(type = T.unsafe(nil)); end # Touch updates expiration time for a given key. @@ -392,41 +395,41 @@ class Dalli::Client # Version of the memcache servers. # - # pkg:gem/dalli#lib/dalli/client.rb:472 + # pkg:gem/dalli#lib/dalli/client.rb:475 def version; end # Stub method so a bare Dalli client can pretend to be a connection pool. # - # pkg:gem/dalli#lib/dalli/client.rb:506 + # pkg:gem/dalli#lib/dalli/client.rb:509 def with; end private - # pkg:gem/dalli#lib/dalli/client.rb:596 + # pkg:gem/dalli#lib/dalli/client.rb:606 def add_query_text(attrs, operation, key_or_keys); end - # pkg:gem/dalli#lib/dalli/client.rb:610 + # pkg:gem/dalli#lib/dalli/client.rb:620 def cas_core(key, always_set, ttl = T.unsafe(nil), req_options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/client.rb:606 + # pkg:gem/dalli#lib/dalli/client.rb:616 def check_positive!(amt); end - # pkg:gem/dalli#lib/dalli/client.rb:618 + # pkg:gem/dalli#lib/dalli/client.rb:628 def fetch_with_lock_request(key, ttl, lock_ttl, recache_threshold, req_options); end - # pkg:gem/dalli#lib/dalli/client.rb:579 + # pkg:gem/dalli#lib/dalli/client.rb:589 def get_multi_attributes(keys); end - # pkg:gem/dalli#lib/dalli/client.rb:531 + # pkg:gem/dalli#lib/dalli/client.rb:534 def get_multi_hash(keys); end - # pkg:gem/dalli#lib/dalli/client.rb:519 + # pkg:gem/dalli#lib/dalli/client.rb:522 def get_multi_yielding(keys); end - # pkg:gem/dalli#lib/dalli/client.rb:590 + # pkg:gem/dalli#lib/dalli/client.rb:600 def multi_trace_attrs(operation, key_count, keys); end - # pkg:gem/dalli#lib/dalli/client.rb:671 + # pkg:gem/dalli#lib/dalli/client.rb:687 def normalize_options(opts); end # Chokepoint method for memcached methods with a key argument. @@ -438,56 +441,56 @@ class Dalli::Client # a particular memcached instance becomes unreachable, or the # operation times out. # - # pkg:gem/dalli#lib/dalli/client.rb:654 - def perform(op, key, *args); end + # pkg:gem/dalli#lib/dalli/client.rb:664 + def perform(op, key, *_arg2, **_arg3, &_arg4); end - # pkg:gem/dalli#lib/dalli/client.rb:701 + # pkg:gem/dalli#lib/dalli/client.rb:717 def pipelined_deleter; end - # pkg:gem/dalli#lib/dalli/client.rb:693 + # pkg:gem/dalli#lib/dalli/client.rb:709 def pipelined_getter; end - # pkg:gem/dalli#lib/dalli/client.rb:697 + # pkg:gem/dalli#lib/dalli/client.rb:713 def pipelined_setter; end - # pkg:gem/dalli#lib/dalli/client.rb:512 + # pkg:gem/dalli#lib/dalli/client.rb:515 def record_hit_miss_metrics(span, key_count, hit_count); end - # pkg:gem/dalli#lib/dalli/client.rb:639 + # pkg:gem/dalli#lib/dalli/client.rb:649 def ring; end - # pkg:gem/dalli#lib/dalli/client.rb:545 + # pkg:gem/dalli#lib/dalli/client.rb:548 def single_server; end - # pkg:gem/dalli#lib/dalli/client.rb:570 + # pkg:gem/dalli#lib/dalli/client.rb:573 def single_server_delete_multi(keys); end - # pkg:gem/dalli#lib/dalli/client.rb:550 + # pkg:gem/dalli#lib/dalli/client.rb:553 def single_server_get_multi(keys); end - # pkg:gem/dalli#lib/dalli/client.rb:561 + # pkg:gem/dalli#lib/dalli/client.rb:564 def single_server_set_multi(hash, ttl, req_options); end - # pkg:gem/dalli#lib/dalli/client.rb:583 + # pkg:gem/dalli#lib/dalli/client.rb:593 def trace_attrs(operation, key, server); end # Uses the argument TTL or the client-wide default. Ensures # that the value is an integer # - # pkg:gem/dalli#lib/dalli/client.rb:633 + # pkg:gem/dalli#lib/dalli/client.rb:643 def ttl_or_default(ttl); end - # pkg:gem/dalli#lib/dalli/client.rb:685 + # pkg:gem/dalli#lib/dalli/client.rb:701 def warn_removed_options(opts); end end -# pkg:gem/dalli#lib/dalli/client.rb:447 +# pkg:gem/dalli#lib/dalli/client.rb:450 Dalli::Client::ALLOWED_STAT_KEYS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/client.rb:495 +# pkg:gem/dalli#lib/dalli/client.rb:498 Dalli::Client::CACHE_NILS = T.let(T.unsafe(nil), Hash) -# pkg:gem/dalli#lib/dalli/client.rb:678 +# pkg:gem/dalli#lib/dalli/client.rb:694 Dalli::Client::REMOVED_OPTIONS = T.let(T.unsafe(nil), Hash) # Default compressor used by Dalli, that uses @@ -809,27 +812,6 @@ class Dalli::NilObject; end # pkg:gem/dalli#lib/dalli.rb:26 class Dalli::NotPermittedMultiOpError < ::Dalli::DalliError; end -# Dalli::PIDCache is a wrapper class for PID checking to avoid system calls when checking the PID. -# -# pkg:gem/dalli#lib/dalli/pid_cache.rb:7 -module Dalli::PIDCache - class << self - # pkg:gem/dalli#lib/dalli/pid_cache.rb:13 - def pid; end - - # pkg:gem/dalli#lib/dalli/pid_cache.rb:15 - def update!; end - end -end - -# Dalli::PIDCache::CoreExt hooks into Process to be able to reset the PID cache after fork -# -# pkg:gem/dalli#lib/dalli/pid_cache.rb:24 -module Dalli::PIDCache::CoreExt - # pkg:gem/dalli#lib/dalli/pid_cache.rb:25 - 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. @@ -842,28 +824,32 @@ class Dalli::PipelinedDeleter # Deletes multiple keys from memcached. # # @param keys [Array] keys to delete - # @return [void] + # @return [Integer] the number of keys that were deleted. This is + # best-effort: on a network error the operation is retried, and keys + # deleted before the error are not recounted, so the result may + # under-report the number actually removed when a failure occurs. # - # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:21 + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:24 def process(keys); end private # Sends noop to each server to flush responses and ensure all deletes complete. + # Returns the total successful deletes across servers. # - # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:60 - def finish_requests(servers); end + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:66 + def finish_requests(groups); end - # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:69 + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:76 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 + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:49 def make_delete_requests(groups); end - # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:36 + # pkg:gem/dalli#lib/dalli/pipelined_deleter.rb:39 def setup_requests(keys); end end @@ -1003,7 +989,7 @@ class Dalli::Protocol::Base # Boolean method used by clients of this class to determine if this # particular memcached instance is available for use. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:65 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:79 def alive?; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1030,10 +1016,10 @@ class Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def hostname(*_arg0, **_arg1, &_arg2); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:73 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:87 def lock!; end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:159 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:172 def multi?; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1051,12 +1037,12 @@ class Dalli::Protocol::Base # # Returns nothing. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:139 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:152 def pipeline_abort; end # Did the last call to #pipeline_response_setup complete successfully? # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:152 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:165 def pipeline_complete?; end # Attempt to receive and parse as many key/value pairs as possible @@ -1068,7 +1054,7 @@ class Dalli::Protocol::Base # avoiding intermediate Hash allocation. Returns nil. # Without a block, returns a Hash of { key => [value, cas] }. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:99 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:112 def pipeline_next_responses(&block); end # Start reading key/value pairs from this connection. This is usually called @@ -1077,13 +1063,13 @@ class Dalli::Protocol::Base # # Returns nothing. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:82 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:96 def pipeline_response_setup; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def port(*_arg0, **_arg1, &_arg2); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:156 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:169 def quiet?; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1115,7 +1101,7 @@ class Dalli::Protocol::Base # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 def socket_type(*_arg0, **_arg1, &_arg2); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:75 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:89 def unlock!; end # pkg:gem/dalli#lib/dalli/protocol/base.rb:20 @@ -1132,17 +1118,17 @@ class Dalli::Protocol::Base private - # pkg:gem/dalli#lib/dalli/protocol/base.rb:221 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:234 def cache_nils?(opts); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:227 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:240 def connect; end # Non-blocking read and processing of any available pipeline responses. # Used during interleaved pipelined gets to prevent buffer deadlock. # Populates the provided results hash directly to avoid allocation overhead. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:271 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:284 def drain_pipeline_responses(results); end # The socket connection to the underlying server is initialized as a side @@ -1155,196 +1141,221 @@ class Dalli::Protocol::Base # Since this is invoked exclusively in verify_state!, we don't need to worry about # thread safety. Using it elsewhere may require revisiting that assumption. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:213 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:226 def ensure_connected!; end # Called after the noop response is received at the end of a set # of pipelined gets # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:298 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:311 def finish_pipeline; end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:309 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:322 def log_marshal_err(key, err); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:314 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:327 def log_unexpected_err(err); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:233 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:246 def pipelined_get(keys); end # For large batches, interleave writing requests with draining responses. # This prevents socket buffer deadlock when sending many keys. # Populates the provided results hash with any responses drained during send. # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:250 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:263 def pipelined_get_interleaved(keys, chunk_size, results); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:305 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:318 def reconnect_on_pipeline_complete!; end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:292 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:305 def response_buffer; end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:178 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:191 def verify_allowed_quiet!(opkey); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:199 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:212 def verify_pipelined_state(_opkey); end # Checks to see if we can execute the specified operation. Checks # whether the connection is in use, and whether the command is allowed # - # pkg:gem/dalli#lib/dalli/protocol/base.rb:188 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:201 def verify_state(opkey); end - # pkg:gem/dalli#lib/dalli/protocol/base.rb:169 + # pkg:gem/dalli#lib/dalli/protocol/base.rb:182 def warn_uri_credentials(user_creds); end end -# pkg:gem/dalli#lib/dalli/protocol/base.rb:175 +# pkg:gem/dalli#lib/dalli/protocol/base.rb:188 Dalli::Protocol::Base::ALLOWED_QUIET_OPS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/base.rb:165 +# pkg:gem/dalli#lib/dalli/protocol/base.rb:178 Dalli::Protocol::Base::URI_CREDENTIAL_WARNING = T.let(T.unsafe(nil), String) +# Compact the buffer when the consumed portion exceeds this +# threshold and represents more than half the buffer +# +# pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:10 +Dalli::Protocol::COMPACT_THRESHOLD = T.let(T.unsafe(nil), Integer) + # Manages the socket connection to the server, including ensuring liveness # and retries. # -# pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:15 +# pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:13 class Dalli::Protocol::ConnectionManager - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:32 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:30 def initialize(hostname, port, socket_type, client_options); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:146 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:150 def abort_request!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:113 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:111 def close; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:107 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:105 def confirm_in_progress!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:102 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:100 def confirm_ready!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:126 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:130 def connected?; end # Marks the server instance as down. Updates the down_at state # and raises an Dalli::NetworkError that includes the underlying # error in the message. Calls close to clean up socket state # - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:85 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:83 def down!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:204 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:212 def error_on_request!(err_or_string); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:52 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:50 def establish_connection; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:140 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:144 def finish_request!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:180 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:188 def flush; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:186 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:194 def flushed_write(bytes); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:254 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:262 def fork_detected?; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def hostname; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def hostname=(_arg0); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:258 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:266 def log_down_detected; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:270 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:278 def log_up_detected; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:239 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:247 def log_warn_message(err_or_string); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:200 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:208 def max_allowed_failures; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:231 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:239 def memcached_socket; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:44 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:42 def name; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def options; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def options=(_arg0); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def port; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def port=(_arg0); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:94 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:92 def raise_down_error; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:167 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:171 def read(count); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:150 - def read_line; end - # Non-blocking read. Here to support the operation # of the get_multi operation # - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:196 - def read_nonblock; end + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:204 + def read_available(*_arg0, **_arg1, &_arg2); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:217 + # Alias for callers that want to make the exact-length contract explicit + # at the call site. + # + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:180 + def read_exact(count); end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:154 + def read_line; end + + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:225 def reconnect!(message); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:64 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:62 def reconnect_down_server?; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:246 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:254 def reconnect_on_fork; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:130 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:134 def request_in_progress?; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:223 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:231 def reset_down_info; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:30 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:28 def sock; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:98 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:96 def socket_timeout; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def socket_type; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:29 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:27 def socket_type=(_arg0); end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:134 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:138 def start_request!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:77 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:75 def up!; end - # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:174 + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:182 def write(bytes); end + + private + + # Reads exactly `count` bytes. IO#read(count) on a blocking socket blocks + # until it has `count` bytes, accumulating across TCP chunks internally, + # and only hands back a shorter (or nil) buffer when the stream hits EOF. + # So a short read means the peer closed mid-response: raise EOFError and + # let read's existing `rescue EOFError` route it through + # error_on_request!, which closes the dirty socket for a retry on a fresh + # connection (and preserves the $ERROR_INFO context down! relies on). + # + # pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:294 + def read_bytes(count); end end -# pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:16 +# pkg:gem/dalli#lib/dalli/protocol/connection_manager.rb:14 Dalli::Protocol::ConnectionManager::DEFAULTS = T.let(T.unsafe(nil), Hash) # Access point for a single Memcached server, accessed via Memcached's meta @@ -1358,35 +1369,35 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base private - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:133 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:125 def add(key, value, ttl, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:156 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:146 def append(key, value); end # TODO: This is confusing, as there's a cas command in memcached # and this isn't it. Maybe rename? Maybe eliminate? # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:61 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:56 def cas(key); end # Arithmetic Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:196 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:187 def decr(key, count, ttl, initial); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:204 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:195 def decr_incr(incr, key, delta, ttl, initial); end # Delete Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:178 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:167 def delete(key, cas); end # Single-server fast path for delete_multi. Writes all quiet delete requests # terminated by a noop, then consumes all responses. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:321 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:288 def delete_multi_req(keys); end # Delete with stale invalidation instead of actual deletion. @@ -1397,15 +1408,18 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # @param cas [Integer] optional CAS value for compare-and-swap # @return [Boolean] true if successful # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:114 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:107 def delete_stale(key, cas = T.unsafe(nil)); end + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:181 + def finish_pipelined_delete(sent); end + # Other Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:214 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:204 def flush(delay = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:42 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:39 def gat(key, ttl, options = T.unsafe(nil)); end # Retrieval Commands @@ -1413,7 +1427,7 @@ 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:200 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:191 def incr(key, count, ttl, initial); end # Comprehensive meta get with support for all metadata flags. @@ -1441,79 +1455,79 @@ class Dalli::Protocol::Meta < ::Dalli::Protocol::Base # - :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:92 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:86 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:222 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:212 def noop; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:284 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:260 def parse_multi_get_value(line, key_index, is_raw); end # Pipelined delete - writes a quiet delete request without reading response. # Used by PipelinedDeleter for bulk operations. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:189 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:176 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:129 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:121 def pipelined_set(key, value, ttl, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:161 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:151 def prepend(key, value); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:35 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:34 def quiet_get_request(key); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:271 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:247 def read_multi_get_responses(is_raw); end # Single-server fast path for get_multi. Inlines request formatting and # response parsing to minimize per-key overhead. Avoids the PipelinedGetter # machinery (IO.select, response buffering, server grouping). # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:249 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:239 def read_multi_req(keys); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:138 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:130 def replace(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:232 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:222 def reset_stats; end # Storage Commands # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:122 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:114 def set(key, value, ttl, cas, options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:227 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:217 def stats(info = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:51 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:47 def touch(key, ttl); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:237 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:227 def version; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:167 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:157 def write_append_prepend_req(mode, key, value, ttl = T.unsafe(nil), cas = T.unsafe(nil), _options = T.unsafe(nil)); end # Single-server fast path for set_multi. Inlines request formatting to # minimize per-key overhead. Avoids PipelinedSetter server grouping. # - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:299 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:274 def write_multi_req(pairs, ttl, req_options); end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:242 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:232 def write_noop; end - # pkg:gem/dalli#lib/dalli/protocol/meta.rb:144 + # pkg:gem/dalli#lib/dalli/protocol/meta.rb:135 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 @@ -1524,93 +1538,118 @@ end # whitespace or non-ASCII characters, provided the 'b' flag is included in the request. # # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:12 -class Dalli::Protocol::Meta::KeyRegularizer +module Dalli::Protocol::Meta::KeyRegularizer + private + + # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:23 + def decode(encoded_key); end + + # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:19 + def encode(key); end + + # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:15 + def required?(key); end + class << self - # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:22 - def decode(encoded_key, base64_encoded); end + # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:23 + def decode(encoded_key); end - # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:15 + # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:19 def encode(key); end + + # pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:15 + def required?(key); end end end -# pkg:gem/dalli#lib/dalli/protocol/key_regularizer.rb:13 -Dalli::Protocol::Meta::KeyRegularizer::WHITESPACE = T.let(T.unsafe(nil), Regexp) - # Class that encapsulates logic for formatting meta protocol requests # to memcached. # # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:10 -class Dalli::Protocol::Meta::RequestFormatter - class << self - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:140 - def cas_string(cas); end +module Dalli::Protocol::Meta::RequestFormatter + extend ::Dalli::Protocol::Meta::RequestFormatter - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:108 - def flush(delay: T.unsafe(nil), quiet: T.unsafe(nil)); end + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:162 + def encoded_key(key); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:83 - 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/request_formatter.rb:145 + def flush(delay: 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/request_formatter.rb:73 - 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 + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:121 + def meta_arithmetic(key:, delta:, initial:, incr: T.unsafe(nil), cas: T.unsafe(nil), ttl: T.unsafe(nil), quiet: 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. - # - # - # 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/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), skip_flags: 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/request_formatter.rb:104 + def meta_delete(key:, cas: T.unsafe(nil), ttl: T.unsafe(nil), quiet: T.unsafe(nil), stale: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:100 - def meta_noop; 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. + # + # + # 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/request_formatter.rb:37 + def meta_get(key:, value: T.unsafe(nil), return_cas: T.unsafe(nil), ttl: 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), skip_flags: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:58 - 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/request_formatter.rb:137 + def meta_noop; end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:125 - def mode_to_token(mode); end + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:67 + def meta_set(key:, value:, bitflags: T.unsafe(nil), cas: T.unsafe(nil), ttl: T.unsafe(nil), mode: T.unsafe(nil), quiet: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:145 - def parse_to_64_bit_int(val, default); end + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:113 + def multi_meta_delete(keys); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:117 - def stats(arg = T.unsafe(nil)); end + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:56 + def multi_meta_get(keys, skip_flags: T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:104 - def version; end - end + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:83 + def multi_meta_set(entries, ttl: T.unsafe(nil)); end + + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:154 + def stats(arg = T.unsafe(nil)); end + + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:141 + def version; end + + private + + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:187 + def cas_string(cas); end + + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:172 + def mode_to_token(mode); end + + # pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:192 + def parse_to_64_bit_int(val, default); end end -# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:115 +# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:152 Dalli::Protocol::Meta::RequestFormatter::ALLOWED_STATS_ARGS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:99 +# pkg:gem/dalli#lib/dalli/protocol/request_formatter.rb:136 Dalli::Protocol::Meta::RequestFormatter::META_NOOP = T.let(T.unsafe(nil), String) # Class that encapsulates logic for processing meta protocol responses @@ -1622,16 +1661,16 @@ class Dalli::Protocol::Meta::ResponseProcessor # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:36 def initialize(io_source, value_marshaller); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:212 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:231 def bitflags_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:241 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:263 def body_len_from_tokens(tokens); end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:84 def build_metadata_result(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:216 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:235 def cas_from_tokens(tokens); end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:153 @@ -1640,13 +1679,13 @@ class Dalli::Protocol::Meta::ResponseProcessor # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:118 def decr_incr; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:202 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:221 def error_on_unexpected!(expected_codes); end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:136 def flush; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:160 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:177 def full_response_from_buffer(tokens, body, resp_size); end # This method returns an array of values used in a pipelined @@ -1658,22 +1697,22 @@ class Dalli::Protocol::Meta::ResponseProcessor # The remaining three values in the array are the ResponseHeader, # key, and value. # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:175 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:192 def getk_response_from_buffer(buf, offset = T.unsafe(nil)); end # 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/response_processor.rb:228 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:250 def hit_status_from_tokens(tokens); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:220 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:239 def key_from_tokens(tokens); end # Returns seconds since last access, or nil if not requested # The l flag returns l # - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:237 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:259 def last_access_from_tokens(tokens); end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:113 @@ -1709,16 +1748,27 @@ class Dalli::Protocol::Meta::ResponseProcessor # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:99 def meta_set_with_cas; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:256 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:282 def next_line_to_tokens; end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:92 def parse_value_from_tokens(tokens, cache_nils); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:261 + # Consumes the responses to a batch of quiet (pipelined) delete + # requests, which are terminated by a noop (MN). In quiet mode + # memcached suppresses the success response for each deleted key, so + # every line received before the terminator corresponds to a key that + # was NOT deleted -- a miss (NF) or an error. Returns that count so + # callers can derive the number of successful deletes as + # (keys_sent - non_deletions). + # + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:167 + def pipelined_delete_non_deletions; end + + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:287 def read_data(data_size); end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:252 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:278 def read_line; end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:142 @@ -1727,7 +1777,7 @@ class Dalli::Protocol::Meta::ResponseProcessor # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:126 def stats; end - # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:245 + # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:267 def value_from_tokens(tokens, flag); end # pkg:gem/dalli#lib/dalli/protocol/response_processor.rb:148 @@ -1812,30 +1862,30 @@ Dalli::Protocol::NOT_FOUND = T.let(T.unsafe(nil), Dalli::NilObject) # Uses an offset-based approach to avoid string allocations # when advancing through parsed responses. # -# pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:13 +# pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:17 class Dalli::Protocol::ResponseBuffer # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:18 def initialize(io_source, response_processor); end # Clear the internal response buffer # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:56 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:66 def clear; end # Ensures the buffer is initialized for reading without discarding # existing data. Used by interleaved pipelined get which may have # already buffered partial responses during the send phase. # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:48 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:58 def ensure_ready; end - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:61 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:72 def in_progress?; end # Attempts to process a single response from the buffer, # advancing the offset past the consumed bytes. # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:31 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:41 def process_single_getk_response; end # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:25 @@ -1844,25 +1894,10 @@ class Dalli::Protocol::ResponseBuffer # Resets the internal buffer to an empty state, # so that we're ready to read pipelined responses # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:40 + # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:49 def reset; end - - private - - # Only compact when we've consumed a significant portion of the buffer. - # This avoids per-response string allocation while preventing unbounded - # memory growth for large pipelines. - # - # pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:70 - def compact_if_needed; end end -# Compact the buffer when the consumed portion exceeds this -# threshold and represents more than half the buffer -# -# pkg:gem/dalli#lib/dalli/protocol/response_buffer.rb:16 -Dalli::Protocol::ResponseBuffer::COMPACT_THRESHOLD = T.let(T.unsafe(nil), Integer) - # SSL errors that occur during read/write operations (not during initial # handshake) should trigger reconnection. These indicate transient network # issues, not configuration problems. @@ -2309,76 +2344,64 @@ module Dalli::Socket; end # # pkg:gem/dalli#lib/dalli/socket.rb:14 module Dalli::Socket::InstanceMethods - # pkg:gem/dalli#lib/dalli/socket.rb:39 - def append_to_buffer?(result); end - - # pkg:gem/dalli#lib/dalli/socket.rb:54 + # pkg:gem/dalli#lib/dalli/socket.rb:44 def logged_options; end - # pkg:gem/dalli#lib/dalli/socket.rb:46 - def nonblock_timed_out?(result); end - - # pkg:gem/dalli#lib/dalli/socket.rb:25 - def read_available; end - # pkg:gem/dalli#lib/dalli/socket.rb:15 - def readfull(count); end + def read_available(reusable_buffer = T.unsafe(nil)); end end -# pkg:gem/dalli#lib/dalli/socket.rb:53 +# pkg:gem/dalli#lib/dalli/socket.rb:43 Dalli::Socket::InstanceMethods::FILTERED_OUT_OPTIONS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/socket.rb:37 -Dalli::Socket::InstanceMethods::WAIT_RCS = T.let(T.unsafe(nil), Array) - # Wraps the below TCP socket class in the case where the client # has configured a TLS/SSL connection between Dalli and the # Memcached server. # -# pkg:gem/dalli#lib/dalli/socket.rb:64 +# pkg:gem/dalli#lib/dalli/socket.rb:79 class Dalli::Socket::SSLSocket < ::OpenSSL::SSL::SSLSocket include ::Dalli::Socket::InstanceMethods - # pkg:gem/dalli#lib/dalli/socket.rb:67 + # pkg:gem/dalli#lib/dalli/socket.rb:82 def options; end end # A standard TCP socket between the Dalli client and the Memcached server. # -# pkg:gem/dalli#lib/dalli/socket.rb:87 +# pkg:gem/dalli#lib/dalli/socket.rb:102 class Dalli::Socket::TCP < ::TCPSocket include ::Dalli::Socket::InstanceMethods # options - supports enhanced logging in the case of a timeout # - # pkg:gem/dalli#lib/dalli/socket.rb:91 + # pkg:gem/dalli#lib/dalli/socket.rb:106 def options; end # options - supports enhanced logging in the case of a timeout # - # pkg:gem/dalli#lib/dalli/socket.rb:91 + # pkg:gem/dalli#lib/dalli/socket.rb:106 def options=(_arg0); end class << self - # pkg:gem/dalli#lib/dalli/socket.rb:148 + # pkg:gem/dalli#lib/dalli/socket.rb:163 def configure_socket_buffers(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:143 + # pkg:gem/dalli#lib/dalli/socket.rb:158 def configure_tcp_options(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:153 + # pkg:gem/dalli#lib/dalli/socket.rb:168 def configure_timeout(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:125 + # pkg:gem/dalli#lib/dalli/socket.rb:140 def create_socket_with_timeout(host, port, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:137 + # pkg:gem/dalli#lib/dalli/socket.rb:152 def init_socket_options(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:99 + # pkg:gem/dalli#lib/dalli/socket.rb:114 def open(host, port, options = T.unsafe(nil)); end - # pkg:gem/dalli#lib/dalli/socket.rb:189 + # pkg:gem/dalli#lib/dalli/socket.rb:204 def pack_timeval(sock, seconds, microseconds); end # Detect and cache whether TCPSocket supports the connect_timeout: keyword argument. @@ -2386,16 +2409,16 @@ class Dalli::Socket::TCP < ::TCPSocket # which forwards keyword arguments through its patch. # Returns false when monkey-patched by gems like socksify or resolv-replace < 0.2.0. # - # pkg:gem/dalli#lib/dalli/socket.rb:113 + # pkg:gem/dalli#lib/dalli/socket.rb:128 def supports_connect_timeout?; end # Detect and cache the correct pack format for struct timeval on this platform. # Different architectures have different sizes for time_t and suseconds_t. # - # pkg:gem/dalli#lib/dalli/socket.rb:181 + # pkg:gem/dalli#lib/dalli/socket.rb:196 def timeval_pack_format(sock); end - # pkg:gem/dalli#lib/dalli/socket.rb:193 + # pkg:gem/dalli#lib/dalli/socket.rb:208 def wrapping_ssl_socket(tcp_socket, host, ssl_context); end end end @@ -2404,7 +2427,7 @@ end # Used to detect when gems like socksify or resolv-replace have monkey-patched # TCPSocket, which breaks the connect_timeout: keyword argument. # -# pkg:gem/dalli#lib/dalli/socket.rb:96 +# pkg:gem/dalli#lib/dalli/socket.rb:111 Dalli::Socket::TCP::TCPSOCKET_NATIVE_PARAMETERS = T.let(T.unsafe(nil), Array) # Pack formats for struct timeval across architectures. @@ -2412,10 +2435,10 @@ Dalli::Socket::TCP::TCPSOCKET_NATIVE_PARAMETERS = T.let(T.unsafe(nil), Array) # - ll: 8 bytes (32-bit time_t, 32-bit suseconds_t) # - qq: 16 bytes (64-bit time_t, 64-bit suseconds_t or padded 32-bit) # -# pkg:gem/dalli#lib/dalli/socket.rb:175 +# pkg:gem/dalli#lib/dalli/socket.rb:190 Dalli::Socket::TCP::TIMEVAL_PACK_FORMATS = T.let(T.unsafe(nil), Array) -# pkg:gem/dalli#lib/dalli/socket.rb:176 +# pkg:gem/dalli#lib/dalli/socket.rb:191 Dalli::Socket::TCP::TIMEVAL_TEST_VALUES = T.let(T.unsafe(nil), Array) # UNIX domain sockets are not supported on Windows platforms. @@ -2425,27 +2448,27 @@ Dalli::Socket::TCP::TIMEVAL_TEST_VALUES = T.let(T.unsafe(nil), Array) # mechanism between processes on the same host. Used when the Memcached server # is running on the same machine as the Dalli client. # -# pkg:gem/dalli#lib/dalli/socket.rb:218 +# pkg:gem/dalli#lib/dalli/socket.rb:233 class Dalli::Socket::UNIX < ::UNIXSocket include ::Dalli::Socket::InstanceMethods # options - supports enhanced logging in the case of a timeout # server - used to support IO.select in the pipelined getter # - # pkg:gem/dalli#lib/dalli/socket.rb:223 + # pkg:gem/dalli#lib/dalli/socket.rb:238 def options; end # options - supports enhanced logging in the case of a timeout # server - used to support IO.select in the pipelined getter # - # pkg:gem/dalli#lib/dalli/socket.rb:223 + # pkg:gem/dalli#lib/dalli/socket.rb:238 def options=(_arg0); end class << self - # pkg:gem/dalli#lib/dalli/socket.rb:234 + # pkg:gem/dalli#lib/dalli/socket.rb:249 def init_socket_options(sock, options); end - # pkg:gem/dalli#lib/dalli/socket.rb:225 + # pkg:gem/dalli#lib/dalli/socket.rb:240 def open(path, options = T.unsafe(nil)); end end end @@ -2479,7 +2502,7 @@ module Dalli::Threadsafe def pipeline_response_setup; end # pkg:gem/dalli#lib/dalli/options.rb:16 - def request(opcode, *args); end + def request(*_arg0, **_arg1, &_arg2); end # pkg:gem/dalli#lib/dalli/options.rb:56 def unlock!; end @@ -2503,14 +2526,6 @@ Dalli::VERSION = T.let(T.unsafe(nil), String) # pkg:gem/dalli#lib/dalli.rb:23 class Dalli::ValueOverMaxSize < ::Dalli::DalliError; end -module Process - extend ::SQLite3::ForkSafety::CoreExt - extend ::Dalli::PIDCache::CoreExt - extend ::ConnectionPool::ForkTracker - extend ::RedisClient::PIDCache::CoreExt - extend ::ActiveSupport::ForkTracker::CoreExt -end - # pkg:gem/dalli#lib/rack/session/dalli.rb:8 module Rack; end diff --git a/sorbet/rbi/gems/rbi@0.4.2.rbi b/sorbet/rbi/gems/rbi@0.4.3.rbi similarity index 89% rename from sorbet/rbi/gems/rbi@0.4.2.rbi rename to sorbet/rbi/gems/rbi@0.4.3.rbi index 9bf57f083..66530354b 100644 --- a/sorbet/rbi/gems/rbi@0.4.2.rbi +++ b/sorbet/rbi/gems/rbi@0.4.3.rbi @@ -14,21 +14,21 @@ # pkg:gem/rbi#lib/rbi.rb:7 module RBI; end -# pkg:gem/rbi#lib/rbi/model.rb:978 +# pkg:gem/rbi#lib/rbi/model.rb:1011 class RBI::Arg < ::RBI::Node - # pkg:gem/rbi#lib/rbi/model.rb:983 + # pkg:gem/rbi#lib/rbi/model.rb:1016 sig { params(value: ::String, loc: T.nilable(::RBI::Loc)).void } def initialize(value, loc: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/model.rb:989 + # pkg:gem/rbi#lib/rbi/model.rb:1022 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:994 + # pkg:gem/rbi#lib/rbi/model.rb:1027 sig { returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:980 + # pkg:gem/rbi#lib/rbi/model.rb:1013 sig { returns(::String) } def value; end end @@ -165,7 +165,7 @@ class RBI::AttrAccessor < ::RBI::Attr # @override # - # pkg:gem/rbi#lib/rbi/rewriters/attr_to_methods.rb:130 + # pkg:gem/rbi#lib/rbi/rewriters/attr_to_methods.rb:131 sig { override.returns(T::Array[::RBI::Method]) } def convert_to_methods; end @@ -206,7 +206,7 @@ class RBI::AttrReader < ::RBI::Attr # @override # - # pkg:gem/rbi#lib/rbi/rewriters/attr_to_methods.rb:145 + # pkg:gem/rbi#lib/rbi/rewriters/attr_to_methods.rb:146 sig { override.returns(T::Array[::RBI::Method]) } def convert_to_methods; end @@ -247,7 +247,7 @@ class RBI::AttrWriter < ::RBI::Attr # @override # - # pkg:gem/rbi#lib/rbi/rewriters/attr_to_methods.rb:155 + # pkg:gem/rbi#lib/rbi/rewriters/attr_to_methods.rb:156 sig { override.returns(T::Array[::RBI::Method]) } def convert_to_methods; end @@ -273,9 +273,9 @@ class RBI::BlankLine < ::RBI::Comment def initialize(loc: T.unsafe(nil)); end end -# pkg:gem/rbi#lib/rbi/model.rb:810 +# pkg:gem/rbi#lib/rbi/model.rb:843 class RBI::BlockParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:816 + # pkg:gem/rbi#lib/rbi/model.rb:849 sig do params( name: T.nilable(::String), @@ -286,25 +286,25 @@ class RBI::BlockParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:835 + # pkg:gem/rbi#lib/rbi/model.rb:868 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:830 + # pkg:gem/rbi#lib/rbi/model.rb:863 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:813 + # pkg:gem/rbi#lib/rbi/model.rb:846 sig { override.returns(T.nilable(::String)) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:824 + # pkg:gem/rbi#lib/rbi/model.rb:857 sig { override.returns(::String) } def to_s; end end @@ -455,11 +455,11 @@ class RBI::DuplicateNodeError < ::RBI::Error; end # pkg:gem/rbi#lib/rbi.rb:8 class RBI::Error < ::StandardError; end -# pkg:gem/rbi#lib/rbi/model.rb:868 +# pkg:gem/rbi#lib/rbi/model.rb:901 class RBI::Extend < ::RBI::Mixin include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:870 + # pkg:gem/rbi#lib/rbi/model.rb:903 sig do params( name: ::String, @@ -485,7 +485,7 @@ class RBI::Extend < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/model.rb:877 + # pkg:gem/rbi#lib/rbi/model.rb:910 sig { override.returns(::String) } def to_s; end end @@ -522,7 +522,7 @@ class RBI::File sig { returns(T::Boolean) } def empty?; end - # pkg:gem/rbi#lib/rbi/printer.rb:859 + # pkg:gem/rbi#lib/rbi/printer.rb:866 sig do params( out: T.any(::IO, ::StringIO), @@ -533,11 +533,11 @@ class RBI::File end def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1246 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1218 sig { params(out: T.any(::IO, ::StringIO), indent: ::Integer, print_locs: T::Boolean).void } def rbs_print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1252 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1224 sig { params(indent: ::Integer, print_locs: T::Boolean).returns(::String) } def rbs_string(indent: T.unsafe(nil), print_locs: T.unsafe(nil)); end @@ -555,7 +555,7 @@ class RBI::File # pkg:gem/rbi#lib/rbi/model.rb:148 def strictness=(_arg0); end - # pkg:gem/rbi#lib/rbi/printer.rb:865 + # pkg:gem/rbi#lib/rbi/printer.rb:872 sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) } def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end end @@ -661,11 +661,11 @@ class RBI::GroupNodesError < ::RBI::Error; end # Sorbet's misc. # -# pkg:gem/rbi#lib/rbi/model.rb:1309 +# pkg:gem/rbi#lib/rbi/model.rb:1349 class RBI::Helper < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1314 + # pkg:gem/rbi#lib/rbi/model.rb:1354 sig do params( name: ::String, @@ -688,22 +688,22 @@ class RBI::Helper < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1311 + # pkg:gem/rbi#lib/rbi/model.rb:1351 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1322 + # pkg:gem/rbi#lib/rbi/model.rb:1362 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:854 +# pkg:gem/rbi#lib/rbi/model.rb:887 class RBI::Include < ::RBI::Mixin include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:856 + # pkg:gem/rbi#lib/rbi/model.rb:889 sig do params( name: ::String, @@ -729,7 +729,7 @@ class RBI::Include < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/model.rb:863 + # pkg:gem/rbi#lib/rbi/model.rb:896 sig { override.returns(::String) } def to_s; end end @@ -789,28 +789,28 @@ module RBI::Indexable def index_ids; end end -# pkg:gem/rbi#lib/rbi/model.rb:999 +# pkg:gem/rbi#lib/rbi/model.rb:1032 class RBI::KwArg < ::RBI::Arg - # pkg:gem/rbi#lib/rbi/model.rb:1004 + # pkg:gem/rbi#lib/rbi/model.rb:1037 sig { params(keyword: ::String, value: ::String, loc: T.nilable(::RBI::Loc)).void } def initialize(keyword, value, loc: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/model.rb:1010 + # pkg:gem/rbi#lib/rbi/model.rb:1043 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1001 + # pkg:gem/rbi#lib/rbi/model.rb:1034 sig { returns(::String) } def keyword; end - # pkg:gem/rbi#lib/rbi/model.rb:1015 + # pkg:gem/rbi#lib/rbi/model.rb:1048 sig { returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:746 +# pkg:gem/rbi#lib/rbi/model.rb:754 class RBI::KwOptParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:755 + # pkg:gem/rbi#lib/rbi/model.rb:763 sig do params( name: ::String, @@ -822,36 +822,36 @@ class RBI::KwOptParam < ::RBI::Param end def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:775 + # pkg:gem/rbi#lib/rbi/model.rb:783 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:770 + # pkg:gem/rbi#lib/rbi/model.rb:778 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:749 + # pkg:gem/rbi#lib/rbi/model.rb:757 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:764 + # pkg:gem/rbi#lib/rbi/model.rb:772 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:752 + # pkg:gem/rbi#lib/rbi/model.rb:760 sig { returns(::String) } def value; end end -# pkg:gem/rbi#lib/rbi/model.rb:716 +# pkg:gem/rbi#lib/rbi/model.rb:724 class RBI::KwParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:722 + # pkg:gem/rbi#lib/rbi/model.rb:730 sig do params( name: ::String, @@ -862,32 +862,32 @@ class RBI::KwParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:741 + # pkg:gem/rbi#lib/rbi/model.rb:749 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:736 + # pkg:gem/rbi#lib/rbi/model.rb:744 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:719 + # pkg:gem/rbi#lib/rbi/model.rb:727 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:730 + # pkg:gem/rbi#lib/rbi/model.rb:738 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:780 +# pkg:gem/rbi#lib/rbi/model.rb:788 class RBI::KwRestParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:786 + # pkg:gem/rbi#lib/rbi/model.rb:794 sig do params( name: T.nilable(::String), @@ -898,25 +898,25 @@ class RBI::KwRestParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:805 + # pkg:gem/rbi#lib/rbi/model.rb:813 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:800 + # pkg:gem/rbi#lib/rbi/model.rb:808 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:783 + # pkg:gem/rbi#lib/rbi/model.rb:791 sig { override.returns(T.nilable(::String)) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:794 + # pkg:gem/rbi#lib/rbi/model.rb:802 sig { override.returns(::String) } def to_s; end end @@ -1020,7 +1020,7 @@ class RBI::Method < ::RBI::NodeWithComments sig { params(param: ::RBI::Param).void } def <<(param); end - # pkg:gem/rbi#lib/rbi/model.rb:546 + # pkg:gem/rbi#lib/rbi/model.rb:551 sig { params(name: ::String).void } def add_block_param(name); end @@ -1036,6 +1036,10 @@ class RBI::Method < ::RBI::NodeWithComments sig { params(name: ::String).void } def add_kw_rest_param(name); end + # pkg:gem/rbi#lib/rbi/model.rb:546 + sig { void } + def add_no_kw_param; end + # pkg:gem/rbi#lib/rbi/model.rb:521 sig { params(name: ::String, default_value: ::String).void } def add_opt_param(name, default_value); end @@ -1048,11 +1052,12 @@ class RBI::Method < ::RBI::NodeWithComments sig { params(name: ::String).void } def add_rest_param(name); end - # pkg:gem/rbi#lib/rbi/model.rb:559 + # pkg:gem/rbi#lib/rbi/model.rb:565 sig do params( params: T.nilable(T::Array[::RBI::SigParam]), return_type: T.any(::RBI::Type, ::String), + bind_type: T.nilable(T.any(::RBI::Type, ::String)), is_abstract: T::Boolean, is_override: T::Boolean, is_overridable: T::Boolean, @@ -1062,7 +1067,7 @@ class RBI::Method < ::RBI::NodeWithComments block: T.nilable(T.proc.params(node: ::RBI::Sig).void) ).void end - def add_sig(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), &block); end + def add_sig(params: T.unsafe(nil), return_type: T.unsafe(nil), bind_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), &block); end # @override # @@ -1070,7 +1075,7 @@ class RBI::Method < ::RBI::NodeWithComments sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:585 + # pkg:gem/rbi#lib/rbi/model.rb:593 sig { returns(::String) } def fully_qualified_name; end @@ -1115,7 +1120,7 @@ class RBI::Method < ::RBI::NodeWithComments # @override # - # pkg:gem/rbi#lib/rbi/model.rb:595 + # pkg:gem/rbi#lib/rbi/model.rb:603 sig { override.returns(::String) } def to_s; end @@ -1141,11 +1146,11 @@ class RBI::Method < ::RBI::NodeWithComments def rename_sigs_params(sigs, params); end end -# pkg:gem/rbi#lib/rbi/model.rb:1353 +# pkg:gem/rbi#lib/rbi/model.rb:1393 class RBI::MixesInClassMethods < ::RBI::Mixin include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1360 + # pkg:gem/rbi#lib/rbi/model.rb:1400 sig do params( name: ::String, @@ -1171,18 +1176,18 @@ class RBI::MixesInClassMethods < ::RBI::Mixin # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1367 + # pkg:gem/rbi#lib/rbi/model.rb:1407 sig { override.returns(::String) } def to_s; end end # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:843 +# pkg:gem/rbi#lib/rbi/model.rb:876 class RBI::Mixin < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:848 + # pkg:gem/rbi#lib/rbi/model.rb:881 sig do params( name: ::String, @@ -1199,7 +1204,7 @@ class RBI::Mixin < ::RBI::NodeWithComments sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:845 + # pkg:gem/rbi#lib/rbi/model.rb:878 sig { returns(T::Array[::String]) } def names; end end @@ -1234,6 +1239,35 @@ class RBI::Module < ::RBI::Scope def name; end end +# pkg:gem/rbi#lib/rbi/model.rb:818 +class RBI::NoKwParam < ::RBI::Param + # pkg:gem/rbi#lib/rbi/model.rb:820 + sig do + params( + loc: T.nilable(::RBI::Loc), + comments: T.nilable(T::Array[::RBI::Comment]), + block: T.nilable(T.proc.params(node: ::RBI::NoKwParam).void) + ).void + end + def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + + # pkg:gem/rbi#lib/rbi/model.rb:838 + sig { params(other: T.nilable(::Object)).returns(T::Boolean) } + def ==(other); end + + # @override + # + # pkg:gem/rbi#lib/rbi/model.rb:833 + sig { override.returns(T::Boolean) } + def anonymous?; end + + # @override + # + # pkg:gem/rbi#lib/rbi/model.rb:827 + sig { override.returns(::String) } + def to_s; end +end + # @abstract # # pkg:gem/rbi#lib/rbi/model.rb:8 @@ -1282,7 +1316,7 @@ class RBI::Node # pkg:gem/rbi#lib/rbi/model.rb:10 def parent_tree=(_arg0); end - # pkg:gem/rbi#lib/rbi/printer.rb:877 + # pkg:gem/rbi#lib/rbi/printer.rb:884 sig do params( out: T.any(::IO, ::StringIO), @@ -1293,7 +1327,7 @@ class RBI::Node end def print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1261 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1233 sig do params( out: T.any(::IO, ::StringIO), @@ -1304,7 +1338,7 @@ class RBI::Node end def rbs_print(out: T.unsafe(nil), indent: T.unsafe(nil), print_locs: T.unsafe(nil), positional_names: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1267 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1239 sig { params(indent: ::Integer, print_locs: T::Boolean, positional_names: T::Boolean).returns(::String) } def rbs_string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), positional_names: T.unsafe(nil)); end @@ -1316,7 +1350,7 @@ class RBI::Node sig { params(version: ::Gem::Version).returns(T::Boolean) } def satisfies_version?(version); end - # pkg:gem/rbi#lib/rbi/printer.rb:883 + # pkg:gem/rbi#lib/rbi/printer.rb:890 sig { params(indent: ::Integer, print_locs: T::Boolean, max_line_length: T.nilable(::Integer)).returns(::String) } def string(indent: T.unsafe(nil), print_locs: T.unsafe(nil), max_line_length: T.unsafe(nil)); end end @@ -1361,9 +1395,9 @@ class RBI::NodeWithComments < ::RBI::Node def version_requirements; end end -# pkg:gem/rbi#lib/rbi/model.rb:652 +# pkg:gem/rbi#lib/rbi/model.rb:660 class RBI::OptParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:661 + # pkg:gem/rbi#lib/rbi/model.rb:669 sig do params( name: ::String, @@ -1375,46 +1409,46 @@ class RBI::OptParam < ::RBI::Param end def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:681 + # pkg:gem/rbi#lib/rbi/model.rb:689 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:676 + # pkg:gem/rbi#lib/rbi/model.rb:684 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:655 + # pkg:gem/rbi#lib/rbi/model.rb:663 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:670 + # pkg:gem/rbi#lib/rbi/model.rb:678 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:658 + # pkg:gem/rbi#lib/rbi/model.rb:666 sig { returns(::String) } def value; end end # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:601 +# pkg:gem/rbi#lib/rbi/model.rb:609 class RBI::Param < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:603 + # pkg:gem/rbi#lib/rbi/model.rb:611 sig { params(loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void } def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil)); end # @abstract # - # pkg:gem/rbi#lib/rbi/model.rb:617 + # pkg:gem/rbi#lib/rbi/model.rb:625 sig { abstract.returns(T::Boolean) } def anonymous?; end @@ -1424,7 +1458,7 @@ class RBI::Param < ::RBI::NodeWithComments sig { override.params(other: T.nilable(::RBI::Node)).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:608 + # pkg:gem/rbi#lib/rbi/model.rb:616 sig { returns(T.nilable(::String)) } def name; end end @@ -1475,127 +1509,131 @@ class RBI::Parser end end -# pkg:gem/rbi#lib/rbi/parser.rb:1013 +# pkg:gem/rbi#lib/rbi/parser.rb:1044 class RBI::Parser::HeredocLocationVisitor < ::Prism::Visitor - # pkg:gem/rbi#lib/rbi/parser.rb:1015 + # pkg:gem/rbi#lib/rbi/parser.rb:1046 sig { params(source: ::Prism::Source, begin_offset: ::Integer, end_offset: ::Integer).void } def initialize(source, begin_offset, end_offset); end - # pkg:gem/rbi#lib/rbi/parser.rb:1046 + # pkg:gem/rbi#lib/rbi/parser.rb:1077 sig { returns(::Prism::Location) } def location; end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:1036 + # pkg:gem/rbi#lib/rbi/parser.rb:1067 sig { override.params(node: ::Prism::InterpolatedStringNode).void } def visit_interpolated_string_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:1025 + # pkg:gem/rbi#lib/rbi/parser.rb:1056 sig { override.params(node: ::Prism::StringNode).void } def visit_string_node(node); end private - # pkg:gem/rbi#lib/rbi/parser.rb:1057 + # pkg:gem/rbi#lib/rbi/parser.rb:1088 sig { params(node: T.any(::Prism::InterpolatedStringNode, ::Prism::StringNode)).void } def handle_string_node(node); end end -# pkg:gem/rbi#lib/rbi/parser.rb:915 +# pkg:gem/rbi#lib/rbi/parser.rb:935 class RBI::Parser::SigBuilder < ::RBI::Parser::Visitor - # pkg:gem/rbi#lib/rbi/parser.rb:920 + # pkg:gem/rbi#lib/rbi/parser.rb:940 sig { params(content: ::String, file: ::String).void } def initialize(content, file:); end - # pkg:gem/rbi#lib/rbi/parser.rb:996 + # pkg:gem/rbi#lib/rbi/parser.rb:1027 sig { params(node: ::Prism::CallNode, value: ::String).returns(T::Boolean) } def allow_incompatible_override?(node, value); end - # pkg:gem/rbi#lib/rbi/parser.rb:917 + # pkg:gem/rbi#lib/rbi/parser.rb:937 sig { returns(::RBI::Sig) } def current; end - # pkg:gem/rbi#lib/rbi/parser.rb:986 + # pkg:gem/rbi#lib/rbi/parser.rb:1017 sig { params(node: ::Prism::Node).returns(::String) } def sig_param_name(node); end + # pkg:gem/rbi#lib/rbi/parser.rb:1006 + sig { params(node: ::Prism::CallNode).returns(T.nilable(::String)) } + def sig_type_argument(node); end + # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:978 + # pkg:gem/rbi#lib/rbi/parser.rb:998 sig { override.params(node: ::Prism::AssocNode).void } def visit_assoc_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:928 + # pkg:gem/rbi#lib/rbi/parser.rb:948 sig { override.params(node: ::Prism::CallNode).void } def visit_call_node(node); end end -# pkg:gem/rbi#lib/rbi/parser.rb:164 +# pkg:gem/rbi#lib/rbi/parser.rb:179 class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor - # pkg:gem/rbi#lib/rbi/parser.rb:172 + # pkg:gem/rbi#lib/rbi/parser.rb:187 sig { params(source: ::String, comments: T::Array[::Prism::Comment], file: ::String).void } def initialize(source, comments:, file:); end - # pkg:gem/rbi#lib/rbi/parser.rb:169 + # pkg:gem/rbi#lib/rbi/parser.rb:184 sig { returns(T.nilable(::Prism::Node)) } def last_node; end - # pkg:gem/rbi#lib/rbi/parser.rb:166 + # pkg:gem/rbi#lib/rbi/parser.rb:181 sig { returns(::RBI::Tree) } def tree; end - # pkg:gem/rbi#lib/rbi/parser.rb:361 + # pkg:gem/rbi#lib/rbi/parser.rb:376 sig { params(node: ::Prism::CallNode).void } def visit_call_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:185 + # pkg:gem/rbi#lib/rbi/parser.rb:200 sig { override.params(node: ::Prism::ClassNode).void } def visit_class_node(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:236 + # pkg:gem/rbi#lib/rbi/parser.rb:251 sig { params(node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode)).void } def visit_constant_assign(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:229 + # pkg:gem/rbi#lib/rbi/parser.rb:244 sig { override.params(node: ::Prism::ConstantPathWriteNode).void } def visit_constant_path_write_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:221 + # pkg:gem/rbi#lib/rbi/parser.rb:236 sig { override.params(node: ::Prism::ConstantWriteNode).void } def visit_constant_write_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:291 + # pkg:gem/rbi#lib/rbi/parser.rb:306 sig { override.params(node: ::Prism::DefNode).void } def visit_def_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:313 + # pkg:gem/rbi#lib/rbi/parser.rb:328 sig { override.params(node: ::Prism::ModuleNode).void } def visit_module_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:332 + # pkg:gem/rbi#lib/rbi/parser.rb:347 sig { override.params(node: ::Prism::ProgramNode).void } def visit_program_node(node); end # @override # - # pkg:gem/rbi#lib/rbi/parser.rb:344 + # pkg:gem/rbi#lib/rbi/parser.rb:359 sig { override.params(node: ::Prism::SingletonClassNode).void } def visit_singleton_class_node(node); end @@ -1603,49 +1641,49 @@ class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor # Collect all the remaining comments within a node # - # pkg:gem/rbi#lib/rbi/parser.rb:539 + # pkg:gem/rbi#lib/rbi/parser.rb:554 sig { params(node: ::Prism::Node).void } def collect_dangling_comments(node); end # Collect all the remaining comments after visiting the tree # - # pkg:gem/rbi#lib/rbi/parser.rb:557 + # pkg:gem/rbi#lib/rbi/parser.rb:572 sig { void } def collect_orphan_comments; end - # pkg:gem/rbi#lib/rbi/parser.rb:580 + # pkg:gem/rbi#lib/rbi/parser.rb:595 sig { returns(::RBI::Tree) } def current_scope; end - # pkg:gem/rbi#lib/rbi/parser.rb:585 + # pkg:gem/rbi#lib/rbi/parser.rb:600 sig { returns(T::Array[::RBI::Sig]) } def current_sigs; end - # pkg:gem/rbi#lib/rbi/parser.rb:592 + # pkg:gem/rbi#lib/rbi/parser.rb:607 sig { params(sigs: T::Array[::RBI::Sig]).returns(T::Array[::RBI::Comment]) } def detach_comments_from_sigs(sigs); end - # pkg:gem/rbi#lib/rbi/parser.rb:604 + # pkg:gem/rbi#lib/rbi/parser.rb:619 sig { params(node: ::Prism::Node).returns(T::Array[::RBI::Comment]) } def node_comments(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:666 + # pkg:gem/rbi#lib/rbi/parser.rb:681 sig { params(node: ::Prism::Comment).returns(::RBI::Comment) } def parse_comment(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:699 + # pkg:gem/rbi#lib/rbi/parser.rb:714 sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Param]) } def parse_params(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:673 + # pkg:gem/rbi#lib/rbi/parser.rb:688 sig { params(node: T.nilable(::Prism::Node)).returns(T::Array[::RBI::Arg]) } def parse_send_args(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:765 + # pkg:gem/rbi#lib/rbi/parser.rb:785 sig { params(node: ::Prism::CallNode).returns(::RBI::Sig) } def parse_sig(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:774 + # pkg:gem/rbi#lib/rbi/parser.rb:794 sig do params( node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode) @@ -1653,27 +1691,27 @@ class RBI::Parser::TreeBuilder < ::RBI::Parser::Visitor end def parse_struct(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:822 + # pkg:gem/rbi#lib/rbi/parser.rb:842 sig { params(send: ::Prism::CallNode).void } def parse_tstruct_field(send); end - # pkg:gem/rbi#lib/rbi/parser.rb:859 + # pkg:gem/rbi#lib/rbi/parser.rb:879 sig { params(name: ::String, node: ::Prism::Node).returns(::RBI::Visibility) } def parse_visibility(name, node); end - # pkg:gem/rbi#lib/rbi/parser.rb:873 + # pkg:gem/rbi#lib/rbi/parser.rb:893 sig { void } def separate_header_comments; end - # pkg:gem/rbi#lib/rbi/parser.rb:883 + # pkg:gem/rbi#lib/rbi/parser.rb:903 sig { void } def set_root_tree_loc; end - # pkg:gem/rbi#lib/rbi/parser.rb:902 + # pkg:gem/rbi#lib/rbi/parser.rb:922 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def t_enum_value?(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:897 + # pkg:gem/rbi#lib/rbi/parser.rb:917 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def type_variable_definition?(node); end end @@ -1686,10 +1724,14 @@ class RBI::Parser::Visitor < ::Prism::Visitor private - # pkg:gem/rbi#lib/rbi/parser.rb:143 + # pkg:gem/rbi#lib/rbi/parser.rb:158 sig { params(node: ::Prism::Node).returns(::Prism::Location) } def adjust_prism_location_for_heredoc(node); end + # pkg:gem/rbi#lib/rbi/parser.rb:149 + sig { params(node: ::Prism::Node).returns(T::Boolean) } + def braceless_shape?(node); end + # pkg:gem/rbi#lib/rbi/parser.rb:126 sig { params(node: ::Prism::Node).returns(::RBI::Loc) } def node_loc(node); end @@ -1702,13 +1744,17 @@ class RBI::Parser::Visitor < ::Prism::Visitor sig { params(node: ::Prism::Node).returns(::String) } def node_string!(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:154 + # pkg:gem/rbi#lib/rbi/parser.rb:169 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def self?(node); end - # pkg:gem/rbi#lib/rbi/parser.rb:159 + # pkg:gem/rbi#lib/rbi/parser.rb:174 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def t_sig_without_runtime?(node); end + + # pkg:gem/rbi#lib/rbi/parser.rb:143 + sig { params(node: ::Prism::Node).returns(::String) } + def type_string(node); end end # pkg:gem/rbi#lib/rbi/printer.rb:7 @@ -1799,41 +1845,41 @@ class RBI::Printer < ::RBI::Visitor private - # pkg:gem/rbi#lib/rbi/printer.rb:702 + # pkg:gem/rbi#lib/rbi/printer.rb:708 sig { params(node: ::RBI::Node).returns(T::Boolean) } def oneline?(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:670 + # pkg:gem/rbi#lib/rbi/printer.rb:676 sig { params(node: ::RBI::Node).void } def print_blank_line_before(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:680 + # pkg:gem/rbi#lib/rbi/printer.rb:686 sig { params(node: ::RBI::Node).void } def print_loc(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:686 + # pkg:gem/rbi#lib/rbi/printer.rb:692 sig { params(node: ::RBI::Param, last: T::Boolean).void } def print_param_comment_leading_space(node, last:); end - # pkg:gem/rbi#lib/rbi/printer.rb:761 + # pkg:gem/rbi#lib/rbi/printer.rb:767 sig { params(node: ::RBI::Sig).void } def print_sig_as_block(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:731 + # pkg:gem/rbi#lib/rbi/printer.rb:737 sig { params(node: ::RBI::Sig).void } def print_sig_as_line(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:694 + # pkg:gem/rbi#lib/rbi/printer.rb:700 sig { params(node: ::RBI::SigParam, last: T::Boolean).void } def print_sig_param_comment_leading_space(node, last:); end - # pkg:gem/rbi#lib/rbi/printer.rb:831 + # pkg:gem/rbi#lib/rbi/printer.rb:837 sig { params(node: ::RBI::Sig).returns(T::Array[::String]) } def sig_modifiers(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:481 + # pkg:gem/rbi#lib/rbi/printer.rb:487 sig { override.params(node: ::RBI::Arg).void } def visit_arg(node); end @@ -1867,7 +1913,7 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:401 + # pkg:gem/rbi#lib/rbi/printer.rb:407 sig { override.params(node: ::RBI::BlockParam).void } def visit_block_param(node); end @@ -1885,7 +1931,7 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:646 + # pkg:gem/rbi#lib/rbi/printer.rb:652 sig { override.params(node: ::RBI::ConflictTree).void } def visit_conflict_tree(node); end @@ -1897,31 +1943,31 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:413 + # pkg:gem/rbi#lib/rbi/printer.rb:419 sig { override.params(node: ::RBI::Extend).void } def visit_extend(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:615 + # pkg:gem/rbi#lib/rbi/printer.rb:621 sig { override.params(node: ::RBI::Group).void } def visit_group(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:599 + # pkg:gem/rbi#lib/rbi/printer.rb:605 sig { override.params(node: ::RBI::Helper).void } def visit_helper(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:407 + # pkg:gem/rbi#lib/rbi/printer.rb:413 sig { override.params(node: ::RBI::Include).void } def visit_include(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:487 + # pkg:gem/rbi#lib/rbi/printer.rb:493 sig { override.params(node: ::RBI::KwArg).void } def visit_kw_arg(node); end @@ -1951,11 +1997,11 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:609 + # pkg:gem/rbi#lib/rbi/printer.rb:615 sig { override.params(node: ::RBI::MixesInClassMethods).void } def visit_mixes_in_class_methods(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:418 + # pkg:gem/rbi#lib/rbi/printer.rb:424 sig { params(node: ::RBI::Mixin).void } def visit_mixin(node); end @@ -1965,6 +2011,12 @@ class RBI::Printer < ::RBI::Visitor sig { override.params(node: ::RBI::Module).void } def visit_module(node); end + # @override + # + # pkg:gem/rbi#lib/rbi/printer.rb:401 + sig { override.params(node: ::RBI::NoKwParam).void } + def visit_no_kw_param(node); end + # @override # # pkg:gem/rbi#lib/rbi/printer.rb:371 @@ -1973,19 +2025,19 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:448 + # pkg:gem/rbi#lib/rbi/printer.rb:454 sig { override.params(node: ::RBI::Private).void } def visit_private(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:442 + # pkg:gem/rbi#lib/rbi/printer.rb:448 sig { override.params(node: ::RBI::Protected).void } def visit_protected(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:436 + # pkg:gem/rbi#lib/rbi/printer.rb:442 sig { override.params(node: ::RBI::Public).void } def visit_public(node); end @@ -2003,7 +2055,7 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:636 + # pkg:gem/rbi#lib/rbi/printer.rb:642 sig { override.params(node: ::RBI::RequiresAncestor).void } def visit_requires_ancestor(node); end @@ -2023,7 +2075,7 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:656 + # pkg:gem/rbi#lib/rbi/printer.rb:662 sig { override.params(node: ::RBI::ScopeConflict).void } def visit_scope_conflict(node); end @@ -2033,19 +2085,19 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:463 + # pkg:gem/rbi#lib/rbi/printer.rb:469 sig { override.params(node: ::RBI::Send).void } def visit_send(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:495 + # pkg:gem/rbi#lib/rbi/printer.rb:501 sig { override.params(node: ::RBI::Sig).void } def visit_sig(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:516 + # pkg:gem/rbi#lib/rbi/printer.rb:522 sig { override.params(node: ::RBI::SigParam).void } def visit_sig_param(node); end @@ -2061,25 +2113,25 @@ class RBI::Printer < ::RBI::Visitor sig { override.params(node: ::RBI::Struct).void } def visit_struct(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:541 + # pkg:gem/rbi#lib/rbi/printer.rb:547 sig { params(node: ::RBI::TStructField).void } def visit_t_struct_field(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:560 + # pkg:gem/rbi#lib/rbi/printer.rb:566 sig { override.params(node: ::RBI::TEnum).void } def visit_tenum(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:566 + # pkg:gem/rbi#lib/rbi/printer.rb:572 sig { override.params(node: ::RBI::TEnumBlock).void } def visit_tenum_block(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:579 + # pkg:gem/rbi#lib/rbi/printer.rb:585 sig { override.params(node: ::RBI::TEnumValue).void } def visit_tenum_value(node); end @@ -2091,40 +2143,40 @@ class RBI::Printer < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:524 + # pkg:gem/rbi#lib/rbi/printer.rb:530 sig { override.params(node: ::RBI::TStruct).void } def visit_tstruct(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:530 + # pkg:gem/rbi#lib/rbi/printer.rb:536 sig { override.params(node: ::RBI::TStructConst).void } def visit_tstruct_const(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:536 + # pkg:gem/rbi#lib/rbi/printer.rb:542 sig { override.params(node: ::RBI::TStructProp).void } def visit_tstruct_prop(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:589 + # pkg:gem/rbi#lib/rbi/printer.rb:595 sig { override.params(node: ::RBI::TypeMember).void } def visit_type_member(node); end - # pkg:gem/rbi#lib/rbi/printer.rb:453 + # pkg:gem/rbi#lib/rbi/printer.rb:459 sig { params(node: ::RBI::Visibility).void } def visit_visibility(node); end # @override # - # pkg:gem/rbi#lib/rbi/printer.rb:622 + # pkg:gem/rbi#lib/rbi/printer.rb:628 sig { override.params(node: ::RBI::VisibilityGroup).void } def visit_visibility_group(node); end end -# pkg:gem/rbi#lib/rbi/printer.rb:828 +# pkg:gem/rbi#lib/rbi/printer.rb:834 RBI::Printer::EMPTY_MODIFIERS = T.let(T.unsafe(nil), Array) # pkg:gem/rbi#lib/rbi/printer.rb:10 @@ -2138,9 +2190,9 @@ RBI::Printer::MAX_CACHED_INDENT = T.let(T.unsafe(nil), Integer) # pkg:gem/rbi#lib/rbi/printer.rb:5 class RBI::PrinterError < ::RBI::Error; end -# pkg:gem/rbi#lib/rbi/model.rb:937 +# pkg:gem/rbi#lib/rbi/model.rb:970 class RBI::Private < ::RBI::Visibility - # pkg:gem/rbi#lib/rbi/model.rb:939 + # pkg:gem/rbi#lib/rbi/model.rb:972 sig do params( loc: T.nilable(::RBI::Loc), @@ -2151,9 +2203,9 @@ class RBI::Private < ::RBI::Visibility def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:929 +# pkg:gem/rbi#lib/rbi/model.rb:962 class RBI::Protected < ::RBI::Visibility - # pkg:gem/rbi#lib/rbi/model.rb:931 + # pkg:gem/rbi#lib/rbi/model.rb:964 sig do params( loc: T.nilable(::RBI::Loc), @@ -2164,9 +2216,9 @@ class RBI::Protected < ::RBI::Visibility def initialize(loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:918 +# pkg:gem/rbi#lib/rbi/model.rb:951 class RBI::Public < ::RBI::Visibility - # pkg:gem/rbi#lib/rbi/model.rb:920 + # pkg:gem/rbi#lib/rbi/model.rb:953 sig do params( loc: T.nilable(::RBI::Loc), @@ -2179,7 +2231,7 @@ end # Shared default instance to avoid allocating a new Public on every Method/Attr creation. # -# pkg:gem/rbi#lib/rbi/model.rb:926 +# pkg:gem/rbi#lib/rbi/model.rb:959 RBI::Public::DEFAULT = T.let(T.unsafe(nil), RBI::Public) # pkg:gem/rbi#lib/rbi/rbs/method_type_translator.rb:5 @@ -2264,23 +2316,23 @@ class RBI::RBS::TypeTranslator private - # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:222 + # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:225 sig { params(type_name: ::String).returns(::String) } def erase_t_generic_type(type_name); end - # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:135 + # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:138 sig { params(type: ::RBS::Types::ClassInstance).returns(::RBI::Type) } def translate_class_instance(type); end - # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:149 + # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:152 sig { params(type: ::RBS::Types::Function).returns(::RBI::Type) } def translate_function(type); end - # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:217 + # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:220 sig { params(type_name: ::String).returns(::String) } def translate_t_generic_type(type_name); end - # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:123 + # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:126 sig { params(type: ::RBS::Types::Alias).returns(::RBI::Type) } def translate_type_alias(type); end @@ -2295,18 +2347,18 @@ class RBI::RBS::TypeTranslator end end -# pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:208 +# pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:211 RBI::RBS::TypeTranslator::GENERIC_TYPE_TO_SORBET_GENERIC_TYPE = T.let(T.unsafe(nil), Hash) # pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:38 RBI::RBS::TypeTranslator::Options = RBI::RBS::MethodTypeTranslator::Options -# pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:195 +# pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:198 RBI::RBS::TypeTranslator::RUNTIME_GENERIC_TYPES = T.let(T.unsafe(nil), Array) RBI::RBS::TypeTranslator::RbsType = T.type_alias { T.any(::RBS::Types::Alias, ::RBS::Types::Bases::Any, ::RBS::Types::Bases::Bool, ::RBS::Types::Bases::Bottom, ::RBS::Types::Bases::Class, ::RBS::Types::Bases::Instance, ::RBS::Types::Bases::Nil, ::RBS::Types::Bases::Self, ::RBS::Types::Bases::Top, ::RBS::Types::Bases::Void, ::RBS::Types::ClassInstance, ::RBS::Types::ClassSingleton, ::RBS::Types::Function, ::RBS::Types::Interface, ::RBS::Types::Intersection, ::RBS::Types::Literal, ::RBS::Types::Optional, ::RBS::Types::Proc, ::RBS::Types::Record, ::RBS::Types::Tuple, ::RBS::Types::Union, ::RBS::Types::UntypedFunction, ::RBS::Types::Variable) } -# pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:212 +# pkg:gem/rbi#lib/rbi/rbs/type_translator.rb:215 RBI::RBS::TypeTranslator::SORBET_GENERIC_TYPE_TO_GENERIC_TYPE = T.let(T.unsafe(nil), Hash) # A comment representing a RBS type prefixed with `#:` @@ -2387,13 +2439,13 @@ class RBI::RBSPrinter < ::RBI::Visitor sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void } def print_method_sig(node, sig); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:426 - sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void } - def print_method_sig_inline(node, sig); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:491 - sig { params(node: ::RBI::Method, sig: ::RBI::Sig).void } - def print_method_sig_multiline(node, sig); end + sig { params(sig_param: T.nilable(::RBI::SigParam)).void } + def print_method_sig_block(sig_param); end + + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:426 + sig { params(node: ::RBI::Method, sig: ::RBI::Sig, multiline: T::Boolean).void } + def print_method_sig_content(node, sig, multiline:); end # Print a string with indentation and `\n` at the end. # @@ -2421,7 +2473,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:693 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:662 sig { override.params(node: ::RBI::Arg).void } def visit_arg(node); end @@ -2455,7 +2507,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:625 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:594 sig { override.params(node: ::RBI::BlockParam).void } def visit_block_param(node); end @@ -2473,7 +2525,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:829 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:798 sig { override.params(node: ::RBI::ConflictTree).void } def visit_conflict_tree(node); end @@ -2485,7 +2537,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:637 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:606 sig { override.params(node: ::RBI::Extend).void } def visit_extend(node); end @@ -2497,43 +2549,43 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:802 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:771 sig { override.params(node: ::RBI::Group).void } def visit_group(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:790 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:759 sig { override.params(node: ::RBI::Helper).void } def visit_helper(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:631 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:600 sig { override.params(node: ::RBI::Include).void } def visit_include(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:699 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:668 sig { override.params(node: ::RBI::KwArg).void } def visit_kw_arg(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:612 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:575 sig { override.params(node: ::RBI::KwOptParam).void } def visit_kw_opt_param(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:606 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:569 sig { override.params(node: ::RBI::KwParam).void } def visit_kw_param(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:618 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:581 sig { override.params(node: ::RBI::KwRestParam).void } def visit_kw_rest_param(node); end @@ -2545,11 +2597,11 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:796 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:765 sig { override.params(node: ::RBI::MixesInClassMethods).void } def visit_mixes_in_class_methods(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:642 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:611 sig { params(node: ::RBI::Mixin).void } def visit_mixin(node); end @@ -2561,43 +2613,49 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:589 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:588 + sig { override.params(node: ::RBI::NoKwParam).void } + def visit_no_kw_param(node); end + + # @override + # + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:552 sig { override.params(node: ::RBI::OptParam).void } def visit_opt_param(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:672 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:641 sig { override.params(node: ::RBI::Private).void } def visit_private(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:666 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:635 sig { override.params(node: ::RBI::Protected).void } def visit_protected(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:660 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:629 sig { override.params(node: ::RBI::Public).void } def visit_public(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:579 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:542 sig { override.params(node: ::RBI::ReqParam).void } def visit_req_param(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:823 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:792 sig { override.params(node: ::RBI::RequiresAncestor).void } def visit_requires_ancestor(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:599 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:562 sig { override.params(node: ::RBI::RestParam).void } def visit_rest_param(node); end @@ -2611,7 +2669,7 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:839 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:808 sig { override.params(node: ::RBI::ScopeConflict).void } def visit_scope_conflict(node); end @@ -2621,15 +2679,15 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:687 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:656 sig { override.params(node: ::RBI::Send).void } def visit_send(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:560 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:523 sig { params(node: ::RBI::Sig).void } def visit_sig(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:573 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:536 sig { params(node: ::RBI::SigParam).void } def visit_sig_param(node); end @@ -2647,19 +2705,19 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:756 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:725 sig { override.params(node: ::RBI::TEnum).void } def visit_tenum(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:762 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:731 sig { override.params(node: ::RBI::TEnumBlock).void } def visit_tenum_block(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:768 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:737 sig { override.params(node: ::RBI::TEnumValue).void } def visit_tenum_value(node); end @@ -2671,41 +2729,41 @@ class RBI::RBSPrinter < ::RBI::Visitor # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:705 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:674 sig { override.params(node: ::RBI::TStruct).void } def visit_tstruct(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:740 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:709 sig { override.params(node: ::RBI::TStructConst).void } def visit_tstruct_const(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:748 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:717 sig { override.params(node: ::RBI::TStructProp).void } def visit_tstruct_prop(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:784 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:753 sig { override.params(node: ::RBI::TypeMember).void } def visit_type_member(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:677 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:646 sig { params(node: ::RBI::Visibility).void } def visit_visibility(node); end # @override # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:809 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:778 sig { override.params(node: ::RBI::VisibilityGroup).void } def visit_visibility_group(node); end private - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:939 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:908 sig { params(node: ::RBI::Node).returns(T::Boolean) } def oneline?(node); end @@ -2713,31 +2771,31 @@ class RBI::RBSPrinter < ::RBI::Visitor # # Returns `nil` is the string is not a `T.let`. # - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:973 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:942 sig { params(code: T.nilable(::String)).returns(T.nilable(::String)) } def parse_t_let(code); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:961 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:930 sig { params(type: T.any(::RBI::Type, ::String)).returns(::RBI::Type) } def parse_type(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:855 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:824 sig { params(node: ::RBI::Node).void } def print_blank_line_before(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:874 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:843 sig { params(node: ::RBI::Node).void } def print_loc(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:923 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:892 sig { params(node: ::RBI::Param, last: T::Boolean).void } def print_param_comment_leading_space(node, last:); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:880 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:849 sig { params(sig_param: ::RBI::SigParam, method_param: ::RBI::Param).void } def print_sig_param(sig_param, method_param); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:931 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:900 sig { params(node: ::RBI::SigParam, last: T::Boolean).void } def print_sig_param_comment_leading_space(node, last:); end end @@ -2748,9 +2806,9 @@ class RBI::RBSPrinter::Error < ::RBI::Error; end # pkg:gem/rbi#lib/rbi/model.rb:5 class RBI::ReplaceNodeError < ::RBI::Error; end -# pkg:gem/rbi#lib/rbi/model.rb:622 +# pkg:gem/rbi#lib/rbi/model.rb:630 class RBI::ReqParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:628 + # pkg:gem/rbi#lib/rbi/model.rb:636 sig do params( name: ::String, @@ -2761,34 +2819,34 @@ class RBI::ReqParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:647 + # pkg:gem/rbi#lib/rbi/model.rb:655 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:642 + # pkg:gem/rbi#lib/rbi/model.rb:650 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:625 + # pkg:gem/rbi#lib/rbi/model.rb:633 sig { override.returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:636 + # pkg:gem/rbi#lib/rbi/model.rb:644 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:1372 +# pkg:gem/rbi#lib/rbi/model.rb:1412 class RBI::RequiresAncestor < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1377 + # pkg:gem/rbi#lib/rbi/model.rb:1417 sig { params(name: ::String, loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void } def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil)); end @@ -2798,20 +2856,20 @@ class RBI::RequiresAncestor < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1374 + # pkg:gem/rbi#lib/rbi/model.rb:1414 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1384 + # pkg:gem/rbi#lib/rbi/model.rb:1424 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:686 +# pkg:gem/rbi#lib/rbi/model.rb:694 class RBI::RestParam < ::RBI::Param - # pkg:gem/rbi#lib/rbi/model.rb:692 + # pkg:gem/rbi#lib/rbi/model.rb:700 sig do params( name: T.nilable(::String), @@ -2822,25 +2880,25 @@ class RBI::RestParam < ::RBI::Param end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:711 + # pkg:gem/rbi#lib/rbi/model.rb:719 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:706 + # pkg:gem/rbi#lib/rbi/model.rb:714 sig { override.returns(T::Boolean) } def anonymous?; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:689 + # pkg:gem/rbi#lib/rbi/model.rb:697 sig { override.returns(T.nilable(::String)) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:700 + # pkg:gem/rbi#lib/rbi/model.rb:708 sig { override.returns(::String) } def to_s; end end @@ -2870,7 +2928,7 @@ class RBI::Rewriters::AddSigTemplates < ::RBI::Visitor sig { params(method: ::RBI::Method).void } def add_method_sig(method); end - # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:69 + # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:71 sig { params(node: ::RBI::NodeWithComments).void } def add_todo_comment(node); end end @@ -3580,11 +3638,11 @@ end # Sends # -# pkg:gem/rbi#lib/rbi/model.rb:947 +# pkg:gem/rbi#lib/rbi/model.rb:980 class RBI::Send < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:955 + # pkg:gem/rbi#lib/rbi/model.rb:988 sig do params( method: ::String, @@ -3596,15 +3654,15 @@ class RBI::Send < ::RBI::NodeWithComments end def initialize(method, args = T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:963 + # pkg:gem/rbi#lib/rbi/model.rb:996 sig { params(arg: ::RBI::Arg).void } def <<(arg); end - # pkg:gem/rbi#lib/rbi/model.rb:968 + # pkg:gem/rbi#lib/rbi/model.rb:1001 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:952 + # pkg:gem/rbi#lib/rbi/model.rb:985 sig { returns(T::Array[::RBI::Arg]) } def args; end @@ -3620,24 +3678,25 @@ class RBI::Send < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:949 + # pkg:gem/rbi#lib/rbi/model.rb:982 sig { returns(::String) } def method; end - # pkg:gem/rbi#lib/rbi/model.rb:973 + # pkg:gem/rbi#lib/rbi/model.rb:1006 sig { returns(::String) } def to_s; end end # Sorbet's sigs # -# pkg:gem/rbi#lib/rbi/model.rb:1022 +# pkg:gem/rbi#lib/rbi/model.rb:1055 class RBI::Sig < ::RBI::NodeWithComments - # pkg:gem/rbi#lib/rbi/model.rb:1080 + # pkg:gem/rbi#lib/rbi/model.rb:1117 sig do params( params: T.nilable(T::Array[::RBI::SigParam]), return_type: T.any(::RBI::Type, ::String), + bind_type: T.nilable(T.any(::RBI::Type, ::String)), is_abstract: T::Boolean, is_override: T::Boolean, is_overridable: T::Boolean, @@ -3652,99 +3711,106 @@ class RBI::Sig < ::RBI::NodeWithComments block: T.nilable(T.proc.params(node: ::RBI::Sig).void) ).void end - def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), allow_incompatible_override: T.unsafe(nil), allow_incompatible_override_visibility: T.unsafe(nil), without_runtime: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end + def initialize(params: T.unsafe(nil), return_type: T.unsafe(nil), bind_type: T.unsafe(nil), is_abstract: T.unsafe(nil), is_override: T.unsafe(nil), is_overridable: T.unsafe(nil), is_final: T.unsafe(nil), allow_incompatible_override: T.unsafe(nil), allow_incompatible_override_visibility: T.unsafe(nil), without_runtime: T.unsafe(nil), type_params: T.unsafe(nil), checked: T.unsafe(nil), loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1112 + # pkg:gem/rbi#lib/rbi/model.rb:1151 sig { params(param: ::RBI::SigParam).void } def <<(param); end - # pkg:gem/rbi#lib/rbi/model.rb:1122 + # pkg:gem/rbi#lib/rbi/model.rb:1161 sig { params(other: ::Object).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1117 + # pkg:gem/rbi#lib/rbi/model.rb:1156 sig { params(name: ::String, type: T.any(::RBI::Type, ::String)).void } def add_param(name, type); end - # pkg:gem/rbi#lib/rbi/model.rb:1044 + # pkg:gem/rbi#lib/rbi/model.rb:1080 sig { returns(T::Boolean) } def allow_incompatible_override; end - # pkg:gem/rbi#lib/rbi/model.rb:1044 + # pkg:gem/rbi#lib/rbi/model.rb:1080 def allow_incompatible_override=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1047 + # pkg:gem/rbi#lib/rbi/model.rb:1083 sig { returns(T::Boolean) } def allow_incompatible_override_visibility; end - # pkg:gem/rbi#lib/rbi/model.rb:1047 + # pkg:gem/rbi#lib/rbi/model.rb:1083 def allow_incompatible_override_visibility=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1063 + # pkg:gem/rbi#lib/rbi/model.rb:1065 + sig { returns(T.nilable(T.any(::RBI::Type, ::String))) } + def bind_type; end + + # pkg:gem/rbi#lib/rbi/model.rb:1065 + def bind_type=(_arg0); end + + # pkg:gem/rbi#lib/rbi/model.rb:1099 sig { returns(T.nilable(::Symbol)) } def checked; end - # pkg:gem/rbi#lib/rbi/model.rb:1063 + # pkg:gem/rbi#lib/rbi/model.rb:1099 def checked=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1032 + # pkg:gem/rbi#lib/rbi/model.rb:1068 sig { returns(T::Boolean) } def is_abstract; end - # pkg:gem/rbi#lib/rbi/model.rb:1032 + # pkg:gem/rbi#lib/rbi/model.rb:1068 def is_abstract=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1041 + # pkg:gem/rbi#lib/rbi/model.rb:1077 sig { returns(T::Boolean) } def is_final; end - # pkg:gem/rbi#lib/rbi/model.rb:1041 + # pkg:gem/rbi#lib/rbi/model.rb:1077 def is_final=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1038 + # pkg:gem/rbi#lib/rbi/model.rb:1074 sig { returns(T::Boolean) } def is_overridable; end - # pkg:gem/rbi#lib/rbi/model.rb:1038 + # pkg:gem/rbi#lib/rbi/model.rb:1074 def is_overridable=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1035 + # pkg:gem/rbi#lib/rbi/model.rb:1071 sig { returns(T::Boolean) } def is_override; end - # pkg:gem/rbi#lib/rbi/model.rb:1035 + # pkg:gem/rbi#lib/rbi/model.rb:1071 def is_override=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1024 + # pkg:gem/rbi#lib/rbi/model.rb:1057 sig { returns(T::Array[::RBI::SigParam]) } def params; end - # pkg:gem/rbi#lib/rbi/model.rb:1029 + # pkg:gem/rbi#lib/rbi/model.rb:1062 sig { returns(T.any(::RBI::Type, ::String)) } def return_type; end - # pkg:gem/rbi#lib/rbi/model.rb:1029 + # pkg:gem/rbi#lib/rbi/model.rb:1062 def return_type=(_arg0); end - # pkg:gem/rbi#lib/rbi/model.rb:1053 + # pkg:gem/rbi#lib/rbi/model.rb:1089 sig { returns(T::Array[::String]) } def type_params; end - # pkg:gem/rbi#lib/rbi/model.rb:1058 + # pkg:gem/rbi#lib/rbi/model.rb:1094 sig { returns(T::Boolean) } def type_params?; end - # pkg:gem/rbi#lib/rbi/model.rb:1050 + # pkg:gem/rbi#lib/rbi/model.rb:1086 sig { returns(T::Boolean) } def without_runtime; end - # pkg:gem/rbi#lib/rbi/model.rb:1050 + # pkg:gem/rbi#lib/rbi/model.rb:1086 def without_runtime=(_arg0); end end -# pkg:gem/rbi#lib/rbi/model.rb:1131 +# pkg:gem/rbi#lib/rbi/model.rb:1171 class RBI::SigParam < ::RBI::NodeWithComments - # pkg:gem/rbi#lib/rbi/model.rb:1139 + # pkg:gem/rbi#lib/rbi/model.rb:1179 sig do params( name: ::String, @@ -3756,25 +3822,25 @@ class RBI::SigParam < ::RBI::NodeWithComments end def initialize(name, type, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1159 + # pkg:gem/rbi#lib/rbi/model.rb:1199 sig { params(other: ::Object).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1154 + # pkg:gem/rbi#lib/rbi/model.rb:1194 sig { returns(T::Boolean) } def anonymous?; end - # pkg:gem/rbi#lib/rbi/model.rb:1133 + # pkg:gem/rbi#lib/rbi/model.rb:1173 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1149 + # pkg:gem/rbi#lib/rbi/model.rb:1189 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:1136 + # pkg:gem/rbi#lib/rbi/model.rb:1176 sig { returns(T.any(::RBI::Type, ::String)) } def type; end end @@ -3846,9 +3912,9 @@ end # Sorbet's T::Enum # -# pkg:gem/rbi#lib/rbi/model.rb:1256 +# pkg:gem/rbi#lib/rbi/model.rb:1296 class RBI::TEnum < ::RBI::Class - # pkg:gem/rbi#lib/rbi/model.rb:1258 + # pkg:gem/rbi#lib/rbi/model.rb:1298 sig do params( name: ::String, @@ -3860,9 +3926,9 @@ class RBI::TEnum < ::RBI::Class def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:1264 +# pkg:gem/rbi#lib/rbi/model.rb:1304 class RBI::TEnumBlock < ::RBI::Scope - # pkg:gem/rbi#lib/rbi/model.rb:1266 + # pkg:gem/rbi#lib/rbi/model.rb:1306 sig do params( loc: T.nilable(::RBI::Loc), @@ -3874,7 +3940,7 @@ class RBI::TEnumBlock < ::RBI::Scope # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1273 + # pkg:gem/rbi#lib/rbi/model.rb:1313 sig { override.returns(::String) } def fully_qualified_name; end @@ -3886,16 +3952,16 @@ class RBI::TEnumBlock < ::RBI::Scope # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1279 + # pkg:gem/rbi#lib/rbi/model.rb:1319 sig { override.returns(::String) } def to_s; end end -# pkg:gem/rbi#lib/rbi/model.rb:1284 +# pkg:gem/rbi#lib/rbi/model.rb:1324 class RBI::TEnumValue < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1289 + # pkg:gem/rbi#lib/rbi/model.rb:1329 sig do params( name: ::String, @@ -3906,7 +3972,7 @@ class RBI::TEnumValue < ::RBI::NodeWithComments end def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1296 + # pkg:gem/rbi#lib/rbi/model.rb:1336 sig { returns(::String) } def fully_qualified_name; end @@ -3916,22 +3982,22 @@ class RBI::TEnumValue < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1286 + # pkg:gem/rbi#lib/rbi/model.rb:1326 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1302 + # pkg:gem/rbi#lib/rbi/model.rb:1342 sig { override.returns(::String) } def to_s; end end # Sorbet's T::Struct # -# pkg:gem/rbi#lib/rbi/model.rb:1168 +# pkg:gem/rbi#lib/rbi/model.rb:1208 class RBI::TStruct < ::RBI::Class - # pkg:gem/rbi#lib/rbi/model.rb:1170 + # pkg:gem/rbi#lib/rbi/model.rb:1210 sig do params( name: ::String, @@ -3943,11 +4009,11 @@ class RBI::TStruct < ::RBI::Class def initialize(name, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end end -# pkg:gem/rbi#lib/rbi/model.rb:1200 +# pkg:gem/rbi#lib/rbi/model.rb:1240 class RBI::TStructConst < ::RBI::TStructField include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1208 + # pkg:gem/rbi#lib/rbi/model.rb:1248 sig do params( name: ::String, @@ -3968,7 +4034,7 @@ class RBI::TStructConst < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1215 + # pkg:gem/rbi#lib/rbi/model.rb:1255 sig { override.returns(T::Array[::String]) } def fully_qualified_names; end @@ -3980,18 +4046,18 @@ class RBI::TStructConst < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1222 + # pkg:gem/rbi#lib/rbi/model.rb:1262 sig { override.returns(::String) } def to_s; end end # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:1177 +# pkg:gem/rbi#lib/rbi/model.rb:1217 class RBI::TStructField < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:1188 + # pkg:gem/rbi#lib/rbi/model.rb:1228 sig do params( name: ::String, @@ -4009,36 +4075,36 @@ class RBI::TStructField < ::RBI::NodeWithComments sig { override.params(other: ::RBI::Node).returns(T::Boolean) } def compatible_with?(other); end - # pkg:gem/rbi#lib/rbi/model.rb:1185 + # pkg:gem/rbi#lib/rbi/model.rb:1225 sig { returns(T.nilable(::String)) } def default; end - # pkg:gem/rbi#lib/rbi/model.rb:1185 + # pkg:gem/rbi#lib/rbi/model.rb:1225 def default=(_arg0); end # @abstract # - # pkg:gem/rbi#lib/rbi/model.rb:1197 + # pkg:gem/rbi#lib/rbi/model.rb:1237 sig { abstract.returns(T::Array[::String]) } def fully_qualified_names; end - # pkg:gem/rbi#lib/rbi/model.rb:1179 + # pkg:gem/rbi#lib/rbi/model.rb:1219 sig { returns(::String) } def name; end - # pkg:gem/rbi#lib/rbi/model.rb:1182 + # pkg:gem/rbi#lib/rbi/model.rb:1222 sig { returns(T.any(::RBI::Type, ::String)) } def type; end - # pkg:gem/rbi#lib/rbi/model.rb:1182 + # pkg:gem/rbi#lib/rbi/model.rb:1222 def type=(_arg0); end end -# pkg:gem/rbi#lib/rbi/model.rb:1227 +# pkg:gem/rbi#lib/rbi/model.rb:1267 class RBI::TStructProp < ::RBI::TStructField include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1235 + # pkg:gem/rbi#lib/rbi/model.rb:1275 sig do params( name: ::String, @@ -4059,7 +4125,7 @@ class RBI::TStructProp < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1242 + # pkg:gem/rbi#lib/rbi/model.rb:1282 sig { override.returns(T::Array[::String]) } def fully_qualified_names; end @@ -4071,7 +4137,7 @@ class RBI::TStructProp < ::RBI::TStructField # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1249 + # pkg:gem/rbi#lib/rbi/model.rb:1289 sig { override.returns(::String) } def to_s; end end @@ -4092,7 +4158,7 @@ class RBI::Tree < ::RBI::NodeWithComments sig { params(node: ::RBI::Node).void } def <<(node); end - # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:77 + # pkg:gem/rbi#lib/rbi/rewriters/add_sig_templates.rb:79 sig { params(with_todo_comment: T::Boolean).void } def add_sig_templates!(with_todo_comment: T.unsafe(nil)); end @@ -4244,7 +4310,7 @@ class RBI::Type sig { abstract.returns(::RBI::Type) } def normalize; end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1276 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1248 sig { returns(::String) } def rbs_string; end @@ -4314,8 +4380,13 @@ class RBI::Type # Builds a type that represents the singleton class of another type like `T.class_of(Foo)`. # # pkg:gem/rbi#lib/rbi/type.rb:917 - sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).returns(::RBI::Type::ClassOf) } - def class_of(type, type_parameter = T.unsafe(nil)); end + sig do + params( + type: ::RBI::Type::Simple, + type_parameters: T.any(::RBI::Type, T::Array[::RBI::Type]) + ).returns(::RBI::Type::ClassOf) + end + def class_of(type, *type_parameters); end # Builds a type that represents a generic type like `T::Array[String]` or `T::Hash[Symbol, Integer]`. # @@ -4416,15 +4487,15 @@ class RBI::Type private - # pkg:gem/rbi#lib/rbi/type_parser.rb:322 + # pkg:gem/rbi#lib/rbi/type_parser.rb:320 sig { params(node: ::Prism::CallNode).returns(T::Array[::Prism::Node]) } def call_chain(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:309 + # pkg:gem/rbi#lib/rbi/type_parser.rb:307 sig { params(node: ::Prism::CallNode, count: ::Integer).returns(T::Array[::Prism::Node]) } def check_arguments_at_least!(node, count); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:294 + # pkg:gem/rbi#lib/rbi/type_parser.rb:292 sig { params(node: ::Prism::CallNode, count: ::Integer).returns(T::Array[::Prism::Node]) } def check_arguments_exactly!(node, count); end @@ -4440,43 +4511,43 @@ class RBI::Type sig { params(node: T.any(::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode)).returns(::RBI::Type) } def parse_constant_assignment(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:244 + # pkg:gem/rbi#lib/rbi/type_parser.rb:242 sig { params(node: ::Prism::CallNode).returns(::RBI::Type) } def parse_proc(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:223 + # pkg:gem/rbi#lib/rbi/type_parser.rb:221 sig { params(node: T.any(::Prism::HashNode, ::Prism::KeywordHashNode)).returns(::RBI::Type) } def parse_shape(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:218 + # pkg:gem/rbi#lib/rbi/type_parser.rb:216 sig { params(node: ::Prism::ArrayNode).returns(::RBI::Type) } def parse_tuple(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:335 + # pkg:gem/rbi#lib/rbi/type_parser.rb:333 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def t?(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:354 + # pkg:gem/rbi#lib/rbi/type_parser.rb:352 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def t_boolean?(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:361 + # pkg:gem/rbi#lib/rbi/type_parser.rb:359 sig { params(node: ::Prism::ConstantPathNode).returns(T::Boolean) } def t_class?(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:371 + # pkg:gem/rbi#lib/rbi/type_parser.rb:369 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def t_class_of?(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:366 + # pkg:gem/rbi#lib/rbi/type_parser.rb:364 sig { params(node: ::Prism::ConstantPathNode).returns(T::Boolean) } def t_module?(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:378 + # pkg:gem/rbi#lib/rbi/type_parser.rb:376 sig { params(node: ::Prism::CallNode).returns(T::Boolean) } def t_proc?(node); end - # pkg:gem/rbi#lib/rbi/type_parser.rb:347 + # pkg:gem/rbi#lib/rbi/type_parser.rb:345 sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) } def t_type_alias?(node); end @@ -4665,8 +4736,8 @@ end # pkg:gem/rbi#lib/rbi/type.rb:314 class RBI::Type::ClassOf < ::RBI::Type # pkg:gem/rbi#lib/rbi/type.rb:322 - sig { params(type: ::RBI::Type::Simple, type_parameter: T.nilable(::RBI::Type)).void } - def initialize(type, type_parameter = T.unsafe(nil)); end + sig { params(type: ::RBI::Type::Simple, type_parameters: ::RBI::Type).void } + def initialize(type, *type_parameters); end # @override # @@ -4697,8 +4768,8 @@ class RBI::Type::ClassOf < ::RBI::Type def type; end # pkg:gem/rbi#lib/rbi/type.rb:319 - sig { returns(T.nilable(::RBI::Type)) } - def type_parameter; end + sig { returns(T::Array[::RBI::Type]) } + def type_parameters; end end # A type that is composed of multiple types like `T.all(String, Integer)`. @@ -5297,11 +5368,11 @@ class RBI::Type::Void < ::RBI::Type def to_rbi; end end -# pkg:gem/rbi#lib/rbi/model.rb:1327 +# pkg:gem/rbi#lib/rbi/model.rb:1367 class RBI::TypeMember < ::RBI::NodeWithComments include ::RBI::Indexable - # pkg:gem/rbi#lib/rbi/model.rb:1332 + # pkg:gem/rbi#lib/rbi/model.rb:1372 sig do params( name: ::String, @@ -5313,7 +5384,7 @@ class RBI::TypeMember < ::RBI::NodeWithComments end def initialize(name, value, loc: T.unsafe(nil), comments: T.unsafe(nil), &block); end - # pkg:gem/rbi#lib/rbi/model.rb:1340 + # pkg:gem/rbi#lib/rbi/model.rb:1380 sig { returns(::String) } def fully_qualified_name; end @@ -5323,113 +5394,113 @@ class RBI::TypeMember < ::RBI::NodeWithComments sig { override.returns(T::Array[::String]) } def index_ids; end - # pkg:gem/rbi#lib/rbi/model.rb:1329 + # pkg:gem/rbi#lib/rbi/model.rb:1369 sig { returns(::String) } def name; end # @override # - # pkg:gem/rbi#lib/rbi/model.rb:1348 + # pkg:gem/rbi#lib/rbi/model.rb:1388 sig { override.returns(::String) } def to_s; end - # pkg:gem/rbi#lib/rbi/model.rb:1329 + # pkg:gem/rbi#lib/rbi/model.rb:1369 def value; end end -# pkg:gem/rbi#lib/rbi/rbs_printer.rb:994 +# pkg:gem/rbi#lib/rbi/rbs_printer.rb:963 class RBI::TypePrinter - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:999 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:968 sig { params(max_line_length: T.nilable(::Integer)).void } def initialize(max_line_length: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:996 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:965 sig { returns(::String) } def string; end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1005 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:974 sig { params(node: ::RBI::Type).void } def visit(node); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1127 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1099 sig { params(type: ::RBI::Type::All).void } def visit_all(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1137 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1109 sig { params(type: ::RBI::Type::Any).void } def visit_any(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1072 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1041 sig { params(type: ::RBI::Type::Anything).void } def visit_anything(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1097 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1066 sig { params(type: ::RBI::Type::AttachedClass).void } def visit_attached_class(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1056 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1025 sig { params(type: ::RBI::Type::Boolean).void } def visit_boolean(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1204 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1176 sig { params(type: ::RBI::Type::Class).void } def visit_class(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1115 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1084 sig { params(type: ::RBI::Type::ClassOf).void } def visit_class_of(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1061 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1030 sig { params(type: ::RBI::Type::Generic).void } def visit_generic(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1211 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1183 sig { params(type: ::RBI::Type::Module).void } def visit_module(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1102 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1071 sig { params(type: ::RBI::Type::Nilable).void } def visit_nilable(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1082 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1051 sig { params(type: ::RBI::Type::NoReturn).void } def visit_no_return(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1177 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1149 sig { params(type: ::RBI::Type::Proc).void } def visit_proc(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1092 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1061 sig { params(type: ::RBI::Type::SelfType).void } def visit_self_type(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1157 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1129 sig { params(type: ::RBI::Type::Shape).void } def visit_shape(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1051 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1020 sig { params(type: ::RBI::Type::Simple).void } def visit_simple(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1147 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1119 sig { params(type: ::RBI::Type::Tuple).void } def visit_tuple(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1199 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1171 sig { params(type: ::RBI::Type::TypeParameter).void } def visit_type_parameter(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1087 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1056 sig { params(type: ::RBI::Type::Untyped).void } def visit_untyped(type); end - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1077 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1046 sig { params(type: ::RBI::Type::Void).void } def visit_void(type); end private - # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1220 + # pkg:gem/rbi#lib/rbi/rbs_printer.rb:1192 sig { params(type_name: ::String).returns(::String) } def translate_t_type(type_name); end end @@ -5465,31 +5536,31 @@ RBI::VERSION = T.let(T.unsafe(nil), String) # @abstract # -# pkg:gem/rbi#lib/rbi/model.rb:885 +# pkg:gem/rbi#lib/rbi/model.rb:918 class RBI::Visibility < ::RBI::NodeWithComments abstract! - # pkg:gem/rbi#lib/rbi/model.rb:890 + # pkg:gem/rbi#lib/rbi/model.rb:923 sig { params(visibility: ::Symbol, loc: T.nilable(::RBI::Loc), comments: T.nilable(T::Array[::RBI::Comment])).void } def initialize(visibility, loc: T.unsafe(nil), comments: T.unsafe(nil)); end - # pkg:gem/rbi#lib/rbi/model.rb:896 + # pkg:gem/rbi#lib/rbi/model.rb:929 sig { params(other: T.nilable(::Object)).returns(T::Boolean) } def ==(other); end - # pkg:gem/rbi#lib/rbi/model.rb:913 + # pkg:gem/rbi#lib/rbi/model.rb:946 sig { returns(T::Boolean) } def private?; end - # pkg:gem/rbi#lib/rbi/model.rb:908 + # pkg:gem/rbi#lib/rbi/model.rb:941 sig { returns(T::Boolean) } def protected?; end - # pkg:gem/rbi#lib/rbi/model.rb:903 + # pkg:gem/rbi#lib/rbi/model.rb:936 sig { returns(T::Boolean) } def public?; end - # pkg:gem/rbi#lib/rbi/model.rb:887 + # pkg:gem/rbi#lib/rbi/model.rb:920 sig { returns(::Symbol) } def visibility; end end @@ -5515,189 +5586,193 @@ class RBI::Visitor sig { params(node: T.nilable(::RBI::Node)).void } def visit(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:108 + # pkg:gem/rbi#lib/rbi/visitor.rb:110 sig { params(nodes: T::Array[::RBI::Node]).void } def visit_all(nodes); end - # pkg:gem/rbi#lib/rbi/visitor.rb:113 + # pkg:gem/rbi#lib/rbi/visitor.rb:115 sig { params(file: ::RBI::File).void } def visit_file(file); end private - # pkg:gem/rbi#lib/rbi/visitor.rb:198 + # pkg:gem/rbi#lib/rbi/visitor.rb:203 sig { params(node: ::RBI::Arg).void } def visit_arg(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:147 + # pkg:gem/rbi#lib/rbi/visitor.rb:149 sig { params(node: ::RBI::AttrAccessor).void } def visit_attr_accessor(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:150 + # pkg:gem/rbi#lib/rbi/visitor.rb:152 sig { params(node: ::RBI::AttrReader).void } def visit_attr_reader(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:153 + # pkg:gem/rbi#lib/rbi/visitor.rb:155 sig { params(node: ::RBI::AttrWriter).void } def visit_attr_writer(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:126 + # pkg:gem/rbi#lib/rbi/visitor.rb:128 sig { params(node: ::RBI::BlankLine).void } def visit_blank_line(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:177 + # pkg:gem/rbi#lib/rbi/visitor.rb:182 sig { params(node: ::RBI::BlockParam).void } def visit_block_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:132 + # pkg:gem/rbi#lib/rbi/visitor.rb:134 sig { params(node: ::RBI::Class).void } def visit_class(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:120 + # pkg:gem/rbi#lib/rbi/visitor.rb:122 sig { params(node: ::RBI::Comment).void } def visit_comment(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:246 + # pkg:gem/rbi#lib/rbi/visitor.rb:251 sig { params(node: ::RBI::ConflictTree).void } def visit_conflict_tree(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:144 + # pkg:gem/rbi#lib/rbi/visitor.rb:146 sig { params(node: ::RBI::Const).void } def visit_const(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:183 + # pkg:gem/rbi#lib/rbi/visitor.rb:188 sig { params(node: ::RBI::Extend).void } def visit_extend(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:240 + # pkg:gem/rbi#lib/rbi/visitor.rb:245 sig { params(node: ::RBI::Group).void } def visit_group(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:228 + # pkg:gem/rbi#lib/rbi/visitor.rb:233 sig { params(node: ::RBI::Helper).void } def visit_helper(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:180 + # pkg:gem/rbi#lib/rbi/visitor.rb:185 sig { params(node: ::RBI::Include).void } def visit_include(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:201 + # pkg:gem/rbi#lib/rbi/visitor.rb:206 sig { params(node: ::RBI::KwArg).void } def visit_kw_arg(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:171 + # pkg:gem/rbi#lib/rbi/visitor.rb:173 sig { params(node: ::RBI::KwOptParam).void } def visit_kw_opt_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:168 + # pkg:gem/rbi#lib/rbi/visitor.rb:170 sig { params(node: ::RBI::KwParam).void } def visit_kw_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:174 + # pkg:gem/rbi#lib/rbi/visitor.rb:176 sig { params(node: ::RBI::KwRestParam).void } def visit_kw_rest_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:156 + # pkg:gem/rbi#lib/rbi/visitor.rb:158 sig { params(node: ::RBI::Method).void } def visit_method(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:234 + # pkg:gem/rbi#lib/rbi/visitor.rb:239 sig { params(node: ::RBI::MixesInClassMethods).void } def visit_mixes_in_class_methods(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:129 + # pkg:gem/rbi#lib/rbi/visitor.rb:131 sig { params(node: ::RBI::Module).void } def visit_module(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:162 + # pkg:gem/rbi#lib/rbi/visitor.rb:179 + sig { params(node: ::RBI::NoKwParam).void } + def visit_no_kw_param(node); end + + # pkg:gem/rbi#lib/rbi/visitor.rb:164 sig { params(node: ::RBI::OptParam).void } def visit_opt_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:192 + # pkg:gem/rbi#lib/rbi/visitor.rb:197 sig { params(node: ::RBI::Private).void } def visit_private(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:189 + # pkg:gem/rbi#lib/rbi/visitor.rb:194 sig { params(node: ::RBI::Protected).void } def visit_protected(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:186 + # pkg:gem/rbi#lib/rbi/visitor.rb:191 sig { params(node: ::RBI::Public).void } def visit_public(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:123 + # pkg:gem/rbi#lib/rbi/visitor.rb:125 sig { params(node: ::RBI::RBSComment).void } def visit_rbs_comment(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:159 + # pkg:gem/rbi#lib/rbi/visitor.rb:161 sig { params(node: ::RBI::ReqParam).void } def visit_req_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:237 + # pkg:gem/rbi#lib/rbi/visitor.rb:242 sig { params(node: ::RBI::RequiresAncestor).void } def visit_requires_ancestor(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:165 + # pkg:gem/rbi#lib/rbi/visitor.rb:167 sig { params(node: ::RBI::RestParam).void } def visit_rest_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:249 + # pkg:gem/rbi#lib/rbi/visitor.rb:254 sig { params(node: ::RBI::ScopeConflict).void } def visit_scope_conflict(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:195 + # pkg:gem/rbi#lib/rbi/visitor.rb:200 sig { params(node: ::RBI::Send).void } def visit_send(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:204 + # pkg:gem/rbi#lib/rbi/visitor.rb:209 sig { params(node: ::RBI::Sig).void } def visit_sig(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:207 + # pkg:gem/rbi#lib/rbi/visitor.rb:212 sig { params(node: ::RBI::SigParam).void } def visit_sig_param(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:135 + # pkg:gem/rbi#lib/rbi/visitor.rb:137 sig { params(node: ::RBI::SingletonClass).void } def visit_singleton_class(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:138 + # pkg:gem/rbi#lib/rbi/visitor.rb:140 sig { params(node: ::RBI::Struct).void } def visit_struct(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:219 + # pkg:gem/rbi#lib/rbi/visitor.rb:224 sig { params(node: ::RBI::TEnum).void } def visit_tenum(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:222 + # pkg:gem/rbi#lib/rbi/visitor.rb:227 sig { params(node: ::RBI::TEnumBlock).void } def visit_tenum_block(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:225 + # pkg:gem/rbi#lib/rbi/visitor.rb:230 sig { params(node: ::RBI::TEnumValue).void } def visit_tenum_value(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:141 + # pkg:gem/rbi#lib/rbi/visitor.rb:143 sig { params(node: ::RBI::Tree).void } def visit_tree(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:210 + # pkg:gem/rbi#lib/rbi/visitor.rb:215 sig { params(node: ::RBI::TStruct).void } def visit_tstruct(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:213 + # pkg:gem/rbi#lib/rbi/visitor.rb:218 sig { params(node: ::RBI::TStructConst).void } def visit_tstruct_const(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:216 + # pkg:gem/rbi#lib/rbi/visitor.rb:221 sig { params(node: ::RBI::TStructProp).void } def visit_tstruct_prop(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:231 + # pkg:gem/rbi#lib/rbi/visitor.rb:236 sig { params(node: ::RBI::TypeMember).void } def visit_type_member(node); end - # pkg:gem/rbi#lib/rbi/visitor.rb:243 + # pkg:gem/rbi#lib/rbi/visitor.rb:248 sig { params(node: ::RBI::VisibilityGroup).void } def visit_visibility_group(node); end end diff --git a/sorbet/rbi/gems/rbs@4.1.2.rbi b/sorbet/rbi/gems/rbs@4.1.3.rbi similarity index 100% rename from sorbet/rbi/gems/rbs@4.1.2.rbi rename to sorbet/rbi/gems/rbs@4.1.3.rbi diff --git a/sorbet/rbi/gems/redis-client@0.29.0.rbi b/sorbet/rbi/gems/redis-client@0.29.0.rbi index 2157cb385..40fa12ff0 100644 --- a/sorbet/rbi/gems/redis-client@0.29.0.rbi +++ b/sorbet/rbi/gems/redis-client@0.29.0.rbi @@ -7,7 +7,6 @@ module Process extend ::SQLite3::ForkSafety::CoreExt - extend ::Dalli::PIDCache::CoreExt extend ::ConnectionPool::ForkTracker extend ::RedisClient::PIDCache::CoreExt extend ::ActiveSupport::ForkTracker::CoreExt diff --git a/sorbet/rbi/gems/rubocop-shopify@3.0.1.rbi b/sorbet/rbi/gems/rubocop-shopify@3.0.1.rbi deleted file mode 100644 index f742e7aee..000000000 --- a/sorbet/rbi/gems/rubocop-shopify@3.0.1.rbi +++ /dev/null @@ -1,120 +0,0 @@ -# typed: true - -# DO NOT EDIT MANUALLY -# This is an autogenerated file for types exported from the `rubocop-shopify` gem. -# Please instead update this file by running `bin/tapioca gem rubocop-shopify`. - - -# pkg:gem/rubocop-shopify#lib/rubocop/shopify/version.rb:3 -module RuboCop; end - -# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:6 -module RuboCop::Cop; end - -# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:7 -module RuboCop::Cop::Lint; end - -# Checks for the use of a `return` with a value in `begin..end` blocks -# in the context of instance variable assignment such as memoization. -# Using `return` with a value in these blocks can lead to unexpected behavior -# as the `return` will exit the method that contains and not set the values -# of the instance variable. -# -# @example -# -# # bad -# def foo -# @foo ||= begin -# return 1 if bar -# 2 -# end -# end -# -# # bad -# def foo -# @foo = begin -# return 1 if bar -# 2 -# end -# end -# -# # bad -# def foo -# @foo += begin -# return 1 if bar -# 2 -# end -# end -# -# # bad - using return in rescue blocks still exits the method -# def foo -# @foo ||= begin -# bar -# rescue -# return 2 if baz -# end -# end -# -# # good -# def foo -# @foo ||= begin -# if bar -# 1 -# else -# 2 -# end -# end -# end -# -# # good - not an assignment to an instance variable -# def foo -# foo = begin -# return 1 if bar -# 2 -# end -# end -# -# # good - proper exception handling without return -# def foo -# @foo ||= begin -# bar -# rescue -# baz ? 2 : 3 -# end -# end -# -# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:76 -class RuboCop::Cop::Lint::NoReturnInMemoization < ::RuboCop::Cop::Base - # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:94 - def on_and_asgn(node); end - - # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:93 - def on_ivasgn(node); end - - # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:87 - def on_op_asgn(node); end - - # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:79 - def on_or_asgn(node); end -end - -# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:77 -RuboCop::Cop::Lint::NoReturnInMemoization::MSG = T.let(T.unsafe(nil), String) - -# pkg:gem/rubocop-shopify#lib/rubocop/shopify/version.rb:4 -module RuboCop::Shopify; end - -# pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:7 -class RuboCop::Shopify::Plugin < ::LintRoller::Plugin - # pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:8 - def about; end - - # pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:21 - def rules(context); end - - # pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:17 - def supported?(context); end -end - -# pkg:gem/rubocop-shopify#lib/rubocop/shopify/version.rb:5 -RuboCop::Shopify::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/rubocop-shopify@3.0.2.rbi b/sorbet/rbi/gems/rubocop-shopify@3.0.2.rbi new file mode 100644 index 000000000..78c6c04fb --- /dev/null +++ b/sorbet/rbi/gems/rubocop-shopify@3.0.2.rbi @@ -0,0 +1,207 @@ +# typed: true + +# DO NOT EDIT MANUALLY +# This is an autogenerated file for types exported from the `rubocop-shopify` gem. +# Please instead update this file by running `bin/tapioca gem rubocop-shopify`. + + +# pkg:gem/rubocop-shopify#lib/rubocop/shopify/version.rb:3 +module RuboCop; end + +# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:6 +module RuboCop::Cop; end + +# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:7 +module RuboCop::Cop::Lint; end + +# Checks for the use of a `return` with a value in `begin..end` blocks +# in the context of instance variable assignment such as memoization. +# Using `return` with a value in these blocks can lead to unexpected behavior +# as the `return` will exit the method that contains and not set the values +# of the instance variable. +# +# @example +# +# # bad +# def foo +# @foo ||= begin +# return 1 if bar +# 2 +# end +# end +# +# # bad +# def foo +# @foo = begin +# return 1 if bar +# 2 +# end +# end +# +# # bad +# def foo +# @foo += begin +# return 1 if bar +# 2 +# end +# end +# +# # bad - using return in rescue blocks still exits the method +# def foo +# @foo ||= begin +# bar +# rescue +# return 2 if baz +# end +# end +# +# # good +# def foo +# @foo ||= begin +# if bar +# 1 +# else +# 2 +# end +# end +# end +# +# # good - not an assignment to an instance variable +# def foo +# foo = begin +# return 1 if bar +# 2 +# end +# end +# +# # good - proper exception handling without return +# def foo +# @foo ||= begin +# bar +# rescue +# baz ? 2 : 3 +# end +# end +# +# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:76 +class RuboCop::Cop::Lint::NoReturnInMemoization < ::RuboCop::Cop::Base + # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:94 + def on_and_asgn(node); end + + # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:93 + def on_ivasgn(node); end + + # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:87 + def on_op_asgn(node); end + + # pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:79 + def on_or_asgn(node); end +end + +# pkg:gem/rubocop-shopify#lib/rubocop/cop/lint/no_return_in_memoization.rb:77 +RuboCop::Cop::Lint::NoReturnInMemoization::MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:7 +module RuboCop::Cop::Style; end + +# Checks for `case` statements whose `when` conditions are only proc/lambda +# literals and value literals (with at least one proc). +# +# Such a `case` is just a harder-to-read `if`/`elsif` tree with a needless +# performance cost: a `when` clause matches using `pattern === subject`, +# and for a proc `Proc#===` is an alias for `Proc#call`. Every inline proc +# literal therefore allocates a brand new `Proc` object each time the +# `case` is evaluated (on a hot path, once per branch per call) and adds +# `Proc#call` indirection, where an `if`/`elsif` allocates nothing. For a +# value literal (number, string, symbol, `nil`, `true`, `false`) `===` is +# `==`, so the whole statement is exactly equivalent to `if`/`elsif` using +# `Proc#call` and `==`. Use `if`/`elsif` instead. +# +# Constants assigned a proc literal or a value literal *in the same file* +# are resolved and treated as such. Constants defined in other files cannot +# be resolved: a bare `when SOME_CONST` is indistinguishable from matching +# against a class, so those are left alone to avoid flagging idiomatic +# `case obj when SomeClass`. +# +# Cases that use class, range, or regexp patterns are also left alone: +# those rely on `===` in ways that read far worse as `if` conditions +# (`is_a?`, `cover?`, `match?`), which is exactly what `case` is for. +# +# @example +# +# # bad - every `when` is a proc (a new proc is allocated on each call) +# case value +# when ->(x) { x > 10 } then :big +# when ->(x) { x < 0 } then :negative +# else :other +# end +# +# # bad - only procs and value literals (including value-literal constants) +# NAME = "widget" +# case value +# when NAME then :named +# when ->(x) { x > 10 } then :big +# end +# +# # good - no proc allocation, and easier to read +# if value > 10 +# :big +# elsif value < 0 +# :negative +# else +# :other +# end +# +# # good - a class/range/regexp pattern makes `case` the clearer choice, +# # even alongside a proc. +# case value +# when Integer then :int +# when ->(x) { x > 10 } then :big +# end +# +# pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:62 +class RuboCop::Cop::Style::ProcCaseWhen < ::RuboCop::Cop::Base + # pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:84 + def on_case(node); end + + # pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:79 + def on_new_investigation; end + + # pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:72 + def proc_literal?(param0 = T.unsafe(nil)); end + + private + + # Maps the short (demodulized) name of every constant assigned in this + # file to its kind, so bare `when CONST` references can be resolved. + # + # pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:124 + def collect_constant_kinds; end + + # Classifies a `when` condition (or a constant's assigned value) as a + # proc, a value literal, or `:other` (anything we should not rewrite). + # + # pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:105 + def kind_of(node); end +end + +# pkg:gem/rubocop-shopify#lib/rubocop/cop/style/proc_case_when.rb:63 +RuboCop::Cop::Style::ProcCaseWhen::MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop-shopify#lib/rubocop/shopify/version.rb:4 +module RuboCop::Shopify; end + +# pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:7 +class RuboCop::Shopify::Plugin < ::LintRoller::Plugin + # pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:8 + def about; end + + # pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:21 + def rules(context); end + + # pkg:gem/rubocop-shopify#lib/rubocop/shopify/plugin.rb:17 + def supported?(context); end +end + +# pkg:gem/rubocop-shopify#lib/rubocop/shopify/version.rb:5 +RuboCop::Shopify::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/rubocop-sorbet@0.13.2.rbi b/sorbet/rbi/gems/rubocop-sorbet@0.14.0.rbi similarity index 89% rename from sorbet/rbi/gems/rubocop-sorbet@0.13.2.rbi rename to sorbet/rbi/gems/rubocop-sorbet@0.14.0.rbi index eb81a8e1c..e00963d26 100644 --- a/sorbet/rbi/gems/rubocop-sorbet@0.13.2.rbi +++ b/sorbet/rbi/gems/rubocop-sorbet@0.14.0.rbi @@ -11,6 +11,12 @@ module RuboCop; end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb:4 module RuboCop::Cop; end +module RuboCop::Cop::Lint; end + +class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Sorbet::VoidSorbetAwareBehaviour +end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb:5 module RuboCop::Cop::Sorbet; end @@ -33,6 +39,9 @@ class RuboCop::Cop::Sorbet::AllowIncompatibleOverride < ::RuboCop::Cop::Base # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:55 def on_block(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:73 + def on_itblock(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb:72 def on_numblock(node); end @@ -169,45 +178,48 @@ class RuboCop::Cop::Sorbet::BlockMethodDefinition < ::RuboCop::Cop::Base # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:80 def on_block(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:95 + def on_itblock(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:94 def on_numblock(node); end private - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:186 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:187 def adjust_for_closing_parenthesis(end_pos); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:106 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:107 def autocorrect_method_in_block(corrector, node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:198 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:199 def closing_parenthesis_follows(source); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:175 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:176 def find_end_position_with_arguments(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:182 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:183 def find_end_position_without_arguments(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:167 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:168 def find_method_signature_end_position(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:143 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:144 def handle_method_without_body(node, indent); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:161 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:162 def handle_multiline_method_without_body(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:155 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:156 def handle_single_line_method(node, indent); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:98 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:99 def in_activesupport_concern_class_methods_block?(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:151 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:152 def single_line_method?(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:132 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/block_method_definition.rb:133 def transform_args_to_block_args(node); end end @@ -702,102 +714,94 @@ class RuboCop::Cop::Sorbet::EnforceSignatures::Param < ::Struct end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:254 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:250 class RuboCop::Cop::Sorbet::EnforceSignatures::RBSSignatureChecker < ::RuboCop::Cop::Sorbet::EnforceSignatures::SignatureChecker - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:257 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:251 def signature_node(node); end - - private - - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:270 - def find_non_send_ancestor(node); end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:255 -RuboCop::Cop::Sorbet::EnforceSignatures::RBSSignatureChecker::RBS_COMMENT_REGEX = T.let(T.unsafe(nil), Regexp) - -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:330 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:310 class RuboCop::Cop::Sorbet::EnforceSignatures::RBSSuggestion - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:333 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:313 def initialize(indent); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def attribute; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def attribute=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def has_block; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def has_block=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def params; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def params=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def returns; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:331 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:311 def returns=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:341 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:321 def to_autocorrect; end private - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:347 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:327 def generate_signature; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:365 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:345 def rbs_param(param); end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:276 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:256 class RuboCop::Cop::Sorbet::EnforceSignatures::SigSignatureChecker < ::RuboCop::Cop::Sorbet::EnforceSignatures::SignatureChecker - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:277 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:257 def initialize(processed_source); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:290 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:270 def clear_signature(scope); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:286 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:266 def on_signature(node, scope); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:282 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:262 def signature_node(scope); end end -# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:295 +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:275 class RuboCop::Cop::Sorbet::EnforceSignatures::SigSuggestion - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:298 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:278 def initialize(indent, param_placeholder, return_placeholder); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:296 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:276 def params; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:296 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:276 def params=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:296 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:276 def returns; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:296 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:276 def returns=(_arg0); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:306 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:286 def to_autocorrect; end private - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:312 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:292 def generate_params; end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:319 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:299 def generate_return; end end @@ -808,9 +812,6 @@ class RuboCop::Cop::Sorbet::EnforceSignatures::SignatureChecker protected - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:249 - def preceding_comments(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb:247 def processed_source; end end @@ -1614,6 +1615,9 @@ class RuboCop::Cop::Sorbet::ForbidTTypeAlias < ::RuboCop::Cop::Base # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:23 def on_block(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:27 + def on_itblock(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_t_type_alias.rb:26 def on_numblock(node); end @@ -1701,6 +1705,9 @@ class RuboCop::Cop::Sorbet::ForbidTypeAliasedShapes < ::RuboCop::Cop::Base # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_type_aliased_shapes.rb:36 def on_block(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_type_aliased_shapes.rb:41 + def on_itblock(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/forbid_type_aliased_shapes.rb:40 def on_numblock(node); end @@ -2383,6 +2390,104 @@ RuboCop::Cop::Sorbet::SelectByIsA::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/select_by_is_a.rb:23 RuboCop::Cop::Sorbet::SelectByIsA::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Checks that setter methods (methods whose name ends with `=`) +# declare a `void` return type, in either a Sorbet `sig` block or an +# RBS inline comment signature. +# +# Sorbet requires setter methods to return `void`. Declaring any other +# return type violates the setter contract and is rejected by Sorbet +# +# @example +# +# # bad +# sig { params(name: String).returns(String) } +# def name=(name); end +# +# # good +# sig { params(name: String).void } +# def name=(name); end +# +# # bad +# #: (String) -> String +# def name=(name); end +# +# # good +# #: (String) -> void +# def name=(name); end +# +# # bad +# #: ( +# #| String name +# #| ) -> String +# def name=(name); end +# +# # good +# #: ( +# #| String name +# #| ) -> void +# def name=(name); end +# +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:44 +class RuboCop::Cop::Sorbet::SetterReturnType < ::RuboCop::Cop::Base + include ::RuboCop::Cop::Sorbet::SignatureHelp + include ::RuboCop::Cop::RangeHelp + extend ::RuboCop::Cop::AutoCorrector + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:53 + def on_def(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:56 + def on_defs(node); end + + private + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:60 + def check(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:140 + def check_rbs(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:103 + def check_sig(sig); end + + # Climb past `private`/`public`/`protected` and other send wrappers so + # sig/RBS lookup runs against the real surrounding siblings rather than + # the send's other arguments. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:80 + def outermost_send_ancestor(node); end + + # The `sig` blocks immediately preceding `target` among its siblings, + # supporting consecutive overload sigs. The scan stops at the first + # non-signature sibling so a setter never inherits another method's sig. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:88 + def preceding_sigs(target); end + + # Walks the receiver chain of the sig body (the builder call chain) + # and returns the outermost `void` or `returns` node, so a `void` or + # `returns` nested inside a type argument (e.g. `T.proc.void`) is not + # mistaken for the method's return declaration. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:121 + def return_declaration(node); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:72 + def setter?(node); end + + # Range covering `returns(TYPE)` (selector through the closing + # paren / last argument), to be replaced with `void`. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:133 + def sig_return_range(returns_node); end +end + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:49 +RuboCop::Cop::Sorbet::SetterReturnType::MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/setter_return_type.rb:51 +RuboCop::Cop::Sorbet::SetterReturnType::NON_SETTER_OPERATORS = T.let(T.unsafe(nil), Array) + # Checks for the correct order of `sig` builder methods. # # Options: @@ -2439,10 +2544,13 @@ module RuboCop::Cop::Sorbet::SignatureHelp # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/signature_help.rb:42 def on_block(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/signature_help.rb:47 + def on_itblock(node); end + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/signature_help.rb:46 def on_numblock(node); end - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/signature_help.rb:48 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/signature_help.rb:49 def on_signature(_node); end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/signature_help.rb:25 @@ -2550,14 +2658,14 @@ module RuboCop::Cop::Sorbet::TLetCorrection # Returns the comment trailing the heredoc marker, including its leading space. # For example, the marker line `<<~SQL, String) # query` returns ` # query`. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:55 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:65 def marker_line_comment(value_node); end # Expands the correction range to include every heredoc body and terminator. # For example, the range for `T.let(<<~SQL, String)` extends through the # final `SQL` terminator rather than ending at the closing parenthesis. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:35 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:45 def range_including_heredocs(t_let_node, heredocs); end # Replaces `T.let(value, Type)` with `value`. @@ -2569,15 +2677,22 @@ module RuboCop::Cop::Sorbet::TLetCorrection # contained in the value. For example, `T.let(<<~SQL, String)` becomes # `<<~SQL` followed by its original body and terminator. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:25 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:35 def replace_t_let_preserving_heredocs(corrector, t_let_node, value_node, heredocs); end # Reconstructs the value with its marker-line comment and heredoc bodies. # For example, `T.let(<<~SQL, String) # query` becomes a source string # containing `<<~SQL # query`, followed by its body and `SQL` terminator. # - # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:44 + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:54 def source_including_heredocs(value_node, heredocs); end + + # Heredocs at the tail of the value, whose body sits past `value_node`'s + # source range. An interior heredoc, e.g. `Foo.new(a: <<~X, b: 2)`, already + # lives inside `value_node.source` and must not be reattached. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/t_let_correction.rb:25 + def tail_heredocs(value_node); end end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb:6 @@ -2808,6 +2923,45 @@ end # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/signatures/void_checked_tests.rb:41 RuboCop::Cop::Sorbet::VoidCheckedTests::MESSAGE = T.let(T.unsafe(nil), String) +# Patches `Lint/Void` to be aware of RBS inline `#: absurd` type +# assertions, which are used to mark unreachable branches in exhaustive +# `case`/`when` matching. +# +# Without this patch, RuboCop 1.85+ flags the expression in the +# unreachable branch as "used in void context" because `Lint/Void` now +# inspects `case`/`when` branch bodies (rubocop/rubocop#14756). +# +# @example +# +# # good (not flagged) +# #: ((String | Integer) x) -> void +# def foo(x) +# case x +# when String +# when Integer +# else +# x #: absurd +# end +# end +# +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/void_sorbet_aware_behaviour.rb:28 +module RuboCop::Cop::Sorbet::VoidSorbetAwareBehaviour + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/void_sorbet_aware_behaviour.rb:31 + def check_expression(expr); end + + private + + # Checks whether `node` is followed by an RBS `#: absurd` inline + # comment on the same line, indicating a deliberate unreachable-type + # assertion that should not be treated as a void-context misuse. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/void_sorbet_aware_behaviour.rb:43 + def rbs_absurd_assertion?(node); end +end + +# pkg:gem/rubocop-sorbet#lib/rubocop/cop/sorbet/void_sorbet_aware_behaviour.rb:29 +RuboCop::Cop::Sorbet::VoidSorbetAwareBehaviour::RBS_ABSURD_PATTERN = T.let(T.unsafe(nil), Regexp) + module RuboCop::Cop::Style; end class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base @@ -2817,7 +2971,7 @@ end # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/version.rb:4 module RuboCop::Sorbet; end -# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet.rb:11 +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet.rb:12 class RuboCop::Sorbet::Error < ::StandardError; end # A plugin that integrates RuboCop Sorbet with RuboCop's plugin system. @@ -2834,5 +2988,124 @@ class RuboCop::Sorbet::Plugin < ::LintRoller::Plugin def supported?(context); end end +# Pure helpers for parsing RBS inline-comment signatures (`#:` / `#|`). +# +# Every public method takes a `processed_source` and/or comment nodes +# explicitly, so this module is usable both from a Cop and from a plain +# service class such as +# `RuboCop::Cop::Sorbet::EnforceSignatures::RBSSignatureChecker`. +# No Cop::Base state is required. +# +# `rbs_signatures_before` returns `Signature` objects that encapsulate one +# RBS overload each; ask them for `return_type`, `return_type_range`, and +# `void?` rather than reaching back into the parser for those facts. +# +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:16 +module RuboCop::Sorbet::RBSParser + class << self + # The RBS signatures attached to `node`, one `Signature` per overload. + # Climbs `private`/`public`/other send wrappers, collects the contiguous + # comment block above the unwrapped node, and groups the RBS comments. + # A signature separated from the method by a blank line is not attached. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:27 + def rbs_signatures_before(processed_source, node); end + + private + + # Comments forming a contiguous block immediately above `node`, in source + # order. A blank line or non-comment sibling breaks the run. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:53 + def comments_above(processed_source, node); end + + # Group already-collected comments into RBS signatures. A `#:` line begins + # a new overload; subsequent `#|` lines continue it. Non-RBS comments are + # skipped. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:38 + def rbs_signature_groups(comments); end + end +end + +# `#|` continues the preceding `#:` signature (e.g. multiline params/returns). +# +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:20 +RuboCop::Sorbet::RBSParser::RBS_CONTINUATION_PREFIX = T.let(T.unsafe(nil), Regexp) + +# `#:` begins an RBS signature (each repeated `#:` line is a new overload). +# +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:18 +RuboCop::Sorbet::RBSParser::RBS_SIGNATURE_PREFIX = T.let(T.unsafe(nil), Regexp) + +# One RBS signature (a `#:` line plus any `#|` continuation lines). +# Encapsulates the parsed structure so callers query the signature rather +# than re-parsing comments through the module. +# +# pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:75 +class RuboCop::Sorbet::RBSParser::Signature + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:78 + def initialize(processed_source, comments); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:76 + def comments; end + + # The return type expression as a string (e.g. `"String"`, `"void"`, + # `"^(Integer) -> void"`, `"Integer | String"`), or nil if the + # signature has no return arrow or an empty return. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:86 + def return_type; end + + # `[highlight_range, replace_range]` covering the return type + # expression, or nil if there is no return type. `highlight_range` + # covers the first token (which may span `#|` lines); `replace_range` + # covers the entire return expression. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:94 + def return_type_range; end + + # True if the signature declares a `void` return type. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:101 + def void?; end + + private + + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:111 + def compute; end + + # Index of the method return arrow: the first `->` at the top level, + # i.e. outside parameter/block/proc delimiters. A proc return type such + # as `^(Integer) -> void` has its own nested arrow that must not be + # mistaken for the method arrow. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:132 + def method_arrow_index(joined); end + + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:107 + def parsed; end + + # Map a position within the joined signature back to the originating + # comment and build a source range covering `length` characters. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:149 + def range_for_token(segments, token_start, length); end + + # Source position at the end of the group's last non-blank signature + # content; the return type expression runs to here. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:167 + def return_end_pos(segments); end + + # Strip the leading `#:`/`#|` marker and surrounding whitespace, + # returning `[content, prefix_length]`. `prefix_length` is the number + # of characters consumed from the original text, for mapping + # joined-content positions back to source offsets. + # + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/rbs_parser.rb:179 + def strip_rbs_prefix(text); end +end + # pkg:gem/rubocop-sorbet#lib/rubocop/sorbet/version.rb:5 RuboCop::Sorbet::VERSION = T.let(T.unsafe(nil), String) diff --git a/sorbet/rbi/gems/rubocop@1.88.2.rbi b/sorbet/rbi/gems/rubocop@1.89.0.rbi similarity index 94% rename from sorbet/rbi/gems/rubocop@1.88.2.rbi rename to sorbet/rbi/gems/rubocop@1.89.0.rbi index 51f98d0be..7d4848305 100644 --- a/sorbet/rbi/gems/rubocop@1.88.2.rbi +++ b/sorbet/rbi/gems/rubocop@1.89.0.rbi @@ -909,6 +909,15 @@ class RuboCop::CommentConfig # pkg:gem/rubocop#lib/rubocop/comment_config.rb:56 def extra_enabled_comments; end + # The names of the cops that are opted in by an `enable` comment directive, + # used to mobilize cops disabled in the config on demand. + # + # @api private + # @return [Set] + # + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:73 + def opt_in_cops; end + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:30 def processed_source; end @@ -917,64 +926,69 @@ class RuboCop::CommentConfig private - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:99 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:104 def analyze; end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:174 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:181 def analyze_cop(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:192 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:199 def analyze_disabled(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:199 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:206 def analyze_rest(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:185 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:192 def analyze_single_line(analysis, directive); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:145 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:152 def apply_cop_op(analyses, operation, cop, line); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:139 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:146 def apply_push(analyses, resolved_cops, line); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:206 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:213 def cop_line_ranges(analysis); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:212 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:219 def each_directive; end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:133 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:140 def expand_cop_name(name); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:70 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:88 def extra_enabled_comments_with_names(extras:, names:); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:232 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:248 def handle_enable_all(directive, names, extras); end # Collect cops that have been disabled or enabled by name in a directive comment # so that `Lint/RedundantCopEnableDirective` can register offenses correctly. # - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:246 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:262 def handle_switch(directive, names, extras); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:165 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:172 def inject_disabled_cops_directives(analyses); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:225 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:241 def non_comment_token_line_numbers; end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:85 - def opt_in_cops; end - - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:155 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:162 def pop_state(analyses, line); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:221 + # `Style/DisableCopsWithinSourceCodeDirective` cannot be disabled via + # directive comments when it is explicitly enabled with `Enabled: true`. + # This prevents users from bypassing the cop by writing a disable + # directive that targets this cop itself. + # + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:236 + def prevent_directive_disabling?(cop_name); end + + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:228 def qualified_cop_name(cop_name); end - # pkg:gem/rubocop#lib/rubocop/comment_config.rb:127 + # pkg:gem/rubocop#lib/rubocop/comment_config.rb:134 def resolve_push_cops(directive); end end @@ -1106,13 +1120,13 @@ class RuboCop::Config # pkg:gem/rubocop#lib/rubocop/config.rb:97 def []=(*_arg0, **_arg1, &_arg2); end - # pkg:gem/rubocop#lib/rubocop/config.rb:212 + # pkg:gem/rubocop#lib/rubocop/config.rb:226 def active_support_extensions_enabled?; end # pkg:gem/rubocop#lib/rubocop/config.rb:127 def add_excludes_from_higher_level(highest_config); end - # pkg:gem/rubocop#lib/rubocop/config.rb:240 + # pkg:gem/rubocop#lib/rubocop/config.rb:254 def allowed_camel_case_file?(file); end # Paths specified in configuration files starting with .rubocop are @@ -1121,12 +1135,12 @@ class RuboCop::Config # config/default.yml, for example, are not relative to RuboCop's config # directory since that wouldn't work. # - # pkg:gem/rubocop#lib/rubocop/config.rb:281 + # pkg:gem/rubocop#lib/rubocop/config.rb:295 def base_dir_for_path_parameters; end # @return [String, nil] # - # pkg:gem/rubocop#lib/rubocop/config.rb:311 + # pkg:gem/rubocop#lib/rubocop/config.rb:325 def bundler_lock_file_path; end # pkg:gem/rubocop#lib/rubocop/config.rb:85 @@ -1159,20 +1173,28 @@ class RuboCop::Config # pkg:gem/rubocop#lib/rubocop/config.rb:97 def each_key(*_arg0, **_arg1, &_arg2); end + # Whether the given pending cop should be enabled, based on the `NewCops` setting of + # its department (if any) or of `AllCops`. A department may set `NewCops` to `enable`, + # `disable`, `pending`, or a version, in which case pending cops added in that version + # or earlier are enabled. + # + # pkg:gem/rubocop#lib/rubocop/config.rb:216 + def enabled_new_cop?(qualified_cop_name); end + # pkg:gem/rubocop#lib/rubocop/config.rb:208 def enabled_new_cops?; end # pkg:gem/rubocop#lib/rubocop/config.rb:97 def fetch(*_arg0, **_arg1, &_arg2); end - # pkg:gem/rubocop#lib/rubocop/config.rb:259 + # pkg:gem/rubocop#lib/rubocop/config.rb:273 def file_to_exclude?(file); end # Returns true if the file matches any include pattern. If a block is given, the block is called # to determine if the pattern is relevant (true returned by the block) or should be skipped # (false returned). # - # pkg:gem/rubocop#lib/rubocop/config.rb:223 + # pkg:gem/rubocop#lib/rubocop/config.rb:237 def file_to_include?(file); end # pkg:gem/rubocop#lib/rubocop/config.rb:196 @@ -1208,10 +1230,10 @@ class RuboCop::Config # Returns target's locked gem versions (i.e. from Gemfile.lock or gems.locked) # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names. # - # pkg:gem/rubocop#lib/rubocop/config.rb:336 + # pkg:gem/rubocop#lib/rubocop/config.rb:351 def gem_versions_in_target; end - # pkg:gem/rubocop#lib/rubocop/config.rb:340 + # pkg:gem/rubocop#lib/rubocop/config.rb:355 def inspect; end # True if this is a config file that is shipped with RuboCop @@ -1243,25 +1265,25 @@ class RuboCop::Config # pkg:gem/rubocop#lib/rubocop/config.rb:97 def merge(*_arg0, **_arg1, &_arg2); end - # pkg:gem/rubocop#lib/rubocop/config.rb:291 + # pkg:gem/rubocop#lib/rubocop/config.rb:305 def parser_engine; end - # pkg:gem/rubocop#lib/rubocop/config.rb:272 + # pkg:gem/rubocop#lib/rubocop/config.rb:286 def path_relative_to_config(path); end - # pkg:gem/rubocop#lib/rubocop/config.rb:268 + # pkg:gem/rubocop#lib/rubocop/config.rb:282 def patterns_to_exclude; end - # pkg:gem/rubocop#lib/rubocop/config.rb:264 + # pkg:gem/rubocop#lib/rubocop/config.rb:278 def patterns_to_include; end - # pkg:gem/rubocop#lib/rubocop/config.rb:322 + # pkg:gem/rubocop#lib/rubocop/config.rb:336 def pending_cops; end # Returns true if there's a chance that an Include pattern matches hidden # files, false if that's definitely not possible. # - # pkg:gem/rubocop#lib/rubocop/config.rb:251 + # pkg:gem/rubocop#lib/rubocop/config.rb:265 def possibly_include_hidden?; end # pkg:gem/rubocop#lib/rubocop/config.rb:97 @@ -1270,13 +1292,13 @@ class RuboCop::Config # pkg:gem/rubocop#lib/rubocop/config.rb:105 def signature; end - # pkg:gem/rubocop#lib/rubocop/config.rb:306 + # pkg:gem/rubocop#lib/rubocop/config.rb:320 def smart_loaded_path; end - # pkg:gem/rubocop#lib/rubocop/config.rb:216 + # pkg:gem/rubocop#lib/rubocop/config.rb:230 def string_literals_frozen_by_default?; end - # pkg:gem/rubocop#lib/rubocop/config.rb:295 + # pkg:gem/rubocop#lib/rubocop/config.rb:309 def target_rails_version; end # pkg:gem/rubocop#lib/rubocop/config.rb:99 @@ -1302,34 +1324,56 @@ class RuboCop::Config private - # pkg:gem/rubocop#lib/rubocop/config.rb:396 + # Returns a `Gem::Version` for values like `'1.19'` or `1.19`, and `nil` + # for non-version values like `'N/A'` or `'<>'`. + # + # pkg:gem/rubocop#lib/rubocop/config.rb:451 + def comparable_version(value); end + + # pkg:gem/rubocop#lib/rubocop/config.rb:411 def department_of(qualified_cop_name); end - # pkg:gem/rubocop#lib/rubocop/config.rb:384 + # pkg:gem/rubocop#lib/rubocop/config.rb:399 def enable_cop?(qualified_cop_name, cop_options); end # @param [Gem::Version] gem_version an object like `Gem::Version.new("7.1.2.3")` # @return [Float] The major and minor version, like `7.1` # - # pkg:gem/rubocop#lib/rubocop/config.rb:371 + # pkg:gem/rubocop#lib/rubocop/config.rb:386 def gem_version_to_major_minor_float(gem_version); end - # pkg:gem/rubocop#lib/rubocop/config.rb:346 + # pkg:gem/rubocop#lib/rubocop/config.rb:361 def match_relative_or_absolute_path?(pattern, relative_file_path, absolute_file_path); end + # Whether the cop's pending status is resolved by a `NewCops` setting, + # so that it should not appear in the pending cops warning. + # Unlike `enabled_new_cop?`, `disable` counts as covered. + # + # pkg:gem/rubocop#lib/rubocop/config.rb:430 + def new_cops_covered?(qualified_cop_name); end + + # The effective `NewCops` setting for the given cop: the department-level + # setting if present, otherwise the `AllCops` setting. + # + # pkg:gem/rubocop#lib/rubocop/config.rb:420 + def new_cops_setting_for(qualified_cop_name); end + + # pkg:gem/rubocop#lib/rubocop/config.rb:440 + def new_cops_version_covers?(new_cops_version, qualified_cop_name); end + # @returns [Hash{String => Gem::Version}] The locked gem versions, keyed by the gems' names. # - # pkg:gem/rubocop#lib/rubocop/config.rb:377 + # pkg:gem/rubocop#lib/rubocop/config.rb:392 def read_gem_versions_from_target_lockfile; end # @return [Float, nil] The Rails version as a `major.minor` Float. # - # pkg:gem/rubocop#lib/rubocop/config.rb:358 + # pkg:gem/rubocop#lib/rubocop/config.rb:373 def read_rails_version_from_bundler_lock_file; end # @return [Float, nil] The Rails version as a `major.minor` Float. # - # pkg:gem/rubocop#lib/rubocop/config.rb:353 + # pkg:gem/rubocop#lib/rubocop/config.rb:368 def target_rails_version_from_bundler_lock_file; end class << self @@ -2146,19 +2190,19 @@ end class RuboCop::ConfigValidator extend ::RuboCop::SimpleForwardable - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:28 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:30 def initialize(config); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:26 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:28 def for_all_cops(*_arg0, **_arg1, &_arg2); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:26 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:28 def smart_loaded_path(*_arg0, **_arg1, &_arg2); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:65 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:67 def target_ruby_version; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:34 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:36 def validate; end # Validations that should only be run after all config resolving has @@ -2167,62 +2211,74 @@ class RuboCop::ConfigValidator # chain has been loaded so that only the final value is validated, and # any obsolete but overridden values are ignored. # - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:61 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:63 def validate_after_resolution; end private - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:100 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:102 def alert_about_unrecognized_cops(invalid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:263 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:300 def check_cop_config_value(hash, parent = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:73 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:75 def check_obsoletions; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:80 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:82 def check_target_ruby; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:205 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:239 def each_invalid_parameter(cop_name); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:116 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:118 def list_unknown_cops(invalid_cop_names); end + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:196 + def new_cops_value_for_department(name, section); end + + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:203 + def new_cops_version_value?(value); end + # FIXME: Handling colors in exception messages like this is ugly. # - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:284 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:321 def param_error_message(parent, key, value, supposed_values); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:252 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:289 def reject_conflicting_safe_settings; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:243 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:280 def reject_mutually_exclusive_defaults; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:139 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:141 def suggestion(name); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:71 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:73 def target_ruby; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:217 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:173 + def validate_all_cops_new_cops_parameter; end + + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:184 + def validate_department_new_cops_parameters; end + + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:254 def validate_enforced_styles(valid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:166 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:168 def validate_new_cops_parameter; end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:191 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:225 def validate_parameter_names(valid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:177 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:211 def validate_parameter_shape(valid_cop_names); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:237 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:274 def validate_support_and_has_list(name, formats, valid); end - # pkg:gem/rubocop#lib/rubocop/config_validator.rb:155 + # pkg:gem/rubocop#lib/rubocop/config_validator.rb:157 def validate_syntax_cop; end end @@ -2231,15 +2287,15 @@ end # pkg:gem/rubocop#lib/rubocop/config_validator.rb:11 RuboCop::ConfigValidator::COMMON_PARAMS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/config_validator.rb:23 +# pkg:gem/rubocop#lib/rubocop/config_validator.rb:25 RuboCop::ConfigValidator::CONFIG_CHECK_AUTOCORRECTS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/config_validator.rb:22 +# pkg:gem/rubocop#lib/rubocop/config_validator.rb:24 RuboCop::ConfigValidator::CONFIG_CHECK_DEPARTMENTS = T.let(T.unsafe(nil), Array) # @api private # -# pkg:gem/rubocop#lib/rubocop/config_validator.rb:21 +# pkg:gem/rubocop#lib/rubocop/config_validator.rb:23 RuboCop::ConfigValidator::CONFIG_CHECK_KEYS = T.let(T.unsafe(nil), Set) # @api private @@ -2252,6 +2308,11 @@ RuboCop::ConfigValidator::INTERNAL_PARAMS = T.let(T.unsafe(nil), Array) # pkg:gem/rubocop#lib/rubocop/config_validator.rb:18 RuboCop::ConfigValidator::NEW_COPS_VALUES = T.let(T.unsafe(nil), Array) +# @api private +# +# pkg:gem/rubocop#lib/rubocop/config_validator.rb:20 +RuboCop::ConfigValidator::NEW_COPS_VERSION_PATTERN = T.let(T.unsafe(nil), Regexp) + # pkg:gem/rubocop#lib/rubocop/cop/util.rb:4 module RuboCop::Cop; end @@ -2316,54 +2377,82 @@ class RuboCop::Cop::AlignmentCorrector extend ::RuboCop::Cop::Alignment class << self - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:32 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:40 def align_end(corrector, processed_source, node, align_to); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:15 - def correct(corrector, processed_source, node, column_delta); end + # `tab_indentation` may only be set by callers whose `column_delta` represents + # whole indentation levels (e.g. `Layout/IndentationWidth`). + # Alignment to an arbitrary column cannot be expressed with tabs, so those callers + # leave tab correction disabled to avoid producing a never-converging correction. + # + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:19 + def correct(corrector, processed_source, node, column_delta, tab_indentation: T.unsafe(nil)); end # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:13 def processed_source; end private - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:168 def alignment_column(align_to); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:47 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:55 def autocorrect_line(corrector, line_begin_pos, expr, column_delta, taboo_ranges); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:136 def block_comment_within?(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:142 def calculate_range(expr, line_begin_pos, column_delta); end + # The number of columns a single tab spans. This must match the width + # `Layout/IndentationWidth` uses to compute `column_delta`, otherwise + # the division below would not land on a tab boundary. `Layout/IndentationStyle` + # has its own `IndentationWidth`, but that only governs how that cop replaces tabs + # with spaces, so it must not be consulted here. + # + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:107 + def configured_indentation_width; end + + # Tab indentation is corrected by rewriting each line's leading whitespace to + # the target number of tabs. Working in whole tabs rather than applying a column delta + # keeps the result idempotent, which avoids the infinite loops that delta-based correction + # caused for tabs. + # + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:73 + def correct_tab_indentation(corrector, expr, column_delta, taboo_ranges); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:82 + def correct_tab_line(corrector, line_range, column_delta, taboo_ranges); end + # Some special kinds of string literals are not composed of literal # characters between two delimiters: # - The source map of `?a` responds to :begin and :end but its end is # nil. # - The source map of `__FILE__` responds to neither :begin nor :end. # - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:132 def delimited_string_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:154 def each_line(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:128 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:178 def indentation_string(column); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:117 def inside_string_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:111 def inside_string_ranges(node); end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:93 + def target_tab_indentation(leading, column_delta); end + + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:186 def using_tabs?; end - # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/correctors/alignment_corrector.rb:162 def whitespace_range(node); end end end @@ -2693,13 +2782,19 @@ class RuboCop::Cop::Badge # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:51 def match?(other); end - # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:59 + # Returns true if the badge's qualified name or the badge's department + # matches any of the given names. + # + # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:57 + def match_name?(given_names); end + + # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:67 def qualified?; end - # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:55 + # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:63 def to_s; end - # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/badge.rb:71 def with_department(department); end class << self @@ -2913,87 +3008,87 @@ class RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:490 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:492 def annotate(message); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:381 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:387 def apply_correction(corrector); end # @return [Symbol] offense status # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:454 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:456 def attempt_correction(range, corrector); end # Reserved for Cop::Cop # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:377 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:383 def callback_argument(range); end # Called to complete an investigation # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:410 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:412 def complete_investigation; end # @return [Symbol, Corrector] offense status # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:428 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:430 def correct(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:395 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:401 def current_corrector; end # Reserved for Commissioner: # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:387 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:393 def current_offense_locations; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:399 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:405 def current_offenses; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:391 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:397 def currently_disabled_lines; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:533 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:535 def custom_severity; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:529 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:531 def default_severity; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:468 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:470 def disable_uncorrectable(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:519 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:521 def enabled_line?(line_number); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:496 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:498 def file_name_matches_any?(file, parameter, default_result); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:486 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:488 def find_message(range, message); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:525 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:527 def find_severity(_range, severity); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:511 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:513 def matches_absolute_include_pattern?(patterns, file); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:546 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:548 def range_for_original(range); end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:475 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:477 def range_from_node_or_range(node_or_range); end # Actually private methods # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:420 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:422 def reset_investigation; end - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:557 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:559 def target_satisfies_all_gem_version_requirements?; end # @return [Symbol] offense status # - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:443 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:445 def use_corrector(range, corrector); end class << self @@ -3093,12 +3188,12 @@ class RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/base.rb:403 + # pkg:gem/rubocop#lib/rubocop/cop/base.rb:377 def restrict_on_send; end end end -# pkg:gem/rubocop#lib/rubocop/cop/base.rb:407 +# pkg:gem/rubocop#lib/rubocop/cop/base.rb:409 RuboCop::Cop::Base::EMPTY_OFFENSES = T.let(T.unsafe(nil), Array) # Reports of an investigation. @@ -3154,8 +3249,13 @@ end # pkg:gem/rubocop#lib/rubocop/cop/base.rb:52 RuboCop::Cop::Base::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Set) -# pkg:gem/rubocop#lib/rubocop/cop/bundler/duplicated_gem.rb:5 -module RuboCop::Cop::Bundler; end +# Cops for the `Bundler` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/bundler.rb:7 +module RuboCop::Cop::Bundler + extend ::RuboCop::Cop::LazyLoader +end # A Gem's requirements should be listed only once in a Gemfile. # @@ -3832,35 +3932,42 @@ module RuboCop::Cop::CheckLineBreakable # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:202 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:220 def all_on_same_line?(nodes); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:222 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:240 def already_on_multiple_lines?(node); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:137 def breakable_collection?(node, elements); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:228 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:246 def chained_to_heredoc?(node); end # @api private + # The result depends only on the given node, but the check may traverse all children of + # a large collection and is repeated for each contained element, so memoize it per node. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:189 - def children_could_be_broken_up?(children); end + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:195 + def children_could_be_broken_up?(node, children); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:207 + def compute_children_could_be_broken_up?(children); end + + # @api private + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:154 def contained_by_breakable_collection_on_same_line?(node); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:174 def contained_by_multiline_collection_that_could_be_broken_up?(node); end # @api private @@ -3870,34 +3977,34 @@ module RuboCop::Cop::CheckLineBreakable # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:76 def extract_first_element_over_column_limit(node, elements, max); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:96 def first_argument_is_heredoc?(node); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:227 def process_args(args); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:121 def safe_to_ignore?(node); end # @api private # If a `send` or `csend` node contains a heredoc argument, splitting cannot happen # after the heredoc or else it will cause a syntax error. # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:105 def shift_elements_for_heredoc_arg(node, elements, index); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/check_line_breakable.rb:116 def within_column_limit?(element, max, line); end end @@ -5171,8 +5278,14 @@ module RuboCop::Cop::EndlessMethodRewriter private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_rewriter.rb:19 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_rewriter.rb:23 def arguments(node, missing = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_rewriter.rb:27 + def configured_indentation_width; end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/endless_method_rewriter.rb:19 + def receiver(node); end end # Common functionality for enforcing a specific superclass. @@ -5398,8 +5511,13 @@ module RuboCop::Cop::GemDeclaration def gem_declaration?(param0 = T.unsafe(nil)); end end -# pkg:gem/rubocop#lib/rubocop/cop/gemspec/add_runtime_dependency.rb:5 -module RuboCop::Cop::Gemspec; end +# Cops for the `Gemspec` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/gemspec.rb:7 +module RuboCop::Cop::Gemspec + extend ::RuboCop::Cop::LazyLoader +end # Prefer `add_dependency` over `add_runtime_dependency` as the latter is # considered soft-deprecated. @@ -6173,13 +6291,16 @@ class RuboCop::Cop::Generator # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:119 def initialize(name, output: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:143 def inject_config(config_file_path: T.unsafe(nil), version_added: T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:139 + def inject_registration; end + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:135 def inject_require(root_file_path: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:156 def todo; end # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:127 @@ -6190,31 +6311,31 @@ class RuboCop::Cop::Generator private - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:166 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:170 def badge; end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:193 def generate(template); end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:185 def generated_source; end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:189 def generated_spec; end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:166 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:170 def output; end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:218 def snake_case(camel_case_string); end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:208 def source_path; end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:198 def spec_path; end - # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/generator.rb:172 def write_unless_file_exists(path, contents); end end @@ -6263,6 +6384,99 @@ end # pkg:gem/rubocop#lib/rubocop/cop/generator/configuration_injector.rb:10 RuboCop::Cop::Generator::ConfigurationInjector::TEMPLATE = T.let(T.unsafe(nil), String) +# A class that injects a `register_cop` directive into the cop's department module +# so that the new cop is registered for lazy loading. +# The directive is injected in alphabetical order among the existing directives without +# reordering them, since the registration order defines the cop execution order. +# When the department module file does not exist yet, it is created, and a require for +# it is injected into the root RuboCop file. +# +# Anything unexpected in the department module, such as a commented-out or otherwise +# unparsable `register_cop` line, raises an error instead of silently producing +# a broken registration. +# +# pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:16 +class RuboCop::Cop::Generator::RegistrationInjector + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:25 + def initialize(source_path:, badge:, root_file_path: T.unsafe(nil), output: T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:33 + def inject; end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:44 + def badge; end + + # The directive path is relative to the department module file's directory, + # which `__dir__` resolves to at load time. + # + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:99 + def cop_path; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:57 + def create_department_file; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:44 + def department_file_path; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:152 + def department_module_source; end + + # The department requires form the contiguous block right before + # the `rubocop/cop/team` require in the root RuboCop file. + # + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:120 + def department_require_index(lines, require_directive); end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:114 + def directive; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:136 + def first_directive_position(lines); end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:63 + def inject_department_require; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:46 + def inject_directive; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:103 + def insertion_point(lines, entries); end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:182 + def module_closing_lines(modules); end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:166 + def module_opening_lines(modules); end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:44 + def output; end + + # @return [Array] the `register_cop` entries with their line numbers + # + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:83 + def parse_entries(lines); end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:44 + def root_file_path; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:44 + def source_path; end + + # pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:76 + def write_department_file(lines); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:23 +RuboCop::Cop::Generator::RegistrationInjector::DEPARTMENT_REQUIRE_PATTERN = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:18 +RuboCop::Cop::Generator::RegistrationInjector::ENTRY_PATTERN = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rubocop#lib/rubocop/cop/generator/registration_injector.rb:17 +RuboCop::Cop::Generator::RegistrationInjector::EXTEND_PATTERN = T.let(T.unsafe(nil), Regexp) + # A class that injects a require directive into the root RuboCop file. # It looks for other directives that require files in the same (cop) # namespace and injects the provided one in alpha @@ -6348,30 +6562,30 @@ end # This is a special case that just ensures the kwsplat is aligned with the rest of the hash # since a `kwsplat` does not have a key, separator or value. # -# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:146 +# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:163 class RuboCop::Cop::HashAlignmentStyles::KeywordSplatAlignment - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:164 def deltas(first_pair, current_pair); end end # Handles calculation of deltas when the enforced style is 'separator'. # -# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:121 +# pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:138 class RuboCop::Cop::HashAlignmentStyles::SeparatorAlignment include ::RuboCop::Cop::HashAlignmentStyles::ValueAlignment - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:141 def deltas_for_first_pair(_first_pair); end private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:151 def hash_rocket_delta(first_pair, current_pair); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:130 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:147 def key_delta(first_pair, current_pair); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:155 def value_delta(first_pair, current_pair); end end @@ -6392,13 +6606,25 @@ class RuboCop::Cop::HashAlignmentStyles::TableAlignment # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:94 def key_delta(first_pair, current_pair); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:132 def max_delimiter_width(hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:128 def max_key_width(hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:124 + def multiline_key_end_columns(hash_node); end + + # The column the separator should land on: the shared key margin + # plus the widest single-line key, or, if larger, a multiline key's + # own last-line end column. The latter can't be measured from a + # multiline key's (newline-including) source length, so it's a + # separate candidate rather than folded into `max_key_width`. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:114 + def target_operator_column(first_pair); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/hash_alignment_styles.rb:102 def value_delta(first_pair, current_pair); end end @@ -7017,8 +7243,13 @@ class RuboCop::Cop::LambdaLiteralToMethodCorrector def separating_space?; end end -# pkg:gem/rubocop#lib/rubocop/cop/mixin/empty_lines_around_body.rb:5 -module RuboCop::Cop::Layout; end +# Cops for the `Layout` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/layout.rb:7 +module RuboCop::Cop::Layout + extend ::RuboCop::Cop::LazyLoader +end # Bare access modifiers (those not applying to specific methods) should be # indented as deep as method definitions, or as deep as the `class`/`module` @@ -7928,16 +8159,16 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:209 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:351 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:357 def begin_pos_with_comment(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:374 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:380 def buffer; end # Setting categories hash allow you to group methods in group to match # in the {expected_order}. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:386 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:392 def categories; end # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:276 @@ -7954,22 +8185,22 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:229 def classify(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:317 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:323 def dynamic_constant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:341 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:347 def end_position_for(node); end # Load expected order from `ExpectedOrder` config. # Define new terms in the expected order by adding new {categories}. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:380 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:386 def expected_order; end # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:261 def find_category(name); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:370 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:376 def find_heredoc(node); end # Categorize a node according to the {expected_order} @@ -7981,28 +8212,31 @@ class RuboCop::Cop::Layout::ClassStructure < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:248 def find_send_node_category(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:308 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:299 + def flatten_class_elements(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:314 def humanize_node(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:292 def ignore?(node, classification); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:299 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:305 def ignore_for_autocorrect?(node, sibling); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:335 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:341 def marked_as_private_constant?(node, name); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:325 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:331 def private_constant?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:366 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:372 def start_line_position(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:267 def walk_over_nested_class_definition(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:362 + # pkg:gem/rubocop#lib/rubocop/cop/layout/class_structure.rb:368 def whole_line_comment_at_line?(line); end end @@ -12161,115 +12395,115 @@ class RuboCop::Cop::Layout::IndentationWidth < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:277 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:279 def access_modifier_indentation_style; end # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:206 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:503 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:505 def block_body_indentation_base(node, end_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:287 def check_assignment(node, rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:305 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:307 def check_if(node, body, else_clause, base_loc); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:318 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:320 def check_indentation(base_loc, body_node, style = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:219 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:221 def check_members(base, members); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:243 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:245 def check_members_for_indented_internal_methods_style(members); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:249 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:251 def check_members_for_normal_style(base, members); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:412 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:414 def check_rescue?(rescue_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:468 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:470 def column_offset_between(base_range, range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:454 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:456 def contains_access_modifier?(body_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:515 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:517 def dot_on_new_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:257 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:259 def each_member(members); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:281 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:283 def indentation_consistency_style; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:460 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:462 def indentation_style; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:395 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:397 def indentation_to_check?(base_loc, body_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:269 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:271 def indented_internal_methods_style?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:497 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:499 def leftmost_modifier_of(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:479 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:481 def line_indentation(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:484 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:486 def line_uses_tabs?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:352 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:354 def message(configured_indentation_width, indentation, name); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:373 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:375 def message_for_spaces(configured_indentation_width, indentation, name); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:360 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:362 def message_for_tabs(configured_indentation_width, indentation, name); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:431 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:433 def offending_range(body_node, indentation); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:328 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:330 def offense(body_node, indentation, style); end # Returns a range at the first non-space column of the line the opening parenthesis is on, # used as the base to indent the body from. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:216 def opening_line_start(begin_loc); end # Returns true if the given node is within another node that has # already been marked for autocorrection by this cop. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:385 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:387 def other_offense_in_same_range?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:231 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:233 def select_check_member(member); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:523 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:525 def selector_on_new_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:416 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:418 def skip_check?(base_loc, body_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:273 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:275 def special_modifier?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:445 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:447 def starts_with_access_modifier?(body_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:464 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:466 def using_tabs?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:488 + # pkg:gem/rubocop#lib/rubocop/cop/layout/indentation_width.rb:490 def visual_column(range); end end @@ -12405,66 +12639,90 @@ RuboCop::Cop::Layout::InitialIndentation::MSG = T.let(T.unsafe(nil), String) # # name = 'John' #: String # -# pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:101 +# @example AllowYARDCommentBlockSeparator: false (default) +# +# # bad +# +# # Copyright (c) Example Corp +# #- +# class Client +# end +# +# @example AllowYARDCommentBlockSeparator: true +# +# # good +# +# # Copyright (c) Example Corp +# #- +# class Client +# end +# +# pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:119 class RuboCop::Cop::Layout::LeadingCommentSpace < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:125 def on_new_investigation; end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:180 def allow_doxygen_comment?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:169 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:188 def allow_gemfile_ruby_comment?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:204 def allow_rbs_inline_annotation?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:193 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:212 def allow_steep_annotation?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:131 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:220 + def allow_yard_comment_block_separator?; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:150 def allowed_on_first_line?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:184 def doxygen_comment_style?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:192 def gemfile?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:181 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:200 def gemfile_ruby_comment?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:146 def hash_mark(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:176 def rackup_config_file?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:172 def rackup_options?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:208 def rbs_inline_annotation?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:196 def ruby_comment_in_gemfile?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:154 def shebang?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:158 def shebang_continuation?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:216 def steep_annotation?(comment); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:224 + def yard_comment_block_separator?(comment); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:105 +# pkg:gem/rubocop#lib/rubocop/cop/layout/leading_comment_space.rb:123 RuboCop::Cop::Layout::LeadingCommentSpace::MSG = T.let(T.unsafe(nil), String) # Checks for unnecessary leading blank lines at the beginning @@ -12850,98 +13108,96 @@ class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::EndlessMethodRewriter extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:71 def max=(value); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:92 def on_array(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:75 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:95 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:97 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:104 def on_defs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:85 def on_dstr(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:93 def on_hash(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:112 def on_investigation_end; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:79 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:106 def on_new_investigation; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:78 def on_numblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:89 def on_potential_breakable_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:94 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:81 def on_str(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:316 - def allow_heredoc?; end - - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:324 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:401 def allow_string_split?; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:391 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:464 def allowed_combination?(line, uri_range, qualified_name_range); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:320 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:397 def allowed_heredoc; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:353 def allowed_line?(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:254 def breakable_block_range(block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:403 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:476 def breakable_dstr?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:231 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:303 def breakable_dstr_begin_position(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:120 def breakable_range; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:112 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:120 def breakable_range=(_arg0); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:262 def breakable_range_after_semicolon(semicolon_token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:236 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:308 def breakable_range_by_line_index; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:245 def breakable_string?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:316 def breakable_string_delimiters; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:203 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:275 def breakable_string_position(node); end # Locate where to break a string that is too long, ensuring that escape characters @@ -12949,79 +13205,100 @@ class RuboCop::Cop::Layout::LineLength < ::RuboCop::Cop::Base # If the string contains spaces, use them to determine a place for a clean break; # otherwise, the string will be broken at the line length limit. # - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:215 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:287 def breakable_string_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:358 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:431 def check_directive_line(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:207 def check_for_breakable_block(block_node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:230 def check_for_breakable_dstr(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:186 def check_for_breakable_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:199 def check_for_breakable_semicolons(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:218 def check_for_breakable_str(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:332 def check_line(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:375 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:448 def check_line_for_exemptions(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:300 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:174 + def correct_endless_method_block_to_multiline(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:164 + def correctable_endless_method_block?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:312 + def endless_methods_by_line; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:381 def excess_range(uri_range, line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:328 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:405 def extract_heredocs(ast); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:244 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:127 + def handle_endless_method_line(line, line_index); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:320 def heredocs; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:324 def highlight_start(line); end # Find the largest possible substring of a string node to retain before a break # - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:419 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:492 def largest_possible_string(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:347 - def line_in_heredoc?(line_number); end - - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:338 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:415 def line_in_permitted_heredoc?(line_number); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:311 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:392 def max; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:314 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:395 def max_line_length; end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:385 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:458 def range_if_applicable(line, type); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:351 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:424 def receiver_contains_heredoc?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:282 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:140 + def register_endless_method_offense(line, line_index); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:363 def register_offense(loc, line, line_index, length: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:278 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:151 + def register_required_endless_method_offense(line, line_index); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:135 + def require_endless_methods?; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:359 def shebang?(line, line_index); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:408 + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:481 def string_delimiter(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:122 + def track_endless_method(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:72 +# pkg:gem/rubocop#lib/rubocop/cop/layout/line_length.rb:73 RuboCop::Cop::Layout::LineLength::MSG = T.let(T.unsafe(nil), String) # Checks that the closing brace in an array literal is either @@ -13887,7 +14164,7 @@ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Bas # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:379 def first_call_alignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:435 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:445 def first_call_has_a_dot(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:180 @@ -13896,7 +14173,7 @@ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Bas # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:396 def get_dot_right_above(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:425 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:435 def handle_descendant_block(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:220 @@ -13911,6 +14188,9 @@ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Bas # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:205 def inside_multiline_chain_arg?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:425 + def leftmost_call_on_same_line(node); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:262 def message(node, lhs, rhs); end @@ -13923,10 +14203,10 @@ class RuboCop::Cop::Layout::MultilineMethodCallIndentation < ::RuboCop::Cop::Bas # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:125 def offending_range(node, lhs, rhs, given_style); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:442 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:452 def operation_rhs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:452 + # pkg:gem/rubocop#lib/rubocop/cop/layout/multiline_method_call_indentation.rb:462 def operator_rhs?(node, receiver); end # a @@ -14393,51 +14673,90 @@ RuboCop::Cop::Layout::ParameterAlignment::FIXED_INDENT_MSG = T.let(T.unsafe(nil) class RuboCop::Cop::Layout::RedundantLineBreak < ::RuboCop::Cop::Base include ::RuboCop::Cop::CheckAssignment include ::RuboCop::Cop::CheckSingleLineSuitability + include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:71 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:56 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:57 def on_lvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:61 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:78 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:97 + def apply_reparse_correction(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:79 def check_assignment(node, _rhs); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:185 def configured_to_not_be_inspected?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:204 def convertible_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:75 def end_with_percent_blank_string?(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:102 + # Joining lines merges split string literals (`"a" \ "b"` into + # `"ab"`) and turns mixed-quote pairs into `+` concatenation, which + # changes the tree but not the resulting string. Normalize all string + # concatenation to a canonical form before comparing: nested + # concatenations are flattened and adjacent literal parts merged. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:118 + def fold_string_concatenation(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:179 def index_access_call_chained?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:154 + def merge_plain_strings(chunk); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:145 + def merge_string_parts(parts); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:109 + def normalize_reparsed_ast(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:168 def offense?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:192 def other_cop_takes_precedence?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:164 + def plain_string?(node); end + + # Joining lines shifts the value of any later `__LINE__`, exactly as + # any other line-removing correction does; neutralize it on both sides + # with an identifier, which stays valid in every position the keyword + # can appear in. + # + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:105 + def preprocess_reparsed_source(source); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:85 def register_offense(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:175 def require_backslash?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:200 def single_line_block_chain_enabled?; end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:135 + def string_concatenation_parts(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:160 + def stringish?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:54 +# pkg:gem/rubocop#lib/rubocop/cop/layout/redundant_line_break.rb:55 RuboCop::Cop::Layout::RedundantLineBreak::MSG = T.let(T.unsafe(nil), String) # Checks whether the rescue and ensure keywords are aligned @@ -15705,17 +16024,17 @@ class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Ba # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:110 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:231 def compact(corrector, bracket, side); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:218 - def compact_corrections(corrector, node, left, right); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:217 + def compact_corrections(corrector, tokens, left, right); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:210 + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:209 def compact_offense(node, token, side: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:172 - def compact_offenses(node, left, right, start_ok, end_ok); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:175 + def compact_offenses(node, tokens, left, right, start_ok, end_ok); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:133 def empty_config; end @@ -15727,28 +16046,25 @@ class RuboCop::Cop::Layout::SpaceInsideArrayLiteralBrackets < ::RuboCop::Cop::Ba def find_node_with_brackets(node); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:148 - def index_for(node, token); end + def index_for(tokens, token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:156 - def issue_offenses(node, left, right, start_ok, end_ok); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:157 + def issue_offenses(node, tokens, left, right, start_ok, end_ok); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:152 def line_and_column_for(token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:193 - def multi_dimensional_array?(node, token, side: T.unsafe(nil)); end - - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:204 - def next_to_bracket?(token, side: T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:198 + def multi_dimensional_array?(tokens, token, side: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:168 - def next_to_comment?(node, token); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:170 + def next_to_comment?(tokens, token); end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:137 - def next_to_newline?(node, token); end + def next_to_newline?(tokens, token); end - # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:185 - def qualifies_for_compact?(node, token, side: T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:190 + def qualifies_for_compact?(tokens, token, side: T.unsafe(nil)); end end # pkg:gem/rubocop#lib/rubocop/cop/layout/space_inside_array_literal_brackets.rb:84 @@ -16548,6 +16864,38 @@ end # pkg:gem/rubocop#lib/rubocop/cop/layout/trailing_whitespace.rb:47 RuboCop::Cop::Layout::TrailingWhitespace::MSG = T.let(T.unsafe(nil), String) +# Extend a department module with this module and call `register_cop` to register +# the department's cops with the global registry without loading their files until +# a cop class itself is needed: +# +# module RuboCop +# module Cop +# # The Foo department. +# module Foo +# extend LazyLoader +# +# register_cop :BarBaz, "#{__dir__}/foo/bar_baz" +# end +# end +# end +# +# pkg:gem/rubocop#lib/rubocop/cop/lazy_loader.rb:19 +module RuboCop::Cop::LazyLoader + # Registers a cop for lazy loading. The cop appears in the registry by name right away, + # but its file is loaded only when the cop class is needed, e.g. when the cop is enabled + # for an inspection run. + # + # The path must be absolute so that loading does not depend on `$LOAD_PATH` and cannot resolve + # to another RuboCop installation. + # + # @param constant_name [Symbol] name of the cop class, e.g. `:BarBaz` + # @param path [String] absolute path to the file defining the cop class, + # with or without the `.rb` extension + # + # pkg:gem/rubocop#lib/rubocop/cop/lazy_loader.rb:30 + def register_cop(constant_name, path); end +end + # pkg:gem/rubocop#lib/rubocop/cop/legacy/corrections_proxy.rb:5 module RuboCop::Cop::Legacy; end @@ -16678,8 +17026,13 @@ module RuboCop::Cop::LineLengthHelp def valid_uri?(uri_ish_string); end end -# pkg:gem/rubocop#lib/rubocop/cop/mixin/unused_argument.rb:5 -module RuboCop::Cop::Lint; end +# Cops for the `Lint` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/lint.rb:7 +module RuboCop::Cop::Lint + extend ::RuboCop::Cop::LazyLoader +end # Checks for mistyped shorthand assignments. # @@ -16698,39 +17051,32 @@ module RuboCop::Cop::Lint; end # # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:21 class RuboCop::Cop::Lint::AmbiguousAssignment < ::RuboCop::Cop::Base + include ::RuboCop::Cop::CheckAssignment include ::RuboCop::Cop::RangeHelp - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:30 - def on_asgn(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:40 - def on_casgn(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:40 - def on_cvasgn(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:40 - def on_gvasgn(node); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:29 + def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:40 - def on_ivasgn(node); end + private - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:40 - def on_lvasgn(node); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:33 + def check_assignment(node, rhs); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:28 +# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:27 RuboCop::Cop::Lint::AmbiguousAssignment::MISTAKES = T.let(T.unsafe(nil), Hash) -# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:24 +# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:25 RuboCop::Cop::Lint::AmbiguousAssignment::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_assignment.rb:26 -RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) - # Checks for ambiguous block association with method # when param passed without parentheses. # +# This cop also detects `do...end` blocks that are likely intended for +# an enumerable method in the arguments but actually bind to the outer +# method call. For example, in `render json: data.map do |x| x end`, +# Ruby parses the `do...end` block as belonging to `render`, not `map`. +# # This cop can customize allowed methods with `AllowedMethods`. # By default, there are no allowed methods. # @@ -16745,6 +17091,18 @@ RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsaf # # or (different meaning) # some_method(a) { |val| puts val } # +# # bad +# render json: data.map do |item| +# item.to_h +# end +# +# # good +# render json: data.map { |item| item.to_h } +# +# # good +# mapped = data.map { |item| item.to_h } +# render json: mapped +# # # good # # Operator methods require no disambiguation # foo == bar { |b| b.baz } @@ -16774,36 +17132,62 @@ RuboCop::Cop::Lint::AmbiguousAssignment::SIMPLE_ASSIGNMENT_TYPES = T.let(T.unsaf # expect { do_something }.to change { object.attribute } # expect { do_something }.to not_change { object.attribute } # -# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:52 +# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:69 class RuboCop::Cop::Lint::AmbiguousBlockAssociation < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::AllowedPattern extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:75 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:107 + def on_block(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:105 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:120 + def on_itblock(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:119 + def on_numblock(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:92 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:141 def allowed_method_pattern?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:137 def ambiguous_block_association?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:124 + def find_ambiguous_block_method(block_node); end + + # Only the call the `do` block could actually have attached to is a candidate: + # the one whose source ends where the arguments end. This skips calls chained + # into another call (`foo bar.map.to_a`) and calls buried inside a + # parenthesized subcall (`foo bar(baz.map)`), which were never block candidates. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:157 + def find_block_method_arg(send_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:147 def message(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:166 def wrap_in_parentheses(corrector, node); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:58 +# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:82 +RuboCop::Cop::Lint::AmbiguousBlockAssociation::BLOCK_METHODS = T.let(T.unsafe(nil), Set) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:75 RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG = T.let(T.unsafe(nil), String) +# pkg:gem/rubocop#lib/rubocop/cop/lint/ambiguous_block_association.rb:78 +RuboCop::Cop::Lint::AmbiguousBlockAssociation::MSG_DO_END_BLOCK = T.let(T.unsafe(nil), String) + # Checks for ambiguous operators in the first argument of a # method invocation without parentheses. # @@ -17668,9 +18052,6 @@ class RuboCop::Cop::Lint::ConstantReassignment < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_reassignment.rb:201 def identifier_namespaces(identifier); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_reassignment.rb:219 - def prior_definition_in_other_file(declaration); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_reassignment.rb:209 def report_cross_file_collision(node, fully_qualified_name, display_name); end @@ -17707,6 +18088,12 @@ RuboCop::Cop::Lint::ConstantReassignment::RESTRICT_ON_SEND = T.let(T.unsafe(nil) # to prevent conflicting rules. This is because it respects user configurations # that want to enable this cop which is disabled by default. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, only genuinely ambiguous constants are reported: those +# that resolve to a different declaration through the surrounding +# nesting than they would fully qualified. This makes the cop practical +# to enable without `Only`/`Ignore` lists. +# # @example # # By default checks every constant # @@ -17746,27 +18133,39 @@ RuboCop::Cop::Lint::ConstantReassignment::RESTRICT_ON_SEND = T.let(T.unsafe(nil) # # good # Login # -# pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:62 +# pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:68 class RuboCop::Cop::Lint::ConstantResolution < ::RuboCop::Cop::Base - # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:70 + include ::RuboCop::Cop::ProjectIndexHelp + + # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:78 def on_const(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:74 def unqualified_const?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:108 def allowed_names; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:78 + # When `AllCops/UseProjectIndex` is enabled, only genuinely ambiguous + # references are reported: the constant resolves to a different + # declaration through the lexical nesting than it would fully + # qualified. Names that resolve identically either way, or that the + # index cannot resolve at all (e.g. constants from gems), are not + # reported. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:93 + def ambiguous_resolution?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:103 def const_name?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:112 def ignored_names; end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:63 +# pkg:gem/rubocop#lib/rubocop/cop/lint/constant_resolution.rb:71 RuboCop::Cop::Lint::ConstantResolution::MSG = T.let(T.unsafe(nil), String) # are strictly formatted. @@ -18166,6 +18565,121 @@ RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::NO_ARG_ALGORITHM = T.let(T.unsafe # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_open_ssl_constant.rb:36 RuboCop::Cop::Lint::DeprecatedOpenSSLConstant::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# Checks for calls to methods and references to constants that are documented +# as deprecated with a YARD `@deprecated` tag. +# +# The check is powered by the project-wide index, so it only runs when +# `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed. +# Without the index the cop does nothing. +# +# Only references that can be resolved without type inference are checked: +# constants, method calls without an explicit receiver (or with `self`), +# which are looked up in the enclosing class or module and its ancestry, +# and calls whose receiver is a constant, which are looked up in that +# namespace's singleton class. Calls on arbitrary objects are not checked. +# +# References made from a definition that is itself deprecated are allowed, +# so deprecated implementations can keep calling each other. +# +# @example +# # Given a deprecated method and constant: +# # +# # class Api +# # # @deprecated Use `#new_method` instead. +# # def old_method +# # end +# # +# # # @deprecated +# # OLD_TIMEOUT = 10 +# # end +# +# # bad +# class Client < Api +# def call +# old_method +# end +# +# def timeout +# OLD_TIMEOUT +# end +# end +# +# # good +# class Client < Api +# def call +# new_method +# end +# +# def timeout +# NEW_TIMEOUT +# end +# end +# +# pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:56 +class RuboCop::Cop::Lint::DeprecatedReference < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ProjectIndexHelp + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:82 + def on_const(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:80 + def on_csend(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:65 + def on_new_investigation; end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:70 + def on_send(node); end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:117 + def const_receiver_declaration(node, receiver); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:153 + def deprecated?(declaration); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:175 + def deprecation_text(declaration); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:168 + def detail_for(declaration); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:124 + def enclosing_namespace(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:106 + def implicit_receiver_declaration(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:96 + def method_declaration_for(node); end + + # Whether an implicit-receiver call runs with the class or module itself + # as `self` (directly in a namespace body, in a singleton method, or + # inside `class << self`) rather than inside an instance method. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:136 + def singleton_context?(node); end + + # References from a definition that is itself documented as deprecated + # are allowed. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:161 + def within_deprecated_definition?(node); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:60 +RuboCop::Cop::Lint::DeprecatedReference::CONSTANT_MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:62 +RuboCop::Cop::Lint::DeprecatedReference::DEPRECATED_TAG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:63 +RuboCop::Cop::Lint::DeprecatedReference::DEPRECATION_DETAIL = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/deprecated_reference.rb:59 +RuboCop::Cop::Lint::DeprecatedReference::METHOD_MSG = T.let(T.unsafe(nil), String) + # Checks constructors for disjunctive assignments (`||=`) that should # be plain assignments. # @@ -18611,6 +19125,17 @@ RuboCop::Cop::Lint::DuplicateMatchPattern::MSG = T.let(T.unsafe(nil), String) # the developer intends to suppress Ruby's method redefinition warnings. # See https://bugs.ruby-lang.org/issues/13574. # +# By default the cop can only detect duplicates within a single file. +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed, +# the cop additionally consults the project-wide index and reports methods +# whose duplicate definition lives in another file. +# +# NOTE: The project index does not record whether a definition in another +# file is wrapped in a conditional, so a platform-specific redefinition in +# another file may still be reported. Aliasing the method to itself (see above) +# before redefining marks the redefinition as intentional and is respected +# across files. +# # @example # # # bad @@ -18719,115 +19244,218 @@ RuboCop::Cop::Lint::DuplicateMatchPattern::MSG = T.let(T.unsafe(nil), String) # delegate :foo, to: :bar # end # -# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:121 +# @example DelegatingMethods: ['delegate', 'expose'] (default: ['delegate']) +# # A project's own `delegate`-shaped macros can be registered so the +# # methods they define are recognized (with +# # `AllCops/ActiveSupportExtensionsEnabled: true`). +# +# # bad +# def foo +# 1 +# end +# +# expose :foo, to: :bar +# +# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:144 class RuboCop::Cop::Lint::DuplicateMethods < ::RuboCop::Cop::Base - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:127 + include ::RuboCop::Cop::ProjectIndexHelp + + # No `RESTRICT_ON_SEND`: the delegating method names are configurable + # (`DelegatingMethods`), so `on_send` must see every call. The handler + # returns quickly for calls that are not method definitions, and + # benchmarks show no measurable cost over the previous fixed list. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:159 def initialize(config = T.unsafe(nil), options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:211 def alias_method?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:201 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:255 + def class_new_block?(param0 = T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:248 def class_or_module_new_block?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:172 - def delegate_method?(param0 = T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:219 + def delegate_args(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:180 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:227 def delegator?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:190 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:237 def delegators?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:193 def method_alias?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:197 def on_alias(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:173 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:181 def on_defs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:166 + def on_new_investigation; end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:261 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:245 def sym_name(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:317 + # Internal identity for an anonymous block, used as a scope key. + # Includes the source range's begin position to distinguish blocks + # that share the same line (e.g. two Class.new calls separated by `;`). + # The user-facing offense message still uses `source_location`, which + # shows only `path:line`. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:618 + def anon_block_identity(anon_block); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:387 def anon_block_scope_id(anon_block); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:308 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:378 def anonymous_class_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:291 def check_const_receiver(node, name, const_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:545 + def check_cross_file_duplicate(node, method_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:298 def check_self_receiver(node, name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:270 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:557 + def cross_file_prior_definition(method_name); end + + # An alias of the method alongside one of its definitions in another file may be + # the self-alias trick marking an intentional redefinition there, so no offense + # is registered. A genuine `alias` duplicate is still reported when the alias + # itself is inspected. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:595 + def cross_file_self_alias_trick?(definitions); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:340 def delegate_prefix(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:395 + # Recognizing a delegating call as a method definition is Active + # Support behavior, so it stays gated on `ActiveSupportExtensionsEnabled` + # as it was when only `delegate` was supported. `DelegatingMethods` lets + # a project register its own `delegate`-shaped macros. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:321 + def delegating_method?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:326 + def delegating_methods; end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:604 + def first_indexed_definition(definitions); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:497 def found_attr(node, args, readable: T.unsafe(nil), writable: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:356 def found_instance_method(node, name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:344 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:427 def found_method(node, method_name, scope_id: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:333 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:440 + def found_redefinition(node, method_name, key, scope); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:417 def found_sclass_method(node, name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:282 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:352 def hash_value(node, key); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:300 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:370 def humanize_scope(scope); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:251 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:608 + def index_source_location(definition); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:582 + def indexed_declaration_definitions(namespace, name); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:568 + def indexed_definitions(owner, separator, name); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:308 def inside_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:373 + # The self-alias trick (`alias foo foo` or `alias_method :foo, :foo` right before + # a `def`) suppresses Ruby's method redefinition warning, signaling an intentional + # redefinition of a method defined in another file. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:454 + def intentional_cross_file_redefinition?(node, method_name, key); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:475 def location(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:405 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:507 def lookup_constant(node, const_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:312 def message_for_dup(node, method_name, key); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:365 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:467 def method_key(node, method_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:328 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:412 def named_receiver(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:381 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:483 def on_attr(node, attr_name, args); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:330 def on_delegate(node, method_names); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:423 + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:525 def qualified_name(enclosing, namespace, mod_name); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:437 + # When a Class.new block is passed as an argument to a named-receiver + # method call (e.g. T.cast(Class.new(Base) do ... end, ...)), the + # receiver-based scope id (e.g. "T.cast") is the same for every call, + # causing false positives for methods defined in distinct anonymous + # classes. Return nil so the block falls through to the unique + # source-location-based scope id. + # Module.new blocks are excluded because they may be intentionally + # mixed into the same target via prepend/include/extend. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:406 + def scope_receiver(parent, anon_block); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:539 def source_location(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:460 + def track_self_alias(node, name); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:586 + def writer_attr_definition?(definition); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:122 -RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String) +# Method names the cop registers that can be looked up in the project index: +# a fully qualified namespace followed by `#` (instance) or `.` (singleton) +# and the method name. +# +# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:152 +RuboCop::Cop::Lint::DuplicateMethods::INDEXABLE_METHOD_NAME = T.let(T.unsafe(nil), Regexp) -# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:123 -RuboCop::Cop::Lint::DuplicateMethods::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) +# pkg:gem/rubocop#lib/rubocop/cop/lint/duplicate_methods.rb:147 +RuboCop::Cop::Lint::DuplicateMethods::MSG = T.let(T.unsafe(nil), String) # Checks for duplicate elements in `Regexp` character classes. # @@ -20442,6 +21070,11 @@ RuboCop::Cop::Lint::IneffectiveAccessModifier::MSG = T.let(T.unsafe(nil), String # exception class handle `StandardError` and its subclasses, # but not `Exception` and its subclasses. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, indirect inheritance is also detected: a class whose parent +# (defined anywhere in the project) ultimately inherits from `Exception` +# is reported, without autocorrection. +# # @example EnforcedStyle: standard_error (default) # # bad # @@ -20468,42 +21101,61 @@ RuboCop::Cop::Lint::IneffectiveAccessModifier::MSG = T.let(T.unsafe(nil), String # # C = Class.new(RuntimeError) # -# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:40 +# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:45 class RuboCop::Cop::Lint::InheritException < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ProjectIndexHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:60 def class_new_call?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:66 def on_class(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:84 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:121 + def exception_ancestor(declaration); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:101 def exception_class?(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:127 + def exception_superclass_reference?(ancestor); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:137 def inherit_exception_class_with_omitted_namespace?(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:83 + # When `AllCops/UseProjectIndex` is enabled, indirect inheritance is + # detected by walking the parent's indexed ancestry: `Exception` itself + # is not indexed, so a chain ending in it shows up as an ancestor whose + # superclass reference is unresolved and literally named `Exception`. + # Returns the name of that ancestor, or `nil`. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:110 + def inherits_exception_via(parent_class); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:97 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:145 def preferred_base_class; end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:44 +# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:51 +RuboCop::Cop::Lint::InheritException::INDIRECT_MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:50 RuboCop::Cop::Lint::InheritException::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:45 +# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:52 RuboCop::Cop::Lint::InheritException::PREFERRED_BASE_CLASS = T.let(T.unsafe(nil), Hash) -# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:50 +# pkg:gem/rubocop#lib/rubocop/cop/lint/inherit_exception.rb:57 RuboCop::Cop::Lint::InheritException::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Checks for interpolation in a single quoted string. @@ -21038,6 +21690,13 @@ RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), # `AllowedParentClasses` option to specify which classes should be allowed # *in addition to* `Object` and `BasicObject`. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed, +# the constructor check additionally consults the project-wide index: if the +# class' entire ancestry is resolvable and no ancestor defines `initialize`, +# no offense is registered, since `super` would only reach the no-op +# `Object#initialize`. Classes whose ancestry contains an unresolvable +# superclass or mixin (e.g. one defined in a gem) are still reported. +# # @example # # bad # class Employee < Person @@ -21099,54 +21758,65 @@ RuboCop::Cop::Lint::MissingCopEnableDirective::MSG_BOUND = T.let(T.unsafe(nil), # end # end # -# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:85 +# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:92 class RuboCop::Cop::Lint::MissingSuper < ::RuboCop::Cop::Base - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:99 + include ::RuboCop::Cop::ProjectIndexHelp + + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:108 def class_new_block(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:114 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:115 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:124 def on_defs(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:159 def allowed_class?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:163 def allowed_classes; end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:136 def callback_method_def?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:142 def contains_super?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:137 + # With the project index, the offense is skipped when the class' whole ancestry + # is resolvable and none of the inherited ancestors defines `initialize` — + # `super` would only reach the no-op `Object#initialize`. An unresolvable + # superclass or mixin anywhere in the chain (e.g. a class from a gem) means + # the ancestry cannot be verified and the offense is kept. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:172 + def index_verified_stateless_ancestry?(class_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:146 def inside_class_with_stateful_parent?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:132 def offender?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:96 +# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:105 RuboCop::Cop::Lint::MissingSuper::CALLBACKS = T.let(T.unsafe(nil), Set) -# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:87 +# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:96 RuboCop::Cop::Lint::MissingSuper::CALLBACK_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:91 +# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:100 RuboCop::Cop::Lint::MissingSuper::CLASS_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:86 +# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:95 RuboCop::Cop::Lint::MissingSuper::CONSTRUCTOR_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:92 +# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:101 RuboCop::Cop::Lint::MissingSuper::METHOD_LIFECYCLE_CALLBACKS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:89 +# pkg:gem/rubocop#lib/rubocop/cop/lint/missing_super.rb:98 RuboCop::Cop::Lint::MissingSuper::STATELESS_CLASSES = T.let(T.unsafe(nil), Array) # Checks for mixed-case character ranges since they include likely unintended characters. @@ -21284,6 +21954,143 @@ RuboCop::Cop::Lint::MultipleComparison::RESTRICT_ON_SEND = T.let(T.unsafe(nil), # pkg:gem/rubocop#lib/rubocop/cop/lint/multiple_comparison.rb:25 RuboCop::Cop::Lint::MultipleComparison::SET_OPERATION_OPERATORS = T.let(T.unsafe(nil), Array) +# Checks for probable typos in constant and method names: a name that +# does not resolve anywhere in the project, used in a namespace the +# project does define, with a close-named sibling to suggest instead. +# +# The check is powered by the project-wide index, so it only runs when +# `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed. +# Without the index the cop does nothing. +# +# Constants are checked only in qualified references (`Foo::Bar`) whose +# namespace resolves in the index; bare names cannot be distinguished +# from constants provided by gems or the standard library. Methods are +# checked only in calls on constant receivers (`Foo.bar`) whose entire +# indexed ancestry is resolved, so methods gained through gem classes or +# dynamic definitions never produce offenses. In both cases an offense +# requires a similarly named alternative to exist — an unknown name +# alone is not reported, since the index does not see gems or the +# standard library. +# +# Names that appear as symbols or inside string literals in the same +# file are never reported, since they usually belong to runtime +# definitions the index cannot see (`stub_const`, `const_set`, +# `define_method`, and the like). +# +# @example +# # bad - Services::UserCraetor is not defined, Services::UserCreator is +# Services::UserCraetor.new +# +# # good +# Services::UserCreator.new +# +# # bad - Report.generate_sumary is not defined, Report.generate_summary is +# Report.generate_sumary +# +# # good +# Report.generate_summary +# +# @example CheckConstants: false +# # good - constant references are not checked +# Services::UserCraetor.new +# +# @example CheckMethods: false +# # good - method calls are not checked +# Report.generate_sumary +# +# @example AllowedNames: ['generate_sumary'] +# # good - the name is explicitly allowed +# Report.generate_sumary +# +# pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:60 +class RuboCop::Cop::Lint::NameTypo < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ProjectIndexHelp + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:71 + def on_const(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:96 + def on_csend(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:98 + def on_new_investigation; end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:83 + def on_send(node); end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:115 + def allowed_name?(name); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:105 + def check?(key); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:109 + def checkable_constant?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:199 + def constant_member_names(namespace); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:131 + def constant_typo_suggestion(node); end + + # `defined?(Foo::Bar)` probes whether a name exists; unknown names + # there are deliberate. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:127 + def defined_check?(node); end + + # The last segment of a class, module or constant definition is being + # defined, not referenced. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:121 + def definition_identifier?(node); end + + # Names mentioned as symbols or inside string literals in the current + # file belong to runtime definitions (`stub_const`, `const_set`, + # `define_method`) that the index cannot see. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:187 + def literal_names; end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:206 + def method_member_names(declaration); end + + # Writers are indexed under the reader's name, so setter calls are + # verified and spell-checked through the base name. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:145 + def method_typo_suggestion(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:174 + def responds_in_index?(declaration, name, base); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:170 + def setter_call?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:215 + def spell_check(name, dictionary); end + + # The receiver's declaration when it resolves in the index, its whole + # ancestry is resolved, and the method is not found — nil otherwise. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:161 + def unknown_method_owner(node, base); end +end + +# pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:63 +RuboCop::Cop::Lint::NameTypo::CONSTANT_MSG = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:69 +RuboCop::Cop::Lint::NameTypo::LITERAL_IDENTIFIER_PATTERN = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:68 +RuboCop::Cop::Lint::NameTypo::METHOD_MEMBER_REGEXP = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/name_typo.rb:65 +RuboCop::Cop::Lint::NameTypo::METHOD_MSG = T.let(T.unsafe(nil), String) + # Checks for nested method definitions. # # @example @@ -22246,9 +23053,6 @@ class RuboCop::Cop::Lint::OutOfRangeRegexpRef < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:103 def check_regexp(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:123 - def nth_ref_receiver?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/out_of_range_regexp_ref.rb:114 def regexp_first_argument?(send_node); end @@ -23958,6 +24762,13 @@ RuboCop::Cop::Lint::ReturnInVoidContext::SCOPE_CHANGING_METHODS = T.let(T.unsafe # safe navigation operator after a safe navigation operator. # This cop checks for the problem outlined above. # +# @safety +# This cop's autocorrection is unsafe because it changes the behavior of +# the code: `x&.foo.bar` raises `NoMethodError` when `x` or `x&.foo` is `nil`, +# whereas the corrected `x&.foo&.bar` returns `nil` instead. The autocorrection +# also assumes that extending safe navigation through the chain is intended, +# while removing the first `&.` may be what was intended instead. +# # @example # # # bad @@ -23969,17 +24780,17 @@ RuboCop::Cop::Lint::ReturnInVoidContext::SCOPE_CHANGING_METHODS = T.let(T.unsafe # x&.foo&.bar # x&.foo || bar # -# pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:22 +# pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:29 class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::NilMethods extend ::RuboCop::Cop::AutoCorrector extend ::RuboCop::Cop::TargetRubyVersion - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:33 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:40 def bad_method?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:42 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:49 def on_send(node); end private @@ -23988,39 +24799,39 @@ class RuboCop::Cop::Lint::SafeNavigationChain < ::RuboCop::Cop::Base # @param [RuboCop::AST::SendNode] send_node # @return [String] # - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:92 def add_safe_navigation_operator(offense_range:, send_node:); end # @param [RuboCop::Cop::Corrector] corrector # @param [Parser::Source::Range] offense_range # @param [RuboCop::AST::SendNode] send_node # - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:111 def autocorrect(corrector, offense_range:, send_node:); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:120 def brackets?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:133 def operator_inside_collection_literal?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:124 def require_parentheses?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:70 def require_safe_navigation?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:76 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:83 def ternary_else_branch?(node, safe_nav); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:77 def ternary_safe_navigation?(node, safe_nav); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:29 +# pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:36 RuboCop::Cop::Lint::SafeNavigationChain::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:30 +# pkg:gem/rubocop#lib/rubocop/cop/lint/safe_navigation_chain.rb:37 RuboCop::Cop::Lint::SafeNavigationChain::PLUS_MINUS_METHODS = T.let(T.unsafe(nil), Array) # Checks that if safe navigation is used in an `&&` or `||` condition, @@ -25135,7 +25946,7 @@ class RuboCop::Cop::Lint::ToEnumArguments < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:139 def argument_match?(send_arg, def_arg); end # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:61 @@ -25143,25 +25954,45 @@ class RuboCop::Cop::Lint::ToEnumArguments < ::RuboCop::Cop::Base # A splat or argument forwarding on the call side can expand to any arity. # - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:92 def expandable_arguments?(arguments); end + # A call-side keyword splat or argument forwarding can expand to any set of keywords. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:118 + def expandable_keyword_arguments?(arguments); end + + # The enumerator re-invokes the method with these arguments, so passing + # unexpected keyword arguments raises `ArgumentError` at runtime. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:106 + def extra_keyword_arguments?(arguments, def_node); end + # The enumerator re-invokes the method with these arguments, so passing more # positional arguments than the method accepts raises `ArgumentError` at runtime. # - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:81 def extra_positional_arguments?(arguments, def_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:162 def keyword_hash_argument?(send_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:132 + def keyword_parameters(def_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:124 + def passed_keyword_arguments(arguments); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:96 def positional_arguments(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:100 def positional_parameters(def_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:113 + def variadic_keyword_parameters?(def_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/to_enum_arguments.rb:87 def variadic_parameters?(def_node); end end @@ -26221,6 +27052,116 @@ class RuboCop::Cop::Lint::UnusedMethodArgument < ::RuboCop::Cop::Base end end +# Checks for private instance methods that are not referenced anywhere +# in the project. +# +# The check is powered by the project-wide index, so it only runs when +# `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed. +# Without the index the cop does nothing. +# +# A method counts as referenced when a call with its name appears anywhere +# in the indexed project (regardless of the receiver), when it is the source +# of an `alias`, or when its name appears in the same file as a symbol or +# inside a string literal (covering `send(:name)` and declarative DSLs like +# `before_action :name`). Methods defined in classes or modules with +# descendants are not checked, since they may be invoked through `super` +# or inherited dispatch, and neither are methods whose names are built +# dynamically (e.g. `send("do_#{action}")`). +# +# The cop is disabled by default because symbol-based references from +# *other* files (e.g. a Rails callback declared in a concern) cannot be +# detected and would be reported as false positives. It is best suited +# for occasional dead-code sweeps rather than permanent enforcement. +# +# @example +# # bad - `helper` is never referenced anywhere in the project +# class Service +# def call +# do_something +# end +# +# private +# +# def helper +# end +# end +# +# # good +# class Service +# def call +# do_something(helper) +# end +# +# private +# +# def helper +# end +# end +# +# pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:52 +class RuboCop::Cop::Lint::UnusedPrivateMethod < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ProjectIndexHelp + + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:77 + def on_def(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:72 + def on_new_investigation; end + + private + + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:91 + def checkable_declaration(node); end + + # Symbol literals and identifier-like tokens inside string literals in the + # current file, covering `send(:name)`, declarative DSLs like + # `before_action :name` and names embedded in strings (e.g. node-pattern + # `#helper` references). + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:123 + def literal_names; end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:100 + def method_declaration(node, namespace_node); end + + # An override of an inherited method may be invoked polymorphically + # (e.g. a framework hook), even when no direct reference exists. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:146 + def override?(declaration, method_name); end + + # A method defined in a class or module with descendants may be invoked + # through `super` or inherited dispatch, which the index does not track. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:137 + def owner_with_descendants?(declaration); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:107 + def referenced?(method_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:113 + def referenced_names; end + + class << self + # The reference-name set is derived once per index and shared by the + # per-file cop instances. + # + # pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:67 + def reference_names_cache; end + end +end + +# pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:57 +RuboCop::Cop::Lint::UnusedPrivateMethod::IDENTIFIER_PATTERN = T.let(T.unsafe(nil), Regexp) + +# Methods invoked implicitly by the Ruby runtime. +# +# pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:60 +RuboCop::Cop::Lint::UnusedPrivateMethod::IMPLICITLY_INVOKED_METHODS = T.let(T.unsafe(nil), Set) + +# pkg:gem/rubocop#lib/rubocop/cop/lint/unused_private_method.rb:55 +RuboCop::Cop::Lint::UnusedPrivateMethod::MSG = T.let(T.unsafe(nil), String) + # Identifies places where `URI.escape` can be replaced by # `CGI.escape`, `URI.encode_www_form`, or `URI.encode_www_form_component` # depending on your specific use case. @@ -27181,7 +28122,7 @@ class RuboCop::Cop::Lint::UselessRuby2Keywords < ::RuboCop::Cop::Base # `ruby2_keywords` is only allowed if there's a `restarg` and no keyword arguments # - # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_ruby2_keywords.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_ruby2_keywords.rb:124 def allowed_arguments?(arguments); end # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_ruby2_keywords.rb:109 @@ -27357,7 +28298,9 @@ RuboCop::Cop::Lint::UselessTimes::MSG = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/cop/lint/useless_times.rb:29 RuboCop::Cop::Lint::UselessTimes::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/utils/nil_receiver_checker.rb:6 +# Utility classes for `Lint` department cops. +# +# pkg:gem/rubocop#lib/rubocop/cop/lint.rb:171 module RuboCop::Cop::Lint::Utils; end # Utility class that checks if the receiver can't be nil. @@ -27418,11 +28361,14 @@ RuboCop::Cop::Lint::Utils::NilReceiverChecker::NIL_METHODS = T.let(T.unsafe(nil) # enumerator.each { |item| item >= 2 } #=> [2, 3] # ---- # -# NOTE: Return values in assignment method definitions such as `def foo=(arg)` are -# detected because they are in a void context. However, autocorrection does not remove -# the return value, as that would change behavior. In such cases, whether to remove -# the return value or rename the method to something more appropriate should be left to -# the user. +# NOTE: The last expression in an assignment method definition such as `def foo=(arg)` +# is not flagged. Ruby discards it (the method returns its argument), but the method can +# still be called directly and its return value relied upon, so flagging it would be a +# false positive for this lint. +# +# NOTE: A constant used in a void context is flagged but not autocorrected, since +# referencing a constant can trigger autoloading side effects (e.g. forcing a file to +# load before a monkey-patch), so removing it may change behavior. # # @example CheckForMethodsWithNoSideEffects: false (default) # # bad @@ -27459,129 +28405,132 @@ RuboCop::Cop::Lint::Utils::NilReceiverChecker::NIL_METHODS = T.let(T.unsafe(nil) # do_something(some_array) # end # -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:59 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:62 class RuboCop::Cop::Lint::Void < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:98 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:122 + def check_expression(expr); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:101 def on_begin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:90 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:106 def on_ensure(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:99 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:104 def on_kwbegin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:98 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:289 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:300 def all_keys_entirely_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:293 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:304 def all_values_entirely_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:278 def autocorrect_nonmutating_send(corrector, node, suggestion); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:267 def autocorrect_void_expression(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:247 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:254 def autocorrect_void_op(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:112 def check_begin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:144 def check_case_expression(case_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:149 def check_case_match_expression(case_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:235 def check_ensure(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:119 - def check_expression(expr); end - - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:140 def check_if_expression(if_node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:191 def check_literal(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:217 def check_nonmutating(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:201 def check_self(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:173 def check_var(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:206 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:209 def check_void_expression(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:130 def check_void_expression_nodes(expr); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:157 def check_void_op(node, &block); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:287 def entirely_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:243 def in_void_context?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:250 + def setter_method?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:72 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:75 RuboCop::Cop::Lint::Void::BINARY_OPERATORS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:66 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:69 RuboCop::Cop::Lint::Void::CONST_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:69 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:72 RuboCop::Cop::Lint::Void::EXPRESSION_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:67 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:70 RuboCop::Cop::Lint::Void::LIT_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:82 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:85 RuboCop::Cop::Lint::Void::METHODS_REPLACEABLE_BY_EACH = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:84 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:87 RuboCop::Cop::Lint::Void::NONMUTATING_METHODS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:75 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:78 RuboCop::Cop::Lint::Void::NONMUTATING_METHODS_WITH_BANG_VERSION = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:70 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:73 RuboCop::Cop::Lint::Void::NONMUTATING_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:74 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:77 RuboCop::Cop::Lint::Void::OPERATORS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:64 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:67 RuboCop::Cop::Lint::Void::OP_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:68 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:71 RuboCop::Cop::Lint::Void::SELF_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:73 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:76 RuboCop::Cop::Lint::Void::UNARY_OPERATORS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:65 +# pkg:gem/rubocop#lib/rubocop/cop/lint/void.rb:68 RuboCop::Cop::Lint::Void::VAR_MSG = T.let(T.unsafe(nil), String) # Common functionality for obtaining source ranges from regexp matches @@ -27764,8 +28713,13 @@ module RuboCop::Cop::MethodPreference def preferred_methods; end end -# pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:5 -module RuboCop::Cop::Metrics; end +# Cops for the `Metrics` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/metrics.rb:7 +module RuboCop::Cop::Metrics + extend ::RuboCop::Cop::LazyLoader +end # Checks that the ABC size of methods is not higher than the # configured maximum. The ABC size is based on assignments, branches @@ -28415,7 +29369,9 @@ RuboCop::Cop::Metrics::PerceivedComplexity::COUNTED_NODES = T.let(T.unsafe(nil), # pkg:gem/rubocop#lib/rubocop/cop/metrics/perceived_complexity.rb:44 RuboCop::Cop::Metrics::PerceivedComplexity::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/metrics/utils/repeated_csend_discount.rb:6 +# Utility classes for `Metrics` department cops. +# +# pkg:gem/rubocop#lib/rubocop/cop/metrics.rb:22 module RuboCop::Cop::Metrics::Utils; end # > ABC is .. a software size metric .. computed by counting the number @@ -28694,8 +29650,13 @@ module RuboCop::Cop::Metrics::Utils::RepeatedCsendDiscount def reset_repeated_csend; end end -# pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:8 -module RuboCop::Cop::Migration; end +# Cops for the `Migration` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/migration.rb:7 +module RuboCop::Cop::Migration + extend ::RuboCop::Cop::LazyLoader +end # department name. # @@ -28714,19 +29675,16 @@ class RuboCop::Cop::Migration::DepartmentName < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:53 def check_cop_name(name, comment, offset); end - # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:75 def contain_unexpected_character_for_department_name?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:53 - def disable_comment_offset; end - - # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:79 def qualified_legacy_cop_name(cop_name); end - # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/migration/department_name.rb:69 def valid_content_token?(content_token); end end @@ -29090,8 +30048,13 @@ module RuboCop::Cop::MultilineLiteralBraceLayout def opening_brace_on_same_line?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:5 -module RuboCop::Cop::Naming; end +# Cops for the `Naming` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/naming.rb:7 +module RuboCop::Cop::Naming + extend ::RuboCop::Cop::LazyLoader +end # Avoid prefixing accessor method names with `get_` or `set_`. # Applies to both instance and class methods. @@ -29101,6 +30064,11 @@ module RuboCop::Cop::Naming; end # Getters (`get_attribute`) must have no arguments to be registered, # and setters (`set_attribute(value)`) must have exactly one. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, methods that override a method defined by an ancestor +# elsewhere in the project are not reported, since renaming an override +# breaks the inherited contract. +# # @example # # bad # def set_attribute(value) @@ -29126,33 +30094,42 @@ module RuboCop::Cop::Naming; end # def set_value # end # -# pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:38 +# pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:43 class RuboCop::Cop::Naming::AccessorMethodName < ::RuboCop::Cop::Base - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:42 + include ::RuboCop::Cop::ProjectIndexHelp + + # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:49 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:50 + # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:58 def on_defs(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:66 + # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:74 def bad_reader_name?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:78 def bad_writer_name?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:54 + # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:62 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:62 + # When `AllCops/UseProjectIndex` is enabled, methods that override a + # method defined by an ancestor elsewhere in the project are not + # reported: renaming an override breaks the inherited contract. + # + # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:87 + def overrides_inherited_method?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:70 def proper_attribute_name?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:39 +# pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:46 RuboCop::Cop::Naming::AccessorMethodName::MSG_READER = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:40 +# pkg:gem/rubocop#lib/rubocop/cop/naming/accessor_method_name.rb:47 RuboCop::Cop::Naming::AccessorMethodName::MSG_WRITER = T.let(T.unsafe(nil), String) # Checks for non-ascii characters in identifier and constant names. @@ -30564,6 +31541,11 @@ RuboCop::Cop::Naming::PredicateMethod::MSG_PREDICATE = T.let(T.unsafe(nil), Stri # offenses if the method has a Sorbet `sig` with a return type of # `T::Boolean`. Dynamic methods are not supported with this configuration. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, methods that override a method defined by an ancestor +# elsewhere in the project are not reported, since renaming an override +# breaks the inherited contract. +# # @example NamePrefix: ['is_', 'has_', 'have_'] (default) # # bad # def is_even(value) @@ -30643,52 +31625,63 @@ RuboCop::Cop::Naming::PredicateMethod::MSG_PREDICATE = T.let(T.unsafe(nil), Stri # # good # def_node_matcher(:even?) { |value| } # -# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:103 +# pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:108 class RuboCop::Cop::Naming::PredicatePrefix < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ProjectIndexHelp include ::RuboCop::Cop::AllowedMethods - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:107 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:113 def dynamic_method_define(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:145 + def offending_prefixes_for(node, method_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:132 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:151 def on_defs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:119 def on_send(node); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:166 def sorbet_return_type(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:141 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:153 def validate_config; end private - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:164 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:176 def allowed_method_name?(method_name, prefix); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:184 def expected_name(method_name, prefix); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:198 def forbidden_prefixes; end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:194 def message(method_name, new_name); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:198 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:210 def method_definition_macro?(macro_name); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:190 + # When `AllCops/UseProjectIndex` is enabled, methods that override a + # method defined by an ancestor elsewhere in the project are not + # reported: renaming an override breaks the inherited contract. + # + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:217 + def overrides_inherited_method?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:202 def predicate_prefixes; end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:170 def sorbet_sig?(node, return_type: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/naming/predicate_prefix.rb:206 def use_sorbet_sigs?; end end @@ -31043,7 +32036,7 @@ class RuboCop::Cop::Naming::VariableNumber < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/naming/variable_number.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/naming/variable_number.rb:144 def message(style); end end @@ -31109,7 +32102,7 @@ class RuboCop::Cop::Offense # @return [Integer] # comparison result # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:245 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:249 def <=>(other); end # @api public @@ -31117,22 +32110,22 @@ class RuboCop::Cop::Offense # @return [Boolean] # returns `true` if two offenses contain same attributes # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:230 def ==(other); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:175 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:181 def column; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:189 def column_length; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:213 def column_range; end # @api public @@ -31156,7 +32149,7 @@ class RuboCop::Cop::Offense # whether this offense can be automatically corrected via autocorrect. # This includes todo comments, for example when requested with `--disable-uncorrectable`. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:124 def correctable?; end # @api public @@ -31167,7 +32160,7 @@ class RuboCop::Cop::Offense # whether this offense is automatically corrected via # autocorrect or a todo. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:135 def corrected?; end # @api public @@ -31177,7 +32170,7 @@ class RuboCop::Cop::Offense # @return [Boolean] # whether this offense is automatically disabled via a todo. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:145 def corrected_with_todo?; end # @api public @@ -31198,18 +32191,18 @@ class RuboCop::Cop::Offense # whether this offense was locally disabled with a # disable or todo where it occurred. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:148 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:156 def disabled?; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:232 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:236 def eql?(other); end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:198 def first_line; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:238 def hash; end # @api public @@ -31217,22 +32210,22 @@ class RuboCop::Cop::Offense # @return [Parser::Source::Range] # the range of the code that is highlighted # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:164 def highlighted_area; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:208 def last_column; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:203 def last_line; end # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:178 def line; end # @api public @@ -31248,10 +32241,10 @@ class RuboCop::Cop::Offense # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:28 def location; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:107 def marshal_dump; end - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:111 def marshal_load(array); end # @api public @@ -31273,7 +32266,7 @@ class RuboCop::Cop::Offense # outputting column numbers, we want them to start at 1. One # reason is that editors, such as Emacs, expect this. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:218 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:222 def real_column; end # @api public @@ -31287,7 +32280,7 @@ class RuboCop::Cop::Offense # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:180 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:184 def source_line; end # @api private @@ -31298,7 +32291,7 @@ class RuboCop::Cop::Offense # @api private # This is just for debugging purpose. # - # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:163 + # pkg:gem/rubocop#lib/rubocop/cop/offense.rb:171 def to_s; end end @@ -31801,13 +32794,102 @@ RuboCop::Cop::PreferredDelimiters::PERCENT_LITERAL_TYPES = T.let(T.unsafe(nil), # # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:13 module RuboCop::Cop::ProjectIndexHelp - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:20 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:28 def external_dependency_checksum; end private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:30 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:170 + def compute_project_index_signature; end + + # Returns the definitions among `definitions` that live in a file other than the + # one being inspected, ordered by path and line. Definitions without a `file://` + # URI (e.g. Rubydex's built-in declarations) are ignored. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:41 + def definitions_in_other_files(definitions); end + + # Whether every link of the declaration's ancestry is resolved in the + # index: no definition of any ancestor has an unresolved superclass or + # mixin reference. Unresolved links silently vanish from `ancestors`, + # so this is the completeness check that must pass before reasoning + # about what an ancestry does or does not define. `extend` mixins only + # affect the singleton class; pass `ignore_extend: true` when reasoning + # about instance-side ancestry only. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:129 + def fully_resolved_index_ancestry?(declaration, ignore_extend: T.unsafe(nil)); end + + # A namespace without any singleton method has no singleton-class + # declaration of its own, so the lookup starts from the first ancestor + # that has one; its `find_member` covers the rest of the chain. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:105 + def indexed_singleton_member(namespace, member_name); end + + # The declaration of `declaration`'s singleton class, or nil when no + # singleton method is defined on it anywhere in the project. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:98 + def indexed_singleton_of(declaration); end + + # Whether an ancestor of `scope` other than `scope` itself defines + # `member_name`. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:116 + def inherited_index_member?(scope, member_name); end + + # The lexical nesting the node's constants resolve through, outermost + # first. Only scopes whose *body* contains the node count: a class or + # module's identifier and superclass expression are evaluated before its + # scope exists, so ancestors reached through them are excluded. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:82 + def lexical_nesting_of(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:53 + def prior_definition_in_other_file(definitions); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:161 def project_index_signature; end + + # Resolves a constant node the way Ruby does: the first segment through + # the lexical nesting and every following segment inside the previous + # one. (Qualified names cannot be passed to `resolve_constant` as a + # whole, since it only applies the nesting to the full name. Later + # segments use `find_member` — the namespace and its ancestors — since + # `resolve_constant` cannot take an already-resolved namespace as the + # scope, only names as they appear in source.) + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:64 + def resolve_constant_in_index(const_node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:144 + def resolved_mixin_references?(definition, ignore_extend: T.unsafe(nil)); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:138 + def resolved_superclass_reference?(definition); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:154 + def same_file?(path, other); end + + class << self + # The signature is a property of the index, not of the cop, and computing + # it stats every indexed file, so all cops sharing an index share one + # computation. A single-entry cache (instead of a hash keyed by index) + # avoids retaining stale graphs in long-lived processes. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:25 + def cached_index_signature; end + + # The signature is a property of the index, not of the cop, and computing + # it stats every indexed file, so all cops sharing an index share one + # computation. A single-entry cache (instead of a hash keyed by index) + # avoids retaining stale graphs in long-lived processes. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:25 + def cached_index_signature=(_arg0); end + end end # pkg:gem/rubocop#lib/rubocop/cop/mixin/project_index_help.rb:14 @@ -31942,84 +33024,114 @@ class RuboCop::Cop::Registry # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:51 def initialize(cops = T.unsafe(nil), options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:237 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:290 def ==(other); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:138 def contains_cop_matching?(names); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:222 def cops; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:229 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:280 def cops_for_department(department); end # @return [Boolean] Checks if given name is department # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:134 def department?(name); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:149 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:188 def department_missing?(badge, name); end # @return [Array] list of departments for current cops. # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:104 def departments; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:197 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:245 def disabled(config); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:74 + # Returns the names of the disabled cops without loading any of them. + # + # @api private + # @return [Array] + # + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:253 + def disabled_names(config); end + + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:90 def dismiss(cop); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:253 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:306 def each(&block); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:193 + # Returns the enabled cop classes, loading lazy-loaded cops only when they are enabled. + # + # @return [Array] + # + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:236 def enabled(config); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:201 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:260 def enabled?(cop, config); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:217 - def enabled_pending_cop?(cop_cfg, config); end + # @param cop [Class, String, nil] the cop class or the qualified cop name + # + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:265 + def enabled_pending_cop?(cop_cfg, config, cop = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:86 def enlist(cop); end + # Returns a new registry containing the cops whose badge satisfies the given block, + # keeping lazy-loaded cops unloaded. + # + # @api private + # @return [Registry] + # + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:124 + def filter_by_badge(options = T.unsafe(nil)); end + # @param [String] cop_name # @return [Class, nil] # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:312 def find_by_cop_name(cop_name); end # When a cop name is given returns a single-element array with the cop class. # When a department name is given returns an array with all the cop classes # for that department. # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:268 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:323 def find_cops_by_directive(directive); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:273 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:328 def freeze; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:64 - def lazy_load(cop_name, constant_name); end + # Registers a cop by its badge and constant name without loading the class. + # The constant is resolved (loading the cop's file through `autoload`) only + # when the cop class itself is needed. + # + # @param badge [Badge, String] the badge, or the qualified cop name + # @param constant_name [String] the fully qualified constant name + # + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:75 + def lazy_load(badge, constant_name); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:228 def length; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:275 def names; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:233 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:284 def names_for_department(department); end # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:49 def options; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:153 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:192 def print_department_missing_warning(name, path); end # Convert a user provided cop name into a properly namespaced name @@ -32055,73 +33167,87 @@ class RuboCop::Cop::Registry # # @return [String] Qualified cop name # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:174 def qualified_cop_name(name, path, warn: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:208 def qualify_badge(badge); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:249 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:302 def select(&block); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:241 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:294 def sort!; end # @return [Hash{String => Array}] # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:176 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:216 def to_h; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:200 def unqualified_cop_names; end # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:49 def warnings; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:286 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:341 def warnings?(path); end # @return [Registry] Cops for that specific department. # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:110 def with_department(department); end # @return [Registry] Cops not for a specific department. # - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:115 def without_department(department); end + protected + + # Adds an already-loaded cop class or a lazy-load constant name under the given badge, + # used to build filtered copies. + # + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:349 + def add_entry(badge, cop_or_name); end + private - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:296 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:368 def clear_enrollment_queue; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:331 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:441 def emit_warning(path, message); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:292 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:385 + def enabled_cop_name?(cop_name, config); end + + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:356 def initialize_copy(reg); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:401 def load_all_lazy_cops; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:310 + # @return [Class, nil] the loaded cop class, or nil if the cop excluded + # itself from the registry while being loaded + # + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:410 def load_lazy_cop(badge); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:336 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:446 def registered?(badge); end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:321 - def resolve_badge(given_badge, real_badge, source_path, warn: T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:380 + def registered_badges; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:317 - def with(cops); end + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:431 + def resolve_badge(given_badge, real_badge, source_path, warn: T.unsafe(nil)); end class << self # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:22 def all; end - # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:283 + # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:338 def global; end # pkg:gem/rubocop#lib/rubocop/cop/registry.rb:44 @@ -32141,6 +33267,120 @@ class RuboCop::Cop::Registry end end +# Verifies that a candidate correction of the inspected source is a +# syntactic no-op: the corrected source must parse successfully and produce +# the same AST as the original. +# +# This turns "is this piece of syntax redundant?" questions into a +# parser-backed check instead of a hand-maintained enumeration of grammar +# rules: instead of modeling which constructs make (for example) a line +# continuation or a pair of parentheses significant, a cop can apply the +# correction and let the parser answer. +# +# Cops implement `#apply_reparse_correction(corrector, item)` and call +# `verified_by_reparse(items)`, which returns the items whose corrections +# are verified. Items sharing a reparse scope (the innermost method +# definition or class/module body, which parse standalone and cannot +# capture outer local variables) are verified together with a single +# reparse, falling back to per-item verification when the batch does not +# hold. Scope groups are keyed by node identity, since structurally +# identical definitions in different places must not share a group. +# +# Two hooks customize the comparison: +# +# * `normalize_reparsed_ast(node)` - loosen strict tree equality where a +# cop's correction is equivalence-preserving beyond parse identity (such +# laws must be justified per cop; the default compares trees as-is). +# * `preprocess_reparsed_source(source)` - rewrite both sides before +# parsing (e.g. to neutralize `__LINE__` when a correction legitimately +# shifts line numbers). +# +# `__FILE__` is handled by parsing with the original path, and fragments +# containing `__LINE__` are verified by reparsing both sides so that +# fragment line offsets cancel out. +# +# Note that comments are invisible to the AST, so corrections that may +# touch comment text must be guarded separately by the caller. +# +# pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:39 +module RuboCop::Cop::ReparsedEquivalence + private + + # The corrections' edits are all contained within the scope, so the + # corrected fragment can be cut out of the corrected source by adjusting + # for the edits' length delta. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:139 + def corrected_scope_fragment(scope, corrected); end + + # Whether the exact correction for `item` produces source that still + # parses, without requiring an equivalent AST. For corrections that + # intentionally change the tree. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:66 + def correction_parses?(item); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:121 + def corrections_verify?(scope, items); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:93 + def item_range(item); end + + # Hook: loosen strict tree equality for corrections that are + # equivalence-preserving beyond parse identity. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:77 + def normalize_reparsed_ast(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:159 + def normalized_original(original_source, original_ast); end + + # Both sides are parsed with the original path so that `__FILE__` + # resolves identically. The original side is reparsed (instead of using + # the already parsed node) when preprocessing altered it or it contains + # `__LINE__`, whose values would otherwise differ from a fragment parsed + # at a different line offset. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:151 + def parses_equivalently?(original_source, original_ast, corrected_source); end + + # Hook: rewrite both sides before parsing. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:82 + def preprocess_reparsed_source(source); end + + # The innermost scope that both contains `range` and parses standalone. + # Method definitions and class/module bodies neither capture outer local + # variables nor continue an outer expression; blocks and single + # statements do not qualify, since an outer local would reparse as a + # method call. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:102 + def reparse_scope(range); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:86 + def scope_groups(items); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:116 + def verification_too_large?(scope); end + + # Returns the items whose corrections are verified. `oversized` controls + # items whose reparse scope exceeds `MAX_VERIFICATION_FRAGMENT_SIZE`: + # `:report` accepts them unverified (for cops whose offense logic stands + # on its own and uses verification as a safety gate), `:verify` reparses + # regardless of size (for cops where verification is the offense logic). + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:52 + def verified_by_reparse(items, oversized: T.unsafe(nil)); end +end + +# Above this size, verification does not reparse. What happens to such +# items depends on `oversized`; in practice only machine-generated files +# come near the limit. +# +# pkg:gem/rubocop#lib/rubocop/cop/mixin/reparsed_equivalence.rb:43 +RuboCop::Cop::ReparsedEquivalence::MAX_VERIFICATION_FRAGMENT_SIZE = T.let(T.unsafe(nil), Integer) + # Ensure a require statement is present for a standard library determined # by variable library_name # @@ -32229,8 +33469,13 @@ module RuboCop::Cop::SafeAssignment def safe_assignment_allowed?; end end -# pkg:gem/rubocop#lib/rubocop/cop/security/compound_hash.rb:5 -module RuboCop::Cop::Security; end +# Cops for the `Security` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/security.rb:7 +module RuboCop::Cop::Security + extend ::RuboCop::Cop::LazyLoader +end # Checks for implementations of the `hash` method which combine # values using custom logic instead of delegating to `Array#hash`. @@ -32717,49 +33962,72 @@ end module RuboCop::Cop::StatementModifier include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::AllowedPattern private - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:85 + # Rather than comparing the rendered modifier form against the bare + # maximum, ask the question `Layout/LineLength` would: a line the user's + # configuration exempts (`Layout/LineLength` disabled at that line, an + # allowed pattern, an allowed cop directive, an allowed URI) fits by + # definition. This keeps every modifier cop consistent with + # `Layout/LineLength` instead of each reimplementing part of its policy. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:55 + def acceptable_line_length?(line, line_number); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:68 + def allowed_by_uri?(line); end + + # `Layout/LineLength`'s allowed patterns, so a modifier line that the + # user has configured that cop to accept is not flagged for length here. + # + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:81 + def allowed_patterns; end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:121 def code_after(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:103 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:139 def comment_disables_cop?(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:113 def first_line_comment(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:57 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:93 def if_body_source(if_body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:43 - def length_in_modifier_form(node); end + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:42 + def line_in_modifier_form(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:75 + def line_length_enabled_at_line?(line); end + + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:107 def method_source(if_body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:37 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:38 def modifier_fits_on_single_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:26 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:27 def non_eligible_body?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:33 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:34 def non_eligible_condition?(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:19 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:20 def non_eligible_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:101 def omitted_value_in_last_hash_arg?(if_body); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:127 def parenthesize?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:11 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:12 def single_line_as_modifier?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:50 + # pkg:gem/rubocop#lib/rubocop/cop/mixin/statement_modifier.rb:86 def to_modifier_form(node); end end @@ -32814,8 +34082,13 @@ module RuboCop::Cop::StringLiteralsHelp def wrong_quotes?(src_or_node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/access_modifier_declarations.rb:5 -module RuboCop::Cop::Style; end +# Cops for the `Style` department. The department's cops are registered for lazy loading +# and their files are loaded on demand. +# +# pkg:gem/rubocop#lib/rubocop/cop/style.rb:7 +module RuboCop::Cop::Style + extend ::RuboCop::Cop::LazyLoader +end # Access modifiers should be declared to apply to a group of methods # or inline before each method, depending on configuration. @@ -33922,6 +35195,11 @@ RuboCop::Cop::Style::ArrayFirstLast::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr # only cases where exactly one argument is provided can be replaced with # `Array#intersect?` and are handled by this cop. # +# NOTE: In the block form, `include?` is only detected when its receiver is +# an array literal, because `include?` is defined with different semantics +# on many non-array classes (e.g. `String#include?` checks for substrings). +# `member?` does not have this restriction. +# # @safety # This cop cannot guarantee that `array1` and `array2` are # actually arrays while method `intersect?` is for arrays only. @@ -33939,7 +35217,7 @@ RuboCop::Cop::Style::ArrayFirstLast::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr # # # bad # array1.any? { |elem| array2.member?(elem) } -# array1.none? { |elem| array2.include?(elem) } +# array1.none? { |elem| [1, 2].include?(elem) } # # # good # array1.intersect?(array2) @@ -33972,69 +35250,72 @@ RuboCop::Cop::Style::ArrayFirstLast::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Arr # array1.intersect?(array2) # !array1.intersect?(array2) # -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:82 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:87 class RuboCop::Cop::Style::ArrayIntersect < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector extend ::RuboCop::Cop::TargetRubyVersion - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:124 def any_none_block_intersection(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:99 def bad_intersection_check?(param0 = T.unsafe(nil), param1); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:110 def intersection_size_check?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:163 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:161 def on_csend(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:176 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:175 def on_numblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:142 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:147 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:172 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:180 def bad_intersection?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:177 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:185 def bad_intersection_predicates; end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:189 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:208 def register_offense(node, replacement); end - # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:193 def straight?(method_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:197 + def uncorrectable_block_intersection?(node, method_name, argument, block_method); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:89 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:94 RuboCop::Cop::Style::ArrayIntersect::ACTIVE_SUPPORT_PREDICATES = T.let(T.unsafe(nil), Set) -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:91 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:96 RuboCop::Cop::Style::ArrayIntersect::ARRAY_SIZE_METHODS = T.let(T.unsafe(nil), Set) -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:137 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:142 RuboCop::Cop::Style::ArrayIntersect::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:139 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:144 RuboCop::Cop::Style::ArrayIntersect::NEGATED_METHODS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:88 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:93 RuboCop::Cop::Style::ArrayIntersect::PREDICATES = T.let(T.unsafe(nil), Set) -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:140 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:145 RuboCop::Cop::Style::ArrayIntersect::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:138 +# pkg:gem/rubocop#lib/rubocop/cop/style/array_intersect.rb:143 RuboCop::Cop::Style::ArrayIntersect::STRAIGHT_METHODS = T.let(T.unsafe(nil), Array) # Use `include?(element)` instead of `intersect?([element])`. @@ -34821,27 +36102,27 @@ RuboCop::Cop::Style::BlockDelimiters::BRACES_REQUIRED_MESSAGE = T.let(T.unsafe(n # Corrector to correct conditional assignment in `case` statements. # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:611 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:633 class RuboCop::Cop::Style::CaseCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:616 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:638 def correct(corrector, cop, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:626 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:648 def move_assignment_inside_condition(corrector, node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:646 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:668 def extract_branches(case_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:640 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:662 def extract_tail_branches(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:656 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:678 def move_branch_inside_condition(corrector, branch, condition, assignment, column); end end end @@ -35122,10 +36403,15 @@ RuboCop::Cop::Style::CharacterLiteral::MSG = T.let(T.unsafe(nil), String) # # Moving from `compact` to `nested` children requires knowledge of whether the # outer parent is a module or a class. Moving from `nested` to `compact` requires -# verification that the outer parent is defined elsewhere. RuboCop does not -# have the knowledge to perform either operation safely and thus requires +# verification that the outer parent is defined elsewhere. By default RuboCop does +# not have the knowledge to perform either operation safely and thus requires # manual oversight. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed, +# the project-wide index is consulted to resolve whether the outer parent is a +# class or a module, and compacting is skipped when the outer parent is not +# defined elsewhere. +# # @example EnforcedStyle: nested (default) # # bad # class Foo::Bar @@ -35150,95 +36436,118 @@ RuboCop::Cop::Style::CharacterLiteral::MSG = T.let(T.unsafe(nil), String) # # The compact style is only forced for classes/modules with one child. # -# pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:53 +# pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:58 class RuboCop::Cop::Style::ClassAndModuleChildren < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ProjectIndexHelp include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:62 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:68 def on_class(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:68 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:74 def on_module(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:136 def add_trailing_end(corrector, node, padding); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:276 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:265 def check_compact_style(node, body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:256 def check_nested_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:238 def check_style(node, body, style); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:141 def compact_definition(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:192 def compact_identifier_name(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:122 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:177 def compact_node(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:230 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:286 def compact_node_name?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:182 def compact_replacement(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:193 + # Compacting removes this definition of the namespace, so the result raises + # `NameError` at load time unless the namespace is also defined somewhere else. + # With the project index this is verified before correcting; without it the + # correction is performed regardless (the cop's autocorrection is unsafe). + # + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:156 + def compactible_namespace?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:249 def const_namespace?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:165 + def definition_elsewhere?(definition, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:119 + def heuristic_namespace_keyword(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:108 + def indexed_namespace_keyword(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:225 def leading_spaces(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:104 + def namespace_keyword(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:282 def needs_compacting?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:90 def nest_definition(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:80 def nest_or_compact(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:198 def remove_end(corrector, body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:93 - def replace_namespace_keyword(corrector, node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:172 + # A tab counts as `configured_indentation_width` columns, matching the + # width `AlignmentCorrector` uses to convert `column_delta` back into + # tabs. Using `Layout/IndentationStyle`'s own `IndentationWidth` here + # would make the delta and the correction disagree. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:233 def spaces_size(spaces_string); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:127 def split_on_double_colon(corrector, node, padding); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:294 def style_for_classes; end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:238 - def style_for_modules; end + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:290 + def style_for_kind(kind); end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:177 - def tab_indentation_width; end + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:298 + def style_for_modules; end - # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:211 def unindent(corrector, node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:60 +# pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:66 RuboCop::Cop::Style::ClassAndModuleChildren::COMPACT_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:59 +# pkg:gem/rubocop#lib/rubocop/cop/style/class_and_module_children.rb:65 RuboCop::Cop::Style::ClassAndModuleChildren::NESTED_MSG = T.let(T.unsafe(nil), String) # Enforces consistent use of `Object#is_a?` or `Object#kind_of?`. @@ -36671,80 +37980,87 @@ RuboCop::Cop::Style::ConcatArrayLiterals::RESTRICT_ON_SEND = T.let(T.unsafe(nil) class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base include ::RuboCop::Cop::Style::ConditionalAssignmentHelper include ::RuboCop::Cop::ConfigurableEnforcedStyle + include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:218 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:219 def assignment_type?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:302 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:304 def candidate_condition?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_and_asgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:255 def on_case(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:264 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:265 def on_case_match(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_casgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_cvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_gvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:241 def on_if(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_ivasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_lvasgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_masgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_op_asgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:226 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:227 def on_or_asgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:235 def on_send(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:308 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:310 def allowed_single_line?(branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:382 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:404 def allowed_statements?(branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:304 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:306 def allowed_ternary?(assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:312 + # `ReparsedEquivalence#correction_parses?` contract: apply the exact + # correction this cop would perform. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:400 + def apply_reparse_correction(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:314 def assignment_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:359 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:361 def assignment_types_match?(*nodes); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:374 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:377 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:297 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:299 def candidate_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:277 def check_assignment_to_condition(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:365 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:367 def check_node(node, branches); end # If `Layout/LineLength` is enabled, we do not want to introduce an @@ -36755,50 +38071,61 @@ class RuboCop::Cop::Style::ConditionalAssignment < ::RuboCop::Cop::Base # of the longest line + the length of the corrected assignment is # greater than the max configured line length # - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:398 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:420 def correction_exceeds_line_limit?(node, branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:421 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:443 def include_ternary?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:352 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:354 def lhs_all_match?(branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:410 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:432 def longest_line(node, assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:406 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:428 def longest_line_exceeds_line_limit?(node, assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:336 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:338 def move_assignment_inside_condition(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:326 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:328 def move_assignment_outside_condition(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:417 + # The correction rewrites the conditional structurally, so full AST + # equivalence cannot be asserted, but the result must at least reparse + # to valid Ruby. Applying the correction to a throwaway buffer here + # also exercises the branch-shape handling before an offense is even + # reported, so unusual branches that the corrector cannot handle are + # left alone instead of crashing or emitting invalid code - the bug + # class behind most of this cop's history. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:392 + def safe_to_correct?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:439 def single_line_conditions_only?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:348 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:350 def ternary_condition?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:211 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:212 RuboCop::Cop::Style::ConditionalAssignment::ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:209 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:210 RuboCop::Cop::Style::ConditionalAssignment::ASSIGN_TO_CONDITION_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:212 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:213 RuboCop::Cop::Style::ConditionalAssignment::ENABLED = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:208 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:209 RuboCop::Cop::Style::ConditionalAssignment::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:213 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:214 RuboCop::Cop::Style::ConditionalAssignment::SINGLE_LINE_CONDITIONS_ONLY = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:210 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:211 RuboCop::Cop::Style::ConditionalAssignment::VARIABLE_ASSIGNMENT_TYPES = T.let(T.unsafe(nil), Array) # Helper module to provide common methods to classes needed for the @@ -36864,27 +38191,27 @@ RuboCop::Cop::Style::ConditionalAssignmentHelper::KEYWORD = T.let(T.unsafe(nil), # Helper module to provide common methods to ConditionalAssignment # correctors # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:428 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:450 module RuboCop::Cop::Style::ConditionalCorrectorHelper - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:466 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:488 def assignment(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:495 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:517 def correct_branches(corrector, branches); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:472 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:494 def correct_if_branches(corrector, cop, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:430 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:452 def remove_whitespace_in_branches(corrector, branch, condition, column); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:482 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:504 def replace_branch_assignment(corrector, branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:451 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:473 def same_line?(node1, node2); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:455 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:477 def white_space_range(node, column); end end @@ -36975,39 +38302,39 @@ class RuboCop::Cop::Style::Copyright < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:28 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:29 def on_new_investigation; end private - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:45 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:50 def autocorrect(corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:119 def autocorrect_notice; end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:86 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:91 def encoding_token?(processed_source, token_index); end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:77 def insert_notice_before(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:52 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:57 def normalized_autocorrect_notice; end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:110 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:115 def notice; end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:98 def notice_found?(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:111 def notice_regexp; end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:84 def shebang_token?(processed_source, token_index); end - # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/copyright.rb:66 def verify_autocorrect_notice!; end end @@ -37332,6 +38659,16 @@ RuboCop::Cop::Style::DirEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # # Specific cops can be allowed with the `AllowedCops` configuration. Note that # +# Alternatively, specific cops can be disallowed with the `DisallowedCops` +# configuration. When `DisallowedCops` is set, only directives for the listed +# cops (and `all`) will be flagged. This is useful when you want +# to protect a small set of critical cops from being disabled rather than +# allowlisting all other cops. `AllowedCops` and `DisallowedCops` should not +# both be set at the same time; if `DisallowedCops` is set, it takes precedence. +# +# This cop cannot be disabled via directive comments when it is explicitly +# enabled with `Enabled: true`. This prevents users from bypassing the cop +# # @example # # bad # def foo @@ -37346,32 +38683,45 @@ RuboCop::Cop::Style::DirEmpty::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # def foo # end # -# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:33 +# @example DisallowedCops: [Lint/Void] +# # bad +# foo +# +# # good +# foo +# +# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:55 class RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:40 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:62 def on_new_investigation; end private - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:111 def allowed_cops; end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:81 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:115 def any_cops_allowed?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:75 + def compute_disallowed_cops(directive_cops); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:106 def directive_cops(comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:119 + def disallowed_cops_config; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:87 def register_offense(comment, directive_cops, disallowed_cops); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:37 +# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:59 RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:38 +# pkg:gem/rubocop#lib/rubocop/cop/style/disable_cops_within_source_code_directive.rb:60 RuboCop::Cop::Style::DisableCopsWithinSourceCodeDirective::MSG_FOR_COPS = T.let(T.unsafe(nil), String) # When using `class_eval` (or other `eval`) with string interpolation, @@ -37499,6 +38849,11 @@ RuboCop::Cop::Style::DocumentDynamicEvalDefinition::RESTRICT_ON_SEND = T.let(T.u # The documentation requirement is annulled if the class or module has # same for all its children. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, a reopened class or module is not reported when any of its +# other definition sites (in the same or another file) carries a +# documentation comment. +# # @example # # bad # class Person @@ -37555,75 +38910,98 @@ RuboCop::Cop::Style::DocumentDynamicEvalDefinition::RESTRICT_ON_SEND = T.let(T.u # end # end # -# pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:72 +# pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:77 class RuboCop::Cop::Style::Documentation < ::RuboCop::Cop::Base include ::RuboCop::Cop::DocumentationComment + include ::RuboCop::Cop::ProjectIndexHelp include ::RuboCop::Cop::RangeHelp - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:89 def constant_definition?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:95 def constant_visibility_declaration?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:100 def include_statement?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:104 def on_class(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:100 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:110 def on_module(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:92 def outer_module(param0); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:174 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:127 + def add_documentation_offense(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:221 def allowed_constants; end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:116 def check(node, body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:147 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:194 def compact_namespace?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:190 def constant_allowed?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:139 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:186 def constant_declaration?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:178 + # A reopened class or module is typically documented at a single + # definition site. When `AllCops/UseProjectIndex` is enabled, the + # documentation requirement is satisfied by a comment on any other + # definition of the same class or module. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:137 + def documented_elsewhere?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:158 + def documenting_comments?(definition); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:225 def identifier(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:170 def include_statement_only?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:176 def namespace?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:217 def nodoc(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:166 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:213 def nodoc?(comment, require_all: T.unsafe(nil)); end # Note: How end-of-line comments are associated with code changed in # parser-2.2.0.4. # - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:156 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:203 def nodoc_comment?(node, require_all: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:165 def nodoc_self_or_outer_module?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:186 + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:150 + def other_definition?(definition, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:233 def qualify_const(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:76 +# Comments that configure tooling rather than document the code. +# +# pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:85 +RuboCop::Cop::Style::Documentation::DIRECTIVE_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) + +# pkg:gem/rubocop#lib/rubocop/cop/style/documentation.rb:82 RuboCop::Cop::Style::Documentation::MSG = T.let(T.unsafe(nil), String) # Checks for missing documentation comment for public methods. @@ -38899,16 +40277,13 @@ class RuboCop::Cop::Style::EndlessMethod < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:229 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:219 def arguments(node, missing = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:233 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:223 def can_be_made_endless?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:209 - def correct_to_multiline(corrector, node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:219 def endless_replacement(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:164 @@ -38923,13 +40298,13 @@ class RuboCop::Cop::Style::EndlessMethod < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:173 def handle_require_single_line_style(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:245 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:235 def modifier_offset(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:225 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:215 def receiver(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:237 + # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:227 def too_long_when_made_endless?(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/endless_method.rb:202 @@ -40814,6 +42189,7 @@ class RuboCop::Cop::Style::GuardClause < ::RuboCop::Cop::Base include ::RuboCop::Cop::MinBodyLength include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::AllowedPattern include ::RuboCop::Cop::StatementModifier extend ::RuboCop::Cop::AutoCorrector @@ -42026,24 +43402,24 @@ RuboCop::Cop::Style::IdenticalConditionalBranches::MSG = T.let(T.unsafe(nil), St # Corrector to correct conditional assignment in `if` statements. # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:564 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:586 class RuboCop::Cop::Style::IfCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:569 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:591 def correct(corrector, cop, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:573 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:595 def move_assignment_inside_condition(corrector, node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:587 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:609 def extract_tail_branches(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:594 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:616 def move_branch_inside_condition(corrector, branch, condition, assignment, column); end end end @@ -42214,126 +43590,114 @@ RuboCop::Cop::Style::IfInsideElse::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::IfUnlessModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp - include ::RuboCop::Cop::StatementModifier include ::RuboCop::Cop::AllowedPattern + include ::RuboCop::Cop::StatementModifier include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::CommentsHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:93 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:95 def on_if(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:191 - def allowed_patterns; end - - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:284 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:243 def another_modifier_if_on_same_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:298 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:257 def another_statement_on_same_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:154 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:278 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:237 def collection_from_ancestor(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:352 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:311 def comment_on_node_line(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:128 def defined_argument_is_undefined?(if_node, defined_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:118 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:120 def defined_nodes(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:116 def endless_method?(body); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:339 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:298 def extract_heredoc_from(last_argument); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:271 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:230 def find_containing_collection(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:235 - def line_length_enabled_at_line?(line); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:146 def message(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:207 def multiline_inside_collection?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:239 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:198 def named_capture_in_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:243 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:202 def non_eligible_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:294 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:253 def non_simple_if_unless?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:138 def pattern_matching_nodes(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:356 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:315 def remove_comment(corrector, _node, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:346 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:305 def remove_heredoc(corrector, heredoc); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:163 def replacement_for_modifier_form(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:226 def shares_line_with?(inner, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:214 def sibling_if_shares_line?(child, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:332 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:291 def to_modifier_form_with_move_comment(node, indentation, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:312 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:271 def to_normal_form(node, indentation); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:320 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:279 def to_normal_form_with_heredoc(node, indentation, heredoc); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:185 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:187 def too_long_due_to_comment_after_modifier?(node, comment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:180 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:182 def too_long_due_to_modifier?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:218 - def too_long_line_based_on_allow_cop_directives?(range, line); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:226 - def too_long_line_based_on_allow_uri?(line); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:209 - def too_long_line_based_on_config?(range, line); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:193 def too_long_single_line?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:260 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:219 def unwrap_begin(node); end class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:90 def autocorrect_incompatible_with; end end end -# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:83 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:81 RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:86 +# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:84 +RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_MODIFIER_PARENS = T.let(T.unsafe(nil), String) + +# pkg:gem/rubocop#lib/rubocop/cop/style/if_unless_modifier.rb:88 RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), String) # Checks for if and unless statements used as modifiers of other if or @@ -42360,6 +43724,7 @@ RuboCop::Cop::Style::IfUnlessModifier::MSG_USE_NORMAL = T.let(T.unsafe(nil), Str class RuboCop::Cop::Style::IfUnlessModifierOfIfUnless < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::AllowedPattern include ::RuboCop::Cop::StatementModifier extend ::RuboCop::Cop::AutoCorrector @@ -43313,34 +44678,39 @@ class RuboCop::Cop::Style::Lambda < ::RuboCop::Cop::Base include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:68 def on_block(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:84 def on_itblock(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:83 def on_numblock(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:120 def arguments_with_whitespace(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:109 def autocorrect_method_to_literal(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:124 def lambda_arg_string(args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:94 def message(node, selector); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:96 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:100 def message_line_modifier(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:88 def offending_selector?(node, selector); end + + class << self + # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:64 + def autocorrect_incompatible_with; end + end end # pkg:gem/rubocop#lib/rubocop/cop/style/lambda.rb:53 @@ -44340,6 +45710,7 @@ class RuboCop::Cop::Style::MethodCallWithArgsParentheses < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedPattern include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::RequireParentheses include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ReparsedEquivalence include ::RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses extend ::RuboCop::Cop::AutoCorrector @@ -44374,128 +45745,135 @@ end # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:9 module RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ReparsedEquivalence + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:17 + def on_investigation_end; end private - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:80 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:97 def allowed_camel_case_method_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:191 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:208 def allowed_chained_call_with_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:187 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:204 def allowed_multiline_call_with_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:102 def allowed_string_interpolation_method_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:217 def ambiguous_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:180 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:197 def ambiguous_range_argument?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:230 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:47 + def apply_reparse_correction(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:247 def assigned_before?(node, target); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:238 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:255 def assignment_in_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:34 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:51 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:162 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:179 def call_as_argument_or_chain?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:172 def call_in_argument_with_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:110 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:127 def call_in_literals?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:119 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:136 def call_in_logical_operators?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:184 def call_in_match_pattern?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:128 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:145 def call_in_optional_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:149 def call_in_single_line_inheritance?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:154 def call_with_ambiguous_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:168 def call_with_braced_block?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:248 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:265 def forwards_anonymous_rest_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:216 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:233 def hash_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:190 def hash_literal_in_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:50 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:67 def inside_endless_method_def?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:234 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:251 def inside_string_interpolation?(node); end # Require hash value omission be enclosed in parentheses to prevent the following issue: # https://bugs.ruby-lang.org/issues/18396. # - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:81 def last_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:114 def legitimate_call_with_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:212 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:229 def logical_operator?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:89 def method_call_before_constant_resolution?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:46 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:63 def offense_range(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:18 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:33 def omit_parentheses(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:107 def parentheses_at_the_end_of_multiline_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:237 def regexp_slash_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:55 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:72 def require_parentheses_for_hash_value_omission?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:221 def splat?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:76 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:93 def super_call_without_arguments?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:68 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:85 def syntax_like_method_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:208 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:225 def ternary_if?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:241 def unary_literal?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:13 +# pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:14 RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::OMIT_MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:12 +# pkg:gem/rubocop#lib/rubocop/cop/style/method_call_with_args_parentheses/omit_parentheses.rb:13 RuboCop::Cop::Style::MethodCallWithArgsParentheses::OmitParentheses::TRAILING_WHITESPACE_REGEX = T.let(T.unsafe(nil), Regexp) # Style require_parentheses @@ -45060,6 +46438,11 @@ RuboCop::Cop::Style::MissingElse::MSG_NIL = T.let(T.unsafe(nil), String) # delegator.upcase # => FOO # ---- # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, `respond_to_missing?` defined in another definition of the +# same class or module (e.g. a reopening in another file) also +# satisfies the check. +# # @example # # bad # def method_missing(name, *args) @@ -45083,12 +46466,14 @@ RuboCop::Cop::Style::MissingElse::MSG_NIL = T.let(T.unsafe(nil), String) # end # end # -# pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:54 +# pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:59 class RuboCop::Cop::Style::MissingRespondToMissing < ::RuboCop::Cop::Base - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:57 + include ::RuboCop::Cop::ProjectIndexHelp + + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:64 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:71 def on_defs(node); end private @@ -45096,14 +46481,26 @@ class RuboCop::Cop::Style::MissingRespondToMissing < ::RuboCop::Cop::Base # The class/module/`class << self` body that lexically contains `node`, # or `nil` when `node` is defined at the top level. # - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:109 def enclosing_scope(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:97 def implements_respond_to_missing?(node); end + + # When `AllCops/UseProjectIndex` is enabled, `respond_to_missing?` + # defined in another definition of the same class or module (e.g. a + # reopening in another file) also satisfies the check. Ancestors are + # not consulted: overriding `method_missing` warrants a matching + # `respond_to_missing?` for the same class. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:80 + def respond_to_missing_elsewhere?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:93 + def singleton_definition?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:55 +# pkg:gem/rubocop#lib/rubocop/cop/style/missing_respond_to_missing.rb:62 RuboCop::Cop::Style::MissingRespondToMissing::MSG = T.let(T.unsafe(nil), String) # Checks for grouping of mixins in `class` and `module` bodies. @@ -45502,6 +46899,7 @@ RuboCop::Cop::Style::MultilineBlockChain::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::MultilineIfModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::AllowedPattern include ::RuboCop::Cop::StatementModifier extend ::RuboCop::Cop::AutoCorrector @@ -45549,6 +46947,12 @@ class RuboCop::Cop::Style::MultilineIfThen < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_then.rb:38 def non_modifier_then?(node); end + + # Prism gives an `elsif` with no `then` of its own the previous branch's `then` location, + # which lies outside the node. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_then.rb:44 + def own_then?(node); end end # pkg:gem/rubocop#lib/rubocop/cop/style/multiline_if_then.rb:26 @@ -45877,7 +47281,7 @@ RuboCop::Cop::Style::MultilineWhenThen::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:73 def on_or(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:64 @@ -45891,31 +47295,40 @@ class RuboCop::Cop::Style::MultipleComparison < ::RuboCop::Cop::Base private - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:154 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:165 def allow_method_comparison?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:132 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:114 + def collect_comparison(node, comparison, variables, values, skipped); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:143 def comparison?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:169 def comparisons_threshold; end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:97 - def find_offending_var(node, variables = T.unsafe(nil), values = T.unsafe(nil)); end + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:101 + def find_offending_var(node, variables = T.unsafe(nil), values = T.unsafe(nil), skipped = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:124 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:135 def nested_comparison?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:116 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:127 def offense_range(values); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:144 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:95 + def preferred_method(variable, values); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:155 def root_of_or_node(or_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:136 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:147 def simple_comparison(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:91 + def skipped_within_range?(skipped, range); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/multiple_comparison.rb:131 def variable_name(node); end end @@ -46008,6 +47421,9 @@ RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) # end # end.freeze # +# # good - `Data.define` declares an immutable value type +# CONST = Data.define(:foo, :bar) +# # @example # # # bad @@ -46016,56 +47432,56 @@ RuboCop::Cop::Style::MultipleComparison::MSG = T.let(T.unsafe(nil), String) # # good # CONST = [1, 2, 3] # -# pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:102 +# pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:105 class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base include ::RuboCop::Cop::Style::MutableConstant::ShareableConstantValue include ::RuboCop::Cop::FrozenStringLiteral include ::RuboCop::Cop::ConfigurableEnforcedStyle extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:159 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:162 def on_assignment(value); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:149 def on_casgn(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:317 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:320 def operation_produces_immutable_object?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:334 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:339 def range_enclosed_in_parentheses?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:310 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:313 def splat_value(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:212 def autocorrect(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:301 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:304 def correct_splat_expansion(corrector, expr, splat_value); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:267 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:270 def explicitly_frozen_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:243 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:246 def freezable_nested_literal?(node); end # Recursively freezes every nested mutable literal inside an array or # hash literal. Already-frozen subtrees are not re-frozen, but their # children are still inspected for unfrozen literals deeper down. # - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:233 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:236 def freeze_nested_literals(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:293 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:296 def frozen_regexp_or_range_literals?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:283 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:286 def immutable_literal?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:199 def literal_check(value); end # Returns the child literals of an array or hash node that may @@ -46073,32 +47489,32 @@ class RuboCop::Cop::Style::MutableConstant < ::RuboCop::Cop::Base # included. Percent-literal arrays (e.g. `%w(a b)`) are skipped because # `.freeze` cannot be appended to their contents. # - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:254 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:257 def literal_children(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:277 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:280 def mutable_literal?(value); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:173 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:176 def mutable_nodes(value, &block); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:204 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:207 def mutable_or_unfrozen_range?(value); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:273 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:276 def recursive?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:297 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:300 def requires_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:287 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:290 def shareable_constant_value?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:187 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:190 def strict_check(value); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:144 +# pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:147 RuboCop::Cop::Style::MutableConstant::MSG = T.let(T.unsafe(nil), String) # Handles magic comment shareable_constant_value with O(n ^ 2) complexity @@ -46106,33 +47522,33 @@ RuboCop::Cop::Style::MutableConstant::MSG = T.let(T.unsafe(nil), String) # Iterates over all lines before a CONSTANT # until it reaches shareable_constant_value # -# pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:107 +# pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:110 module RuboCop::Cop::Style::MutableConstant::ShareableConstantValue private # Identifies the most recent magic comment with valid shareable constant values # that's in scope for this node # - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:124 def magic_comment_in_scope(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:129 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:132 def processed_source_till_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:110 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:113 def recent_shareable_value?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:133 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:136 def shareable_constant_value_enabled?(value); end class << self # Identifies the most recent magic comment with valid shareable constant values # that's in scope for this node # - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:124 def magic_comment_in_scope(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:110 + # pkg:gem/rubocop#lib/rubocop/cop/style/mutable_constant.rb:113 def recent_shareable_value?(node); end end end @@ -46452,22 +47868,22 @@ class RuboCop::Cop::Style::NegativeArrayIndex < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:82 def add_offense_for_subtraction(node, index_arg, negative_index); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:170 def build_current_source(receiver, range_without_parens, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:151 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:153 def build_message_for_range(receiver, start, range_op, index, current); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:126 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:128 def build_range_offense_data(receiver, range_node, range_end, inner_end, negative_index, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:180 def build_range_without_parens(range_start, range_op, range_end, inner_end); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:158 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:160 def build_replacement_string(range_start, range_op, negative_index, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:200 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:202 def extract_base_receiver(node); end # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:78 @@ -46476,25 +47892,25 @@ class RuboCop::Cop::Style::NegativeArrayIndex < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:74 def extract_range_from_begin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:145 def format_range_message_parts(range_start, negative_index, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:113 def handle_range_pattern(receiver, range_node, index_arg); end # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:65 def handle_simple_index_pattern(node, index_arg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:209 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:211 def preserving_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:94 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:95 def range_with_length_subtraction?(range_node, array_receiver); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:184 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:186 def receivers_match?(length_receiver, array_receiver); end - # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:195 + # pkg:gem/rubocop#lib/rubocop/cop/style/negative_array_index.rb:197 def receivers_match_strict?(length_receiver, array_receiver); end end @@ -49386,6 +50802,9 @@ RuboCop::Cop::Style::RedundantArrayFlatten::RESTRICT_ON_SEND = T.let(T.unsafe(ni # Checks for redundant assignment before returning. # +# When there are comments between the assignment and reference, +# the cop will report an offense but it will not autocorrect. +# # @example # # bad # def test @@ -49418,44 +50837,47 @@ RuboCop::Cop::Style::RedundantArrayFlatten::RESTRICT_ON_SEND = T.let(T.unsafe(ni # end # end # -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:40 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:43 class RuboCop::Cop::Style::RedundantAssignment < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:50 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:53 def on_def(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:56 def on_defs(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:46 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:49 def redundant_assignment?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:99 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:102 def check_begin_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:58 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:61 def check_branch(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:79 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:82 def check_case_match_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:77 def check_case_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:98 def check_ensure_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:84 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:87 def check_if_node(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:91 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:94 def check_rescue_node(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:117 + def comments_between_assignment_and_reference?(assignment); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:43 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_assignment.rb:46 RuboCop::Cop::Style::RedundantAssignment::MSG = T.let(T.unsafe(nil), String) # Checks for redundant `begin` blocks. A `begin` block is redundant @@ -49884,6 +51306,11 @@ RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String) # to prevent conflicting rules. This is because it respects user configurations # that want to enable `Lint/ConstantResolution` cop which is disabled by default. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, a leading `::` inside a namespace is also reported when the +# constant provably resolves to the same declaration with and without +# the base, i.e. nothing in the surrounding nesting shadows it. +# # @example # # bad # ::Const @@ -49911,32 +51338,47 @@ RuboCop::Cop::Style::RedundantConditional::MSG = T.let(T.unsafe(nil), String) # ::Const # end # -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:43 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:48 class RuboCop::Cop::Style::RedundantConstantBase < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ProjectIndexHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:48 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:54 def on_cbase(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:67 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:103 def bad?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:63 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:88 + def first_constant_segment(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:99 def lint_constant_resolution_config; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:95 def lint_constant_resolution_cop_enabled?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:71 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:107 def module_nesting_ancestors_of(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:77 + # When `AllCops/UseProjectIndex` is enabled, `::` inside a namespace is + # also redundant when the first constant segment resolves to the same + # declaration with and without the base, i.e. nothing in the + # surrounding nesting shadows it. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:69 + def provably_unshadowed?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:81 + def same_resolution?(segment, nesting); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:113 def used_in_super_class_part?(node, class_node:); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:46 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_constant_base.rb:52 RuboCop::Cop::Style::RedundantConstantBase::MSG = T.let(T.unsafe(nil), String) # Checks for paths given to `require_relative` that start with @@ -50276,7 +51718,10 @@ class RuboCop::Cop::Style::RedundantFileExtensionInRequire < ::RuboCop::Cop::Bas private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_file_extension_in_require.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_file_extension_in_require.rb:63 + def escaped_extension?(name_node, extension_range); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_file_extension_in_require.rb:57 def extension_range(name_node); end end @@ -50444,36 +51889,36 @@ class RuboCop::Cop::Style::RedundantFormat < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:159 def all_fields_literal?(string, arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:266 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:275 def argument_value(argument); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:262 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:271 def argument_values(arguments); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:306 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:315 def complex_value(complex_node); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:129 def detect_unnecessary_fields(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:292 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:301 def dsym_value(dsym_node); end # Escape any control characters in the string (eg. `\t` or `\n` become `\\t` or `\\n`) # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:258 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:267 def escape_control_chars(string); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:190 def find_argument(sequence, arguments, hash); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:233 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:242 def float?(argument); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:296 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:305 def hash_value(hash_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:229 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:238 def integer?(argument); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:205 @@ -50482,16 +51927,23 @@ class RuboCop::Cop::Style::RedundantFormat < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:125 def message(node, prefer); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:223 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:232 def numeric?(argument); end + # `Array#[]` raises `RangeError` for an index beyond the 64-bit range + # (e.g. `format('%*9999999999999999999999$d', 1)`) instead of returning `nil`, + # so the index needs to be checked before accessing the array. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:226 + def positional_argument(arguments, number); end + # Add correct quotes to the formatted string, preferring retaining the existing # quotes if possible. # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:239 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:248 def quote(string, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:302 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:311 def rational_value(rational_node); end # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:142 @@ -50507,7 +51959,7 @@ class RuboCop::Cop::Style::RedundantFormat < ::RuboCop::Cop::Base # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:110 def string_with_format_sequence?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:276 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_format.rb:285 def typed_argument_value(argument); end # If the sequence has a variable (`*`) width, it cannot be autocorrected @@ -50873,10 +52325,13 @@ RuboCop::Cop::Style::RedundantInterpolationUnfreeze::MSG = T.let(T.unsafe(nil), # Checks for redundant line continuation. # -# This cop marks a line continuation as redundant if removing the backslash -# does not result in a syntax error. -# However, a backslash at the end of a comment or -# for string concatenation is not redundant and is not considered an offense. +# A line continuation is redundant when removing the backslash does not +# change how the program parses: the source is reparsed without the +# backslash and the resulting AST is compared to the original. Only +# backslashes that are pure noise are reported; backslashes that are +# significant — inside strings, for string concatenation, before an +# operator or argument that would otherwise start a new statement, and +# so on — are left alone, as are backslashes in comments. # # @example # # bad @@ -50932,104 +52387,91 @@ RuboCop::Cop::Style::RedundantInterpolationUnfreeze::MSG = T.let(T.unsafe(nil), # some_method \ # (argument) # -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:67 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:70 class RuboCop::Cop::Style::RedundantLineContinuation < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::MatchRange + include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:87 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:82 def on_new_investigation; end private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:242 - def argument_is_method?(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:208 - def argument_newline?(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:179 - def code_ends_with_continuation?(last_line); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:113 - def ends_with_uncommented_backslash?(range); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:222 - def find_node_for_line(last_line); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:99 + def apply_reparse_correction(corrector, range); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:193 - def inside_string_literal?(range, token); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:163 + def first_token_after(tokens, range); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:126 - def inside_string_literal_or_method_with_argument?(range); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:137 - def inside_string_literal_with_interpolation?(range); end + # A backslash directly joining two string literals is never redundant: + # removing it moves the second literal onto its own logical line, + # severing the implicit string concatenation. Skipping these up front + # avoids reparse verification, which is prohibitively slow on generated + # files gluing thousands of string fragments with line continuations. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:128 + def implicit_string_concatenation?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:167 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:179 def inspect_end_of_ruby_code_line_continuation; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:151 - def leading_dot_method_chain_with_blank_line?(range); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:249 - def method_call_with_arguments?(node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:158 + def last_token_before(tokens, range); end - # A method call without parentheses such as the following cannot remove `\`: + # The `parser` gem, unlike Ruby itself, accepts a leading-dot method + # chain continued across a blank line, so the reparse check alone would + # deem the backslash redundant even though removing it breaks the code + # on MRI. Prism matches Ruby here and does not need this guard. # - # do_something \ - # argument - # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:201 - def method_with_argument?(line_range, current_token, next_token); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:157 - def redundant_line_continuation?(range); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:104 - def require_line_continuation?(range); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:152 + def leading_dot_method_chain_with_blank_line?(range); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:228 - def same_line?(node, line); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:103 + def line_continuation_candidates; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:253 - def start_with_arithmetic_operator?(range); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:173 + def string_literal_beginning_on_line?(token, line); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:122 - def string_concatenation?(source_line); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:167 + def string_literal_ending_on_line?(token, line); end # The backslash is the last character of the line; locate it by the line's # position in the buffer rather than treating the column as an absolute offset # (which corrupts an earlier line in multi-line files). # - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:188 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:196 def trailing_line_continuation_range(line_number); end -end -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:74 -RuboCop::Cop::Style::RedundantLineContinuation::ALLOWED_STRING_TOKENS = T.let(T.unsafe(nil), Array) + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:117 + def within_comment?(range); end -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:81 -RuboCop::Cop::Style::RedundantLineContinuation::ARGUMENT_TAKING_FLOW_TOKEN_TYPES = T.let(T.unsafe(nil), Array) - -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:75 -RuboCop::Cop::Style::RedundantLineContinuation::ARGUMENT_TYPES = T.let(T.unsafe(nil), Array) - -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:84 -RuboCop::Cop::Style::RedundantLineContinuation::ARITHMETIC_OPERATOR_TOKENS = T.let(T.unsafe(nil), Array) + # A backslash in string content is never a redundant line continuation + # (removing it changes the string's value, which the reparse check would + # detect); skipping it up front just avoids a useless reparse. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:140 + def within_string_content?(range); end +end -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:72 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:76 RuboCop::Cop::Style::RedundantLineContinuation::LINE_CONTINUATION = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:73 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:77 RuboCop::Cop::Style::RedundantLineContinuation::LINE_CONTINUATION_PATTERN = T.let(T.unsafe(nil), Regexp) -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:71 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:75 RuboCop::Cop::Style::RedundantLineContinuation::MSG = T.let(T.unsafe(nil), String) -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:85 -RuboCop::Cop::Style::RedundantLineContinuation::STRING_LITERAL_BEGIN_TOKENS = T.let(T.unsafe(nil), Array) +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:80 +RuboCop::Cop::Style::RedundantLineContinuation::STRING_LITERAL_BEGINNING_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:79 +RuboCop::Cop::Style::RedundantLineContinuation::STRING_LITERAL_ENDING_TOKEN_TYPES = T.let(T.unsafe(nil), Array) + +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_line_continuation.rb:78 +RuboCop::Cop::Style::RedundantLineContinuation::STRING_TOKEN_TYPES = T.let(T.unsafe(nil), Array) # Identifies places where `max_by { ... }`, `min_by { ... }`, or # `minmax_by { ... }` can be replaced by `max`, `min`, or `minmax`. @@ -51111,141 +52553,146 @@ RuboCop::Cop::Style::RedundantMinMaxBy::REPLACEMENTS = T.let(T.unsafe(nil), Hash # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:16 class RuboCop::Cop::Style::RedundantParentheses < ::RuboCop::Cop::Base include ::RuboCop::Cop::Parentheses + include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:31 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:32 def allowed_pin_operator?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:344 - def first_call_argument?(param0 = T.unsafe(nil)); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:195 def interpolation?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:33 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:39 def on_begin(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:28 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:45 + def on_investigation_end; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:34 + def on_new_investigation; end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:29 def rescue?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:23 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:24 def square_brackets?(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:221 def allow_in_multiline_conditions?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:68 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:86 def allowed_ancestor?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:61 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:79 def allowed_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:73 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:91 def allowed_multiple_expression?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:82 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:100 def allowed_ternary?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:196 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:252 + def apply_reparse_correction(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:197 def argument_of_parenthesized_method_call?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:274 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:309 def body_range?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:349 - def call_chain_starts_with_int?(begin_node, send_node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:224 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:225 def call_node?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:138 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:139 def check(begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:228 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:229 def check_send(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:239 def check_unary(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:263 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:301 def disallowed_literal?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:320 def disallowed_one_line_pattern_matching?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:355 - def do_end_block_in_method_chain?(begin_node, node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:127 def empty_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:155 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:156 def find_offense_message(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:114 - def first_arg_begins_with_hash_literal?(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:337 - def first_argument?(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:54 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:72 def ignore_syntax?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:132 def in_pattern_matching_in_method_argument?(begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:259 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:297 def keyword_ancestor?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:305 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:329 def keyword_with_redundant_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:113 def like_method_argument_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:214 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:215 def method_call_parentheses_required?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:318 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:342 def method_call_with_redundant_parentheses?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:130 - def method_chain_begins_with_hash_literal(node); end - - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:120 def multiline_control_flow_statements?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:249 + # Grouping parentheses are transparent to the comparison: single-child + # `begin` nodes are collapsed, a parenthesized statement sequence + # inside another sequence is spliced in place, and chains of the same + # `&&`/`||` operator are normalized to left association (`x && (y && + # z)` and `x && y && z` differ as trees but `&&` and `||` cannot be + # redefined, so same-operator regrouping is semantically transparent). + # + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:262 + def normalize_reparsed_ast(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:248 def offense(node, msg); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:205 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:206 def oneline_rescue_parentheses_required?(begin_node, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:333 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:357 def only_begin_arg?(args); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:45 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:64 def parens_allowed?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:294 - def raised_to_power_negative_numeric?(begin_node, node); end + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:282 + def rotate_same_operator(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:326 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:350 def singular_parenthesized_parent?(begin_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:255 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:276 + def splice_nested_sequences(children); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:293 def suspect_unary?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:88 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:106 def ternary_parentheses_required?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:41 + # pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:60 def variable?(node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:20 +# pkg:gem/rubocop#lib/rubocop/cop/style/redundant_parentheses.rb:21 RuboCop::Cop::Style::RedundantParentheses::ALLOWED_NODE_TYPES = T.let(T.unsafe(nil), Array) # Checks for usage of the %q/%Q syntax when '' or "" would do. @@ -53003,6 +54450,16 @@ RuboCop::Cop::Style::ReverseFind::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # x&.foo # raises NoMethodError # ---- # +# Additionally, when a method chain is converted, a `NoMethodError` that +# the original code raised for an intermediate `nil` value is suppressed: +# +# [source,ruby] +# ---- +# x = Struct.new(:foo).new(nil) +# x && x.foo.bar # raises NoMethodError +# x&.foo&.bar # returns nil +# ---- +# # @example # # bad # foo.bar if foo @@ -53057,7 +54514,7 @@ RuboCop::Cop::Style::ReverseFind::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # foo ? foo[idx] = v : nil # Ignored `foo&.[]=(idx, v)` due to unclear readability benefit. # foo ? foo * 42 : nil # Ignored `foo&.*(42)` due to unclear readability benefit. # -# pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:93 +# pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:103 class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Base include ::RuboCop::Cop::AllowedMethods include ::RuboCop::Cop::NilMethods @@ -53065,121 +54522,121 @@ class RuboCop::Cop::Style::SafeNavigation < ::RuboCop::Cop::Base extend ::RuboCop::Cop::AutoCorrector extend ::RuboCop::Cop::TargetRubyVersion - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:140 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:150 def and_inside_begin?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:134 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:144 def and_with_rhs_or?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:108 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:118 def modifier_if_safe_navigation_candidate(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:137 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:147 def not_nil_check?(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:165 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:175 def on_and(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:156 def on_if(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:143 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:153 def strip_begin(param0 = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:123 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:133 def ternary_safe_navigation_candidate(param0 = T.unsafe(nil)); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:408 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:418 def add_safe_nav_to_all_methods_in_chain(corrector, start_method, method_chain); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:304 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:314 def allowed_if_condition?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:235 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:245 def and_parts(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:400 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:410 def begin_range(node, method_call); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:359 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:369 def chain_length(method_chain, method); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:217 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:227 def collect_and_clauses(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:285 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:295 def comments(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:229 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:239 def concat_nodes(nodes, and_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:264 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:274 def dotless_operator_call?(method_call); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:272 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:282 def dotless_operator_method?(method_call); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:404 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:414 def end_range(node, method_call); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:323 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:333 def extract_common_parts(method_chain, checked_variable); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:256 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:266 def extract_if_body(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:308 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:318 def extract_parts_from_if(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:331 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:341 def find_matching_receiver_invocation(method_chain, checked_variable); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:211 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:221 def find_method_chain(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:278 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:288 def handle_comments(corrector, node, method_call); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:345 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:355 def matching_call_nodes?(left, right); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:341 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:351 def matching_nodes?(left, right); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:421 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:431 def max_chain_length; end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:396 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:406 def method_called?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:388 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:398 def negated?(send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:242 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:252 def offending_node?(node, lhs_receiver, rhs, rhs_receiver); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:291 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:301 def relevant_comment_ranges(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:204 def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:379 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:389 def unsafe_method?(node, send_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:367 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:377 def unsafe_method_used?(node, method_chain, method); end - # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:252 + # pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:262 def use_var_only_in_unless_modifier?(node, variable); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:101 +# pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:111 RuboCop::Cop::Style::SafeNavigation::LOGIC_JUMP_KEYWORDS = T.let(T.unsafe(nil), Array) -# pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:99 +# pkg:gem/rubocop#lib/rubocop/cop/style/safe_navigation.rb:109 RuboCop::Cop::Style::SafeNavigation::MSG = T.let(T.unsafe(nil), String) # Enforces safe navigation chains length to not exceed the configured maximum. @@ -54421,77 +55878,89 @@ RuboCop::Cop::Style::SlicingWithRange::RESTRICT_ON_SEND = T.let(T.unsafe(nil), A # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:49 class RuboCop::Cop::Style::SoleNestedConditional < ::RuboCop::Cop::Base include ::RuboCop::Cop::RangeHelp + include ::RuboCop::Cop::ReparsedEquivalence extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:59 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:60 def on_if(node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:199 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:216 def add_parentheses?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:178 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:195 def add_parentheses_if_needed(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:240 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:257 def allow_modifier?; end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:84 + # Merging the conditionals intentionally produces a different AST, so + # full equivalence cannot be checked, but the corrected source must at + # least remain parseable (see `ReparsedEquivalence#correction_parses?`), + # which suppresses the entire produces-invalid-code bug class. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:90 + def apply_reparse_correction(corrector, node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:101 def assigned_variables(condition); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:207 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:224 def assignment_in_and?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:118 def autocorrect(corrector, node, if_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:126 def autocorrect_outer_condition_basic(corrector, node, if_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:152 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:169 def autocorrect_outer_condition_modify_form(corrector, node, if_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:170 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:187 def chainable_condition(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:152 def correct_for_basic_condition_style(corrector, node, if_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:161 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:178 def correct_for_comment(corrector, node, if_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:125 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:142 def correct_for_guard_condition_style(corrector, node, if_branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:120 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:137 def correct_node(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:92 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:109 def offending_branch?(node, branch); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:194 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:77 + def offending_conditional?(node); end + + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:211 def parenthesize_method?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:220 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:237 def parenthesized_and(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:230 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:247 def parenthesized_and_clause(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:213 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:230 def parenthesized_method_arguments(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:94 def use_variable_assignment_in_condition?(condition, if_branch); end class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:55 + # pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:56 def autocorrect_incompatible_with; end end end -# pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:53 +# pkg:gem/rubocop#lib/rubocop/cop/style/sole_nested_conditional.rb:54 RuboCop::Cop::Style::SoleNestedConditional::MSG = T.let(T.unsafe(nil), String) # Looks for uses of Perl-style global variables. @@ -54723,6 +56192,11 @@ RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_REQUIRE = T.let(T.unsafe(nil), # for some other subclass, monkey-patched with instance methods or # a dummy instance is instantiated from it somewhere. # +# When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is +# installed, classes that are subclassed anywhere in the project are +# not reported, since converting them to modules would break their +# subclasses. +# # @example # # bad # class SomeClass @@ -54754,40 +56228,48 @@ RuboCop::Cop::Style::StabbyLambdaParentheses::MSG_REQUIRE = T.let(T.unsafe(nil), # def self.class_method; end # end # -# pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:46 +# pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:51 class RuboCop::Cop::Style::StaticClass < ::RuboCop::Cop::Base + include ::RuboCop::Cop::ProjectIndexHelp include ::RuboCop::Cop::RangeHelp include ::RuboCop::Cop::VisibilityHelp extend ::RuboCop::Cop::AutoCorrector - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:53 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:59 def on_class(class_node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:64 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:85 def autocorrect(corrector, class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:77 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:98 def autocorrect_def(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:83 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:104 def autocorrect_sclass(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:90 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:111 def class_convertible_to_module?(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:114 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:135 def class_elements(class_node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:102 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:123 def extend_call?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:106 + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:127 def sclass_convertible_to_module?(node); end + + # When `AllCops/UseProjectIndex` is enabled, a class with descendants + # anywhere in the project is not reported: converting it to a module + # would break its subclasses. + # + # pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:74 + def subclassed_in_project?(class_node); end end -# pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:51 +# pkg:gem/rubocop#lib/rubocop/cop/style/static_class.rb:57 RuboCop::Cop::Style::StaticClass::MSG = T.let(T.unsafe(nil), String) # Identifies places where `$stderr.puts` can be replaced by @@ -55885,36 +57367,36 @@ RuboCop::Cop::Style::TallyMethod::RESTRICT_ON_SEND = T.let(T.unsafe(nil), Array) # Corrector to correct conditional assignment in ternary conditions. # -# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:504 +# pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:526 class RuboCop::Cop::Style::TernaryCorrector extend ::RuboCop::Cop::Style::ConditionalAssignmentHelper extend ::RuboCop::Cop::Style::ConditionalCorrectorHelper class << self - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:509 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:531 def correct(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:513 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:535 def move_assignment_inside_condition(corrector, node); end private - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:527 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:549 def correction(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:540 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:562 def element_assignment?(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:544 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:566 def extract_branches(node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:557 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:579 def move_branch_inside_condition(corrector, branch, assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:552 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:574 def remove_parentheses(corrector, node); end - # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:531 + # pkg:gem/rubocop#lib/rubocop/cop/style/conditional_assignment.rb:553 def ternary(node); end end end @@ -57350,6 +58832,7 @@ RuboCop::Cop::Style::WhileUntilDo::MSG = T.let(T.unsafe(nil), String) class RuboCop::Cop::Style::WhileUntilModifier < ::RuboCop::Cop::Base include ::RuboCop::Cop::Alignment include ::RuboCop::Cop::LineLengthHelp + include ::RuboCop::Cop::AllowedPattern include ::RuboCop::Cop::StatementModifier extend ::RuboCop::Cop::AutoCorrector @@ -57931,142 +59414,162 @@ end # # pkg:gem/rubocop#lib/rubocop/cop/team.rb:13 class RuboCop::Cop::Team - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:74 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:89 def initialize(cops, config = T.unsafe(nil), options = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:102 def autocorrect?; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:69 def cops; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:89 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:106 def debug?; end # When set to true, the corrected source is not written back to the # inspected file; it is exposed through `#updated_source` instead. # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:74 def defer_corrections; end # When set to true, the corrected source is not written back to the # inspected file; it is exposed through `#updated_source` instead. # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:65 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:74 def defer_corrections=(_arg0); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:69 def errors; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:135 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:152 def external_dependency_checksum; end # @deprecated # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:127 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:144 def forces; end # @deprecated. Use investigate # @return Array # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:95 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:112 def inspect_file(processed_source); end # @return [Commissioner::InvestigationReport] # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:104 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:121 def investigate(processed_source, offset: T.unsafe(nil), original: T.unsafe(nil)); end # @return [Array] # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:111 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:128 def investigate_fragments(fragments, original:); end + # Registry used to mobilize cops that were not instantiated because they are disabled in + # the config, when a comment directive opts them back in for a file. + # + # @api private + # + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:85 + def standby_registry=(_arg0); end + # The corrected source of the last investigation, if corrections were # made with `#defer_corrections` enabled. # @api private # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:70 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:79 def updated_source; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:69 def updated_source_file; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:72 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:87 def updated_source_file?; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:60 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:69 def warnings; end private - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:157 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:174 def apply_correction(processed_source, new_source); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:146 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:163 def autocorrect(processed_source, corrector); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:168 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:185 def be_ready; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:270 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:315 def collate_corrections(report, offset:, original:); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:261 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:306 def collated_corrector(report, offset:, original:); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:290 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:335 def each_corrector(report); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:342 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:387 def handle_error(error, location, cop); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:334 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:379 def handle_warning(error, location); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:217 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:235 def investigate_fragment(fragment, original, data); end # @return [Commissioner::InvestigationReport] # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:182 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:200 def investigate_partial(cops, processed_source, offset:, original:); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:187 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:205 def investigate_with_corrector(processed_source, offset:, original:); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:280 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:325 def merge_corrector!(corrector, to_merge, offset:); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:317 + # Cops that were not mobilized because they are disabled in the config, + # but are opted back in for the given file by an `enable` comment directive. + # Their classes are loaded on demand. + # + # @return [Array] + # + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:269 + def opted_in_standby_cops(processed_source); end + + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:362 def process_errors(file, errors); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:176 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:194 def reset; end # @return [Array] # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:236 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:254 def roundup_relevant_cops(processed_source); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:252 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:283 + def standby_cop(cop_name); end + + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:297 def support_target_rails_version?(cop); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:246 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:291 def support_target_ruby_version?(cop); end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:305 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:350 def suppress_clobbering; end - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:311 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:356 def validate_config; end class << self # @return [Array] needed for the given cops # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:46 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:55 def forces_for(cops); end # @return [Team] with cops assembled from the given `cop_classes` @@ -58076,7 +59579,7 @@ class RuboCop::Cop::Team # @return [Array] # - # pkg:gem/rubocop#lib/rubocop/cop/team.rb:37 + # pkg:gem/rubocop#lib/rubocop/cop/team.rb:46 def mobilize_cops(cop_classes, config, options = T.unsafe(nil)); end # @return [Team] @@ -59452,7 +60955,7 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:15 def initialize(name, declaration_node, scope); end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:105 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:117 def argument?; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:31 @@ -59461,10 +60964,10 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 def assignments; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:113 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:125 def block_argument?; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:85 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:97 def capture_with_block!; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 @@ -59473,24 +60976,30 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:13 def captured_by_block?; end + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:93 + def covers?(container, node); end + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 def declaration_node; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:121 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:133 def explicit_block_local_variable?; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:77 - def in_modifier_conditional?(assignment); end + def in_modifier_conditional?(assignment, reference_node); end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:117 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:129 def keyword_argument?; end # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:39 def mark_last_as_reassigned!(assignment); end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:109 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:121 def method_argument?; end + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:87 + def modifier_conditional_of(node); end + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 def name; end @@ -59506,7 +61015,7 @@ class RuboCop::Cop::VariableForce::Variable # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:11 def scope; end - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:101 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:113 def should_be_unused?; end # This is a convenient way to check whether the variable is used @@ -59518,7 +61027,7 @@ class RuboCop::Cop::VariableForce::Variable # This means we cannot track the usage of the variable. # So we consider it's used to suppress false positive offenses. # - # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:97 + # pkg:gem/rubocop#lib/rubocop/cop/variable_force/variable.rb:109 def used?; end end @@ -59659,198 +61168,198 @@ RuboCop::Cop::VisibilityHelp::VISIBILITY_SCOPES = T.let(T.unsafe(nil), Set) # # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:7 class RuboCop::DirectiveComment - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:52 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:54 def initialize(comment, cop_registry = T.unsafe(nil)); end # Checks if all cops specified in this directive # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:146 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:148 def all_cops?; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:50 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:52 def comment; end # Returns array of specified in this directive cop names # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:151 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:153 def cop_names; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:50 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:52 def cop_registry; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:50 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:52 def cops; end # Returns array of specified in this directive department names # when all department disabled # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:162 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:164 def department_names; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:176 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:178 def directive_count; end # Checks if this directive disables cops # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:111 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:113 def disabled?; end # Checks if this directive disables all cops # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:141 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:143 def disabled_all?; end # Checks if this directive enables cops # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:116 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:118 def enabled?; end # Checks if this directive enables all cops # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:136 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:138 def enabled_all?; end # Checks if directive departments include cop # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:167 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:169 def in_directive_department?(cop); end # Returns line number for directive # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:181 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:183 def line_number; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:66 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:68 def malformed?; end # Checks if this directive contains all the given cop names # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:87 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:89 def match?(cop_names); end # Returns match captures to directive comment pattern # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:100 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:102 def match_captures; end # Checks if the directive comment is missing a cop name # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:75 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:77 def missing_cop_name?; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:50 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:52 def mode; end # Checks if cop department has already used in directive comment # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:172 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:174 def overridden_by_department?(cop); end # Checks if this directive is a pop # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:126 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:128 def pop?; end # Checks if this directive is a push # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:121 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:123 def push?; end # Returns the push arguments as a hash of cop names with their operations # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:131 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:133 def push_args; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:91 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:93 def range; end # Returns an array of cops for this directive comment, without resolving departments # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:156 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:158 def raw_cop_names; end # Checks if this directive relates to single line # - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:82 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:84 def single_line?; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:61 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:63 def start_with_marker?; end private - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:198 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:200 def all_cop_names; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:202 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:204 def cop_names_for_department(department); end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:194 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:196 def department?(name); end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:207 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:209 def exclude_lint_department_cops(cops); end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:211 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:213 def parse_push_args; end - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:187 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:189 def parsed_cop_names; end class << self - # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:46 + # pkg:gem/rubocop#lib/rubocop/directive_comment.rb:48 def before_comment(line); end end end # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:27 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:29 RuboCop::DirectiveComment::AVAILABLE_MODES = T.let(T.unsafe(nil), Array) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:23 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:25 RuboCop::DirectiveComment::COPS_PATTERN = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:21 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:23 RuboCop::DirectiveComment::COP_NAMES_PATTERN = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:19 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:21 RuboCop::DirectiveComment::COP_NAMES_PATTERN_NC = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:15 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:17 RuboCop::DirectiveComment::COP_NAME_PATTERN = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:17 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:19 RuboCop::DirectiveComment::COP_NAME_PATTERN_NC = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:35 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:37 RuboCop::DirectiveComment::DIRECTIVE_COMMENT_REGEXP = T.let(T.unsafe(nil), Regexp) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:33 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:35 RuboCop::DirectiveComment::DIRECTIVE_HEADER_PATTERN = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:29 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:31 RuboCop::DirectiveComment::DIRECTIVE_MARKER_PATTERN = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:31 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:33 RuboCop::DirectiveComment::DIRECTIVE_MARKER_REGEXP = T.let(T.unsafe(nil), Regexp) # @api private @@ -59870,17 +61379,22 @@ RuboCop::DirectiveComment::LINT_SYNTAX_COP = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:42 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:44 RuboCop::DirectiveComment::MALFORMED_DIRECTIVE_WITHOUT_COP_NAME_REGEXP = T.let(T.unsafe(nil), Regexp) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:25 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:27 RuboCop::DirectiveComment::PUSH_POP_ARGS_PATTERN = T.let(T.unsafe(nil), String) # @api private # -# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:40 +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:15 +RuboCop::DirectiveComment::STYLE_DISABLE_COPS_DIRECTIVE_COP = T.let(T.unsafe(nil), String) + +# @api private +# +# pkg:gem/rubocop#lib/rubocop/directive_comment.rb:42 RuboCop::DirectiveComment::TRAILING_COMMENT_MARKER = T.let(T.unsafe(nil), String) # An Error exception is different from an Offense with severity 'error' @@ -60149,15 +61663,9 @@ class RuboCop::FeatureLoader # pkg:gem/rubocop#lib/rubocop/feature_loader.rb:75 def relative?; end - # @param [LoadError] error - # @return [Boolean] - # - # pkg:gem/rubocop#lib/rubocop/feature_loader.rb:81 - def seems_cannot_load_such_file_error?(error); end - # @return [String] # - # pkg:gem/rubocop#lib/rubocop/feature_loader.rb:86 + # pkg:gem/rubocop#lib/rubocop/feature_loader.rb:80 def target; end class << self @@ -61157,10 +62665,10 @@ RuboCop::Formatter::PacmanFormatter::FALLBACK_TERMINAL_WIDTH = T.let(T.unsafe(ni RuboCop::Formatter::PacmanFormatter::GHOST = T.let(T.unsafe(nil), String) # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:18 -RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::Presenter) +RuboCop::Formatter::PacmanFormatter::PACDOT = T.let(T.unsafe(nil), Rainbow::NullPresenter) # pkg:gem/rubocop#lib/rubocop/formatter/pacman_formatter.rb:17 -RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::Presenter) +RuboCop::Formatter::PacmanFormatter::PACMAN = T.let(T.unsafe(nil), Rainbow::NullPresenter) # This formatter display dots for files with no offenses and # letters for files with problems in the them. In the end it @@ -62131,12 +63639,9 @@ class RuboCop::PendingCopsReporter def pending_cops_only_qualified(pending_cops); end # pkg:gem/rubocop#lib/rubocop/pending_cops_reporter.rb:35 - def possible_new_cops?(config); end - - # pkg:gem/rubocop#lib/rubocop/pending_cops_reporter.rb:40 def warn_on_pending_cops(pending_cops); end - # pkg:gem/rubocop#lib/rubocop/pending_cops_reporter.rb:48 + # pkg:gem/rubocop#lib/rubocop/pending_cops_reporter.rb:43 def warn_pending_cop(cop); end end end @@ -62310,6 +63815,14 @@ module RuboCop::ProjectIndexLoader # pkg:gem/rubocop#lib/rubocop/project_index_loader.rb:57 def build_index(paths); end + # The Ruby source files of every gem in the project's bundle, for + # `AllCops/ProjectIndexIncludesGems`. Returns an empty array when RuboCop + # does not run inside Bundler, so the option silently degrades to + # project-only indexing. + # + # pkg:gem/rubocop#lib/rubocop/project_index_loader.rb:70 + def bundled_gem_source_files; end + # pkg:gem/rubocop#lib/rubocop/project_index_loader.rb:24 def supported_ruby?; end @@ -62334,6 +63847,14 @@ module RuboCop::ProjectIndexLoader # pkg:gem/rubocop#lib/rubocop/project_index_loader.rb:57 def build_index(paths); end + # The Ruby source files of every gem in the project's bundle, for + # `AllCops/ProjectIndexIncludesGems`. Returns an empty array when RuboCop + # does not run inside Bundler, so the option silently degrades to + # project-only indexing. + # + # pkg:gem/rubocop#lib/rubocop/project_index_loader.rb:70 + def bundled_gem_source_files; end + # pkg:gem/rubocop#lib/rubocop/project_index_loader.rb:24 def supported_ruby?; end @@ -62507,7 +64028,7 @@ class RuboCop::ResultCache # This context is for anything that's not (1) the RuboCop executable # checksum or (2) the inspected file checksum. # - # pkg:gem/rubocop#lib/rubocop/result_cache.rb:254 + # pkg:gem/rubocop#lib/rubocop/result_cache.rb:256 def context_checksum(team, options); end # pkg:gem/rubocop#lib/rubocop/result_cache.rb:178 @@ -62614,31 +64135,37 @@ class RuboCop::Runner private - # pkg:gem/rubocop#lib/rubocop/runner.rb:269 + # pkg:gem/rubocop#lib/rubocop/runner.rb:297 def add_redundant_disables(file, offenses, source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:243 + # pkg:gem/rubocop#lib/rubocop/runner.rb:107 + def build_project_index(target_files); end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:129 + def bundled_gem_files; end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:271 def cached_result(file, team); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:324 + # pkg:gem/rubocop#lib/rubocop/runner.rb:352 def cached_run?; end # Check whether a run created source identical to a previous run, which # means that we definitely have an infinite loop. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:433 + # pkg:gem/rubocop#lib/rubocop/runner.rb:461 def check_for_infinite_loop(processed_source, offenses_by_iteration); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:295 + # pkg:gem/rubocop#lib/rubocop/runner.rb:323 def check_for_redundant_disables?(source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:536 + # pkg:gem/rubocop#lib/rubocop/runner.rb:561 def considered_failure?(offense); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:573 + # pkg:gem/rubocop#lib/rubocop/runner.rb:598 def default_config(cop_name); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:342 + # pkg:gem/rubocop#lib/rubocop/runner.rb:370 def do_inspection_loop(file); end # When corrections were written to disk and read back between iterations, @@ -62647,116 +64174,125 @@ class RuboCop::Runner # Apply the same conversion to the in-memory source. The final `File.write` # still performs it for the file itself. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:395 + # pkg:gem/rubocop#lib/rubocop/runner.rb:423 def emulate_write_read_cycle(source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:309 + # pkg:gem/rubocop#lib/rubocop/runner.rb:337 def except_redundant_cop_disable_directive?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:455 + # pkg:gem/rubocop#lib/rubocop/runner.rb:483 def extract_ruby_sources(processed_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:318 + # pkg:gem/rubocop#lib/rubocop/runner.rb:346 def file_finished(file, offenses); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:137 + # pkg:gem/rubocop#lib/rubocop/runner.rb:165 def file_iterator(files, &block); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:247 + # pkg:gem/rubocop#lib/rubocop/runner.rb:275 def file_offense_cache(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:235 + # pkg:gem/rubocop#lib/rubocop/runner.rb:263 def file_offenses(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:313 + # pkg:gem/rubocop#lib/rubocop/runner.rb:341 def file_started(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:516 - def filter_cop_classes(cop_classes, config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:96 def find_target_files(paths); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:157 + # pkg:gem/rubocop#lib/rubocop/runner.rb:185 def finished_report(file, index, offenses); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:527 + # pkg:gem/rubocop#lib/rubocop/runner.rb:552 def formatter_set; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:588 + # pkg:gem/rubocop#lib/rubocop/runner.rb:613 def get_processed_source(file, prism_result, source: T.unsafe(nil)); end # Custom ruby extractors may derive their fragments from the file on # disk rather than from the passed processed source, so corrections can # only be kept in memory when the default extractor is used. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:404 + # pkg:gem/rubocop#lib/rubocop/runner.rb:432 def in_memory_corrections_possible?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:447 + # pkg:gem/rubocop#lib/rubocop/runner.rb:475 def inspect_file(processed_source, team = T.unsafe(nil)); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:118 + # pkg:gem/rubocop#lib/rubocop/runner.rb:146 def inspect_files(files); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:383 + # pkg:gem/rubocop#lib/rubocop/runner.rb:411 def inspect_iteration(processed_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:408 + # pkg:gem/rubocop#lib/rubocop/runner.rb:436 def iterate_until_no_changes(source, offenses_by_iteration); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:221 + # pkg:gem/rubocop#lib/rubocop/runner.rb:249 def list_files(paths); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:569 + # pkg:gem/rubocop#lib/rubocop/runner.rb:594 def mark_as_safe_by_config?(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:577 + # pkg:gem/rubocop#lib/rubocop/runner.rb:602 def minimum_severity_to_fail; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:469 + # pkg:gem/rubocop#lib/rubocop/runner.rb:526 + def mobilize_cop_badge?(badge, config); end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:497 def mobilize_team(processed_source); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:482 + # pkg:gem/rubocop#lib/rubocop/runner.rb:510 def mobilized_cop_classes(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:545 + # pkg:gem/rubocop#lib/rubocop/runner.rb:570 def offense_displayed?(offense); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:557 + # pkg:gem/rubocop#lib/rubocop/runner.rb:582 def offenses_to_report(offenses); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:204 + # pkg:gem/rubocop#lib/rubocop/runner.rb:232 def parallel_file_iterator(files, on_start, on_finish, &block); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:225 + # pkg:gem/rubocop#lib/rubocop/runner.rb:253 def process_file(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:171 + # pkg:gem/rubocop#lib/rubocop/runner.rb:199 def process_remaining_report_queue; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:166 + # pkg:gem/rubocop#lib/rubocop/runner.rb:194 def process_report_queue_entry(index); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:193 + # pkg:gem/rubocop#lib/rubocop/runner.rb:221 def project_index_disables_parallel?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:107 + # pkg:gem/rubocop#lib/rubocop/runner.rb:135 def project_index_enabled?; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:506 + # The index always covers the whole project, not just the files being + # inspected: cross-file offenses must not depend on which files a + # particular run happens to include, or single-file runs (editors, CI + # sharding) would see different offenses than full runs. The project is + # rooted at the directory of the configuration that enabled the index. + # + # pkg:gem/rubocop#lib/rubocop/runner.rb:118 + def project_index_files(target_files); end + + # pkg:gem/rubocop#lib/rubocop/runner.rb:538 def qualify_option_cop_names; end - # pkg:gem/rubocop#lib/rubocop/runner.rb:301 + # pkg:gem/rubocop#lib/rubocop/runner.rb:329 def redundant_cop_disable_directive(file); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:177 + # pkg:gem/rubocop#lib/rubocop/runner.rb:205 def run_in_parallel?(files); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:332 + # pkg:gem/rubocop#lib/rubocop/runner.rb:360 def save_in_cache(cache, offenses); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:208 + # pkg:gem/rubocop#lib/rubocop/runner.rb:236 def serial_file_iterator(files, on_start, on_finish, &block); end # A Cop::Team instance is stateful and may change when inspecting. @@ -62764,16 +64300,16 @@ class RuboCop::Runner # otherwise dormant team that can be used for config- and option- # level caching in ResultCache. # - # pkg:gem/rubocop#lib/rubocop/runner.rb:627 + # pkg:gem/rubocop#lib/rubocop/runner.rb:652 def standby_team(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:523 + # pkg:gem/rubocop#lib/rubocop/runner.rb:548 def style_guide_cops_only?(config); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:561 + # pkg:gem/rubocop#lib/rubocop/runner.rb:586 def supports_safe_autocorrect?(offense); end - # pkg:gem/rubocop#lib/rubocop/runner.rb:284 + # pkg:gem/rubocop#lib/rubocop/runner.rb:312 def team_for_redundant_disables(file, offenses, source); end class << self diff --git a/sorbet/rbi/gems/sqlite3@2.9.0.rbi b/sorbet/rbi/gems/sqlite3@2.9.0.rbi index 2877b7f28..b36430e4a 100644 --- a/sorbet/rbi/gems/sqlite3@2.9.0.rbi +++ b/sorbet/rbi/gems/sqlite3@2.9.0.rbi @@ -7,7 +7,6 @@ module Process extend ::SQLite3::ForkSafety::CoreExt - extend ::Dalli::PIDCache::CoreExt extend ::ConnectionPool::ForkTracker extend ::RedisClient::PIDCache::CoreExt extend ::ActiveSupport::ForkTracker::CoreExt