rubocop-sorbet 0.10.3 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a9ebae9ccd4d5ac64cdcede02bbad10ffe8bd68b31a99d2e3c2914de447dae24
-  data.tar.gz: bbf3c32b940424369bde19fabcd6ec5cab543c265ce810d288a947dbae1d7ea7
+  metadata.gz: '086645a85b87da08958ff04471b05e238fbe14de8bc6108610bd20ca638f5ef7'
+  data.tar.gz: 24b4add23624df28a1019f528b0f24f5f87bf379ecca807d922b0220c65b09d0
 SHA512:
-  metadata.gz: 5cd6ef4d4435d430c26ed33d4267de84fb962fff6d564083428fb3153e7c0486cebe4791080dd22d6312acc8faa8b4154642c5c2eee69d80f5cdde927bacf520
-  data.tar.gz: 1eedabd82415a5c626eb33e297772ffb057d322b298e6504c63437918154e624e2c39c1667a99b703a0d642a9c840f01805a2878349165e16d72720d4656db4b
+  metadata.gz: 3fd16f332f9df0642787e8a60baa934611298a1487aabb3b84c05795764ce839dfb37001413f751bcd6a494c068220038941aaf972d36ebe0edf05315daa1fe2
+  data.tar.gz: 2d015fbdc34e4d4fcb8ba3ea60db28ec9a5af2e88efc78f258152b5cf0c1cb748c15f464b6bba2c596f24141bbb98b2a82d57afb49a3ed27a18901d11f68253b

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.3)
+    rubocop-sorbet (0.10.5)
       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.76.0)
+    rubocop (1.76.1)
       json (~> 2.3)
       language_server-protocol (~> 3.17.0.2)
       lint_roller (~> 1.1.0)

data/VERSION

@@ -1 +1 @@
-0.10.3
+0.10.5

data/config/default.yml

@@ -82,7 +82,7 @@ Sorbet/EnforceSigilOrder:
 Sorbet/EnforceSignatures:
   Description: 'Ensures all methods have a valid signature.'
   Enabled: false
-  AllowRBS: false
+  Style: sig
   VersionAdded: 0.3.4
 
 Sorbet/EnforceSingleSigil:
@@ -171,6 +171,36 @@ Sorbet/ForbidTStruct:
   VersionAdded: 0.7.4
   Safe: false
 
+Sorbet/ForbidTAbsurd:
+  Description: 'Forbid usage of T.absurd.'
+  Enabled: false
+  VersionAdded: 0.10.4
+
+Sorbet/ForbidTBind:
+  Description: 'Forbid usage of T.bind.'
+  Enabled: false
+  VersionAdded: 0.10.4
+
+Sorbet/ForbidTCast:
+  Description: 'Forbid usage of T.cast.'
+  Enabled: false
+  VersionAdded: 0.10.4
+
+Sorbet/ForbidTLet:
+  Description: 'Forbid usage of T.let.'
+  Enabled: false
+  VersionAdded: 0.10.4
+
+Sorbet/ForbidTMust:
+  Description: 'Forbid usage of T.must.'
+  Enabled: false
+  VersionAdded: 0.10.4
+
+Sorbet/ForbidTTypeAlias:
+  Description: 'Forbid usage of T.type_alias.'
+  Enabled: false
+  VersionAdded: 0.10.4
+
 Sorbet/ForbidTUnsafe:
   Description: 'Forbid usage of T.unsafe.'
   Enabled: false

data/config/obsoletion.yml

@@ -6,3 +6,8 @@
 removed:
   Sorbet/OneAncestorPerLine:
     reason: '`require_ancestor` now takes a block instead of arguments'
+
+changed_parameters:
+  - cops: 'Sorbet/EnforceSignatures'
+    parameters: 'AllowRBS'
+    alternative: 'Style'

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/enforce_signatures.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "stringio"
-
 module RuboCop
   module Cop
     module Sorbet
@@ -24,16 +22,12 @@ module RuboCop
       #
       # * `ParameterTypePlaceholder`: placeholders used for parameter types (default: 'T.untyped')
       # * `ReturnTypePlaceholder`: placeholders used for return types (default: 'T.untyped')
+      # * `Style`: signature style to enforce - 'sig' for sig blocks, 'rbs' for RBS comments, 'both' to allow either (default: 'sig')
       class EnforceSignatures < ::RuboCop::Cop::Base
         extend AutoCorrector
         include SignatureHelp
 
-        RBS_COMMENT_REGEX = /^#:.*$/
-
-        def initialize(config = nil, options = nil)
-          super(config, options)
-          @last_sig_for_scope = {}
-        end
+        VALID_STYLES = ["sig", "rbs", "both"].freeze
 
         # @!method accessor?(node)
         def_node_matcher(:accessor?, <<-PATTERN)
@@ -53,7 +47,13 @@ module RuboCop
         end
 
         def on_signature(node)
-          @last_sig_for_scope[scope(node)] = node
+          sig_checker.on_signature(node, scope(node))
+        end
+
+        def on_new_investigation
+          super
+          @sig_checker = nil
+          @rbs_checker = nil
         end
 
         def scope(node)
@@ -67,48 +67,102 @@ module RuboCop
 
         def check_node(node)
           scope = self.scope(node)
-          unless @last_sig_for_scope[scope] || has_rbs_comment?(node)
-            add_offense(
-              node,
-              message: "Each method is required to have a signature.",
-            ) do |corrector|
-              autocorrect(corrector, node)
+          sig_node = sig_checker.signature_node(scope)
+          rbs_node = rbs_checker.signature_node(node)
+
+          case signature_style
+          when "rbs"
+            # RBS style - only RBS signatures allowed
+            if sig_node
+              add_offense(sig_node, message: "Use RBS signature comments rather than sig blocks.")
+              return
+            end
+
+            unless rbs_node
+              add_offense(node, message: "Each method is required to have an RBS signature.") do |corrector|
+                autocorrect_with_signature_type(corrector, node, "rbs")
+              end
+            end
+          when "both"
+            # Both styles allowed - require at least one
+            unless sig_node || rbs_node
+              add_offense(node, message: "Each method is required to have a signature.") do |corrector|
+                autocorrect_with_signature_type(corrector, node, "sig")
+              end
+            end
+          else # "sig" (default)
+            # Sig style - only sig signatures allowed
+            unless sig_node
+              add_offense(node, message: "Each method is required to have a sig block signature.") do |corrector|
+                autocorrect_with_signature_type(corrector, node, "sig")
+              end
             end
           end
-          @last_sig_for_scope[scope] = nil
+        ensure
+          sig_checker.clear_signature(scope)
         end
 
-        def has_rbs_comment?(node)
-          return false unless cop_config["AllowRBS"] == true
-
-          node = node.parent while RuboCop::AST::SendNode === node.parent
-          return false if (comments = preceeding_comments(node)).empty?
+        def sig_checker
+          @sig_checker ||= SigSignatureChecker.new(processed_source)
+        end
 
-          last_comment = comments.last
-          return false if last_comment.loc.line + 1 < node.loc.line
+        def rbs_checker
+          @rbs_checker ||= RBSSignatureChecker.new(processed_source)
+        end
 
-          comments.any? { |comment| RBS_COMMENT_REGEX.match?(comment.text) }
+        def autocorrect_with_signature_type(corrector, node, type)
+          suggest = create_signature_suggestion(node, type)
+          populate_signature_suggestion(suggest, node)
+          corrector.insert_before(node, suggest.to_autocorrect)
         end
 
-        def preceeding_comments(node)
-          processed_source.ast_with_comments[node].select { |comment| comment.loc.line < node.loc.line }
+        def create_signature_suggestion(node, type)
+          case type
+          when "rbs"
+            RBSSuggestion.new(node.loc.column)
+          else # "sig"
+            SigSuggestion.new(node.loc.column, param_type_placeholder, return_type_placeholder)
+          end
         end
 
-        def autocorrect(corrector, node)
-          suggest = SigSuggestion.new(node.loc.column, param_type_placeholder, return_type_placeholder)
+        def populate_signature_suggestion(suggest, node)
+          if node.any_def_type?
+            populate_method_definition_suggestion(suggest, node)
+          elsif accessor?(node)
+            populate_accessor_suggestion(suggest, node)
+          end
+        end
 
-          if node.is_a?(RuboCop::AST::DefNode) # def something
-            node.arguments.each do |arg|
+        def populate_method_definition_suggestion(suggest, node)
+          node.arguments.each do |arg|
+            if arg.blockarg_type? && suggest.respond_to?(:has_block=)
+              suggest.has_block = true
+            else
               suggest.params << arg.children.first
             end
-          elsif accessor?(node) # attr reader, writer, accessor
-            method = node.children[1]
-            symbol = node.children[2]
-            suggest.params << symbol.value if symbol && (method == :attr_writer || method == :attr_accessor)
-            suggest.returns = "void" if method == :attr_writer
           end
+        end
 
-          corrector.insert_before(node, suggest.to_autocorrect)
+        def populate_accessor_suggestion(suggest, node)
+          method = node.children[1]
+          symbol = node.children[2]
+
+          add_accessor_parameter_if_needed(suggest, symbol, method)
+          set_void_return_for_writer(suggest, method)
+        end
+
+        def add_accessor_parameter_if_needed(suggest, symbol, method)
+          return unless symbol && writer_or_accessor?(method)
+
+          suggest.params << symbol.value
+        end
+
+        def set_void_return_for_writer(suggest, method)
+          suggest.returns = "void" if method == :attr_writer
+        end
+
+        def writer_or_accessor?(method)
+          method == :attr_writer || method == :attr_accessor
         end
 
         def param_type_placeholder
@@ -119,6 +173,80 @@ module RuboCop
           cop_config["ReturnTypePlaceholder"] || "T.untyped"
         end
 
+        def allow_rbs?
+          cop_config["AllowRBS"] == true
+        end
+
+        def signature_style
+          config_value = cop_config["Style"]
+          if config_value
+            unless VALID_STYLES.include?(config_value)
+              raise ArgumentError, "Invalid Style option: '#{config_value}'. Valid options are: #{VALID_STYLES.join(", ")}"
+            end
+
+            return config_value
+          end
+
+          return "both" if allow_rbs?
+
+          "sig"
+        end
+
+        class SignatureChecker
+          def initialize(processed_source)
+            @processed_source = processed_source
+          end
+
+          protected
+
+          attr_reader :processed_source
+
+          def preceding_comments(node)
+            processed_source.ast_with_comments[node].select { |comment| comment.loc.line < node.loc.line }
+          end
+        end
+
+        class RBSSignatureChecker < SignatureChecker
+          RBS_COMMENT_REGEX = /^#\s*:.*$/
+
+          def signature_node(node)
+            node = find_non_send_ancestor(node)
+            comments = preceding_comments(node)
+            return if comments.empty?
+
+            last_comment = comments.last
+            return if last_comment.loc.line + 1 < node.loc.line
+
+            comments.find { |comment| RBS_COMMENT_REGEX.match?(comment.text) }
+          end
+
+          private
+
+          def find_non_send_ancestor(node)
+            node = node.parent while node.parent&.send_type?
+            node
+          end
+        end
+
+        class SigSignatureChecker < SignatureChecker
+          def initialize(processed_source)
+            super(processed_source)
+            @last_sig_for_scope = {}
+          end
+
+          def signature_node(scope)
+            @last_sig_for_scope[scope]
+          end
+
+          def on_signature(node, scope)
+            @last_sig_for_scope[scope] = node
+          end
+
+          def clear_signature(scope)
+            @last_sig_for_scope[scope] = nil
+          end
+        end
+
         class SigSuggestion
           attr_accessor :params, :returns
 
@@ -131,34 +259,59 @@ module RuboCop
           end
 
           def to_autocorrect
-            out = StringIO.new
-            out << "sig { "
-            out << generate_params
-            out << generate_return
-            out << " }\n"
-            out << " " * @indent # preserve indent for the next line
-            out.string
+            "sig { #{generate_params}#{generate_return} }\n#{" " * @indent}"
           end
 
           private
 
           def generate_params
-            return if @params.empty?
+            return "" if @params.empty?
 
-            out = StringIO.new
-            out << "params("
-            out << @params.map do |param|
-              "#{param}: #{@param_placeholder}"
-            end.join(", ")
-            out << ")."
-            out.string
+            param_list = @params.map { |param| "#{param}: #{@param_placeholder}" }.join(", ")
+            "params(#{param_list})."
           end
 
           def generate_return
-            return "returns(#{@return_placeholder})" if @returns.nil?
-            return @returns if @returns == "void"
+            if @returns.nil?
+              "returns(#{@return_placeholder})"
+            elsif @returns == "void"
+              "void"
+            else
+              "returns(#{@returns})"
+            end
+          end
+        end
+
+        class RBSSuggestion
+          attr_accessor :params, :returns, :has_block
+
+          def initialize(indent)
+            @params = []
+            @returns = nil
+            @has_block = false
+            @indent = indent
+          end
+
+          def to_autocorrect
+            "#: #{generate_signature}\n#{" " * @indent}"
+          end
+
+          private
+
+          def generate_signature
+            param_types = @params.map { "untyped" }.join(", ")
+            return_type = @returns || "untyped"
+
+            signature = if @params.empty?
+              "()"
+            else
+              "(#{param_types})"
+            end
+
+            signature += " { (?) -> untyped }" if @has_block
+            signature += " -> #{return_type}"
 
-            "returns(#{@returns})"
+            signature
           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"

data/lib/rubocop/sorbet/version.rb

@@ -2,6 +2,6 @@
 
 module RuboCop
   module Sorbet
-    VERSION = "0.10.3"
+    VERSION = "0.10.5"
   end
 end

data/manual/cops.md

@@ -27,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

@@ -331,12 +331,13 @@ 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')
+* `Style`: signature style to enforce - 'sig' for sig blocks, 'rbs' for RBS comments, 'both' to allow either (default: 'sig')
 
 ### Configurable attributes
 
 Name | Default value | Configurable values
 --- | --- | ---
-AllowRBS | `false` | Boolean
+Style | `sig` | String
 
 ## Sorbet/EnforceSingleSigil
 
@@ -632,6 +633,60 @@ Name | Default value | Configurable values
 --- | --- | ---
 Exclude | `db/migrate/*.rb` | Array
 
+## Sorbet/ForbidTAbsurd
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | 0.10.4 | -
+
+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 | 0.10.4 | -
+
+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 | 0.10.4 | -
+
+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
@@ -659,6 +714,42 @@ class MyEnum
 end
 ```
 
+## Sorbet/ForbidTLet
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | 0.10.4 | -
+
+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 | 0.10.4 | -
+
+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
@@ -698,6 +789,24 @@ class MyStruct
 end
 ```
 
+## Sorbet/ForbidTTypeAlias
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | 0.10.4 | -
+
+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.3
+  version: 0.10.5
 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