rubocop-sorbet 0.10.2 → 0.10.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 39f455b224ebfe0ed1167d4f65df45ba786f5605e7571c81775235563c2d964a
-  data.tar.gz: f0b2762513b7ee13abf3e2ad63222e796df11692f837530af59285802a54389c
+  metadata.gz: 79bcbc5d5d2a20065dae6bd132ce89a78f6d55d913253f582d57b26dbc90e3fe
+  data.tar.gz: fc68fab55a25f15a2689564842768d87b2268ed99e8bdcf503284e47dd82deb2
 SHA512:
-  metadata.gz: 1407c352354c7dcc548f0e6f2a031ba214627e09c766fd67665f0c47973232bbe406cff70a1a6c6178494bbacee41fcdc0ace83a2c987c7220cdd9e494384bbe
-  data.tar.gz: 6df2c39e491354b98265115b646ed149bf84b127d28057a0eac05714ed45312377d2fc454945c3e602817b44b46d805c9572affa68d4f04429ef3635faf9663c
+  metadata.gz: 6b67f844675e5ca0c5f229cf8dd55e091f12c068dcaeb0cf289eded28a92367d32ead0f315ca4776bd0acd04e743c3c0420c345ac1ac6a7041f84dc61cc1fa78
+  data.tar.gz: ca77c4f1a29809ce05da20319309c760dff38fcf4adae09b60e4a588a24ca234a32c6a48226df8baa9eaa169b388953e4f65cb079a47d22f062924efdf3b9c3b

data/.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       - name: Set up Ruby
-        uses: ruby/setup-ruby@13e7a03dc3ac6c3798f4570bfead2aed4d96abfb # v1.244.0
+        uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
@@ -31,7 +31,7 @@ jobs:
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       - name: Set up Ruby
-        uses: ruby/setup-ruby@13e7a03dc3ac6c3798f4570bfead2aed4d96abfb # v1.244.0
+        uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0
         with:
           bundler-cache: true
       # This is just to ensure the default config is valid. The target is intentionally set

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorbet (0.10.2)
+    rubocop-sorbet (0.10.4)
       lint_roller
       rubocop (>= 1.75.2)
 
@@ -39,7 +39,7 @@ GEM
     regexp_parser (2.10.0)
     reline (0.6.0)
       io-console (~> 0.5)
-    rubocop (1.75.8)
+    rubocop (1.76.1)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)
@@ -47,17 +47,17 @@ GEM
       parser (>= 3.3.0.2)
       rainbow (>= 2.2.2, < 4.0)
       regexp_parser (>= 2.9.3, < 3.0)
-      rubocop-ast (>= 1.44.0, < 2.0)
+      rubocop-ast (>= 1.45.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 2.4.0, < 4.0)
-    rubocop-ast (1.44.1)
+    rubocop-ast (1.45.1)
       parser (>= 3.3.7.2)
       prism (~> 1.4)
     rubocop-minitest (0.38.1)
       lint_roller (~> 1.1)
       rubocop (>= 1.75.0, < 2.0)
       rubocop-ast (>= 1.38.0, < 2.0)
-    rubocop-shopify (2.17.0)
+    rubocop-shopify (2.17.1)
       rubocop (~> 1.62)
     ruby-progressbar (1.13.0)
     ruby2_keywords (0.0.5)

data/Rakefile

@@ -60,10 +60,10 @@ module Releaser
 
     sh "git add lib/rubocop/sorbet/version.rb config/default.yml Gemfile.lock VERSION manual"
 
-    puts "git commit -m 'Release #{version}'"
-    puts "git push origin main"
-    puts "git tag -a v#{version} -m 'Release #{version}'"
-    puts "git push origin v#{version}"
+    sh "git commit -m 'Release v#{version}'"
+    sh "git push origin main"
+    sh "git tag -a v#{version} -m 'Release v#{version}'"
+    sh "git push origin v#{version}"
   end
 
   private

data/VERSION

@@ -1 +1 @@
-0.10.2
+0.10.3

data/config/default.yml

@@ -23,6 +23,7 @@ Sorbet/BlockMethodDefinition:
   Safe: true
   SafeAutoCorrect: false
   VersionAdded: '0.10.1'
+  VersionChanged: '0.10.3'
 
 Sorbet/BuggyObsoleteStrictMemoization:
   Description: >-
@@ -47,6 +48,12 @@ Sorbet/CallbackConditionalsBinding:
   Safe: false
   VersionAdded: 0.7.0
 
+Sorbet/CapitalizedTypeParameters:
+  Description: 'Ensures that type parameters are capitalized.'
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: '0.10.3'
+
 Sorbet/CheckedTrueInSignature:
   Description: 'Disallows the usage of `checked(true)` in signatures.'
   Enabled: true
@@ -164,6 +171,36 @@ Sorbet/ForbidTStruct:
   VersionAdded: 0.7.4
   Safe: false
 
+Sorbet/ForbidTAbsurd:
+  Description: 'Forbid usage of T.absurd.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTBind:
+  Description: 'Forbid usage of T.bind.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTCast:
+  Description: 'Forbid usage of T.cast.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTLet:
+  Description: 'Forbid usage of T.let.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTMust:
+  Description: 'Forbid usage of T.must.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTTypeAlias:
+  Description: 'Forbid usage of T.type_alias.'
+  Enabled: false
+  VersionAdded: <<next>>
+
 Sorbet/ForbidTUnsafe:
   Description: 'Forbid usage of T.unsafe.'
   Enabled: false

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

@@ -10,7 +10,8 @@ module RuboCop
       #
       # 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).
-
+      # Another exception is for ActiveSupport::Concern `class_methods` blocks.
+      #
       # @example
       #   # bad
       #   yielding_method do
@@ -40,17 +41,50 @@ module RuboCop
       #     end
       #   end
       #
+      #   # good
+      #   module SomeConcern
+      #     extend ActiveSupport::Concern
+      #
+      #     class_methods do
+      #       def good(args)
+      #         # ...
+      #       end
+      #     end
+      #   end
+      #
       class BlockMethodDefinition < Base
         include RuboCop::Cop::Alignment
         extend AutoCorrector
 
         MSG = "Do not define methods in blocks (use `define_method` as a workaround)."
 
+        # @!method activesupport_concern_class_methods_block?(node)
+        def_node_matcher :activesupport_concern_class_methods_block?, <<~PATTERN
+          (block
+            (send nil? :class_methods)
+            _
+            _
+          )
+        PATTERN
+
+        # @!method module_extends_activesupport_concern?(node)
+        def_node_matcher :module_extends_activesupport_concern?, <<~PATTERN
+          (module _
+            (begin
+              <(send nil? :extend (const (const {nil? cbase} :ActiveSupport) :Concern)) ...>
+              ...
+            )
+          )
+        PATTERN
+
         def on_block(node)
           if (parent = node.parent)
             return if parent.casgn_type?
           end
 
+          # Check if this is a class_methods block inside an ActiveSupport::Concern
+          return if in_activesupport_concern_class_methods_block?(node)
+
           node.each_descendant(:any_def) do |def_node|
             add_offense(def_node) do |corrector|
               autocorrect_method_in_block(corrector, def_node)
@@ -61,21 +95,108 @@ module RuboCop
 
         private
 
+        def in_activesupport_concern_class_methods_block?(node)
+          return false unless activesupport_concern_class_methods_block?(node)
+
+          immediate_module = node.each_ancestor(:module).first
+
+          module_extends_activesupport_concern?(immediate_module)
+        end
+
         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}  ")
+          args = transform_args_to_block_args(node)
 
+          # Build the method signature replacement
           if node.def_type?
-            replacement = "define_method(:#{method_name}) do |#{args}|#{body}\n#{indent}end"
+            signature_replacement = "define_method(:#{method_name}) do#{args}"
           elsif node.defs_type?
             receiver = node.receiver.source
-            replacement = "#{receiver}.define_singleton_method(:#{method_name}) do |#{args}|#{body}\n#{indent}end"
+            signature_replacement = "#{receiver}.define_singleton_method(:#{method_name}) do#{args}"
+          end
+
+          if node.body
+            end_pos = node.body.source_range.begin_pos
+            indentation = "\n#{indent}  "
+          else
+            end_pos, indentation = handle_method_without_body(node, indent)
           end
 
-          corrector.replace(node, replacement)
+          signature_range = node.source_range.with(end_pos: end_pos)
+
+          corrector.replace(signature_range, signature_replacement + indentation)
+        end
+
+        def transform_args_to_block_args(node)
+          args = node.arguments
+
+          if args.empty?
+            ""
+          else
+            args_string = args.map(&:source).join(", ")
+            " |#{args_string}|"
+          end
+        end
+
+        def handle_method_without_body(node, indent)
+          if single_line_method?(node)
+            handle_single_line_method(node, indent)
+          else
+            handle_multiline_method_without_body(node)
+          end
+        end
+
+        def single_line_method?(node)
+          !node.source.include?("\n")
+        end
+
+        def handle_single_line_method(node, indent)
+          end_pos = node.source_range.end_pos
+          indentation = "\n#{indent}end"
+          [end_pos, indentation]
+        end
+
+        def handle_multiline_method_without_body(node)
+          end_pos = find_method_signature_end_position(node)
+          indentation = ""
+          [end_pos, indentation]
+        end
+
+        def find_method_signature_end_position(node)
+          if node.arguments.any?
+            find_end_position_with_arguments(node)
+          else
+            find_end_position_without_arguments(node)
+          end
+        end
+
+        def find_end_position_with_arguments(node)
+          last_arg = node.last_argument
+          end_pos = last_arg.source_range.end_pos
+
+          adjust_for_closing_parenthesis(end_pos)
+        end
+
+        def find_end_position_without_arguments(node)
+          node.loc.name.end_pos
+        end
+
+        def adjust_for_closing_parenthesis(end_pos)
+          source_after_last_arg = processed_source.buffer.source[end_pos..-1]
+
+          match = closing_parenthesis_follows(source_after_last_arg)
+
+          if match
+            end_pos + match.end(0)
+          else
+            end_pos
+          end
+        end
+
+        def closing_parenthesis_follows(source)
+          source.match(/\A\s*\)/)
         end
       end
     end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.absurd` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.absurd(foo)
+      #
+      #   # good
+      #   x #: absurd
+      class ForbidTAbsurd < RuboCop::Cop::Base
+        MSG = "Do not use `T.absurd`."
+        RESTRICT_ON_SEND = [:absurd].freeze
+
+        # @!method t_absurd?(node)
+        def_node_matcher(:t_absurd?, "(send (const nil? :T) :absurd _)")
+
+        def on_send(node)
+          add_offense(node) if t_absurd?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.bind` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.bind(self, Integer)
+      #
+      #   # good
+      #   #: self as Integer
+      class ForbidTBind < RuboCop::Cop::Base
+        MSG = "Do not use `T.bind`."
+        RESTRICT_ON_SEND = [:bind].freeze
+
+        # @!method t_bind?(node)
+        def_node_matcher(:t_bind?, "(send (const nil? :T) :bind _ _)")
+
+        def on_send(node)
+          add_offense(node) if t_bind?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.cast` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.cast(foo, Integer)
+      #
+      #   # good
+      #   foo #: as Integer
+      class ForbidTCast < RuboCop::Cop::Base
+        MSG = "Do not use `T.cast`."
+        RESTRICT_ON_SEND = [:cast].freeze
+
+        # @!method t_cast?(node)
+        def_node_matcher(:t_cast?, "(send (const nil? :T) :cast _ _)")
+
+        def on_send(node)
+          add_offense(node) if t_cast?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.let` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.let(foo, Integer)
+      #
+      #   # good
+      #   foo #: Integer
+      class ForbidTLet < RuboCop::Cop::Base
+        MSG = "Do not use `T.let`."
+        RESTRICT_ON_SEND = [:let].freeze
+
+        # @!method t_let?(node)
+        def_node_matcher(:t_let?, "(send (const nil? :T) :let _ _)")
+
+        def on_send(node)
+          add_offense(node) if t_let?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.must` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.must(foo)
+      #
+      #   # good
+      #   foo #: as !nil
+      class ForbidTMust < RuboCop::Cop::Base
+        MSG = "Do not use `T.must`."
+        RESTRICT_ON_SEND = [:must].freeze
+
+        # @!method t_must?(node)
+        def_node_matcher(:t_must?, "(send (const nil? :T) :must _)")
+
+        def on_send(node)
+          add_offense(node) if t_must?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.type_alias` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   STRING_OR_INTEGER = T.type_alias { T.any(Integer, String) }
+      #
+      #   # good
+      #   #: type string_or_integer = Integer | String
+      class ForbidTTypeAlias < RuboCop::Cop::Base
+        MSG = "Do not use `T.type_alias`."
+
+        # @!method t_type_alias?(node)
+        def_node_matcher(:t_type_alias?, "(block (call (const nil? :T) :type_alias) _ _)")
+
+        def on_block(node)
+          add_offense(node) if t_type_alias?(node)
+        end
+        alias_method :on_numblock, :on_block
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Ensure type parameters used in generic methods are always capitalized.
+      #
+      # @example
+      #
+      #   # bad
+      #   sig { type_parameters(:x).params(a: T.type_parameter(:x)).void }
+      #   def foo(a); end
+      #
+      #   # good
+      #   sig { type_parameters(:X).params(a: T.type_parameter(:X)).void }
+      #   def foo(a: 1); end
+      class CapitalizedTypeParameters < ::RuboCop::Cop::Base
+        extend AutoCorrector
+        include SignatureHelp
+
+        MSG = "Type parameters must be capitalized."
+
+        RESTRICT_ON_SEND = [:type_parameter].freeze
+
+        # @!method type_parameters?(node)
+        def_node_matcher(:type_parameters?, <<-PATTERN)
+          (send nil? :type_parameters ...)
+        PATTERN
+
+        # @!method t_type_parameter?(node)
+        def_node_matcher(:t_type_parameter?, <<-PATTERN)
+          (send (const {nil? | cbase} :T) :type_parameter ...)
+        PATTERN
+
+        def on_signature(node)
+          send = node.children[2]
+
+          while send&.send_type?
+            if type_parameters?(send)
+              check_type_parameters_case(send)
+            end
+
+            send = send.children[0]
+          end
+        end
+
+        def on_send(node)
+          check_type_parameters_case(node) if t_type_parameter?(node)
+        end
+
+        def on_csend(node)
+          check_type_parameters_case(node) if t_type_parameter?(node)
+        end
+
+        private
+
+        def check_type_parameters_case(node)
+          node.children[2..].each do |arg|
+            next unless arg.is_a?(RuboCop::AST::SymbolNode)
+            next if arg.value =~ /^[A-Z]/
+
+            add_offense(arg) do |corrector|
+              corrector.replace(arg, arg.value.capitalize.to_sym.inspect)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/sorbet_cops.rb

@@ -14,8 +14,14 @@ require_relative "sorbet/forbid_type_aliased_shapes"
 require_relative "sorbet/forbid_untyped_struct_props"
 require_relative "sorbet/implicit_conversion_method"
 require_relative "sorbet/callback_conditionals_binding"
+require_relative "sorbet/forbid_t_absurd"
+require_relative "sorbet/forbid_t_bind"
+require_relative "sorbet/forbid_t_cast"
 require_relative "sorbet/forbid_t_enum"
+require_relative "sorbet/forbid_t_let"
+require_relative "sorbet/forbid_t_must"
 require_relative "sorbet/forbid_t_struct"
+require_relative "sorbet/forbid_t_type_alias"
 require_relative "sorbet/forbid_t_unsafe"
 require_relative "sorbet/forbid_t_untyped"
 require_relative "sorbet/redundant_extend_t_sig"
@@ -33,6 +39,7 @@ require_relative "sorbet/rbi_versioning/gem_version_annotation_helper"
 require_relative "sorbet/rbi_versioning/valid_gem_version_annotations"
 
 require_relative "sorbet/signatures/allow_incompatible_override"
+require_relative "sorbet/signatures/capitalized_type_parameters"
 require_relative "sorbet/signatures/checked_true_in_signature"
 require_relative "sorbet/signatures/empty_line_after_sig"
 require_relative "sorbet/signatures/enforce_signatures"

data/lib/rubocop/sorbet/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sorbet
-    VERSION = "0.10.2"
+    VERSION = "0.10.4"
   end
 end

data/manual/cops.md

@@ -10,6 +10,7 @@ In the following section you find all available cops:
 * [Sorbet/BlockMethodDefinition](cops_sorbet.md#sorbetblockmethoddefinition)
 * [Sorbet/BuggyObsoleteStrictMemoization](cops_sorbet.md#sorbetbuggyobsoletestrictmemoization)
 * [Sorbet/CallbackConditionalsBinding](cops_sorbet.md#sorbetcallbackconditionalsbinding)
+* [Sorbet/CapitalizedTypeParameters](cops_sorbet.md#sorbetcapitalizedtypeparameters)
 * [Sorbet/CheckedTrueInSignature](cops_sorbet.md#sorbetcheckedtrueinsignature)
 * [Sorbet/ConstantsFromStrings](cops_sorbet.md#sorbetconstantsfromstrings)
 * [Sorbet/EmptyLineAfterSig](cops_sorbet.md#sorbetemptylineaftersig)
@@ -26,8 +27,14 @@ In the following section you find all available cops:
 * [Sorbet/ForbidSigWithRuntime](cops_sorbet.md#sorbetforbidsigwithruntime)
 * [Sorbet/ForbidSigWithoutRuntime](cops_sorbet.md#sorbetforbidsigwithoutruntime)
 * [Sorbet/ForbidSuperclassConstLiteral](cops_sorbet.md#sorbetforbidsuperclassconstliteral)
+* [Sorbet/ForbidTAbsurd](cops_sorbet.md#sorbetforbidtabsurd)
+* [Sorbet/ForbidTBind](cops_sorbet.md#sorbetforbidtbind)
+* [Sorbet/ForbidTCast](cops_sorbet.md#sorbetforbidtcast)
 * [Sorbet/ForbidTEnum](cops_sorbet.md#sorbetforbidtenum)
+* [Sorbet/ForbidTLet](cops_sorbet.md#sorbetforbidtlet)
+* [Sorbet/ForbidTMust](cops_sorbet.md#sorbetforbidtmust)
 * [Sorbet/ForbidTStruct](cops_sorbet.md#sorbetforbidtstruct)
+* [Sorbet/ForbidTTypeAlias](cops_sorbet.md#sorbetforbidttypealias)
 * [Sorbet/ForbidTUnsafe](cops_sorbet.md#sorbetforbidtunsafe)
 * [Sorbet/ForbidTUntyped](cops_sorbet.md#sorbetforbidtuntyped)
 * [Sorbet/ForbidTypeAliasedShapes](cops_sorbet.md#sorbetforbidtypealiasedshapes)

data/manual/cops_sorbet.md

@@ -45,9 +45,16 @@ FooOrBar = T.type_alias { T.any(Foo, Bar) }
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Enabled | Yes | Yes (Unsafe) | 0.10.1 | -
+Enabled | Yes | Yes (Unsafe) | 0.10.1 | 0.10.3
 
+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).
+Another exception is for ActiveSupport::Concern `class_methods` blocks.
 
 ### Examples
 
@@ -79,6 +86,17 @@ MyClass = Class.new do
     # ...
   end
 end
+
+# good
+module SomeConcern
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def good(args)
+      # ...
+    end
+  end
+end
 ```
 
 ## Sorbet/BuggyObsoleteStrictMemoization
@@ -157,6 +175,26 @@ class Post < ApplicationRecord
 end
 ```
 
+## Sorbet/CapitalizedTypeParameters
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes (Unsafe) | 0.10.3 | -
+
+Ensure type parameters used in generic methods are always capitalized.
+
+### Examples
+
+```ruby
+# bad
+sig { type_parameters(:x).params(a: T.type_parameter(:x)).void }
+def foo(a); end
+
+# good
+sig { type_parameters(:X).params(a: T.type_parameter(:X)).void }
+def foo(a: 1); end
+```
+
 ## Sorbet/CheckedTrueInSignature
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -594,6 +632,60 @@ Name | Default value | Configurable values
 --- | --- | ---
 Exclude | `db/migrate/*.rb` | Array
 
+## Sorbet/ForbidTAbsurd
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.absurd` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.absurd(foo)
+
+# good
+x #: absurd
+```
+
+## Sorbet/ForbidTBind
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.bind` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.bind(self, Integer)
+
+# good
+#: self as Integer
+```
+
+## Sorbet/ForbidTCast
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.cast` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.cast(foo, Integer)
+
+# good
+foo #: as Integer
+```
+
 ## Sorbet/ForbidTEnum
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -621,6 +713,42 @@ class MyEnum
 end
 ```
 
+## Sorbet/ForbidTLet
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.let` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.let(foo, Integer)
+
+# good
+foo #: Integer
+```
+
+## Sorbet/ForbidTMust
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.must` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.must(foo)
+
+# good
+foo #: as !nil
+```
+
 ## Sorbet/ForbidTStruct
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -660,6 +788,24 @@ class MyStruct
 end
 ```
 
+## Sorbet/ForbidTTypeAlias
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.type_alias` anywhere.
+
+### Examples
+
+```ruby
+# bad
+STRING_OR_INTEGER = T.type_alias { T.any(Integer, String) }
+
+# good
+#: type string_or_integer = Integer | String
+```
+
 ## Sorbet/ForbidTUnsafe
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-sorbet
 version: !ruby/object:Gem::Version
-  version: 0.10.2
+  version: 0.10.4
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -84,8 +84,14 @@ files:
 - lib/rubocop/cop/sorbet/forbid_include_const_literal.rb
 - lib/rubocop/cop/sorbet/forbid_mixes_in_class_methods.rb
 - lib/rubocop/cop/sorbet/forbid_superclass_const_literal.rb
+- lib/rubocop/cop/sorbet/forbid_t_absurd.rb
+- lib/rubocop/cop/sorbet/forbid_t_bind.rb
+- lib/rubocop/cop/sorbet/forbid_t_cast.rb
 - lib/rubocop/cop/sorbet/forbid_t_enum.rb
+- lib/rubocop/cop/sorbet/forbid_t_let.rb
+- lib/rubocop/cop/sorbet/forbid_t_must.rb
 - lib/rubocop/cop/sorbet/forbid_t_struct.rb
+- lib/rubocop/cop/sorbet/forbid_t_type_alias.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
@@ -114,6 +120,7 @@ files:
 - lib/rubocop/cop/sorbet/sigils/true_sigil.rb
 - lib/rubocop/cop/sorbet/sigils/valid_sigil.rb
 - lib/rubocop/cop/sorbet/signatures/allow_incompatible_override.rb
+- lib/rubocop/cop/sorbet/signatures/capitalized_type_parameters.rb
 - lib/rubocop/cop/sorbet/signatures/checked_true_in_signature.rb
 - lib/rubocop/cop/sorbet/signatures/empty_line_after_sig.rb
 - lib/rubocop/cop/sorbet/signatures/enforce_signatures.rb