rubocop-sorbet 0.7.4 → 0.7.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d771dbc78b04c867bb517a024dacaf6d1c280539ebbd6950374a19fe9d89e439
-  data.tar.gz: 5310766358cdbfec15d154733f32769ab7320cf987798710a2c0f1dcd2fddceb
+  metadata.gz: 6bb19df178a322278126862ef69ee548a1480a3273b2fa7cb390efea682076d3
+  data.tar.gz: a4808b614e42b591e1254298ae40b41327b5762f5d7e494e5dbd476034d7f5a8
 SHA512:
-  metadata.gz: 2b0a1b42b4a1a368565d86ef69a335bc5345a562a892dcc930bd4786e1049c5d4cc018a762df22ffac6189aa68628d3c5f74cee147232f6eb9de62d21350d19b
-  data.tar.gz: 21d0d71d76975bb9204622b40a026fdc3c5c62105506ddfa293df0cf117e52d05e541a430290d045792208019a60ee824c9e8535d36a5d8f70f455abdbc42f89
+  metadata.gz: 495f4c62a3e669483d4a2fb958672480e1f50519589bbef0efab007b32f56c32fad54a795a47ee8da6157d4595da0a50f845744578e0f44fab34e57fc67aa28e
+  data.tar.gz: 3e07de7f56533ed0c86dfb510e8efa0a3d1c9eb79cd130f24235cd6919a1f05ca88afc8fa7ae114de9de3ed49beac2ddc16d0d0c3e37a0a2bf6f7404ac80dcaa

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.4)
+    rubocop-sorbet (0.7.6)
       rubocop (>= 0.90.0)
 
 GEM

data/config/default.yml

@@ -89,6 +89,11 @@ Sorbet/ForbidIncludeConstLiteral:
   VersionAdded: 0.2.0
   VersionChanged: 0.5.0
 
+Sorbet/ForbidTypeAliasedShapes:
+  Description: 'Forbids defining type aliases that contain shapes'
+  Enabled: false
+  VersionAdded: 0.7.6
+
 Sorbet/ForbidSuperclassConstLiteral:
   Description: 'Forbid superclasses which are non-literal constants.'
   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/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

@@ -131,8 +131,13 @@ module RuboCop
           def initialize_param
             rb = String.new
             rb << "#{name}:"
-            rb << " #{default}" if default
-            rb << " #{factory}" if factory
+            if default
+              rb << " #{default}"
+            elsif factory
+              rb << " #{factory}"
+            elsif nilable?
+              rb << " nil"
+            end
             rb
           end
 
@@ -142,6 +147,10 @@ module RuboCop
             rb << ".call" if factory
             rb
           end
+
+          def nilable?
+            type.start_with?("T.nilable(")
+          end
         end
 
         # @!method t_struct?(node)
@@ -203,11 +212,11 @@ module RuboCop
 
         def initialize_method(indent, props)
           # We sort optional keyword arguments after required ones
-          props = props.sort_by { |prop| prop.default || prop.factory ? 1 : 0 }
+          sorted_props = props.sort_by { |prop| prop.default || prop.factory || prop.nilable? ? 1 : 0 }
 
           string = +"\n"
-          string << "#{indent}sig { params(#{props.map(&:initialize_sig_param).join(", ")}).void }\n"
-          string << "#{indent}def initialize(#{props.map(&:initialize_param).join(", ")})\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

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows defining type aliases that contain shapes
+      #
+      # @example
+      #
+      #  # bad
+      #  Foo = T.type_alias { { foo: Integer } }
+      #
+      #  # good
+      #  class Foo
+      #    extend T::Sig
+      #
+      #    sig { params(foo: Integer).void }
+      #    def initialize(foo)
+      #      @foo = foo
+      #    end
+      #  end
+      class ForbidTypeAliasedShapes < RuboCop::Cop::Base
+        MSG = "Type aliases shouldn't contain shapes because of significant performance overhead"
+
+        # @!method shape_type_alias?(node)
+        def_node_matcher(:shape_type_alias?, <<-PATTERN)
+          (block
+            (send (const {nil? cbase} :T) :type_alias)
+            (args)
+            `hash
+          )
+        PATTERN
+
+        def on_block(node)
+          add_offense(node) if shape_type_alias?(node)
+        end
+
+        alias_method :on_numblock, :on_block
+      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/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/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,11 +1,13 @@
 # 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"
 require_relative "sorbet/forbid_superclass_const_literal"
 require_relative "sorbet/forbid_include_const_literal"
+require_relative "sorbet/forbid_type_aliased_shapes"
 require_relative "sorbet/forbid_untyped_struct_props"
 require_relative "sorbet/implicit_conversion_method"
 require_relative "sorbet/one_ancestor_per_line"

data/lib/rubocop/sorbet/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sorbet
-    VERSION = "0.7.4"
+    VERSION = "0.7.6"
   end
 end

data/manual/cops.md

@@ -23,6 +23,7 @@ In the following section you find all available cops:
 * [Sorbet/ForbidTStruct](cops_sorbet.md#sorbetforbidtstruct)
 * [Sorbet/ForbidTUnsafe](cops_sorbet.md#sorbetforbidtunsafe)
 * [Sorbet/ForbidTUntyped](cops_sorbet.md#sorbetforbidtuntyped)
+* [Sorbet/ForbidTypeAliasedShapes](cops_sorbet.md#sorbetforbidtypealiasedshapes)
 * [Sorbet/ForbidUntypedStructProps](cops_sorbet.md#sorbetforbiduntypedstructprops)
 * [Sorbet/HasSigil](cops_sorbet.md#sorbethassigil)
 * [Sorbet/IgnoreSigil](cops_sorbet.md#sorbetignoresigil)
@@ -32,7 +33,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

@@ -184,8 +184,6 @@ Enabled | Yes | Yes  | 0.7.0 | -
 
 Checks for blank lines after signatures.
 
-It also suggests an autocorrect
-
 ### Examples
 
 ```ruby
@@ -498,6 +496,31 @@ sig { params(my_argument: String).void }
 def foo(my_argument); end
 ```
 
+## Sorbet/ForbidTypeAliasedShapes
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | 0.7.6 | -
+
+Disallows defining type aliases that contain shapes
+
+### Examples
+
+```ruby
+# bad
+Foo = T.type_alias { { foo: Integer } }
+
+# good
+class Foo
+  extend T::Sig
+
+  sig { params(foo: Integer).void }
+  def initialize(foo)
+    @foo = foo
+  end
+end
+```
+
 ## Sorbet/ForbidUntypedStructProps
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -710,17 +733,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
+
+```ruby
+# bad
+sig { void.abstract }
 
-You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
+# 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.4
+  version: 0.7.6
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-09-25 00:00:00.000000000 Z
+date: 2023-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -95,8 +95,10 @@ files:
 - 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_type_aliased_shapes.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
@@ -120,7 +122,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
@@ -154,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.4.22
 signing_key: 
 specification_version: 4
 summary: Automatic Sorbet code style checking tool.