rubocop-sorbet 0.7.3 → 0.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a0c73cc4c4d3b4982d210699da94d0dca321a93bf95e98579dc32521714e2921
-  data.tar.gz: b9aa475dea9aa87511868680e92fb1ad5dff83a5b8186439179c17371eaf35f5
+  metadata.gz: 9b2451806224baad5c72fb848ae38e6510037b2e26415afc236c3639f8504655
+  data.tar.gz: e55c4a39d87a4fe345a6257e14483de155738ea5d39c25ef1e7822a2174321cb
 SHA512:
-  metadata.gz: 03a722e469cf1796ba965b044475dabbbe2d99a6b0b79efc083d605bd8dd0973ed1d320dbe511241dd6bfad3c9df7acb6354217ded268db5939ad7f8bf7684aa
-  data.tar.gz: 9fd995f27b0881e5ec939da2b0b1a87372bc910faa4f27cbaf0de43c367d877e1c5b077397f80130ec58f1caa7b6047a7c51ea1eb0872f194f118ce27dbfa10d
+  metadata.gz: d05d0627ce52223c931f3461e221f6cb105838c21eeae6d68a7270934e6e292fcd2a7390453583c95d721bc1544125cb74f2d65ef6161c4d8fe823c3ee8217e6
+  data.tar.gz: adf840bad5a49581286937604e83b3ee864f45031efb115db9faed9032da04d4178d7022b3d2040e08e8b10dc5f7a95bc8bf8a0ee1ac06ba74780b135d947b26

data/.github/workflows/ci.yml

@@ -6,12 +6,12 @@ env:
   SRB_SKIP_GEM_RBIS: true
 
 jobs:
-  build:
+  test:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '2.7', '3.0', '3.1', '3.2' ]
+        ruby: ["2.7", "3.0", "3.1", "3.2"]
     name: Test Ruby ${{ matrix.ruby }}
     steps:
       - uses: actions/checkout@v2
@@ -20,9 +20,22 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
+      - name: Run tests
+        run: bin/rspec
+
+  lint-and-docs:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+    name: Lint & Docs
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 3.2
+          bundler-cache: true
       - name: Lint Ruby files
         run: bin/rubocop
       - name: Verify documentation is up to date
         run: bundle exec rake generate_cops_documentation
-      - name: Run tests
-        run: bin/rspec

data/.rubocop.yml

@@ -22,3 +22,6 @@ Naming/FileName:
 
 Layout/LineLength:
   IgnoreCopDirectives: true
+
+InternalAffairs/UndefinedConfig:
+  Enabled: false # Bug in implementation fails to find our configs

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorbet (0.7.3)
+    rubocop-sorbet (0.7.5)
       rubocop (>= 0.90.0)
 
 GEM

data/config/default.yml

@@ -97,6 +97,13 @@ Sorbet/ForbidSuperclassConstLiteral:
   Exclude:
   - db/migrate/*.rb
 
+Sorbet/ForbidTStruct:
+  Description: 'Forbid usage of T::Struct.'
+  Enabled: false
+  VersionAdded: <<next>>
+  VersionChanged: <<next>>
+  Safe: false
+
 Sorbet/ForbidTUnsafe:
   Description: 'Forbid usage of T.unsafe.'
   Enabled: false
@@ -171,6 +178,23 @@ Sorbet/ObsoleteStrictMemoization:
   Safe: true
   SafeAutoCorrect: true
 
+Sorbet/BuggyObsoleteStrictMemoization:
+  Description: >-
+    Checks for the a mistaken variant of the "obsolete memoization pattern" that used to be required
+    for older Sorbet versions in `#typed: strict` files. The mistaken variant would overwrite the ivar with `nil`
+    on every call, causing the memoized value to be discarded and recomputed on every call.
+    
+    This cop will correct it to read from the ivar instead of `nil`, which will memoize it correctly.
+    
+    The result of this correction will be the "obsolete memoization pattern", which can further be corrected by
+    the `Sorbet/ObsoleteStrictMemoization` cop.
+    
+    See `Sorbet/ObsoleteStrictMemoization` for more details.
+  Enabled: true
+  VersionAdded: '0.7.3'
+  Safe: true
+  SafeAutoCorrect: false
+
 Sorbet/OneAncestorPerLine:
   Description: 'Enforces one ancestor per call to requires_ancestor'
   Enabled: false

data/config/rbi.yml

@@ -242,6 +242,9 @@ Style/ClassAndModuleChildren:
 Style/DefWithParentheses:
   Enabled: true
 
+Sorbet/EmptyLineAfterSig:
+  Enabled: true
+
 Style/EmptyMethod:
   Enabled: true
   EnforcedStyle: compact

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Checks for the a mistaken variant of the "obsolete memoization pattern" that used to be required
+      # for older Sorbet versions in `#typed: strict` files. The mistaken variant would overwrite the ivar with `nil`
+      # on every call, causing the memoized value to be discarded and recomputed on every call.
+      #
+      # This cop will correct it to read from the ivar instead of `nil`, which will memoize it correctly.
+      #
+      # The result of this correction will be the "obsolete memoization pattern", which can further be corrected by
+      # the `Sorbet/ObsoleteStrictMemoization` cop.
+      #
+      # See `Sorbet/ObsoleteStrictMemoization` for more details.
+      #
+      # @safety
+      #   If the computation being memoized had side effects, calling it only once (instead of once on every call
+      #   to the affected method) can be observed, and might be a breaking change.
+      #
+      # @example
+      #   # bad
+      #   sig { returns(Foo) }
+      #   def foo
+      #     # This `nil` is likely a mistake, causing the memoized value to be discarded and recomputed on every call.
+      #     @foo = T.let(nil, T.nilable(Foo))
+      #     @foo ||= some_computation
+      #   end
+      #
+      #   # good
+      #   sig { returns(Foo) }
+      #   def foo
+      #     # This will now memoize the value as was likely intended, so `some_computation` is only ever called once.
+      #     # ⚠️If `some_computation` has side effects, this might be a breaking change!
+      #     @foo = T.let(@foo, T.nilable(Foo))
+      #     @foo ||= some_computation
+      #   end
+      #
+      # @see Sorbet/ObsoleteStrictMemoization
+      class BuggyObsoleteStrictMemoization < RuboCop::Cop::Base
+        include RuboCop::Cop::MatchRange
+        include RuboCop::Cop::Alignment
+        include RuboCop::Cop::LineLengthHelp
+        include RuboCop::Cop::RangeHelp
+        extend AutoCorrector
+
+        include TargetSorbetVersion
+
+        MSG = "This might be a mistaken variant of the two-stage workaround that used to be needed for memoization in "\
+          "`#typed: strict` files. See https://sorbet.org/docs/type-assertions#put-type-assertions-behind-memoization."
+
+        # @!method buggy_legacy_memoization_pattern?(node)
+        def_node_matcher :buggy_legacy_memoization_pattern?, <<~PATTERN
+          (begin
+            ...                                                       # Ignore any other lines that come first.
+            (ivasgn $_ivar                                           # First line: @_ivar = ...
+              (send                                                   # T.let(_ivar, T.nilable(_ivar_type))
+                (const {nil? cbase} :T) :let
+                $nil
+                (send (const {nil? cbase} :T) :nilable _ivar_type))) # T.nilable(_ivar_type)
+            (or-asgn (ivasgn _ivar) _initialization_expr))          # Second line: @_ivar ||= _initialization_expr
+        PATTERN
+
+        def on_begin(node)
+          buggy_legacy_memoization_pattern?(node) do |ivar, nil_node|
+            add_offense(nil_node) do |corrector|
+              corrector.replace(
+                range_between(nil_node.source_range.begin_pos, nil_node.source_range.end_pos),
+                ivar,
+              )
+            end
+          end
+        end
+
+        def relevant_file?(file)
+          super && sorbet_enabled?
+        end
+      end
+    end
+  end
+end

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

@@ -26,44 +26,38 @@ module RuboCop
       # ```ruby
       # include Polaris::Engine.helpers
       # ```
-      class ForbidIncludeConstLiteral < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
-        MSG = "Includes must only contain constant literals"
+      class ForbidIncludeConstLiteral < RuboCop::Cop::Base
+        extend AutoCorrector
 
-        attr_accessor :used_names
+        MSG = "`%<inclusion_method>s` must only be used with constant literals as arguments"
+        RESTRICT_ON_SEND = [:include, :extend, :prepend].freeze
 
-        # @!method not_lit_const_include?(node)
-        def_node_matcher :not_lit_const_include?, <<-PATTERN
-          (send nil? {:include :extend :prepend}
-            $_
-          )
+        # @!method dynamic_inclusion?(node)
+        def_node_matcher :dynamic_inclusion?, <<~PATTERN
+          (send nil? ${:include :extend :prepend} $#neither_const_nor_self?)
         PATTERN
 
-        def initialize(*)
-          super
-          self.used_names = Set.new
-        end
-
         def on_send(node)
-          return unless not_lit_const_include?(node) do |send_argument|
-            ![:const, :self].include?(send_argument.type)
-          end
+          dynamic_inclusion?(node) do |inclusion_method, included|
+            return unless within_onymous_module?(node)
 
-          parent = node.parent
-          return unless parent
+            add_offense(node, message: format(MSG, inclusion_method: inclusion_method)) do |corrector|
+              corrector.replace(node, "T.unsafe(self).#{inclusion_method} #{included.source}")
+            end
+          end
+        end
 
-          parent = parent.parent if [:begin, :block].include?(parent.type)
-          return unless [:module, :class, :sclass].include?(parent.type)
+        private
 
-          add_offense(node)
+        def neither_const_nor_self?(node)
+          !node.const_type? && !node.self_type?
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(
-              node,
-              "T.unsafe(self).#{node.source}",
-            )
-          end
+        # Returns true if the node is within a module declaration that is not anonymous.
+        def within_onymous_module?(node)
+          parent = node.parent
+          parent = parent.parent while parent&.begin_type? || parent&.block_type?
+          parent && (parent.module_type? || parent.class_type? || parent.sclass_type?)
         end
       end
     end

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

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallow using `T::Struct` and `T::Props`.
+      #
+      # @example
+      #
+      #   # bad
+      #   class MyStruct < T::Struct
+      #     const :foo, String
+      #     prop :bar, Integer, default: 0
+      #
+      #     def some_method; end
+      #   end
+      #
+      #   # good
+      #   class MyStruct
+      #     extend T::Sig
+      #
+      #     sig { returns(String) }
+      #     attr_reader :foo
+      #
+      #     sig { returns(Integer) }
+      #     attr_accessor :bar
+      #
+      #     sig { params(foo: String, bar: Integer) }
+      #     def initialize(foo:, bar: 0)
+      #       @foo = foo
+      #       @bar = bar
+      #     end
+      #
+      #     def some_method; end
+      #   end
+      class ForbidTStruct < RuboCop::Cop::Base
+        include Alignment
+        include RangeHelp
+        include CommentsHelp
+        extend AutoCorrector
+
+        RESTRICT_ON_SEND = [:include, :prepend, :extend].freeze
+
+        MSG_STRUCT = "Using `T::Struct` or its variants is deprecated."
+        MSG_PROPS = "Using `T::Props` or its variants is deprecated."
+
+        # This class walks down the class body of a T::Struct and collects all the properties that will need to be
+        # translated into `attr_reader` and `attr_accessor` methods.
+        class TStructWalker
+          include AST::Traversal
+          extend AST::NodePattern::Macros
+
+          attr_reader :props, :has_extend_t_sig
+
+          def initialize
+            @props = []
+            @has_extend_t_sig = false
+          end
+
+          # @!method extend_t_sig?(node)
+          def_node_matcher :extend_t_sig?, <<~PATTERN
+            (send _ :extend (const (const {nil? | cbase} :T) :Sig))
+          PATTERN
+
+          # @!method t_struct_prop?(node)
+          def_node_matcher(:t_struct_prop?, <<~PATTERN)
+            (send nil? {:const :prop} ...)
+          PATTERN
+
+          def on_send(node)
+            if extend_t_sig?(node)
+              # So we know we won't need to generate again a `extend T::Sig` line in the new class body
+              @has_extend_t_sig = true
+              return
+            end
+
+            return unless t_struct_prop?(node)
+
+            kind = node.method?(:const) ? :attr_reader : :attr_accessor
+            name = node.arguments[0].source.delete_prefix(":")
+            type = node.arguments[1].source
+            default = nil
+            factory = nil
+
+            node.arguments[2..-1].each do |arg|
+              next unless arg.hash_type?
+
+              arg.each_pair do |key, value|
+                case key.source
+                when "default"
+                  default = value.source
+                when "factory"
+                  factory = value.source
+                end
+              end
+            end
+
+            @props << Property.new(node, kind, name, type, default: default, factory: factory)
+          end
+        end
+
+        class Property
+          attr_reader :node, :kind, :name, :type, :default, :factory
+
+          def initialize(node, kind, name, type, default:, factory:)
+            @node = node
+            @kind = kind
+            @name = name
+            @type = type
+            @default = default
+            @factory = factory
+
+            # A T::Struct should have both a default and a factory, if we find one let's raise an error
+            raise if @default && @factory
+          end
+
+          def attr_sig
+            "sig { returns(#{type}) }"
+          end
+
+          def attr_accessor
+            "#{kind} :#{name}"
+          end
+
+          def initialize_sig_param
+            "#{name}: #{type}"
+          end
+
+          def initialize_param
+            rb = String.new
+            rb << "#{name}:"
+            if default
+              rb << " #{default}"
+            elsif factory
+              rb << " #{factory}"
+            elsif nilable?
+              rb << " nil"
+            end
+            rb
+          end
+
+          def initialize_assign
+            rb = String.new
+            rb << "@#{name} = #{name}"
+            rb << ".call" if factory
+            rb
+          end
+
+          def nilable?
+            type.start_with?("T.nilable(")
+          end
+        end
+
+        # @!method t_struct?(node)
+        def_node_matcher(:t_struct?, <<~PATTERN)
+          (const (const {nil? cbase} :T) {:Struct :ImmutableStruct :InexactStruct})
+        PATTERN
+
+        # @!method t_props?(node)
+        def_node_matcher(:t_props?, "(send nil? {:include :prepend :extend} `(const (const {nil? cbase} :T) :Props))")
+
+        def on_class(node)
+          return unless t_struct?(node.parent_class)
+
+          add_offense(node, message: MSG_STRUCT) do |corrector|
+            walker = TStructWalker.new
+            walker.walk(node.body)
+
+            range = range_between(node.identifier.source_range.end_pos, node.parent_class.source_range.end_pos)
+            corrector.remove(range)
+            next if node.single_line?
+
+            unless walker.has_extend_t_sig
+              indent = offset(node)
+              corrector.insert_after(node.identifier, "\n#{indent}  extend T::Sig\n")
+            end
+
+            first_prop = walker.props.first
+            walker.props.each do |prop|
+              node = prop.node
+              indent = offset(node)
+              line_range = range_by_whole_lines(prop.node.source_range)
+              new_line = prop != first_prop && !previous_line_blank?(node)
+              trailing_comments = processed_source.each_comment_in_lines(line_range.line..line_range.line)
+
+              corrector.replace(
+                line_range,
+                "#{new_line ? "\n" : ""}" \
+                  "#{trailing_comments.map { |comment| "#{indent}#{comment.text}\n" }.join}" \
+                  "#{indent}#{prop.attr_sig}\n#{indent}#{prop.attr_accessor}",
+              )
+            end
+
+            last_prop = walker.props.last
+            if last_prop
+              indent = offset(last_prop.node)
+              line_range = range_by_whole_lines(last_prop.node.source_range, include_final_newline: true)
+              corrector.insert_after(line_range, initialize_method(indent, walker.props))
+            end
+          end
+        end
+
+        def on_send(node)
+          return unless t_props?(node)
+
+          add_offense(node, message: MSG_PROPS)
+        end
+
+        private
+
+        def initialize_method(indent, props)
+          # We sort optional keyword arguments after required ones
+          sorted_props = props.sort_by { |prop| prop.default || prop.factory || prop.nilable? ? 1 : 0 }
+
+          string = +"\n"
+          string << "#{indent}sig { params(#{sorted_props.map(&:initialize_sig_param).join(", ")}).void }\n"
+          string << "#{indent}def initialize(#{sorted_props.map(&:initialize_param).join(", ")})\n"
+          props.each do |prop|
+            string << "#{indent}  #{prop.initialize_assign}\n"
+          end
+          string << "#{indent}end\n"
+        end
+
+        def previous_line_blank?(node)
+          processed_source.buffer.source_line(node.source_range.line - 1).blank?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet/{signatures/signature_cop.rb → mixin/signature_help.rb}

@@ -1,15 +1,11 @@
 # frozen_string_literal: true
 
-require "rubocop"
-
 module RuboCop
   module Cop
     module Sorbet
-      # Abstract cop specific to Sorbet signatures
-      #
-      # You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
-      class SignatureCop < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
-        @registry = Cop.registry # So we can properly subclass this cop
+      # Mixin for writing cops for signatures, providing a `signature?` node matcher and an `on_signature` trigger.
+      module SignatureHelp
+        extend RuboCop::NodePattern::Macros
 
         # @!method signature?(node)
         def_node_matcher(:signature?, <<~PATTERN)
@@ -22,12 +18,12 @@ module RuboCop
 
         # @!method with_runtime?(node)
         def_node_matcher(:with_runtime?, <<~PATTERN)
-          (const (const nil? :T) :Sig)
+          (const (const {nil? cbase} :T) :Sig)
         PATTERN
 
         # @!method without_runtime?(node)
         def_node_matcher(:without_runtime?, <<~PATTERN)
-          (const (const (const nil? :T) :Sig) :WithoutRuntime)
+          (const (const (const {nil? cbase} :T) :Sig) :WithoutRuntime)
         PATTERN
 
         def on_block(node)
@@ -36,8 +32,8 @@ module RuboCop
 
         alias_method :on_numblock, :on_block
 
-        def on_signature(_)
-          # To be defined in subclasses
+        def on_signature(_node)
+          # To be defined by cop class as needed
         end
       end
     end

data/lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb

@@ -11,21 +11,25 @@ module RuboCop
         end
 
         module ClassMethods
-          # The version of the Sorbet static type checker required by this cop
+          # Sets the version of the Sorbet static type checker required by this cop
           def minimum_target_sorbet_static_version(version)
             @minimum_target_sorbet_static_version = Gem::Version.new(version)
           end
 
-          def support_target_sorbet_static_version?(version)
+          def supports_target_sorbet_static_version?(version)
             @minimum_target_sorbet_static_version <= Gem::Version.new(version)
           end
         end
 
+        def sorbet_enabled?
+          !target_sorbet_static_version_from_bundler_lock_file.nil?
+        end
+
         def enabled_for_sorbet_static_version?
           sorbet_static_version = target_sorbet_static_version_from_bundler_lock_file
           return false unless sorbet_static_version
 
-          self.class.support_target_sorbet_static_version?(sorbet_static_version)
+          self.class.supports_target_sorbet_static_version?(sorbet_static_version)
         end
 
         def target_sorbet_static_version_from_bundler_lock_file

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

@@ -54,7 +54,7 @@ module RuboCop
             $(ivasgn $_ivar                                           # First line: @_ivar = ...
               (send                                                   # T.let(_ivar, T.nilable(_ivar_type))
                 $(const {nil? cbase} :T) :let
-                {(ivar _ivar) nil}
+                (ivar _ivar)
                 (send (const {nil? cbase} :T) :nilable $_ivar_type))) # T.nilable(_ivar_type)
             $(or-asgn (ivasgn _ivar) $_initialization_expr))          # Second line: @_ivar ||= _initialization_expr
         PATTERN

data/lib/rubocop/cop/sorbet/rbi/forbid_rbi_outside_of_allowed_paths.rb

@@ -56,7 +56,7 @@ module RuboCop
         private
 
         def allowed_paths
-          paths = cop_config["AllowedPaths"] # rubocop:todo InternalAffairs/UndefinedConfig
+          paths = cop_config["AllowedPaths"]
           return unless paths.is_a?(Array)
 
           paths.compact

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

@@ -26,6 +26,7 @@ module RuboCop
       #   end
       #
       class RedundantExtendTSig < RuboCop::Cop::Base
+        include RangeHelp
         extend AutoCorrector
 
         MSG = "Do not redundantly `extend T::Sig` when it is already included in all modules."
@@ -40,7 +41,7 @@ module RuboCop
           return unless extend_t_sig?(node)
 
           add_offense(node) do |corrector|
-            corrector.remove(node)
+            corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
           end
         end
       end

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

@@ -90,7 +90,7 @@ module RuboCop
           return suggested_strictness unless minimum_strictness
 
           # special case: if you're using Sorbet/IgnoreSigil without config, we should recommend `ignore`
-          return "ignore" if minimum_strictness == "ignore" && cop_config["SuggestedStrictness"].nil? # rubocop:todo InternalAffairs/UndefinedConfig
+          return "ignore" if minimum_strictness == "ignore" && cop_config["SuggestedStrictness"].nil?
 
           # if a minimum strictness is set (eg. you're using Sorbet/FalseSigil)
           # we want to compare the minimum strictness and suggested strictness. this is because
@@ -161,24 +161,24 @@ module RuboCop
 
         # Default is `false`
         def require_sigil_on_all_files?
-          !!cop_config["RequireSigilOnAllFiles"] # rubocop:todo InternalAffairs/UndefinedConfig
+          !!cop_config["RequireSigilOnAllFiles"]
         end
 
         # Default is `'false'`
         def suggested_strictness
-          config = cop_config["SuggestedStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig
+          config = cop_config["SuggestedStrictness"].to_s
           STRICTNESS_LEVELS.include?(config) ? config : "false"
         end
 
         # Default is `nil`
         def minimum_strictness
-          config = cop_config["MinimumStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig
+          config = cop_config["MinimumStrictness"].to_s
           config if STRICTNESS_LEVELS.include?(config)
         end
 
         # Default is `nil`
         def exact_strictness
-          config = cop_config["ExactStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig
+          config = cop_config["ExactStrictness"].to_s
           config if STRICTNESS_LEVELS.include?(config)
         end
       end

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

@@ -56,7 +56,7 @@ module RuboCop
           return unless sig?(node.send_node)
 
           block = node.children.last
-          return unless block.send_type?
+          return unless block&.send_type?
 
           receiver = block.receiver
           while receiver

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "rubocop"
-require_relative "signature_cop"
-
 module RuboCop
   module Cop
     module Sorbet
@@ -19,8 +16,9 @@ module RuboCop
       #
       #   # good
       #   sig { void }
-      class CheckedTrueInSignature < SignatureCop
+      class CheckedTrueInSignature < ::RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
         include(RuboCop::Cop::RangeHelp)
+        include(RuboCop::Cop::Sorbet::SignatureHelp)
 
         # @!method offending_node(node)
         def_node_search(:offending_node, <<~PATTERN)

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

@@ -1,16 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "signature_cop"
-
 module RuboCop
   module Cop
     module Sorbet
       # Checks for blank lines after signatures.
       #
-      # It also suggests an autocorrect
-      #
       # @example
-      #
       #   # bad
       #   sig { void }
       #
@@ -19,37 +14,60 @@ module RuboCop
       #   # good
       #   sig { void }
       #   def foo; end
-      #
-      class EmptyLineAfterSig < SignatureCop
+      class EmptyLineAfterSig < ::RuboCop::Cop::Base
+        extend AutoCorrector
         include RangeHelp
+        include SignatureHelp
 
-        def on_signature(node)
-          if (next_method(node).line - node.last_line) > 1
-            location = source_range(processed_source.buffer, next_method(node).line - 1, 0)
-            add_offense(node, location: location, message: "Extra empty line or comment detected")
-          end
-        end
+        MSG = "Extra empty line or comment detected"
+
+        # @!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} ...)
+            #signature?
+          }
+        PATTERN
 
-        def autocorrect(node)
-          ->(corrector) do
-            offending_range = node.source_range.with(
-              begin_pos: node.source_range.end_pos + 1,
-              end_pos: processed_source.buffer.line_range(next_method(node).line).begin_pos,
-            )
-            corrector.remove(offending_range)
-            clean_range = offending_range.source.split("\n").reject(&:empty?).join("\n")
-            offending_line = processed_source.buffer.line_range(node.source_range.first_line)
-            corrector.insert_before(offending_line, "#{clean_range}\n") unless clean_range.empty?
+        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?
+
+            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)
+            end
           end
         end
 
         private
 
-        def next_method(node)
-          processed_source.tokens.find do |t|
-            t.line >= node.last_line &&
-              (t.type == :kDEF || t.text.start_with?("attr_"))
-          end
+        def next_sibling(node)
+          node.parent&.children&.at(node.sibling_index + 1)
+        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
+
+          string_in_between = buffer.slice(end_of_node1_pos...start_of_node2_pos)
+          # Fallbacks handle same line edge case
+          begin_offset = string_in_between.index("\n")  || 0
+          end_offset   = string_in_between.rindex("\n") || string_in_between.length - 1
+
+          Parser::Source::Range.new(
+            buffer,
+            end_of_node1_pos + begin_offset + 1, # +1 to exclude post-node1 newline
+            end_of_node1_pos + end_offset   + 1, # +1 to include pre-node2  newline
+          )
         end
       end
     end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require "rubocop"
 require "stringio"
-require_relative "signature_cop"
 
 module RuboCop
   module Cop
@@ -26,7 +24,9 @@ module RuboCop
       #
       # * `ParameterTypePlaceholder`: placeholders used for parameter types (default: 'T.untyped')
       # * `ReturnTypePlaceholder`: placeholders used for return types (default: 'T.untyped')
-      class EnforceSignatures < SignatureCop
+      class EnforceSignatures < ::RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
+        include SignatureHelp
+
         def initialize(config = nil, options = nil)
           super(config, options)
           @last_sig_for_scope = {}

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "rubocop"
-require_relative "signature_cop"
-
 module RuboCop
   module Cop
     module Sorbet
@@ -20,7 +17,9 @@ module RuboCop
       #   # good
       #   sig { params(b: String, a: Integer).void }
       #   def foo(b:, a: 1); end
-      class KeywordArgumentOrdering < SignatureCop
+      class KeywordArgumentOrdering < ::RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
+        include SignatureHelp
+
         def on_signature(node)
           method_node = node.parent.children[node.sibling_index + 1]
           return if method_node.nil?

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "rubocop"
-require_relative "signature_cop"
-
 begin
   require "unparser"
 rescue LoadError
@@ -12,7 +9,28 @@ end
 module RuboCop
   module Cop
     module Sorbet
-      class SignatureBuildOrder < SignatureCop
+      # Checks for the correct order of sig builder methods:
+      # - abstract, override, or overridable
+      # - type_parameters
+      # - params
+      # - returns, or void
+      # - soft, checked, or on_failure
+      #
+      # @example
+      #   # bad
+      #   sig { void.abstract }
+      #
+      #   # good
+      #   sig { abstract.void }
+      #
+      #  # bad
+      #  sig { returns(Integer).params(x: Integer) }
+      #
+      #  # good
+      #  sig { params(x: Integer).returns(Integer) }
+      class SignatureBuildOrder < ::RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
+        include SignatureHelp
+
         ORDER =
           [
             :abstract,

data/lib/rubocop/cop/sorbet_cops.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "sorbet/mixin/target_sorbet_version.rb"
+require_relative "sorbet/mixin/signature_help.rb"
 
 require_relative "sorbet/binding_constant_without_type_alias"
 require_relative "sorbet/constants_from_strings"
@@ -10,11 +11,13 @@ require_relative "sorbet/forbid_untyped_struct_props"
 require_relative "sorbet/implicit_conversion_method"
 require_relative "sorbet/one_ancestor_per_line"
 require_relative "sorbet/callback_conditionals_binding"
+require_relative "sorbet/forbid_t_struct"
 require_relative "sorbet/forbid_t_unsafe"
 require_relative "sorbet/forbid_t_untyped"
 require_relative "sorbet/redundant_extend_t_sig"
 require_relative "sorbet/type_alias_name"
 require_relative "sorbet/obsolete_strict_memoization"
+require_relative "sorbet/buggy_obsolete_strict_memoization"
 
 require_relative "sorbet/rbi/forbid_extend_t_sig_helpers_in_shims"
 require_relative "sorbet/rbi/forbid_rbi_outside_of_allowed_paths"

data/lib/rubocop/sorbet/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sorbet
-    VERSION = "0.7.3"
+    VERSION = "0.7.5"
   end
 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/BuggyObsoleteStrictMemoization](cops_sorbet.md#sorbetbuggyobsoletestrictmemoization)
 * [Sorbet/CallbackConditionalsBinding](cops_sorbet.md#sorbetcallbackconditionalsbinding)
 * [Sorbet/CheckedTrueInSignature](cops_sorbet.md#sorbetcheckedtrueinsignature)
 * [Sorbet/ConstantsFromStrings](cops_sorbet.md#sorbetconstantsfromstrings)
@@ -19,6 +20,7 @@ In the following section you find all available cops:
 * [Sorbet/ForbidIncludeConstLiteral](cops_sorbet.md#sorbetforbidincludeconstliteral)
 * [Sorbet/ForbidRBIOutsideOfAllowedPaths](cops_sorbet.md#sorbetforbidrbioutsideofallowedpaths)
 * [Sorbet/ForbidSuperclassConstLiteral](cops_sorbet.md#sorbetforbidsuperclassconstliteral)
+* [Sorbet/ForbidTStruct](cops_sorbet.md#sorbetforbidtstruct)
 * [Sorbet/ForbidTUnsafe](cops_sorbet.md#sorbetforbidtunsafe)
 * [Sorbet/ForbidTUntyped](cops_sorbet.md#sorbetforbidtuntyped)
 * [Sorbet/ForbidUntypedStructProps](cops_sorbet.md#sorbetforbiduntypedstructprops)
@@ -30,7 +32,6 @@ In the following section you find all available cops:
 * [Sorbet/OneAncestorPerLine](cops_sorbet.md#sorbetoneancestorperline)
 * [Sorbet/RedundantExtendTSig](cops_sorbet.md#sorbetredundantextendtsig)
 * [Sorbet/SignatureBuildOrder](cops_sorbet.md#sorbetsignaturebuildorder)
-* [Sorbet/SignatureCop](cops_sorbet.md#sorbetsignaturecop)
 * [Sorbet/SingleLineRbiClassModuleDefinitions](cops_sorbet.md#sorbetsinglelinerbiclassmoduledefinitions)
 * [Sorbet/StrictSigil](cops_sorbet.md#sorbetstrictsigil)
 * [Sorbet/StrongSigil](cops_sorbet.md#sorbetstrongsigil)

data/manual/cops_sorbet.md

@@ -41,6 +41,44 @@ FooOrBar = T.any(Foo, Bar)
 FooOrBar = T.type_alias { T.any(Foo, Bar) }
 ```
 
+## Sorbet/BuggyObsoleteStrictMemoization
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes (Unsafe) | 0.7.3 | -
+
+Checks for the a mistaken variant of the "obsolete memoization pattern" that used to be required
+for older Sorbet versions in `#typed: strict` files. The mistaken variant would overwrite the ivar with `nil`
+on every call, causing the memoized value to be discarded and recomputed on every call.
+
+This cop will correct it to read from the ivar instead of `nil`, which will memoize it correctly.
+
+The result of this correction will be the "obsolete memoization pattern", which can further be corrected by
+the `Sorbet/ObsoleteStrictMemoization` cop.
+
+See `Sorbet/ObsoleteStrictMemoization` for more details.
+
+### Examples
+
+```ruby
+# bad
+sig { returns(Foo) }
+def foo
+  # This `nil` is likely a mistake, causing the memoized value to be discarded and recomputed on every call.
+  @foo = T.let(nil, T.nilable(Foo))
+  @foo ||= some_computation
+end
+
+# good
+sig { returns(Foo) }
+def foo
+  # This will now memoize the value as was likely intended, so `some_computation` is only ever called once.
+  # ⚠️If `some_computation` has side effects, this might be a breaking change!
+  @foo = T.let(@foo, T.nilable(Foo))
+  @foo ||= some_computation
+end
+```
+
 ## Sorbet/CallbackConditionalsBinding
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -146,8 +184,6 @@ Enabled | Yes | Yes  | 0.7.0 | -
 
 Checks for blank lines after signatures.
 
-It also suggests an autocorrect
-
 ### Examples
 
 ```ruby
@@ -383,6 +419,45 @@ Name | Default value | Configurable values
 --- | --- | ---
 Exclude | `db/migrate/*.rb` | Array
 
+## Sorbet/ForbidTStruct
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | No | Yes  | <<next>> | <<next>>
+
+Disallow using `T::Struct` and `T::Props`.
+
+### Examples
+
+```ruby
+# bad
+class MyStruct < T::Struct
+  const :foo, String
+  prop :bar, Integer, default: 0
+
+  def some_method; end
+end
+
+# good
+class MyStruct
+  extend T::Sig
+
+  sig { returns(String) }
+  attr_reader :foo
+
+  sig { returns(Integer) }
+  attr_accessor :bar
+
+  sig { params(foo: String, bar: Integer) }
+  def initialize(foo:, bar: 0)
+    @foo = foo
+    @bar = bar
+  end
+
+  def some_method; end
+end
+```
+
 ## Sorbet/ForbidTUnsafe
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -633,17 +708,28 @@ Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChan
 --- | --- | --- | --- | ---
 Enabled | Yes | Yes  | 0.3.0 | -
 
-No documentation
+Checks for the correct order of sig builder methods:
+- abstract, override, or overridable
+- type_parameters
+- params
+- returns, or void
+- soft, checked, or on_failure
 
-## Sorbet/SignatureCop
+ # bad
+ sig { returns(Integer).params(x: Integer) }
 
-Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
---- | --- | --- | --- | ---
-Enabled | Yes | No | - | -
+ # good
+ sig { params(x: Integer).returns(Integer) }
 
-Abstract cop specific to Sorbet signatures
+### Examples
 
-You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
+```ruby
+# bad
+sig { void.abstract }
+
+# good
+sig { abstract.void }
+```
 
 ## Sorbet/SingleLineRbiClassModuleDefinitions
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.7.5
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-16 00:00:00.000000000 Z
+date: 2023-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -87,14 +87,17 @@ files:
 - dev.yml
 - lib/rubocop-sorbet.rb
 - lib/rubocop/cop/sorbet/binding_constant_without_type_alias.rb
+- lib/rubocop/cop/sorbet/buggy_obsolete_strict_memoization.rb
 - lib/rubocop/cop/sorbet/callback_conditionals_binding.rb
 - lib/rubocop/cop/sorbet/constants_from_strings.rb
 - lib/rubocop/cop/sorbet/forbid_include_const_literal.rb
 - lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb
+- lib/rubocop/cop/sorbet/forbid_t_struct.rb
 - lib/rubocop/cop/sorbet/forbid_t_unsafe.rb
 - lib/rubocop/cop/sorbet/forbid_t_untyped.rb
 - lib/rubocop/cop/sorbet/forbid_untyped_struct_props.rb
 - lib/rubocop/cop/sorbet/implicit_conversion_method.rb
+- lib/rubocop/cop/sorbet/mixin/signature_help.rb
 - lib/rubocop/cop/sorbet/mixin/target_sorbet_version.rb
 - lib/rubocop/cop/sorbet/mutable_constant_sorbet_aware_behaviour.rb
 - lib/rubocop/cop/sorbet/obsolete_strict_memoization.rb
@@ -118,7 +121,6 @@ files:
 - lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb
 - lib/rubocop/cop/sorbet/signatures/keyword_argument_ordering.rb
 - lib/rubocop/cop/sorbet/signatures/signature_build_order.rb
-- lib/rubocop/cop/sorbet/signatures/signature_cop.rb
 - lib/rubocop/cop/sorbet/type_alias_name.rb
 - lib/rubocop/cop/sorbet_cops.rb
 - lib/rubocop/sorbet.rb
@@ -152,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.18
+rubygems_version: 3.4.21
 signing_key: 
 specification_version: 4
 summary: Automatic Sorbet code style checking tool.