rubocop-sorbet 0.9.0 → 0.10.1

data/dev.yml

@@ -7,5 +7,5 @@ up:
   - "bundler"
 
 commands:
-  test:   "bin/rspec"
+  test:   "bin/rake test"
   style:  "bin/rubocop"

data/lib/rubocop/cop/sorbet/block_method_definition.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallow defining methods in blocks, to prevent running into issues
+      # caused by https://github.com/sorbet/sorbet/issues/3609.
+      #
+      # As a workaround, use `define_method` instead.
+      #
+      # The one exception is for `Class.new` blocks, as long as the result is
+      # assigned to a constant (i.e. as long as it is not an anonymous class).
+
+      # @example
+      #   # bad
+      #   yielding_method do
+      #     def bad(args)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad
+      #   Class.new do
+      #     def bad(args)
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   yielding_method do
+      #     define_method(:good) do |args|
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   MyClass = Class.new do
+      #     def good(args)
+      #       # ...
+      #     end
+      #   end
+      #
+      class BlockMethodDefinition < Base
+        include RuboCop::Cop::Alignment
+        extend AutoCorrector
+
+        MSG = "Do not define methods in blocks (use `define_method` as a workaround)."
+
+        def on_block(node)
+          if (parent = node.parent)
+            return if parent.casgn_type?
+          end
+
+          node.each_descendant(:any_def) do |def_node|
+            add_offense(def_node) do |corrector|
+              autocorrect_method_in_block(corrector, def_node)
+            end
+          end
+        end
+        alias_method :on_numblock, :on_block
+
+        private
+
+        def autocorrect_method_in_block(corrector, node)
+          indent = offset(node)
+
+          method_name = node.method_name
+          args = node.arguments.map(&:source).join(", ")
+          body = node.body&.source&.prepend("\n#{indent}  ")
+
+          if node.def_type?
+            replacement = "define_method(:#{method_name}) do |#{args}|#{body}\n#{indent}end"
+          elsif node.defs_type?
+            receiver = node.receiver.source
+            replacement = "#{receiver}.define_singleton_method(:#{method_name}) do |#{args}|#{body}\n#{indent}end"
+          end
+
+          corrector.replace(node, replacement)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet/forbid_mixes_in_class_methods.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Check that code does not call `mixes_in_class_methods` from Sorbet `T::Helpers`.
+      #
+      # Good:
+      #
+      # ```
+      # module M
+      #   extend ActiveSupport::Concern
+      #
+      #   class_methods do
+      #     ...
+      #   end
+      # end
+      # ```
+      #
+      # Bad:
+      #
+      # ```
+      # module M
+      #   extend T::Helpers
+      #
+      #   module ClassMethods
+      #     ...
+      #   end
+      #
+      #   mixes_in_class_methods(ClassMethods)
+      # end
+      # ```
+      class ForbidMixesInClassMethods < ::RuboCop::Cop::Base
+        MSG = "Do not use `mixes_in_class_methods`, use `extend ActiveSupport::Concern` instead."
+        RESTRICT_ON_SEND = [:mixes_in_class_methods].freeze
+
+        # @!method mixes_in_class_methods?(node)
+        def_node_matcher(:mixes_in_class_methods?, <<~PATTERN)
+          (send {self | nil? | (const (const {cbase | nil?} :T) :Helpers)} :mixes_in_class_methods ...)
+        PATTERN
+
+        def on_send(node)
+          add_offense(node) if mixes_in_class_methods?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet/select_by_is_a.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Suggests using `grep` over `select` when using it only for type narrowing.
+      #
+      # @example
+      #
+      #   # bad
+      #   strings_or_integers.select { |e| e.is_a?(String) }
+      #   strings_or_integers.filter { |e| e.is_a?(String) }
+      #   strings_or_integers.select { |e| e.kind_of?(String) }
+      #
+      #   # good
+      #   strings_or_integers.grep(String)
+      class SelectByIsA < RuboCop::Cop::Base
+        extend AutoCorrector
+
+        MSG = "Use `grep` instead of `select` when using it only for type narrowing."
+        RESTRICT_ON_SEND = [:select, :filter].freeze
+
+        # @!method type_narrowing_select?(node)
+        def_node_matcher :type_narrowing_select?, <<~PATTERN
+          {
+            (block
+              (call _ {:select :filter})
+              (args (arg _))
+              (send (lvar _) { :is_a? :kind_of? } (const nil? _)))
+            (numblock
+              (call _ {:select :filter})
+              _
+              (send (lvar _) { :is_a? :kind_of? } (const nil? _)))
+            (itblock
+              (call _ {:select :filter})
+              _
+              (send (lvar _) { :is_a? :kind_of? } (const nil? _)))
+          }
+        PATTERN
+
+        def on_send(node)
+          block_node = node.block_node
+
+          return unless block_node
+          return unless type_narrowing_select?(block_node)
+
+          add_offense(block_node) do |corrector|
+            receiver = node.receiver
+            type_class = block_node.body.children[2]
+            navigation = node.csend_type? ? "&." : "."
+            replacement = "#{receiver.source}#{navigation}grep(#{type_class.source})"
+
+            corrector.replace(block_node, replacement)
+          end
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet/sigils/enforce_single_sigil.rb

@@ -54,7 +54,7 @@ module RuboCop
           # The first sigil encountered represents the "real" strictness so remove any below
           sigils[1..sigils.size].each do |token|
             corrector.remove(
-              source_range(processed_source.buffer, token.line, (0..token.pos.last_column)),
+              source_range(processed_source.buffer, token.line, 0..token.pos.last_column),
             )
           end
         end

data/lib/rubocop/cop/sorbet/sigils/valid_sigil.rb

@@ -28,6 +28,8 @@ module RuboCop
           return unless check_sigil_present(sigil)
 
           strictness = extract_strictness(sigil)
+          check_double_commented_sigil(sigil, strictness)
+
           return unless check_strictness_not_empty(sigil, strictness)
           return unless check_strictness_valid(sigil, strictness)
 
@@ -37,7 +39,8 @@ module RuboCop
         protected
 
         STRICTNESS_LEVELS = ["ignore", "false", "true", "strict", "strong"]
-        SIGIL_REGEX = /^[[:blank:]]*#[[:blank:]]+typed:(?:[[:blank:]]+([\S]+))?/
+        SIGIL_REGEX = /^[[:blank:]]*(?:#[[:blank:]]*)?#[[:blank:]]+typed:(?:[[:blank:]]+([\S]+))?/
+        INVALID_SIGIL_MSG = "Invalid Sorbet sigil `%<sigil>s`."
 
         # extraction
 
@@ -104,12 +107,27 @@ module RuboCop
           false
         end
 
+        def check_double_commented_sigil(sigil, strictness)
+          return unless sigil.text.start_with?(/[[:blank:]]*#[[:blank:]]*#/)
+
+          add_offense(
+            sigil.pos,
+            message: format(INVALID_SIGIL_MSG, sigil: sigil.text),
+          ) do |corrector|
+            # Remove the extra comment and normalize spaces
+            corrector.replace(
+              sigil.pos,
+              "# typed: #{strictness}",
+            )
+          end
+        end
+
         def check_strictness_valid(sigil, strictness)
           return true if STRICTNESS_LEVELS.include?(strictness)
 
           add_offense(
             sigil.pos,
-            message: "Invalid Sorbet sigil `#{strictness}`.",
+            message: format(INVALID_SIGIL_MSG, sigil: strictness),
           ) do |corrector|
             autocorrect(corrector)
           end

data/lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb

@@ -24,9 +24,8 @@ module RuboCop
         # @!method sig_or_signable_method_definition?(node)
         def_node_matcher :sig_or_signable_method_definition?, <<~PATTERN
           ${
-            def
-            defs
-            (send nil? {:attr_reader :attr_writer :attr_accessor} ...)
+            any_def
+            (send nil? {:attr :attr_reader :attr_writer :attr_accessor} ...)
             #signature?
           }
         PATTERN
@@ -34,16 +33,22 @@ module RuboCop
         def on_signature(sig)
           sig_or_signable_method_definition?(next_sibling(sig)) do |definition|
             range = lines_between(sig, definition)
-            next if range.empty? || range.single_line?
+            next if range.empty? || range.single_line? || contains_only_rubocop_directives?(range)
 
             add_offense(range) do |corrector|
-              corrector.insert_before(
-                range_by_whole_lines(sig.source_range),
-                range.source
-                  .sub(/\A\n+/, "") # remove initial newline(s)
-                  .gsub(/\n{2,}/, "\n"), # remove empty line(s)
-              )
-              corrector.remove(range)
+              lines = range.source.lines
+              rubocop_lines, other_lines = lines.partition { |line| line.strip.start_with?("# rubocop:") }
+
+              unless other_lines.empty?
+                corrector.insert_before(
+                  range_by_whole_lines(sig.source_range),
+                  other_lines.join
+                    .sub(/\A\n+/, "") # remove initial newline(s)
+                    .gsub(/\n{2,}/, "\n"), # remove empty line(s)
+                )
+              end
+
+              corrector.replace(range, rubocop_lines.empty? ? "" : rubocop_lines.join)
             end
           end
         end
@@ -54,6 +59,10 @@ module RuboCop
           node.parent&.children&.at(node.sibling_index + 1)
         end
 
+        def contains_only_rubocop_directives?(range)
+          range.source.lines.all? { |line| line.strip.start_with?("# rubocop:") }
+        end
+
         def lines_between(node1, node2, buffer: processed_source.buffer)
           end_of_node1_pos   = node1.source_range.end_pos
           start_of_node2_pos = node2.source_range.begin_pos

data/lib/rubocop/cop/sorbet_cops.rb

@@ -5,9 +5,11 @@ require_relative "sorbet/mixin/t_enum"
 require_relative "sorbet/mixin/signature_help"
 
 require_relative "sorbet/binding_constant_without_type_alias"
+require_relative "sorbet/block_method_definition"
 require_relative "sorbet/constants_from_strings"
 require_relative "sorbet/forbid_superclass_const_literal"
 require_relative "sorbet/forbid_include_const_literal"
+require_relative "sorbet/forbid_mixes_in_class_methods"
 require_relative "sorbet/forbid_type_aliased_shapes"
 require_relative "sorbet/forbid_untyped_struct_props"
 require_relative "sorbet/implicit_conversion_method"
@@ -18,6 +20,7 @@ require_relative "sorbet/forbid_t_unsafe"
 require_relative "sorbet/forbid_t_untyped"
 require_relative "sorbet/redundant_extend_t_sig"
 require_relative "sorbet/refinement"
+require_relative "sorbet/select_by_is_a"
 require_relative "sorbet/type_alias_name"
 require_relative "sorbet/obsolete_strict_memoization"
 require_relative "sorbet/buggy_obsolete_strict_memoization"

data/lib/rubocop/sorbet/plugin.rb

@@ -1,5 +1,10 @@
 # frozen_string_literal: true
 
+rubocop_min_version = Gem::Version.create("1.72.1")
+rubocop_version = Gem::Version.create(RuboCop::Version.version)
+
+return if rubocop_version < rubocop_min_version
+
 require "rubocop"
 require "lint_roller"
 require "pathname"
@@ -8,9 +13,6 @@ module RuboCop
   module Sorbet
     # A plugin that integrates RuboCop Sorbet with RuboCop's plugin system.
     class Plugin < LintRoller::Plugin
-      RUBOCOP_MIN_VERSION = "1.72.1"
-      SUPPORTED = Gem::Version.create(RuboCop::Version.version) < RUBOCOP_MIN_VERSION
-
       def about
         LintRoller::About.new(
           name: "rubocop-sorbet",

data/lib/rubocop/sorbet/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sorbet
-    VERSION = "0.9.0"
+    VERSION = "0.10.1"
   end
 end

data/lib/rubocop/sorbet.rb

@@ -10,7 +10,7 @@ module RuboCop
   module Sorbet
     class Error < StandardError; end
 
-    unless Plugin::SUPPORTED
+    unless defined?(::RuboCop::Sorbet::Plugin)
       PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
       CONFIG_DEFAULT = PROJECT_ROOT.join("config", "default.yml").freeze
       CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze

data/lib/rubocop-sorbet.rb

@@ -6,7 +6,7 @@ require_relative "rubocop/sorbet"
 require_relative "rubocop/sorbet/version"
 require_relative "rubocop/sorbet/plugin"
 
-unless RuboCop::Sorbet::Plugin::SUPPORTED
+unless defined?(RuboCop::Sorbet::Plugin)
   require_relative "rubocop/sorbet/inject"
   RuboCop::Sorbet::Inject.defaults!
 end

data/manual/cops.md

@@ -7,6 +7,7 @@ In the following section you find all available cops:
 
 * [Sorbet/AllowIncompatibleOverride](cops_sorbet.md#sorbetallowincompatibleoverride)
 * [Sorbet/BindingConstantWithoutTypeAlias](cops_sorbet.md#sorbetbindingconstantwithouttypealias)
+* [Sorbet/BlockMethodDefinition](cops_sorbet.md#sorbetblockmethoddefinition)
 * [Sorbet/BuggyObsoleteStrictMemoization](cops_sorbet.md#sorbetbuggyobsoletestrictmemoization)
 * [Sorbet/CallbackConditionalsBinding](cops_sorbet.md#sorbetcallbackconditionalsbinding)
 * [Sorbet/CheckedTrueInSignature](cops_sorbet.md#sorbetcheckedtrueinsignature)
@@ -19,6 +20,7 @@ In the following section you find all available cops:
 * [Sorbet/ForbidComparableTEnum](cops_sorbet.md#sorbetforbidcomparabletenum)
 * [Sorbet/ForbidExtendTSigHelpersInShims](cops_sorbet.md#sorbetforbidextendtsighelpersinshims)
 * [Sorbet/ForbidIncludeConstLiteral](cops_sorbet.md#sorbetforbidincludeconstliteral)
+* [Sorbet/ForbidMixesInClassMethods](cops_sorbet.md#sorbetforbidmixesinclassmethods)
 * [Sorbet/ForbidRBIOutsideOfAllowedPaths](cops_sorbet.md#sorbetforbidrbioutsideofallowedpaths)
 * [Sorbet/ForbidSig](cops_sorbet.md#sorbetforbidsig)
 * [Sorbet/ForbidSigWithRuntime](cops_sorbet.md#sorbetforbidsigwithruntime)
@@ -38,6 +40,7 @@ In the following section you find all available cops:
 * [Sorbet/ObsoleteStrictMemoization](cops_sorbet.md#sorbetobsoletestrictmemoization)
 * [Sorbet/RedundantExtendTSig](cops_sorbet.md#sorbetredundantextendtsig)
 * [Sorbet/Refinement](cops_sorbet.md#sorbetrefinement)
+* [Sorbet/SelectByIsA](cops_sorbet.md#sorbetselectbyisa)
 * [Sorbet/SignatureBuildOrder](cops_sorbet.md#sorbetsignaturebuildorder)
 * [Sorbet/SingleLineRbiClassModuleDefinitions](cops_sorbet.md#sorbetsinglelinerbiclassmoduledefinitions)
 * [Sorbet/StrictSigil](cops_sorbet.md#sorbetstrictsigil)

data/manual/cops_sorbet.md

@@ -41,6 +41,46 @@ FooOrBar = T.any(Foo, Bar)
 FooOrBar = T.type_alias { T.any(Foo, Bar) }
 ```
 
+## Sorbet/BlockMethodDefinition
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes (Unsafe) | 0.10.1 | -
+
+
+
+### Examples
+
+```ruby
+# bad
+yielding_method do
+  def bad(args)
+    # ...
+  end
+end
+
+# bad
+Class.new do
+  def bad(args)
+    # ...
+  end
+end
+
+# good
+yielding_method do
+  define_method(:good) do |args|
+    # ...
+  end
+end
+
+# good
+MyClass = Class.new do
+  def good(args)
+    # ...
+  end
+end
+```
+
 ## Sorbet/BuggyObsoleteStrictMemoization
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -180,7 +220,7 @@ end
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Enabled | Yes | Yes  | 0.7.0 | -
+Enabled | Yes | Yes  | 0.7.0 | 0.10.1
 
 Checks for blank lines after signatures.
 
@@ -254,6 +294,12 @@ You can configure the placeholders used by changing the following options:
 * `ParameterTypePlaceholder`: placeholders used for parameter types (default: 'T.untyped')
 * `ReturnTypePlaceholder`: placeholders used for return types (default: 'T.untyped')
 
+### Configurable attributes
+
+Name | Default value | Configurable values
+--- | --- | ---
+AllowRBS | `false` | Boolean
+
 ## Sorbet/EnforceSingleSigil
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -385,6 +431,40 @@ or
 include Polaris::Engine.helpers
 ```
 
+## Sorbet/ForbidMixesInClassMethods
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | 0.10.1 | -
+
+Check that code does not call `mixes_in_class_methods` from Sorbet `T::Helpers`.
+
+Good:
+
+```
+module M
+  extend ActiveSupport::Concern
+
+  class_methods do
+    ...
+  end
+end
+```
+
+Bad:
+
+```
+module M
+  extend T::Helpers
+
+  module ClassMethods
+    ...
+  end
+
+  mixes_in_class_methods(ClassMethods)
+end
+```
+
 ## Sorbet/ForbidRBIOutsideOfAllowedPaths
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -421,7 +501,7 @@ Include | `**/*.rbi` | Array
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Disabled | Yes | No | <<next>> | -
+Disabled | Yes | No | 0.9.0 | -
 
 Check that definitions do not use a `sig` block.
 
@@ -443,7 +523,7 @@ def foo; end
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Disabled | Yes | No | <<next>> | -
+Disabled | Yes | No | 0.9.0 | -
 
 Check that definitions do not use a `sig` block.
 
@@ -465,7 +545,7 @@ def foo; end
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Disabled | Yes | Yes  | <<next>> | -
+Disabled | Yes | Yes  | 0.9.0 | -
 
 Check that `sig` is used instead of `T::Sig::WithoutRuntime.sig`.
 
@@ -518,7 +598,7 @@ Exclude | `db/migrate/*.rb` | Array
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Disabled | No | No | <<next>> | <<next>>
+Disabled | No | No | 0.8.9 | -
 
 Disallow using `T::Enum`.
 
@@ -545,7 +625,7 @@ end
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Disabled | No | Yes  | <<next>> | <<next>>
+Disabled | No | Yes  | 0.7.4 | -
 
 Disallow using `T::Struct` and `T::Props`.
 
@@ -714,7 +794,7 @@ Exclude | `bin/**/*`, `db/**/*.rb`, `script/**/*` | Array
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Disabled | Yes | No | <<next>> | -
+Disabled | Yes | No | 0.7.1 | -
 
 Disallows declaring implicit conversion methods.
 Since Sorbet is a nominal (not structural) type system,
@@ -857,7 +937,7 @@ end
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Enabled | Yes | No | <<next>> | -
+Enabled | Yes | No | 0.8.6 | -
 
 Checks for the use of Ruby Refinements library. Refinements add
 complexity and incur a performance penalty that can be significant
@@ -890,6 +970,26 @@ module Foo
 end
 ```
 
+## Sorbet/SelectByIsA
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.10.1 | -
+
+Suggests using `grep` over `select` when using it only for type narrowing.
+
+### Examples
+
+```ruby
+# bad
+strings_or_integers.select { |e| e.is_a?(String) }
+strings_or_integers.filter { |e| e.is_a?(String) }
+strings_or_integers.select { |e| e.kind_of?(String) }
+
+# good
+strings_or_integers.grep(String)
+```
+
 ## Sorbet/SignatureBuildOrder
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged

data/rubocop-sorbet.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/shopify/rubocop-sorbet"
   spec.license       = "MIT"
 
-  spec.required_ruby_version = ">= 3.0"
+  spec.required_ruby_version = ">= 3.1"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
   spec.metadata["homepage_uri"] = spec.homepage
@@ -28,6 +28,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_runtime_dependency("lint_roller", "~> 1.1")
+  spec.add_runtime_dependency("lint_roller")
   spec.add_runtime_dependency("rubocop", ">= 1")
 end