rubocop-sorbet 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6435562ddd6c7da9c69d97032407e065c2258099a118a71b7d6ac5a0e1164fd0
-  data.tar.gz: 22267c08a28a1e491546a310be05de578ba7693aba4c597ba0b508c048669777
+  metadata.gz: b5dcbac6e0a2af2d4bed5b33ef9bd2d9cfad4608a400dc2f81e0c8c338543615
+  data.tar.gz: 9960e81847d7cda7ffb4b94d9dff22ac65f3c2b9c74664c931684b492d7da14e
 SHA512:
-  metadata.gz: 85a52ba95de0151045c93321e38ec24e0859067166084b3bf1d96e3e66e91cb27997224340a26cb39a1684341e4ce1d8e1e596643216b8761d3db0960e5e361a
-  data.tar.gz: d5897dc561a7fe22cbd099c3b34355bf474f7bbcf139c3c7a1c3fed24cf3295cc02e9349a46e75a6d75da0db547f21cd971dd557c0177b88dba6842ca661602e
+  metadata.gz: 7a0e44a9cc6fd67dd8fb564015f9dfee1e76c510d2b5e3dd853cffb72ee4f6b30948593f8d96f008749fdcbb5a70b02b11342396787a8e48f1fd9b11a6f308cd
+  data.tar.gz: 647911f5d12c0a8459e92ee71b0cd3bc01b7d4e8b15195555e82194499f4b57423d2307854f080f00132bf64f86d2356cefc6b22c545cda00b24427cbbb4fd9c

data/.github/workflows/check-version-placeholders.yml

@@ -8,7 +8,7 @@ jobs:
   check-placeholders:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - uses: ruby/setup-ruby@v1
         with:
           bundler-cache: true

data/.github/workflows/ci.yml

@@ -14,7 +14,7 @@ jobs:
         ruby: ["3.1", "3.2", "3.3", "3.4"]
     name: Test Ruby ${{ matrix.ruby }}
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Set up Ruby
         uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0
         with:
@@ -29,7 +29,7 @@ jobs:
       fail-fast: false
     name: Lint & Docs
     steps:
-      - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+      - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
       - name: Set up Ruby
         uses: ruby/setup-ruby@a4effe49ee8ee5b8b5091268c473a4628afb5651 # v1.245.0
         with:

data/.github/workflows/dependabot_automerge.yml

@@ -12,12 +12,12 @@ jobs:
     steps:
       - name: Dependabot metadata
         id: metadata
-        uses: dependabot/fetch-metadata@21025c705c08248db411dc16f3619e6b5f9ea21a # v2.5.0
+        uses: dependabot/fetch-metadata@25dd0e34f4fe68f24cc83900b1fe3fe149efef98 # v3.1.0
         with:
           github-token: "${{ secrets.GITHUB_TOKEN }}"
       - name: Enable auto-merge for Dependabot PRs
         if: ${{ steps.metadata.outputs.update-type != 'version-update:semver-major' }}
-        uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
+        uses: actions/github-script@3a2844b7e9c422d3c10d287c895573f7108da1b3 # v9.0.0
         with:
           github-token: "${{ secrets.GITHUB_TOKEN }}"
           script: |

data/.github/workflows/release.yml

@@ -0,0 +1,52 @@
+name: Release gem on RubyGems.org and create GitHub release
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+
+jobs:
+  release_gem:
+    name: Release gem on RubyGems.org
+    if: github.repository == 'Shopify/rubocop-sorbet'
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+      id-token: write
+
+    environment: release
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+        with:
+          persist-credentials: false
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@c4e5b1316158f92e3d49443a9d58b31d25ac0f8f # v1.306.0
+        with:
+          bundler-cache: true
+
+      - name: Release gem on RubyGems.org
+        uses: rubygems/release-gem@052cc82692552de3ef2b81fd670e41d13cba8092 # v1.4.0
+
+  release_github:
+    name: Create GitHub release
+    if: github.repository == 'Shopify/rubocop-sorbet'
+    needs: release_gem
+    runs-on: ubuntu-latest
+
+    permissions:
+      contents: write
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
+
+      - name: Create GitHub release
+        run: |
+          tag_name="$(git describe --tags --abbrev=0)"
+          gh release create "${tag_name}" --verify-tag --generate-notes
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

data/.github/workflows/stale.yml

@@ -12,7 +12,7 @@ jobs:
   stale:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
+      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
         with:
           stale-pr-message: >
             This PR has been automatically marked as stale because it has not had

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rubocop-sorbet (0.12.0)
+    rubocop-sorbet (0.13.0)
       lint_roller
       rubocop (>= 1.75.2)
 

data/VERSION

@@ -1 +1 @@
-0.12.0
+0.13.0

data/config/default.yml

@@ -8,6 +8,15 @@ Sorbet/ForbidTSig:
   Enabled: false
   VersionAdded: '0.11.0'
 
+Sorbet/RedundantTLet:
+  Description: >-
+    Prevents redundant use of `T.let` where Sorbet infers types automatically:
+    instance variables assigned from signature parameters in `initialize`, and
+    constants assigned constructor calls.
+  Enabled: true
+  SafeAutoCorrect: false
+  VersionAdded: '0.13.0'
+
 inherit_mode:
   merge:
   - Exclude
@@ -97,7 +106,9 @@ Sorbet/EnforceSignatures:
   Description: 'Ensures all methods have a valid signature.'
   Enabled: false
   Style: sig
+  AutocorrectStyle: sig
   VersionAdded: 0.3.4
+  VersionChanged: '0.13.0'
 
 Sorbet/EnforceSingleSigil:
   Description: 'Ensures that there is only one Sorbet sigil in a file.'
@@ -316,6 +327,15 @@ Sorbet/RedundantExtendTSig:
   Safe: false
   VersionAdded: 0.7.0
 
+Sorbet/RedundantTLetForLiteral:
+  Description: >-
+    Checks for redundant `T.let` declarations on constants where the value
+    is a simple literal whose type Sorbet can infer automatically.
+  Enabled: pending
+  Safe: true
+  SafeAutoCorrect: false
+  VersionAdded: '0.13.0'
+
 Sorbet/Refinement:
   Description: >-
                   Checks for the use of Ruby Refinements library. Refinements add

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Shared helper for cops that unwrap a `T.let` on a constant assignment.
+      module ConstantScope
+        private
+
+        # True when the constant is assigned directly in a class, module, or
+        # top-level body. In `typed: strict` files Sorbet requires a `T.let` on
+        # constants assigned elsewhere (inside a conditional, loop, block, or
+        # method — error 7027), so removing the annotation there would break
+        # typechecking.
+        def statically_scoped?(node)
+          ancestor = node.parent
+          ancestor = ancestor.parent if ancestor&.begin_type?
+          ancestor.nil? || ancestor.class_type? || ancestor.module_type? || ancestor.sclass_type?
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Shared autocorrection helper for cops that unwrap a redundant
+      # `T.let(value, Type)` down to `value`, preserving heredoc bodies that a
+      # naive `corrector.replace(t_let_node, value_node.source)` would drop
+      # (`value_node.source` stops at the marker line, so the body and its
+      # terminator sit outside it).
+      module TLetCorrection
+        private
+
+        # Replaces `T.let(value, Type)` with `value`.
+        def replace_t_let(corrector, t_let_node, value_node)
+          heredocs = value_node.each_node(:any_str).select(&:heredoc?)
+          return corrector.replace(t_let_node, value_node.source) if heredocs.empty?
+
+          replace_t_let_preserving_heredocs(corrector, t_let_node, value_node, heredocs)
+        end
+
+        # Replaces `T.let(value, Type)` with `value` without losing any heredocs
+        # contained in the value. For example, `T.let(<<~SQL, String)` becomes
+        # `<<~SQL` followed by its original body and terminator.
+        def replace_t_let_preserving_heredocs(corrector, t_let_node, value_node, heredocs)
+          corrector.replace(
+            range_including_heredocs(t_let_node, heredocs),
+            source_including_heredocs(value_node, heredocs),
+          )
+        end
+
+        # Expands the correction range to include every heredoc body and terminator.
+        # For example, the range for `T.let(<<~SQL, String)` extends through the
+        # final `SQL` terminator rather than ending at the closing parenthesis.
+        def range_including_heredocs(t_let_node, heredocs)
+          end_positions = [t_let_node.source_range.end_pos]
+          end_positions.concat(heredocs.map { |node| node.loc.heredoc_end.end_pos })
+          t_let_node.source_range.with(end_pos: end_positions.max)
+        end
+
+        # Reconstructs the value with its marker-line comment and heredoc bodies.
+        # For example, `T.let(<<~SQL, String) # query` becomes a source string
+        # containing `<<~SQL # query`, followed by its body and `SQL` terminator.
+        def source_including_heredocs(value_node, heredocs)
+          marker_line = "#{value_node.source}#{marker_line_comment(value_node)}"
+          heredoc_bodies = heredocs
+            .sort_by { |node| node.loc.heredoc_body.begin_pos }
+            .map { |node| "#{node.loc.heredoc_body.source}#{node.loc.heredoc_end.source}" }
+
+          ([marker_line] + heredoc_bodies).join("\n")
+        end
+
+        # Returns the comment trailing the heredoc marker, including its leading space.
+        # For example, the marker line `<<~SQL, String) # query` returns ` # query`.
+        def marker_line_comment(value_node)
+          buffer = value_node.source_range.source_buffer.source
+          value_end = value_node.source_range.end_pos
+          line_end = buffer.index("\n", value_end) || buffer.length
+          comment = buffer[value_end...line_end][/#.*/]
+          comment ? " #{comment}" : ""
+        end
+      end
+    end
+  end
+end

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

@@ -12,10 +12,25 @@ module RuboCop
             base.def_node_matcher(:t_let, <<~PATTERN)
               (send (const nil? :T) :let $_constant _type)
             PATTERN
+
+            # @!method sorbet_type_declaration?(node)
+            base.def_node_matcher(:sorbet_type_declaration?, <<~PATTERN)
+              {
+                (send nil? {:type_member :type_template} ...)
+                (block (send nil? {:type_member :type_template} ...) ...)
+                (send (const nil? :T) :type_alias ...)
+                (block (send (const nil? :T) :type_alias ...) ...)
+              }
+            PATTERN
           end
         end
 
         def on_assignment(value)
+          # Sorbet type declarations such as `type_member`, `type_template`,
+          # and `T.type_alias` produce type objects that cannot be frozen
+          # (calling `.freeze` on them breaks Sorbet), so they are exempt.
+          return if sorbet_type_declaration?(value)
+
           t_let(value) do |constant|
             value = constant
           end

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

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Prevents unnecessary `T.let` where Sorbet infers the type automatically.
+      #
+      # When a signature parameter is assigned to an instance variable in
+      # `initialize`, the type is inferred from the signature.
+      #
+      # When a constant is assigned a constructor call (`.new`), optionally
+      # followed by `.freeze` (Sorbet 0.6.13304+), the type is inferred from
+      # the class being instantiated. Generic classes (e.g. `Set`) are
+      # excluded: Sorbet infers their constructor calls as applied types like
+      # `T::Set[T.untyped]`, so an annotation is still required.
+      #
+      # @example
+      #
+      #  # bad
+      #  sig { params(a: Integer) }
+      #  def initialize(a)
+      #    @a = T.let(a, Integer)
+      #  end
+      #
+      #  # good
+      #  sig { params(a: Integer) }
+      #  def initialize(a)
+      #    @a = a
+      #  end
+      #
+      #  # good
+      #  sig { params(a: Integer) }
+      #  def initialize(a)
+      #    @a = T.let(a, T.any(Integer, String))
+      #  end
+      #
+      #  # bad
+      #  DEFAULT_PATH = T.let(Pathname.new("/usr/local").freeze, Pathname)
+      #
+      #  # good
+      #  DEFAULT_PATH = Pathname.new("/usr/local").freeze
+      #
+      #  # good — generic classes are not inferred, so T.let is required
+      #  LICENSES = T.let(Set.new(["mit"]).freeze, T::Set[String])
+      #
+      #  # good — instance variables are only inferred from signature parameters
+      #  @path = T.let(Pathname.new("/usr/local"), Pathname)
+      class RedundantTLet < RuboCop::Cop::Base
+        include SignatureHelp
+        include ConstantScope
+        include TargetSorbetVersion
+        include TLetCorrection
+        extend AutoCorrector
+
+        # The constructor-constant inference these cops rely on (`X = A.new`,
+        # `X = A.new.freeze`) was finalized by Sorbet's freeze-transparent
+        # inference in 0.6.13304. Flagging it against an older Sorbet could
+        # remove a `T.let` that Sorbet still requires, so the constant path
+        # (`on_casgn`) disables itself below that version. The signature-based
+        # instance-variable path (`on_def`) predates this and is not gated.
+        minimum_target_sorbet_static_version "0.6.13304"
+
+        MSG = "Unnecessary T.let. The instance variable type is inferred from the signature."
+        MSG_CONSTRUCTOR = "Unnecessary T.let. The constant type is inferred from the constructor."
+
+        # Classes whose constructor calls Sorbet infers as applied generic
+        # types (e.g. `T::Set[T.untyped]`) rather than the bare class, so
+        # constants assigned them still need an explicit annotation.
+        GENERIC_CLASSES = ["Array", "Class", "Enumerator", "Hash", "Module", "Range", "Set"].freeze
+
+        # @!method t_let(node)
+        def_node_matcher :t_let, "(ivasgn _ $(send (const {nil? cbase} :T) :let (lvar $_) $_))"
+
+        # @!method t_let_casgn(node)
+        def_node_matcher :t_let_casgn, "(casgn _ _ $(send (const {nil? cbase} :T) :let $_ $_))"
+
+        # @!method sig_params(node)
+        def_node_matcher :sig_params, "`(send nil? :params (hash $...))"
+
+        def on_def(node)
+          return unless node.method?(:initialize)
+
+          method_args = named_argument_types(node)
+          return if method_args.none?
+
+          sig_node = find_sig_node(node)
+          return unless sig_node
+
+          sig_params = sig_params(sig_node)&.to_h { |pair| [pair.key.value, pair.value] }
+          return unless sig_params&.any?
+
+          ivar_assignments(node).each do |ivasgn_node|
+            t_let(ivasgn_node) do |tlet_node, tlet_key, tlet_value|
+              find_redundant_t_let(tlet_node, tlet_key, tlet_value, sig_params, method_args)
+            end
+          end
+        end
+
+        def on_casgn(node)
+          return unless enabled_for_sorbet_static_version?
+          return unless statically_scoped?(node)
+
+          t_let_casgn(node) do |tlet_node, value_node, type_node|
+            next unless type_node.const_type?
+
+            constructor = constructor_call(value_node)
+            next unless constructor
+
+            class_path = constructor.receiver.source.delete_prefix("::")
+            next if GENERIC_CLASSES.include?(class_path)
+            next unless class_path == type_node.source.delete_prefix("::")
+
+            add_offense(tlet_node, message: MSG_CONSTRUCTOR) do |corrector|
+              replace_t_let(corrector, tlet_node, value_node)
+            end
+          end
+        end
+
+        private
+
+        # Maps named parameters to their AST types, omitting destructured
+        # parameters because they have no name and cannot appear in a signature.
+        # For example, `def initialize(a, (left, right), *rest)` returns
+        # `{ a: :arg, rest: :restarg }`, omitting `(left, right)`.
+        def named_argument_types(method_node)
+          method_node.arguments.filter_map do |argument|
+            [argument.name, argument.type] if argument.respond_to?(:name)
+          end.to_h
+        end
+
+        # Returns the `.new` call for a constant constructor, looking through
+        # an optional block and trailing `.freeze`. For example,
+        # `Foo.new { _1.enabled = true }.freeze` returns the `Foo.new` call,
+        # while `foo.new` and `Foo.build` return `nil`.
+        def constructor_call(node)
+          node = node.receiver if node.send_type? && node.method?(:freeze)
+          node = unwrap_block(node)
+          return unless node&.send_type? && node.method?(:new)
+          return unless node.receiver&.const_type?
+
+          node
+        end
+
+        # Returns the method send wrapped by a block, or the original node when
+        # no block is present. For example, `Foo.new { _1.enabled = true }`
+        # returns the `Foo.new` send node.
+        def unwrap_block(node)
+          node&.any_block_type? ? node.send_node : node
+        end
+
+        def find_sig_node(method_node)
+          # When the def is wrapped by a method modifier (`private def initialize`),
+          # Sorbet's initializer rewriter does not process the ivar assignments,
+          # so T.let annotations remain required. Skip by returning nil.
+          return if method_node.parent&.send_type?
+
+          method_node.left_sibling.then { |s| signature?(s) ? s : nil }
+        end
+
+        def normalize_whitespace(source)
+          source
+            .gsub(/\s+/, " ")              # collapse all whitespace to single spaces
+            .gsub(/,\s*([)\]\}])/, "\\1")  # remove trailing commas before closing delimiters
+            .gsub(/,\s*/, ", ")            # normalize to a single space after commas
+            .gsub(/\(\s*/, "(")            # remove space after (
+            .gsub(/\s*\)/, ")")            # remove space before )
+            .gsub(/\[\s*/, "[")            # remove space after [
+            .gsub(/\s*\]/, "]")            # remove space before ]
+            .strip
+        end
+
+        def ivar_assignments(node)
+          return [] unless node.body
+          return node.body.each_child_node(:ivasgn) if node.body.begin_type?
+          return [node.body] if node.body.ivasgn_type?
+
+          []
+        end
+
+        def find_redundant_t_let(node, tlet_key, tlet_value, sig_params, method_args)
+          sig_type = sig_params[tlet_key]
+          return unless sig_type
+
+          method_arg_kind = method_args[tlet_key]
+          return unless method_arg_kind
+
+          arg_type = expected_type(normalize_whitespace(sig_type.source), method_arg_kind)
+          return unless normalize_whitespace(tlet_value.source) == arg_type
+
+          add_offense(node) do |corrector|
+            corrector.replace(node, tlet_key.to_s)
+          end
+        end
+
+        def expected_type(sig_type, arg_kind)
+          case arg_kind
+          when :restarg then "T::Array[#{sig_type}]"
+          when :kwrestarg then "T::Hash[Symbol, #{sig_type}]"
+          else sig_type
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Checks for redundant `T.let` declarations where the first argument
+      # is a literal whose type Sorbet can infer automatically, so wrapping
+      # it in `T.let` is redundant.
+      #
+      # Simple literals (strings, symbols, integers, floats, regexps) infer as
+      # their own class. Regexp literals are the only simple literals whose
+      # inference survives a `.freeze` call (Sorbet 0.6.13304+), so
+      # `T.let(/foo/.freeze, Regexp)` is also redundant; other frozen simple
+      # literals (e.g. `"hello".freeze`) are not inferred and still need `T.let`.
+      #
+      # Array literals of simple literals are also inferred:
+      #
+      # * A frozen array (`[...].freeze`) infers as a fixed-size tuple, which is
+      #   a subtype of the annotated `T::Array`, so the annotation is redundant.
+      # * An unfrozen array infers as `T::Array[<element type>]`. It is only
+      #   flagged when that inferred type matches the annotation exactly, to
+      #   avoid silently widening (e.g. `["a", nil]` infers a nilable element).
+      #
+      # Hashes are excluded: Sorbet infers hash literals as `T.untyped`, so the
+      # annotation is required.
+      #
+      # @example
+      #   # bad
+      #   MAX_RETRIES = T.let(3, Integer)
+      #   GREETING = T.let("hello", String)
+      #   RATE = T.let(1.5, Float)
+      #   PATTERN = T.let(/foo/, Regexp)
+      #   FROZEN_PATTERN = T.let(/foo/.freeze, Regexp)
+      #   STATUS = T.let(:active, Symbol)
+      #   SHELLS = T.let([:bash, :zsh].freeze, T::Array[Symbol])
+      #   NAMES = T.let(["alice", "bob"], T::Array[String])
+      #
+      #   # good
+      #   MAX_RETRIES = 3
+      #   GREETING = "hello"
+      #   RATE = 1.5
+      #   PATTERN = /foo/
+      #   FROZEN_PATTERN = /foo/.freeze
+      #   STATUS = :active
+      #   SHELLS = [:bash, :zsh].freeze
+      #   NAMES = ["alice", "bob"]
+      #
+      #   # good — non-regexp frozen simple literals are not inferred
+      #   GREETING = T.let("hello".freeze, String)
+      #
+      #   # good — hash literals are inferred as T.untyped
+      #   OPTIONS = T.let({ verbose: true }, T::Hash[Symbol, T::Boolean])
+      #
+      #   # good — unfrozen array whose annotation is wider than the inferred type
+      #   NAMES = T.let(["alice", "bob"], T::Array[T.nilable(String)])
+      #
+      #   # good — type is not the literal's own class
+      #   value = T.let("hello", T.nilable(String))
+      #
+      #   # good — instance variables need T.let for Sorbet to track their type
+      #   @max_retries = T.let(3, Integer)
+      #
+      #   # good — local variables may need T.let so Sorbet allows reassignment
+      #   count = T.let(0, Integer)
+      class RedundantTLetForLiteral < Base
+        include ConstantScope
+        include TargetSorbetVersion
+        include TLetCorrection
+        extend AutoCorrector
+
+        # The frozen-literal and literal-array inference the newer cases rely on
+        # was added up to Sorbet 0.6.13304 (frozen regexp via freeze-transparent
+        # inference; literal arrays via constant tuple inference). Flagging them
+        # against an older Sorbet could remove a `T.let` it still requires, so
+        # those paths disable themselves below that version. Bare simple
+        # literals (`T.let(3, Integer)`) predate this and are not gated.
+        minimum_target_sorbet_static_version "0.6.13304"
+
+        MSG = "Redundant `T.let` for %{type} literal. Sorbet can infer this type automatically."
+
+        # Simple literal node types Sorbet infers, mapped to the class name.
+        # Interpolated strings/symbols (`dstr`/`dsym`) infer as `String`/`Symbol`.
+        LITERAL_TYPE_TO_CLASS = {
+          dstr: :String,
+          dsym: :Symbol,
+          float: :Float,
+          int: :Integer,
+          regexp: :Regexp,
+          str: :String,
+          sym: :Symbol,
+        }.freeze
+
+        # Element node types allowed inside an inferable array literal: the
+        # literals whose class Sorbet reflects into the array's element type.
+        # Regexps and ranges, by contrast, degrade the array to `T.untyped`, so
+        # they are excluded. Interpolated strings/symbols (`dstr`/`dsym`) infer
+        # as `String`/`Symbol`, the same as their plain literal forms.
+        ARRAY_ELEMENT_TYPES = [:dstr, :dsym, :str, :sym, :int, :float, :true, :false, :nil].freeze
+
+        # Element node types whose inferred class is unambiguous, used to derive
+        # the element type of an unfrozen array literal.
+        ELEMENT_TYPE_TO_CLASS = {
+          dstr: "String",
+          dsym: "Symbol",
+          float: "Float",
+          int: "Integer",
+          str: "String",
+          sym: "Symbol",
+        }.freeze
+
+        # @!method t_let_with_literal_and_class?(node)
+        def_node_matcher :t_let_with_literal_and_class?, <<~PATTERN
+          (casgn _ _ (send (const {nil? cbase} :T) :let ${literal? (send (regexp ...) :freeze)} (const nil? $_)))
+        PATTERN
+
+        # @!method t_let_with_array?(node)
+        def_node_matcher :t_let_with_array?, <<~PATTERN
+          (casgn _ _ (send (const {nil? cbase} :T) :let ${array (send array :freeze)} $_))
+        PATTERN
+
+        def on_casgn(node)
+          return unless statically_scoped?(node)
+
+          t_let_with_literal_and_class?(node) do |value_node, class_name|
+            literal_node = inferable_literal_node(value_node)
+            next unless literal_node
+            next unless LITERAL_TYPE_TO_CLASS[literal_node.type] == class_name
+
+            register_offense(node, value_node, class_name)
+          end
+
+          return unless enabled_for_sorbet_static_version?
+
+          t_let_with_array?(node) do |value_node, type_node|
+            frozen = value_node.send_type?
+            array_node = frozen ? value_node.receiver : value_node
+            next unless inferable_array?(array_node)
+            next unless redundant_array_annotation?(array_node, type_node, frozen: frozen)
+
+            register_offense(node, value_node, :Array)
+          end
+        end
+
+        private
+
+        # Returns the underlying literal when its inference is supported by the
+        # target Sorbet version. Bare literals are always supported; for example,
+        # `3` returns its integer node. Frozen literals are version-gated, so
+        # `/foo/.freeze` returns its regexp node only for supported targets.
+        def inferable_literal_node(value_node)
+          return value_node unless value_node.send_type?
+          return unless enabled_for_sorbet_static_version?
+
+          value_node.receiver
+        end
+
+        def register_offense(node, value_node, type)
+          t_let_node = node.children[2]
+          add_offense(t_let_node, message: format(MSG, type: type)) do |corrector|
+            replace_t_let(corrector, t_let_node, value_node)
+          end
+        end
+
+        # An array literal is inferable only when every element is one of the
+        # simple literals Sorbet reflects into the element type (or a nested
+        # inferable array). Empty arrays are excluded: they infer as
+        # `T::Array[T.untyped]` and so still need the annotation.
+        def inferable_array?(node)
+          return false unless node.array_type?
+          return false if node.children.empty?
+
+          node.children.all? do |child|
+            if child.array_type?
+              inferable_array?(child)
+            else
+              ARRAY_ELEMENT_TYPES.include?(child.type)
+            end
+          end
+        end
+
+        # Returns whether Sorbet's inferred array type makes the annotation
+        # redundant. A frozen `[:a].freeze` infers as a tuple compatible with
+        # any `T::Array[...]`; an unfrozen `[:a]` must infer exactly the
+        # annotated type, such as `T::Array[Symbol]`.
+        def redundant_array_annotation?(array_node, type_node, frozen:)
+          return t_array_type?(type_node) if frozen
+
+          inferred_array_type(array_node) == normalize(type_node.source).delete_prefix("::")
+        end
+
+        # `T::Array[...]` (with or without a leading `::`)
+        def t_array_type?(node)
+          node.send_type? && node.method?(:[]) &&
+            node.receiver&.source&.delete_prefix("::") == "T::Array"
+        end
+
+        # The type Sorbet infers for an unfrozen array literal, or nil when the
+        # element types are not uniform enough to render deterministically
+        # (mixed classes, booleans, nils and nested arrays are left alone).
+        def inferred_array_type(node)
+          classes = node.children.map { |child| ELEMENT_TYPE_TO_CLASS[child.type] }
+          return unless classes.all? && classes.uniq.size == 1
+
+          "T::Array[#{classes.first}]"
+        end
+
+        # Strips whitespace and any trailing comma before a closing delimiter,
+        # so a multi-line annotation (`T::Array[\n  String,\n]`) still compares
+        # equal to the rendered inferred type.
+        def normalize(source)
+          source.gsub(/\s+/, "").gsub(/,([)\]}])/, '\1')
+        end
+      end
+    end
+  end
+end

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

@@ -23,11 +23,13 @@ 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')
+      # * `AutocorrectStyle`: signature style to use when autocorrecting - 'sig' for sig blocks, 'rbs' for RBS comments (default: 'sig'). Only used when `Style` is 'both'.
       class EnforceSignatures < ::RuboCop::Cop::Base
         extend AutoCorrector
         include SignatureHelp
 
         VALID_STYLES = ["sig", "rbs", "both"].freeze
+        VALID_AUTOCORRECT_STYLES = ["sig", "rbs"].freeze
 
         # @!method accessor?(node)
         def_node_matcher(:accessor?, <<-PATTERN)
@@ -87,7 +89,7 @@ module RuboCop
             # 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")
+                autocorrect_with_signature_type(corrector, node, autocorrect_style)
               end
             end
           else # "sig" (default)
@@ -192,6 +194,15 @@ module RuboCop
           "sig"
         end
 
+        def autocorrect_style
+          config_value = cop_config["AutocorrectStyle"] || "sig"
+          unless VALID_AUTOCORRECT_STYLES.include?(config_value)
+            raise ArgumentError, "Invalid AutocorrectStyle option: '#{config_value}'. Valid options are: #{VALID_AUTOCORRECT_STYLES.join(", ")}"
+          end
+
+          config_value
+        end
+
         class SignatureChecker
           def initialize(processed_source)
             @processed_source = processed_source

data/lib/rubocop/cop/sorbet_cops.rb

@@ -3,6 +3,8 @@
 require_relative "sorbet/mixin/target_sorbet_version"
 require_relative "sorbet/mixin/t_enum"
 require_relative "sorbet/mixin/signature_help"
+require_relative "sorbet/mixin/constant_scope"
+require_relative "sorbet/mixin/t_let_correction"
 
 require_relative "sorbet/binding_constant_without_type_alias"
 require_relative "sorbet/block_method_definition"
@@ -27,7 +29,9 @@ 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_t_let"
 require_relative "sorbet/redundant_extend_t_sig"
+require_relative "sorbet/redundant_t_let_for_literal"
 require_relative "sorbet/refinement"
 require_relative "sorbet/select_by_is_a"
 require_relative "sorbet/type_alias_name"

data/manual/cops.md

@@ -49,6 +49,8 @@ In the following section you find all available cops:
 * [Sorbet/MultipleTEnumValues](cops_sorbet.md#sorbetmultipletenumvalues)
 * [Sorbet/ObsoleteStrictMemoization](cops_sorbet.md#sorbetobsoletestrictmemoization)
 * [Sorbet/RedundantExtendTSig](cops_sorbet.md#sorbetredundantextendtsig)
+* [Sorbet/RedundantTLet](cops_sorbet.md#sorbetredundanttlet)
+* [Sorbet/RedundantTLetForLiteral](cops_sorbet.md#sorbetredundanttletforliteral)
 * [Sorbet/Refinement](cops_sorbet.md#sorbetrefinement)
 * [Sorbet/RuntimeOnFailureDependsOnChecked](cops_sorbet.md#sorbetruntimeonfailuredependsonchecked)
 * [Sorbet/SelectByIsA](cops_sorbet.md#sorbetselectbyisa)

data/manual/cops_sorbet.md

@@ -310,7 +310,7 @@ other comments or magic comments are left in the same place.
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
 --- | --- | --- | --- | ---
-Disabled | Yes | Yes  | 0.3.4 | -
+Disabled | Yes | Yes  | 0.3.4 | 0.13.0
 
 Checks that every method definition and attribute accessor has a Sorbet signature.
 
@@ -332,12 +332,14 @@ 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')
+* `AutocorrectStyle`: signature style to use when autocorrecting - 'sig' for sig blocks, 'rbs' for RBS comments (default: 'sig'). Only used when `Style` is 'both'.
 
 ### Configurable attributes
 
 Name | Default value | Configurable values
 --- | --- | ---
 Style | `sig` | String
+AutocorrectStyle | `sig` | String
 
 ## Sorbet/EnforceSingleSigil
 
@@ -1160,6 +1162,126 @@ class Example
 end
 ```
 
+## Sorbet/RedundantTLet
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes (Unsafe) | 0.13.0 | -
+
+Prevents unnecessary `T.let` where Sorbet infers the type automatically.
+
+When a signature parameter is assigned to an instance variable in
+`initialize`, the type is inferred from the signature.
+
+When a constant is assigned a constructor call (`.new`), optionally
+followed by `.freeze` (Sorbet 0.6.13304+), the type is inferred from
+the class being instantiated. Generic classes (e.g. `Set`) are
+excluded: Sorbet infers their constructor calls as applied types like
+`T::Set[T.untyped]`, so an annotation is still required.
+
+### Examples
+
+```ruby
+# bad
+sig { params(a: Integer) }
+def initialize(a)
+  @a = T.let(a, Integer)
+end
+
+# good
+sig { params(a: Integer) }
+def initialize(a)
+  @a = a
+end
+
+# good
+sig { params(a: Integer) }
+def initialize(a)
+  @a = T.let(a, T.any(Integer, String))
+end
+
+# bad
+DEFAULT_PATH = T.let(Pathname.new("/usr/local").freeze, Pathname)
+
+# good
+DEFAULT_PATH = Pathname.new("/usr/local").freeze
+
+# good — generic classes are not inferred, so T.let is required
+LICENSES = T.let(Set.new(["mit"]).freeze, T::Set[String])
+
+# good — instance variables are only inferred from signature parameters
+@path = T.let(Pathname.new("/usr/local"), Pathname)
+```
+
+## Sorbet/RedundantTLetForLiteral
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes (Unsafe) | 0.13.0 | -
+
+Checks for redundant `T.let` declarations where the first argument
+is a literal whose type Sorbet can infer automatically, so wrapping
+it in `T.let` is redundant.
+
+Simple literals (strings, symbols, integers, floats, regexps) infer as
+their own class. Regexp literals are the only simple literals whose
+inference survives a `.freeze` call (Sorbet 0.6.13304+), so
+`T.let(/foo/.freeze, Regexp)` is also redundant; other frozen simple
+literals (e.g. `"hello".freeze`) are not inferred and still need `T.let`.
+
+Array literals of simple literals are also inferred:
+
+* A frozen array (`[...].freeze`) infers as a fixed-size tuple, which is
+  a subtype of the annotated `T::Array`, so the annotation is redundant.
+* An unfrozen array infers as `T::Array[<element type>]`. It is only
+  flagged when that inferred type matches the annotation exactly, to
+  avoid silently widening (e.g. `["a", nil]` infers a nilable element).
+
+Hashes are excluded: Sorbet infers hash literals as `T.untyped`, so the
+annotation is required.
+
+### Examples
+
+```ruby
+# bad
+MAX_RETRIES = T.let(3, Integer)
+GREETING = T.let("hello", String)
+RATE = T.let(1.5, Float)
+PATTERN = T.let(/foo/, Regexp)
+FROZEN_PATTERN = T.let(/foo/.freeze, Regexp)
+STATUS = T.let(:active, Symbol)
+SHELLS = T.let([:bash, :zsh].freeze, T::Array[Symbol])
+NAMES = T.let(["alice", "bob"], T::Array[String])
+
+# good
+MAX_RETRIES = 3
+GREETING = "hello"
+RATE = 1.5
+PATTERN = /foo/
+FROZEN_PATTERN = /foo/.freeze
+STATUS = :active
+SHELLS = [:bash, :zsh].freeze
+NAMES = ["alice", "bob"]
+
+# good — non-regexp frozen simple literals are not inferred
+GREETING = T.let("hello".freeze, String)
+
+# good — hash literals are inferred as T.untyped
+OPTIONS = T.let({ verbose: true }, T::Hash[Symbol, T::Boolean])
+
+# good — unfrozen array whose annotation is wider than the inferred type
+NAMES = T.let(["alice", "bob"], T::Array[T.nilable(String)])
+
+# good — type is not the literal's own class
+value = T.let("hello", T.nilable(String))
+
+# good — instance variables need T.let for Sorbet to track their type
+@max_retries = T.let(3, Integer)
+
+# good — local variables may need T.let so Sorbet allows reassignment
+count = T.let(0, Integer)
+```
+
 ## Sorbet/Refinement
 
 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.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -54,6 +54,7 @@ files:
 - ".github/workflows/ci.yml"
 - ".github/workflows/cla.yml"
 - ".github/workflows/dependabot_automerge.yml"
+- ".github/workflows/release.yml"
 - ".github/workflows/stale.yml"
 - ".gitignore"
 - ".rspec"
@@ -101,8 +102,10 @@ files:
 - 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/constant_scope.rb
 - lib/rubocop/cop/sorbet/mixin/signature_help.rb
 - lib/rubocop/cop/sorbet/mixin/t_enum.rb
+- lib/rubocop/cop/sorbet/mixin/t_let_correction.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
@@ -112,6 +115,8 @@ files:
 - lib/rubocop/cop/sorbet/rbi_versioning/gem_version_annotation_helper.rb
 - lib/rubocop/cop/sorbet/rbi_versioning/valid_gem_version_annotations.rb
 - lib/rubocop/cop/sorbet/redundant_extend_t_sig.rb
+- lib/rubocop/cop/sorbet/redundant_t_let.rb
+- lib/rubocop/cop/sorbet/redundant_t_let_for_literal.rb
 - lib/rubocop/cop/sorbet/refinement.rb
 - lib/rubocop/cop/sorbet/select_by_is_a.rb
 - lib/rubocop/cop/sorbet/sigils/enforce_sigil_order.rb
@@ -170,7 +175,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Automatic Sorbet code style checking tool.
 test_files: []