rubocop-sorbet 0.7.0 → 0.7.1

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

@@ -6,7 +6,7 @@ require "rubocop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop disallows use of `T.untyped` or `T.nilable(T.untyped)`
+      # Disallows use of `T.untyped` or `T.nilable(T.untyped)`
       # as a prop type for `T::Struct` or `T::ImmutableStruct`.
       #
       # @example
@@ -22,38 +22,40 @@ module RuboCop
       #     const :foo, Integer
       #     prop :bar, T.nilable(String)
       #   end
-      class ForbidUntypedStructProps < RuboCop::Cop::Cop
+      class ForbidUntypedStructProps < RuboCop::Cop::Base
         MSG = "Struct props cannot be T.untyped"
 
+        # @!method t_struct(node)
         def_node_matcher :t_struct, <<~PATTERN
-          (const (const nil? :T) :Struct)
-        PATTERN
-
-        def_node_matcher :t_immutable_struct, <<~PATTERN
-          (const (const nil? :T) :ImmutableStruct)
+          (const (const nil? :T) {:Struct :ImmutableStruct})
         PATTERN
 
+        # @!method t_untyped(node)
         def_node_matcher :t_untyped, <<~PATTERN
           (send (const nil? :T) :untyped)
         PATTERN
 
+        # @!method t_nilable_untyped(node)
         def_node_matcher :t_nilable_untyped, <<~PATTERN
           (send (const nil? :T) :nilable {#t_untyped #t_nilable_untyped})
         PATTERN
 
+        # @!method subclass_of_t_struct?(node)
         def_node_matcher :subclass_of_t_struct?, <<~PATTERN
-          (class (const ...) {#t_struct #t_immutable_struct} ...)
+          (class (const ...) #t_struct ...)
         PATTERN
 
+        # @!method untyped_props(node)
+        # Search for untyped prop/const declarations and capture their types
         def_node_search :untyped_props, <<~PATTERN
-          (send nil? {:prop :const} _ {#t_untyped #t_nilable_untyped} ...)
+          (send nil? {:prop :const} _ ${#t_untyped #t_nilable_untyped} ...)
         PATTERN
 
         def on_class(node)
           return unless subclass_of_t_struct?(node)
 
-          untyped_props(node).each do |untyped_prop|
-            add_offense(untyped_prop.child_nodes[1])
+          untyped_props(node).each do |prop_type|
+            add_offense(prop_type)
           end
         end
       end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows declaring implicit conversion methods.
+      # Since Sorbet is a nominal (not structural) type system,
+      # implicit conversion is currently unsupported.
+      #
+      # @example
+      #
+      #   # bad
+      #   def to_str; end
+      #
+      #   # good
+      #   def to_str(x); end
+      #
+      #   # bad
+      #   def self.to_str; end
+      #
+      #   # good
+      #   def self.to_str(x); end
+      #
+      #   # bad
+      #   alias to_str to_s
+      #
+      # @see https://docs.ruby-lang.org/en/master/implicit_conversion_rdoc.html
+      # @note Since the arity of aliased methods is not checked, false positives may result.
+      class ImplicitConversionMethod < RuboCop::Cop::Base
+        IMPLICIT_CONVERSION_METHODS = [:to_ary, :to_int, :to_hash, :to_str].freeze
+        MSG = "Avoid implicit conversion methods, as Sorbet does not support them. " \
+          "Explicity convert to the desired type instead."
+        RESTRICT_ON_SEND = [:alias_method].freeze
+
+        def on_alias(node)
+          new_id = node.new_identifier
+          add_offense(new_id) if IMPLICIT_CONVERSION_METHODS.include?(new_id.value)
+        end
+
+        def on_def(node)
+          return unless IMPLICIT_CONVERSION_METHODS.include?(node.method_name)
+          return unless node.arguments.empty?
+
+          add_offense(node)
+        end
+        alias_method :on_defs, :on_def
+
+        def on_send(node)
+          add_offense(node.first_argument) if IMPLICIT_CONVERSION_METHODS.include?(node.first_argument.value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      module TargetSorbetVersion
+        class << self
+          def included(target)
+            target.extend(ClassMethods)
+          end
+        end
+
+        module ClassMethods
+          # The version of the Sorbet static type checker required by this cop
+          def minimum_target_sorbet_static_version(version)
+            @minimum_target_sorbet_static_version = Gem::Version.new(version)
+          end
+
+          def support_target_sorbet_static_version?(version)
+            @minimum_target_sorbet_static_version <= Gem::Version.new(version)
+          end
+        end
+
+        def enabled_for_sorbet_static_version?
+          sorbet_static_version = target_sorbet_static_version_from_bundler_lock_file
+          return false unless sorbet_static_version
+
+          self.class.support_target_sorbet_static_version?(sorbet_static_version)
+        end
+
+        def target_sorbet_static_version_from_bundler_lock_file
+          # Do memoization with the `defined?` pattern since sorbet-static version might be `nil`
+          if defined?(@target_sorbet_static_version_from_bundler_lock_file)
+            @target_sorbet_static_version_from_bundler_lock_file
+          else
+            @target_sorbet_static_version_from_bundler_lock_file = read_sorbet_static_version_from_bundler_lock_file
+          end
+        end
+
+        def read_sorbet_static_version_from_bundler_lock_file
+          require "bundler"
+          ::Bundler.locked_gems.specs.find { |spec| spec.name == "sorbet-static" }&.version
+        rescue LoadError, Bundler::GemfileNotFound
+          nil
+        end
+      end
+    end
+  end
+end

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

@@ -6,10 +6,13 @@ module RuboCop
   module Cop
     module Sorbet
       module MutableConstantSorbetAwareBehaviour
-        def self.prepended(base)
-          base.def_node_matcher(:t_let, <<~PATTERN)
-            (send (const nil? :T) :let $_constant _type)
-          PATTERN
+        class << self
+          def prepended(base)
+            # @!method t_let(node)
+            base.def_node_matcher(:t_let, <<~PATTERN)
+              (send (const nil? :T) :let $_constant _type)
+            PATTERN
+          end
         end
 
         def on_assignment(value)
@@ -25,5 +28,5 @@ module RuboCop
 end
 
 RuboCop::Cop::Style::MutableConstant.prepend(
-  RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour
+  RuboCop::Cop::Sorbet::MutableConstantSorbetAwareBehaviour,
 )

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Checks for the obsolete pattern for initializing instance variables that was required for older Sorbet
+      # versions in `#typed: strict` files.
+      #
+      # It's no longer required, as of Sorbet 0.5.10210
+      # See https://sorbet.org/docs/type-assertions#put-type-assertions-behind-memoization
+      #
+      # @example
+      #
+      #   # bad
+      #   sig { returns(Foo) }
+      #   def foo
+      #     @foo = T.let(@foo, T.nilable(Foo))
+      #     @foo ||= Foo.new
+      #   end
+      #
+      #   # bad
+      #   sig { returns(Foo) }
+      #   def foo
+      #     # This would have been a mistake, causing the memoized value to be discarded and recomputed on every call.
+      #     @foo = T.let(nil, T.nilable(Foo))
+      #     @foo ||= Foo.new
+      #   end
+      #
+      #   # good
+      #   sig { returns(Foo) }
+      #   def foo
+      #     @foo ||= T.let(Foo.new, T.nilable(Foo))
+      #   end
+      #
+      class ObsoleteStrictMemoization < RuboCop::Cop::Base
+        include RuboCop::Cop::MatchRange
+        include RuboCop::Cop::Alignment
+        include RuboCop::Cop::LineLengthHelp
+        include RuboCop::Cop::RangeHelp
+        extend AutoCorrector
+
+        include TargetSorbetVersion
+        minimum_target_sorbet_static_version "0.5.10210"
+
+        MSG = "This two-stage workaround for memoization in `#typed: strict` files is no longer necessary. " \
+          "See https://sorbet.org/docs/type-assertions#put-type-assertions-behind-memoization."
+
+        # @!method legacy_memoization_pattern?(node)
+        def_node_matcher :legacy_memoization_pattern?, <<~PATTERN
+          (begin
+            ...                                                       # Ignore any other lines that come first.
+            $(ivasgn $_ivar                                           # First line: @_ivar = ...
+              (send                                                   # T.let(_ivar, T.nilable(_ivar_type))
+                $(const {nil? cbase} :T) :let
+                {(ivar _ivar) nil}
+                (send (const {nil? cbase} :T) :nilable $_ivar_type))) # T.nilable(_ivar_type)
+            $(or-asgn (ivasgn _ivar) $_initialization_expr))          # Second line: @_ivar ||= _initialization_expr
+        PATTERN
+
+        def on_begin(node)
+          legacy_memoization_pattern?(node) do |first_asgn_node, ivar, t, ivar_type, second_or_asgn_node, init_expr| # rubocop:disable Metrics/ParameterLists
+            add_offense(first_asgn_node) do |corrector|
+              indent = offset(node)
+              correction = "#{ivar} ||= #{t.source}.let(#{init_expr.source}, #{t.source}.nilable(#{ivar_type.source}))"
+
+              # We know good places to put line breaks, if required.
+              if line_length(indent + correction) > max_line_length || correction.include?("\n")
+                correction = <<~RUBY.chomp
+                  #{ivar} ||= #{t.source}.let(
+                  #{indent}  #{init_expr.source.gsub("\n", "\n#{indent}")},
+                  #{indent}  #{t.source}.nilable(#{ivar_type.source.gsub("\n", "\n#{indent}")}),
+                  #{indent})
+                RUBY
+              end
+
+              corrector.replace(
+                range_between(first_asgn_node.source_range.begin_pos, second_or_asgn_node.source_range.end_pos),
+                correction,
+              )
+            end
+          end
+        end
+
+        def relevant_file?(file)
+          super && enabled_for_sorbet_static_version?
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ require "rubocop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop ensures one ancestor per requires_ancestor line
+      # Ensures one ancestor per requires_ancestor line
       # rather than chaining them as a comma-separated list.
       #
       # @example
@@ -21,17 +21,20 @@ module RuboCop
       #     requires_ancestor Kernel
       #     requires_ancestor Minitest::Assertions
       #   end
-      class OneAncestorPerLine < RuboCop::Cop::Cop
+      class OneAncestorPerLine < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
         MSG = "Cannot require more than one ancestor per line"
 
+        # @!method requires_ancestors(node)
         def_node_search :requires_ancestors, <<~PATTERN
           (send nil? :requires_ancestor ...)
         PATTERN
 
+        # @!method more_than_one_ancestor(node)
         def_node_matcher :more_than_one_ancestor, <<~PATTERN
           (send nil? :requires_ancestor const const+)
         PATTERN
 
+        # @!method abstract?(node)
         def_node_search :abstract?, <<~PATTERN
           (send nil? :abstract!)
         PATTERN
@@ -39,17 +42,19 @@ module RuboCop
         def on_module(node)
           return unless node.body
           return unless requires_ancestors(node)
+
           process_node(node)
         end
 
         def on_class(node)
           return unless abstract?(node)
           return unless requires_ancestors(node)
+
           process_node(node)
         end
 
         def autocorrect(node)
-          -> (corrector) do
+          ->(corrector) do
             ra_call = node.parent
             split_ra_calls = ra_call.source.gsub(/,\s+/, new_ra_line(ra_call.loc.column))
             corrector.replace(ra_call, split_ra_calls)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Sorbet
-      # This cop ensures RBI shims do not include a call to extend T::Sig
+      # Ensures RBI shims do not include a call to extend T::Sig
       # or to extend T::Helpers
       #
       # @example
@@ -22,30 +22,24 @@ module RuboCop
       #     sig { returns(String) }
       #     def foo; end
       #   end
-      class ForbidExtendTSigHelpersInShims < RuboCop::Cop::Cop
+      class ForbidExtendTSigHelpersInShims < RuboCop::Cop::Base
+        extend AutoCorrector
         include RangeHelp
 
         MSG = "Extending T::Sig or T::Helpers in a shim is unnecessary"
-        RESTRICT_ON_SEND = [:extend]
+        RESTRICT_ON_SEND = [:extend].freeze
 
-        def_node_matcher :extend_t_sig?, <<~PATTERN
-          (send nil? :extend (const (const nil? :T) :Sig))
+        # @!method extend_t_sig_or_helpers?(node)
+        def_node_matcher :extend_t_sig_or_helpers?, <<~PATTERN
+          (send nil? :extend (const (const nil? :T) {:Sig :Helpers}))
         PATTERN
 
-        def_node_matcher :extend_t_helpers?, <<~PATTERN
-          (send nil? :extend (const (const nil? :T) :Helpers))
-        PATTERN
-
-        def autocorrect(node)
-          -> (corrector) do
-            corrector.remove(
-              range_by_whole_lines(node.source_range, include_final_newline: true)
-            )
-          end
-        end
-
         def on_send(node)
-          add_offense(node) if extend_t_helpers?(node) || extend_t_sig?(node)
+          extend_t_sig_or_helpers?(node) do
+            add_offense(node) do |corrector|
+              corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
+            end
+          end
         end
       end
     end

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

@@ -5,7 +5,7 @@ require "pathname"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop makes sure that RBI files are always located under the defined allowed paths.
+      # Makes sure that RBI files are always located under the defined allowed paths.
       #
       # Options:
       #
@@ -20,7 +20,7 @@ module RuboCop
       #   # rbi/external_interface.rbi
       #   # sorbet/rbi/some_file.rbi
       #   # sorbet/rbi/any/path/for/file.rbi
-      class ForbidRBIOutsideOfAllowedPaths < RuboCop::Cop::Cop
+      class ForbidRBIOutsideOfAllowedPaths < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
         include RangeHelp
 
         def investigate(processed_source)
@@ -30,14 +30,14 @@ module RuboCop
             add_offense(
               nil,
               location: source_range(processed_source.buffer, 1, 0),
-              message: "AllowedPaths expects an array"
+              message: "AllowedPaths expects an array",
             )
             return
           elsif paths.empty?
             add_offense(
               nil,
               location: source_range(processed_source.buffer, 1, 0),
-              message: "AllowedPaths cannot be empty"
+              message: "AllowedPaths cannot be empty",
             )
             return
           end
@@ -49,15 +49,16 @@ module RuboCop
           add_offense(
             nil,
             location: source_range(processed_source.buffer, 1, 0),
-            message: "RBI file path should match one of: #{paths.join(", ")}"
+            message: "RBI file path should match one of: #{paths.join(", ")}",
           ) if paths.none? { |pattern| File.fnmatch(pattern, rel_path) }
         end
 
         private
 
         def allowed_paths
-          paths = cop_config["AllowedPaths"]
-          return nil unless paths.is_a?(Array)
+          paths = cop_config["AllowedPaths"] # rubocop:todo InternalAffairs/UndefinedConfig
+          return unless paths.is_a?(Array)
+
           paths.compact
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Sorbet
-      # This cop ensures empty class/module definitions in RBI files are
+      # Ensures empty class/module definitions in RBI files are
       # done on a single line rather than being split across multiple lines.
       #
       # @example
@@ -14,32 +14,26 @@ module RuboCop
       #
       #   # good
       #   module SomeModule; end
-      class SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Cop
+      class SingleLineRbiClassModuleDefinitions < RuboCop::Cop::Base
+        extend AutoCorrector
+
         MSG = "Empty class/module definitions in RBI files should be on a single line."
 
         def on_module(node)
-          process_node(node)
-        end
-
-        def on_class(node)
-          process_node(node)
-        end
+          return if node.body
+          return if node.single_line?
 
-        def autocorrect(node)
-          -> (corrector) { corrector.replace(node, convert_newlines(node.source)) }
+          add_offense(node) do |corrector|
+            corrector.replace(node, convert_newlines_to_semicolons(node.source))
+          end
         end
+        alias_method :on_class, :on_module
 
-        protected
+        private
 
-        def convert_newlines(source)
+        def convert_newlines_to_semicolons(source)
           source.sub(/[\r\n]+\s*[\r\n]*/, "; ")
         end
-
-        def process_node(node)
-          return if node.body
-          return if node.single_line?
-          add_offense(node)
-        end
       end
     end
   end

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

@@ -25,10 +25,13 @@ module RuboCop
       #     def no_op; end
       #   end
       #
-      class RedundantExtendTSig < RuboCop::Cop::Cop
+      class RedundantExtendTSig < RuboCop::Cop::Base
+        extend AutoCorrector
+
         MSG = "Do not redundantly `extend T::Sig` when it is already included in all modules."
         RESTRICT_ON_SEND = [:extend].freeze
 
+        # @!method extend_t_sig?(node)
         def_node_matcher :extend_t_sig?, <<~PATTERN
           (send _ :extend (const (const {nil? | cbase} :T) :Sig))
         PATTERN
@@ -36,11 +39,7 @@ module RuboCop
         def on_send(node)
           return unless extend_t_sig?(node)
 
-          add_offense(node)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(node) do |corrector|
             corrector.remove(node)
           end
         end

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

@@ -5,7 +5,7 @@ require "rubocop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop checks that the Sorbet sigil comes as the first magic comment in the file.
+      # Checks that the Sorbet sigil comes as the first magic comment in the file.
       #
       # The expected order for magic comments is: (en)?coding, typed, warn_indent then frozen_string_literal.
       #
@@ -57,6 +57,7 @@ module RuboCop
             (lines.min...lines.max).each do |line|
               next if lines.include?(line)
               next unless processed_source[line - 1].empty?
+
               corrector.remove(source_range(processed_source.buffer, line, 0))
             end
           end
@@ -104,7 +105,7 @@ module RuboCop
               add_offense(
                 token,
                 location: token.pos,
-                message: "Magic comments should be in the following order: #{PREFERRED_ORDER.values.join(", ")}."
+                message: "Magic comments should be in the following order: #{PREFERRED_ORDER.values.join(", ")}.",
               )
             end
           end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Sorbet
-      # This cop checks that there is only one Sorbet sigil in a given file
+      # Checks that there is only one Sorbet sigil in a given file
       #
       # For example, the following class with two sigils
       #
@@ -28,8 +28,9 @@ module RuboCop
 
         def investigate(processed_source)
           return if processed_source.tokens.empty?
+
           sigils = extract_all_sigils(processed_source)
-          return unless sigils.size > 1
+          return if sigils.empty?
 
           sigils[1..sigils.size].each do |token|
             add_offense(token, location: token.pos, message: "Files must only contain one sigil")
@@ -37,14 +38,14 @@ module RuboCop
         end
 
         def autocorrect(_node)
-          -> (corrector) do
+          ->(corrector) do
             sigils = extract_all_sigils(processed_source)
-            return unless sigils.size > 1
+            return if sigils.empty?
 
             # The first sigil encountered represents the "real" strictness so remove any below
             sigils[1..sigils.size].each do |token|
               corrector.remove(
-                source_range(processed_source.buffer, token.line, (0..token.pos.last_column))
+                source_range(processed_source.buffer, token.line, (0..token.pos.last_column)),
               )
             end
           end

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

@@ -6,7 +6,7 @@ require_relative "has_sigil"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop makes the Sorbet `false` sigil mandatory in all files.
+      # Makes the Sorbet `false` sigil mandatory in all files.
       class FalseSigil < HasSigil
         def minimum_strictness
           "false"

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

@@ -6,7 +6,7 @@ require_relative "valid_sigil"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop makes the Sorbet typed sigil mandatory in all files.
+      # Makes the Sorbet typed sigil mandatory in all files.
       #
       # Options:
       #

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

@@ -6,7 +6,7 @@ require_relative "has_sigil"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop makes the Sorbet `ignore` sigil mandatory in all files.
+      # Makes the Sorbet `ignore` sigil mandatory in all files.
       class IgnoreSigil < HasSigil
         def minimum_strictness
           "ignore"

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

@@ -6,7 +6,7 @@ require_relative "has_sigil"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop makes the Sorbet `strict` sigil mandatory in all files.
+      # Makes the Sorbet `strict` sigil mandatory in all files.
       class StrictSigil < HasSigil
         def minimum_strictness
           "strict"

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

@@ -6,7 +6,7 @@ require_relative "has_sigil"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop makes the Sorbet `strong` sigil mandatory in all files.
+      # Makes the Sorbet `strong` sigil mandatory in all files.
       class StrongSigil < HasSigil
         def minimum_strictness
           "strong"

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

@@ -6,7 +6,7 @@ require_relative "has_sigil"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop makes the Sorbet `true` sigil mandatory in all files.
+      # Makes the Sorbet `true` sigil mandatory in all files.
       class TrueSigil < HasSigil
         def minimum_strictness
           "true"