rubocop-sorbet 0.7.0 → 0.7.1

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

@@ -5,7 +5,7 @@ require "rubocop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop checks that every Ruby file contains a valid Sorbet sigil.
+      # Checks that every Ruby file contains a valid Sorbet sigil.
       # Adapted from: https://gist.github.com/clarkdave/85aca4e16f33fd52aceb6a0a29936e52
       #
       # Options:
@@ -13,9 +13,11 @@ module RuboCop
       # * `RequireSigilOnAllFiles`: make offense if the Sorbet typed is not found in the file (default: false)
       # * `SuggestedStrictness`: Sorbet strictness level suggested in offense messages (default: 'false')
       # * `MinimumStrictness`: If set, make offense if the strictness level in the file is below this one
+      # * `ExactStrictness`: If set, make offense if the strictness level in the file is different than this one
       #
-      # If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.
-      class ValidSigil < RuboCop::Cop::Cop
+      # If an `ExactStrictness` level is specified, it will be used in offense messages and autocorrect.
+      # Otherwise, if a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.
+      class ValidSigil < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
         @registry = Cop.registry # So we can properly subclass this cop
 
         def investigate(processed_source)
@@ -36,7 +38,7 @@ module RuboCop
             return unless extract_sigil(processed_source).nil?
 
             token = processed_source.tokens.first
-            replace_with = suggested_strictness_level(minimum_strictness, suggested_strictness)
+            replace_with = suggested_strictness_level
             sigil = "# typed: #{replace_with}"
             if token.text.start_with?("#!") # shebang line
               corrector.insert_after(token.pos, "\n#{sigil}")
@@ -70,34 +72,37 @@ module RuboCop
 
           token = processed_source.tokens.first
           if require_sigil_on_all_files?
-            strictness = suggested_strictness_level(minimum_strictness, suggested_strictness)
+            strictness = suggested_strictness_level
             add_offense(
               token,
               location: token.pos,
               message: "No Sorbet sigil found in file. " \
-                "Try a `typed: #{strictness}` to start (you can also use `rubocop -a` to automatically add this)."
+                "Try a `typed: #{strictness}` to start (you can also use `rubocop -a` to automatically add this).",
             )
           end
           false
         end
 
-        def suggested_strictness_level(minimum_strictness, suggested_strictness)
+        def suggested_strictness_level
+          return exact_strictness if exact_strictness
           # if no minimum strictness is set (eg. using Sorbet/HasSigil without config) then
           # we always use the suggested strictness which defaults to `false`
           return suggested_strictness unless minimum_strictness
 
           # special case: if you're using Sorbet/IgnoreSigil without config, we should recommend `ignore`
-          return "ignore" if minimum_strictness == "ignore" && cop_config["SuggestedStrictness"].nil?
+          return "ignore" if minimum_strictness == "ignore" && cop_config["SuggestedStrictness"].nil? # rubocop:todo InternalAffairs/UndefinedConfig
 
           # if a minimum strictness is set (eg. you're using Sorbet/FalseSigil)
           # we want to compare the minimum strictness and suggested strictness. this is because
           # the suggested strictness might be higher than the minimum (eg. if you want all new files
           # at a higher strictness level, without having to migrate existing files at lower levels).
 
-          suggested_level = STRICTNESS_LEVELS.index(suggested_strictness)
-          minimum_level = STRICTNESS_LEVELS.index(minimum_strictness)
+          levels = [
+            STRICTNESS_LEVELS.index(suggested_strictness),
+            STRICTNESS_LEVELS.index(minimum_strictness),
+          ]
 
-          suggested_level > minimum_level ? suggested_strictness : minimum_strictness
+          STRICTNESS_LEVELS[levels.compact.max]
         end
 
         def check_strictness_not_empty(sigil, strictness)
@@ -106,7 +111,7 @@ module RuboCop
           add_offense(
             sigil,
             location: sigil.pos,
-            message: "Sorbet sigil should not be empty."
+            message: "Sorbet sigil should not be empty.",
           )
           false
         end
@@ -117,24 +122,38 @@ module RuboCop
           add_offense(
             sigil,
             location: sigil.pos,
-            message: "Invalid Sorbet sigil `#{strictness}`."
+            message: "Invalid Sorbet sigil `#{strictness}`.",
           )
           false
         end
 
         def check_strictness_level(sigil, strictness)
-          return true unless minimum_strictness
+          return true if !minimum_strictness && !exact_strictness
 
-          minimum_level = STRICTNESS_LEVELS.index(minimum_strictness)
           current_level = STRICTNESS_LEVELS.index(strictness)
-          if current_level < minimum_level
-            add_offense(
-              sigil,
-              location: sigil.pos,
-              message: "Sorbet sigil should be at least `#{minimum_strictness}` got `#{strictness}`."
-            )
-            return false
+
+          if exact_strictness
+            exact_level = STRICTNESS_LEVELS.index(exact_strictness)
+            if current_level != exact_level
+              add_offense(
+                sigil,
+                location: sigil.pos,
+                message: "Sorbet sigil should be `#{exact_strictness}` got `#{strictness}`.",
+              )
+              return false
+            end
+          else
+            minimum_level = STRICTNESS_LEVELS.index(minimum_strictness)
+            if current_level < minimum_level
+              add_offense(
+                sigil,
+                location: sigil.pos,
+                message: "Sorbet sigil should be at least `#{minimum_strictness}` got `#{strictness}`.",
+              )
+              return false
+            end
           end
+
           true
         end
 
@@ -142,18 +161,24 @@ module RuboCop
 
         # Default is `false`
         def require_sigil_on_all_files?
-          !!cop_config["RequireSigilOnAllFiles"]
+          !!cop_config["RequireSigilOnAllFiles"] # rubocop:todo InternalAffairs/UndefinedConfig
         end
 
         # Default is `'false'`
         def suggested_strictness
-          config = cop_config["SuggestedStrictness"].to_s
+          config = cop_config["SuggestedStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig
           STRICTNESS_LEVELS.include?(config) ? config : "false"
         end
 
         # Default is `nil`
         def minimum_strictness
-          config = cop_config["MinimumStrictness"].to_s
+          config = cop_config["MinimumStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig
+          config if STRICTNESS_LEVELS.include?(config)
+        end
+
+        # Default is `nil`
+        def exact_strictness
+          config = cop_config["ExactStrictness"].to_s # rubocop:todo InternalAffairs/UndefinedConfig
           config if STRICTNESS_LEVELS.include?(config)
         end
       end

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

@@ -5,10 +5,10 @@ require "rubocop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop disallows using `.override(allow_incompatible: true)`.
+      # Disallows using `.override(allow_incompatible: true)`.
       # Using `allow_incompatible` suggests a violation of the Liskov
       # Substitution Principle, meaning that a subclass is not a valid
-      # subtype of it's superclass. This Cop prevents these design smells
+      # subtype of its superclass. This Cop prevents these design smells
       # from occurring.
       #
       # @example
@@ -18,40 +18,29 @@ module RuboCop
       #
       #   # good
       #   sig.override
-      class AllowIncompatibleOverride < RuboCop::Cop::Cop
-        def_node_search(:sig?, <<-PATTERN)
-          (
-            send
-            nil?
-            :sig
-             ...
-          )
-        PATTERN
+      class AllowIncompatibleOverride < RuboCop::Cop::Base
+        MSG = "Usage of `allow_incompatible` suggests a violation of the Liskov Substitution Principle. " \
+          "Instead, strive to write interfaces which respect subtyping principles and remove `allow_incompatible`"
+        RESTRICT_ON_SEND = [:override].freeze
 
-        def not_nil?(node)
-          !node.nil?
-        end
-
-        def_node_search(:allow_incompatible?, <<-PATTERN)
-          (pair (sym :allow_incompatible) (true))
-        PATTERN
-
-        def_node_matcher(:allow_incompatible_override?, <<-PATTERN)
-          (
-            send
-            [#not_nil? #sig?]
+        # @!method allow_incompatible_override?(node)
+        def_node_matcher(:allow_incompatible_override?, <<~PATTERN)
+          (send
+            #sig?
             :override
-            [#not_nil? #allow_incompatible?]
+            (hash <$(pair (sym :allow_incompatible) true) ...>)
           )
         PATTERN
 
+        # @!method sig?(node)
+        def_node_search :sig?, <<~PATTERN
+          (send _ :sig ...)
+        PATTERN
+
         def on_send(node)
-          return unless allow_incompatible_override?(node)
-          add_offense(
-            node.children[2],
-            message: "Usage of `allow_incompatible` suggests a violation of the Liskov Substitution Principle. "\
-            "Instead, strive to write interfaces which respect subtyping principles and remove `allow_incompatible`",
-          )
+          allow_incompatible_override?(node) do |allow_incompatible_pair|
+            add_offense(allow_incompatible_pair)
+          end
         end
       end
     end

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

@@ -6,7 +6,7 @@ require_relative "signature_cop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop disallows the usage of `checked(true)`. This usage could cause
+      # Disallows the usage of `checked(true)`. This usage could cause
       # confusion; it could lead some people to believe that a method would be checked
       # even if runtime checks have not been enabled on the class or globally.
       # Additionally, in the event where checks are enabled, `checked(true)` would
@@ -22,6 +22,7 @@ module RuboCop
       class CheckedTrueInSignature < SignatureCop
         include(RuboCop::Cop::RangeHelp)
 
+        # @!method offending_node(node)
         def_node_search(:offending_node, <<~PATTERN)
           (send _ :checked (true))
         PATTERN
@@ -44,7 +45,7 @@ module RuboCop
               error.location.line,
               (error.location.selector.begin_pos)..(error.location.end.begin_pos),
             ),
-            message: MESSAGE
+            message: MESSAGE,
           )
         end
       end

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

@@ -5,7 +5,7 @@ require_relative "signature_cop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop checks for blank lines after signatures.
+      # Checks for blank lines after signatures.
       #
       # It also suggests an autocorrect
       #
@@ -31,10 +31,10 @@ module RuboCop
         end
 
         def autocorrect(node)
-          -> (corrector) do
+          ->(corrector) do
             offending_range = node.source_range.with(
               begin_pos: node.source_range.end_pos + 1,
-              end_pos: processed_source.buffer.line_range(next_method(node).line).begin_pos
+              end_pos: processed_source.buffer.line_range(next_method(node).line).begin_pos,
             )
             corrector.remove(offending_range)
             clean_range = offending_range.source.split("\n").reject(&:empty?).join("\n")

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

@@ -7,7 +7,7 @@ require_relative "signature_cop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop checks that every method definition and attribute accessor has a Sorbet signature.
+      # Checks that every method definition and attribute accessor has a Sorbet signature.
       #
       # It also suggest an autocorrect with placeholders so the following code:
       #
@@ -32,6 +32,7 @@ module RuboCop
           @last_sig_for_scope = {}
         end
 
+        # @!method accessor?(node)
         def_node_matcher(:accessor?, <<-PATTERN)
           (send nil? {:attr_reader :attr_writer :attr_accessor} ...)
         PATTERN
@@ -67,13 +68,14 @@ module RuboCop
               suggest.returns = "void" if method == :attr_writer
             end
 
-            corrector.insert_before(node.loc.expression, suggest.to_autocorrect)
+            corrector.insert_before(node, suggest.to_autocorrect)
           end
         end
 
         def scope(node)
-          return nil unless node.parent
+          return unless node.parent
           return node.parent if [:begin, :block, :class, :module].include?(node.parent.type)
+
           scope(node.parent)
         end
 
@@ -84,7 +86,7 @@ module RuboCop
           unless @last_sig_for_scope[scope]
             add_offense(
               node,
-              message: "Each method is required to have a signature."
+              message: "Each method is required to have a signature.",
             )
           end
           @last_sig_for_scope[scope] = nil
@@ -123,6 +125,7 @@ module RuboCop
 
           def generate_params
             return if @params.empty?
+
             out = StringIO.new
             out << "params("
             out << @params.map do |param|
@@ -135,6 +138,7 @@ module RuboCop
           def generate_return
             return "returns(#{@return_placeholder})" if @returns.nil?
             return @returns if @returns == "void"
+
             "returns(#{@returns})"
           end
         end

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

@@ -6,7 +6,7 @@ require_relative "signature_cop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop checks for the ordering of keyword arguments required by
+      # Checks for the ordering of keyword arguments required by
       # sorbet-runtime. The ordering requires that all keyword arguments
       # are at the end of the parameters list, and all keyword arguments
       # with a default value must be after those without default values.
@@ -24,6 +24,7 @@ module RuboCop
         def on_signature(node)
           method_node = node.parent.children[node.sibling_index + 1]
           return if method_node.nil?
+
           method_parameters = method_node.arguments
 
           check_order_for_kwoptargs(method_parameters)
@@ -35,13 +36,13 @@ module RuboCop
           out_of_kwoptarg = false
 
           parameters.reverse.each do |param|
-            out_of_kwoptarg = true unless param.type == :kwoptarg || param.type == :blockarg || param.type == :kwrestarg
+            out_of_kwoptarg = true unless param.kwoptarg_type? || param.blockarg_type? || param.kwrestarg_type?
 
-            next unless param.type == :kwoptarg && out_of_kwoptarg
+            next unless param.kwoptarg_type? && out_of_kwoptarg
 
             add_offense(
               param,
-              message: "Optional keyword arguments must be at the end of the parameter list."
+              message: "Optional keyword arguments must be at the end of the parameter list.",
             )
           end
         end

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

@@ -27,13 +27,18 @@ module RuboCop
             :on_failure,
           ].each_with_index.to_h.freeze
 
+        # @!method root_call(node)
         def_node_search(:root_call, <<~PATTERN)
           (send nil? {#{ORDER.keys.map(&:inspect).join(" ")}} ...)
         PATTERN
 
         def on_signature(node)
           calls = call_chain(node.children[2]).map(&:method_name)
-          return unless calls.any?
+          return if calls.empty?
+
+          # While the developer is typing, we may have an incomplete call statement, which means `ORDER[call]` will
+          # return `nil`. In that case, invoking `sort_by` will raise
+          return if calls.any? { |call| ORDER[call].nil? }
 
           expected_order = calls.sort_by { |call| ORDER[call] }
           return if expected_order == calls
@@ -52,7 +57,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return nil unless can_autocorrect?
+          return unless can_autocorrect?
 
           lambda do |corrector|
             tree = call_chain(node_reparsed_with_modern_features(node))
@@ -62,7 +67,7 @@ module RuboCop
               end
 
             corrector.replace(
-              node.source_range,
+              node,
               Unparser.unparse(tree),
             )
           end

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

@@ -8,9 +8,10 @@ module RuboCop
       # Abstract cop specific to Sorbet signatures
       #
       # You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
-      class SignatureCop < RuboCop::Cop::Cop
+      class SignatureCop < RuboCop::Cop::Cop # rubocop:todo InternalAffairs/InheritDeprecatedCopClass
         @registry = Cop.registry # So we can properly subclass this cop
 
+        # @!method signature?(node)
         def_node_matcher(:signature?, <<~PATTERN)
           (block (send
             {nil? #with_runtime? #without_runtime?}
@@ -19,10 +20,12 @@ module RuboCop
           ) (args) ...)
         PATTERN
 
+        # @!method with_runtime?(node)
         def_node_matcher(:with_runtime?, <<~PATTERN)
           (const (const nil? :T) :Sig)
         PATTERN
 
+        # @!method without_runtime?(node)
         def_node_matcher(:without_runtime?, <<~PATTERN)
           (const (const (const nil? :T) :Sig) :WithoutRuntime)
         PATTERN
@@ -31,6 +34,8 @@ module RuboCop
           on_signature(node) if signature?(node)
         end
 
+        alias_method :on_numblock, :on_block
+
         def on_signature(_)
           # To be defined in subclasses
         end

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

@@ -5,7 +5,7 @@ require "rubocop"
 module RuboCop
   module Cop
     module Sorbet
-      # This cop ensures all constants used as `T.type_alias` are using CamelCase.
+      # Ensures all constants used as `T.type_alias` are using CamelCase.
       #
       # @example
       #
@@ -14,30 +14,23 @@ module RuboCop
       #
       #   # good
       #   FooOrBar = T.type_alias { T.any(Foo, Bar) }
-      class TypeAliasName < RuboCop::Cop::Cop
+      class TypeAliasName < RuboCop::Cop::Base
         MSG = "Type alias constant name should be in CamelCase"
 
-        def_node_matcher(:casgn_type_alias?, <<-PATTERN)
+        # @!method underscored_type_alias?(node)
+        def_node_matcher(:underscored_type_alias?, <<-PATTERN)
           (casgn
             _
-            _
+            /_/                                  # Name matches underscore
             (block
-              (send
-                (const nil? :T) :type_alias)
-                _
-                _
-            ))
+              (send (const nil? :T) :type_alias)
+              ...
+            )
+          )
         PATTERN
 
         def on_casgn(node)
-          return unless casgn_type_alias?(node)
-
-          name = node.children[1]
-
-          # From https://github.com/rubocop/rubocop/blob/master/lib/rubocop/cop/naming/class_and_module_camel_case.rb
-          return unless /_/.match?(name)
-
-          add_offense(node)
+          add_offense(node) if underscored_type_alias?(node)
         end
       end
     end

data/lib/rubocop/cop/sorbet_cops.rb

@@ -1,15 +1,20 @@
 # frozen_string_literal: true
-require_relative "sorbet/binding_constants_without_type_alias"
+
+require_relative "sorbet/mixin/target_sorbet_version.rb"
+
+require_relative "sorbet/binding_constant_without_type_alias"
 require_relative "sorbet/constants_from_strings"
 require_relative "sorbet/forbid_superclass_const_literal"
 require_relative "sorbet/forbid_include_const_literal"
 require_relative "sorbet/forbid_untyped_struct_props"
+require_relative "sorbet/implicit_conversion_method"
 require_relative "sorbet/one_ancestor_per_line"
 require_relative "sorbet/callback_conditionals_binding"
 require_relative "sorbet/forbid_t_unsafe"
 require_relative "sorbet/forbid_t_untyped"
 require_relative "sorbet/redundant_extend_t_sig"
 require_relative "sorbet/type_alias_name"
+require_relative "sorbet/obsolete_strict_memoization"
 
 require_relative "sorbet/rbi/forbid_extend_t_sig_helpers_in_shims"
 require_relative "sorbet/rbi/forbid_rbi_outside_of_allowed_paths"

data/lib/rubocop/sorbet/inject.rb

@@ -7,13 +7,15 @@ module RuboCop
     # Because RuboCop doesn't yet support plugins, we have to monkey patch in a
     # bit of our configuration.
     module Inject
-      def self.defaults!
-        path = CONFIG_DEFAULT.to_s
-        hash = ConfigLoader.send(:load_yaml_configuration, path)
-        config = Config.new(hash, path).tap(&:make_excludes_absolute)
-        puts "configuration from #{path}" if ConfigLoader.debug?
-        config = ConfigLoader.merge_with_default(config, path)
-        ConfigLoader.instance_variable_set(:@default_configuration, config)
+      class << self
+        def defaults!
+          path = CONFIG_DEFAULT.to_s
+          hash = ConfigLoader.send(:load_yaml_configuration, path)
+          config = Config.new(hash, path).tap(&:make_excludes_absolute)
+          puts "configuration from #{path}" if ConfigLoader.debug?
+          config = ConfigLoader.merge_with_default(config, path)
+          ConfigLoader.instance_variable_set(:@default_configuration, config)
+        end
       end
     end
   end

data/lib/rubocop/sorbet/version.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
+
 module RuboCop
   module Sorbet
-    VERSION = "0.7.0"
+    VERSION = "0.7.1"
   end
 end

data/lib/rubocop/sorbet.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require "rubocop/sorbet/version"
 require "yaml"
 

data/manual/cops.md

@@ -24,7 +24,9 @@ In the following section you find all available cops:
 * [Sorbet/ForbidUntypedStructProps](cops_sorbet.md#sorbetforbiduntypedstructprops)
 * [Sorbet/HasSigil](cops_sorbet.md#sorbethassigil)
 * [Sorbet/IgnoreSigil](cops_sorbet.md#sorbetignoresigil)
+* [Sorbet/ImplicitConversionMethod](cops_sorbet.md#sorbetimplicitconversionmethod)
 * [Sorbet/KeywordArgumentOrdering](cops_sorbet.md#sorbetkeywordargumentordering)
+* [Sorbet/ObsoleteStrictMemoization](cops_sorbet.md#sorbetobsoletestrictmemoization)
 * [Sorbet/OneAncestorPerLine](cops_sorbet.md#sorbetoneancestorperline)
 * [Sorbet/RedundantExtendTSig](cops_sorbet.md#sorbetredundantextendtsig)
 * [Sorbet/SignatureBuildOrder](cops_sorbet.md#sorbetsignaturebuildorder)