rubocop-sorbet 0.5.1 → 0.6.3

data/config/rbi.yml

@@ -0,0 +1,262 @@
+require:
+  - rubocop-sorbet
+
+AllCops:
+  TargetRubyVersion: 3.0
+  DisabledByDefault: true
+  Include:
+    - '**/*.rbi'
+
+## Layout
+
+Layout/AccessModifierIndentation:
+  Enabled: true
+
+Layout/ArgumentAlignment:
+  Enabled: true
+
+Layout/BlockAlignment:
+  Enabled: true
+
+Layout/BlockEndNewline:
+  Enabled: true
+
+Layout/ClassStructure:
+  Enabled: true
+  ExpectedOrder:
+    - module_inclusion
+    - macros
+    - public_attribute_macros
+    - protected_attribute_macros
+    - private_attribute_macros
+    - initializer
+    - public_methods
+    - protected_methods
+    - private_methods
+    - public_class_methods
+    - constants
+
+Layout/ClosingParenthesisIndentation:
+  Enabled: true
+
+Layout/CommentIndentation:
+  Enabled: true
+
+Layout/EmptyComment:
+  Enabled: true
+
+Layout/EmptyLineAfterMagicComment:
+  Enabled: true
+
+Layout/EmptyLineBetweenDefs:
+  Enabled: true
+  AllowAdjacentOneLineDefs: true
+
+Layout/EmptyLines:
+  Enabled: true
+
+Layout/EmptyLinesAroundAccessModifier:
+  Enabled: true
+
+Layout/EmptyLinesAroundArguments:
+  Enabled: true
+
+Layout/EmptyLinesAroundAttributeAccessor:
+  Enabled: true
+
+Layout/EmptyLinesAroundBlockBody:
+  Enabled: true
+
+Layout/EmptyLinesAroundClassBody:
+  Enabled: true
+
+Layout/EmptyLinesAroundModuleBody:
+  Enabled: true
+
+Layout/EndOfLine:
+  Enabled: true
+  EnforcedStyle: lf
+
+Layout/ExtraSpacing:
+  Enabled: true
+
+Layout/FirstMethodArgumentLineBreak:
+  Enabled: true
+
+Layout/FirstMethodParameterLineBreak:
+  Enabled: true
+
+Layout/FirstParameterIndentation:
+  Enabled: true
+
+Layout/IndentationConsistency:
+  Enabled: true
+
+Layout/IndentationStyle:
+  Enabled: true
+  EnforcedStyle: spaces
+
+Layout/IndentationWidth:
+  Enabled: true
+
+Layout/InitialIndentation:
+  Enabled: true
+
+Layout/LeadingCommentSpace:
+  Enabled: true
+
+Layout/LeadingEmptyLines:
+  Enabled: true
+
+# TODO: make Tapioca break long lines?
+Layout/LineLength:
+  Enabled: false
+
+Layout/MultilineBlockLayout:
+  Enabled: true
+
+Layout/MultilineMethodArgumentLineBreaks:
+  Enabled: true
+
+Layout/MultilineMethodCallBraceLayout:
+  Enabled: true
+
+Layout/MultilineMethodCallIndentation:
+  Enabled: true
+
+Layout/ParameterAlignment:
+  Enabled: true
+
+Layout/RedundantLineBreak:
+  Enabled: true
+
+Layout/SpaceAfterColon:
+  Enabled: true
+
+Layout/SpaceAfterComma:
+  Enabled: true
+
+Layout/SpaceAfterMethodName:
+  Enabled: true
+
+Layout/SpaceAfterSemicolon:
+  Enabled: true
+
+Layout/SpaceAroundEqualsInParameterDefault:
+  Enabled: true
+
+Layout/SpaceAroundKeyword:
+  Enabled: true
+
+Layout/SpaceAroundMethodCallOperator:
+  Enabled: true
+
+Layout/SpaceBeforeBlockBraces:
+  Enabled: true
+
+Layout/SpaceBeforeBrackets:
+  Enabled: true
+
+Layout/SpaceBeforeComma:
+  Enabled: true
+
+Layout/SpaceBeforeComment:
+  Enabled: true
+
+Layout/SpaceBeforeFirstArg:
+  Enabled: true
+
+Layout/SpaceBeforeSemicolon:
+  Enabled: true
+
+Layout/SpaceInsideParens:
+  Enabled: true
+
+Layout/TrailingEmptyLines:
+  Enabled: true
+  EnforcedStyle: final_newline
+
+Layout/TrailingWhitespace:
+  Enabled: true
+
+## Lint
+
+Lint/DuplicateMethods:
+  Enabled: true
+
+Lint/EmptyFile:
+  Enabled: true
+  AllowComments: false
+
+Lint/SyntaxError:
+  Enabled: true
+
+## Sorbet
+
+Sorbet:
+  DisabledByDefault: true
+
+Sorbet/EnforceSigilOrder:
+  Enabled: true
+
+Sorbet/ForbidExtendTSigHelpersInShims:
+  Enabled: true
+
+Sorbet/ForbidIncludeConstLiteral:
+  Enabled: true
+
+Sorbet/ForbidSuperclassConstLiteral:
+  Enabled: true
+
+Sorbet/OneAncestorPerLine:
+  Enabled: true
+
+Sorbet/SignatureBuildOrder:
+  Enabled: true
+
+Sorbet/SingleLineRbiClassModuleDefinitions:
+  Enabled: true
+
+Sorbet/ValidSigil:
+  Enabled: true
+  RequireSigilOnAllFiles: true
+  MinimumStrictness: "false"
+  SuggestedStrictness: "true"
+
+## Style
+
+Style/ClassAndModuleChildren:
+  Enabled: true
+  EnforcedStyle: compact
+
+Style/DefWithParentheses:
+  Enabled: true
+
+Style/EmptyMethod:
+  Enabled: true
+  EnforcedStyle: compact
+
+Style/FrozenStringLiteralComment:
+  Enabled: true
+  EnforcedStyle: never
+
+Style/MethodCallWithArgsParentheses:
+  Enabled: true
+  IgnoreMacros: true
+
+Style/MethodCallWithoutArgsParentheses:
+  Enabled: true
+
+Style/MethodDefParentheses:
+  Enabled: true
+
+Style/MixinGrouping:
+  Enabled: true
+  EnforcedStyle: separated
+
+Style/MixinUsage:
+  Enabled: true
+
+Style/ModuleFunction:
+  Enabled: true
+  EnforcedStyle: forbidden

data/dev.yml

@@ -8,4 +8,4 @@ up:
 
 commands:
   test:   "bin/rspec"
-  style:  "bundle exec rubocop"
+  style:  "bin/rubocop"

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rubocop'
+require "rubocop"
 
 module RuboCop
   module Cop
@@ -94,16 +94,16 @@ module RuboCop
             add_offense(
               node.children[2],
               message: "It looks like you're using the old `T.type_alias` syntax. " \
-              '`T.type_alias` now expects a block.' \
+              "`T.type_alias` now expects a block." \
               'Run Sorbet with the options "--autocorrect --error-white-list=5043" ' \
-              'to automatically upgrade to the new syntax.'
+              "to automatically upgrade to the new syntax."
             )
             return
           end
           add_offense(
             node.children[2],
             message: "It looks like you're trying to bind a type to a constant. " \
-            'To do this, you must alias the type using `T.type_alias`.'
+            "To do this, you must alias the type using `T.type_alias`."
           )
         end
 

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

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop ensures that callback conditionals are bound to the right type
+      # so that they are type checked properly.
+      #
+      # Auto-correction is unsafe because other libraries define similar style callbacks as Rails, but don't always need
+      # binding to the attached class. Auto-correcting those usages can lead to false positives and auto-correction
+      # introduces new typing errors.
+      #
+      # @example
+      #
+      #   # bad
+      #   class Post < ApplicationRecord
+      #     before_create :do_it, if: -> { should_do_it? }
+      #
+      #     def should_do_it?
+      #       true
+      #     end
+      #   end
+      #
+      #   # good
+      #   class Post < ApplicationRecord
+      #     before_create :do_it, if: -> {
+      #       T.bind(self, Post)
+      #       should_do_it?
+      #     }
+      #
+      #     def should_do_it?
+      #       true
+      #     end
+      #   end
+      class CallbackConditionalsBinding < RuboCop::Cop::Cop
+        CALLBACKS = [
+          :validate, :validates, :validates_with, :before_validation, :around_validation, :before_create,
+          :before_save, :before_destroy, :before_update, :after_create, :after_save, :after_destroy,
+          :after_update, :after_touch, :after_initialize, :after_find, :around_create, :around_save,
+          :around_destroy, :around_update, :before_commit, :after_commit, :after_create_commit,
+          :after_destroy_commit, :after_rollback, :after_save_commit, :after_update_commit,
+          :before_action, :prepend_before_action, :append_before_action, :around_action,
+          :prepend_around_action, :append_around_action, :after_action, :prepend_after_action,
+          :append_after_action
+        ].freeze
+
+        def autocorrect(node)
+          lambda do |corrector|
+            options = node.each_child_node.find(&:hash_type?)
+
+            conditional = nil
+            options.each_pair do |keyword, block|
+              if keyword.value == :if || keyword.value == :unless
+                conditional = block
+                break
+              end
+            end
+
+            _, _, block = conditional.child_nodes
+
+            # Find the class node and check if it includes a namespace on the
+            # same line e.g.: Namespace::Class, which will require the fully
+            # qualified name
+
+            klass = node.ancestors.find(&:class_type?)
+
+            expected_class = if klass.children.first.children.first.nil?
+              node.parent_module_name.split("::").last
+            else
+              klass.identifier.source
+            end
+
+            do_end_lambda = conditional.source.include?("do") && conditional.source.include?("end")
+
+            unless do_end_lambda
+              # We are converting a one line lambda into a multiline
+              # Remove the space after the `{`
+              if /{\s/.match?(conditional.source)
+                corrector.remove_preceding(block, 1)
+              end
+
+              # Remove the last space and `}` and re-add it with a line break
+              # and the correct indentation
+              base_indentation = " " * node.loc.column
+              chars_to_remove = /\s}/.match?(conditional.source) ? 2 : 1
+              corrector.remove_trailing(conditional, chars_to_remove)
+              corrector.insert_after(block, "\n#{base_indentation}}")
+            end
+
+            # Add the T.bind
+            indentation = " " * (node.loc.column + 2)
+            line_start = do_end_lambda ? "" : "\n#{indentation}"
+            bind = "#{line_start}T.bind(self, #{expected_class})\n#{indentation}"
+
+            corrector.insert_before(block, bind)
+          end
+        end
+
+        def on_send(node)
+          return unless CALLBACKS.include?(node.method_name)
+
+          options = node.each_child_node.find(&:hash_type?)
+          return if options.nil?
+
+          conditional = nil
+          options.each_pair do |keyword, block|
+            next unless keyword.sym_type?
+
+            if keyword.value == :if || keyword.value == :unless
+              conditional = block
+              break
+            end
+          end
+
+          return if conditional.nil? || conditional.array_type? || conditional.child_nodes.empty?
+
+          return unless conditional.arguments.empty?
+
+          type, _, block = conditional.child_nodes
+          return unless type.lambda_or_proc? || type.block_literal?
+
+          klass = node.ancestors.find(&:class_type?)
+
+          expected_class = if klass&.children&.first&.children&.first.nil?
+            node.parent_module_name&.split("::")&.last
+          else
+            klass.identifier.source
+          end
+
+          return if expected_class.nil?
+
+          unless block.source.include?("T.bind(self")
+            add_offense(
+              node,
+              message: "Callback conditionals should be bound to the right type. Use T.bind(self, #{expected_class})"
+            )
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rubocop'
+require "rubocop"
 
 module RuboCop
   module Cop

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
-require 'rubocop'
+require "rubocop"
 
 # Correct `send` expressions in include statements by constant literals.
 #
@@ -27,7 +27,7 @@ module RuboCop
   module Cop
     module Sorbet
       class ForbidIncludeConstLiteral < RuboCop::Cop::Cop
-        MSG = 'Includes must only contain constant literals'
+        MSG = "Includes must only contain constant literals"
 
         attr_accessor :used_names
 
@@ -52,6 +52,15 @@ module RuboCop
           return unless [:module, :class, :sclass].include?(parent.type)
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(
+              node.source_range,
+              "T.unsafe(self).#{node.source}"
+            )
+          end
+        end
       end
     end
   end

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
-require 'rubocop'
+require "rubocop"
 
 # Correct superclass `send` expressions by constant literals.
 #
@@ -25,7 +25,7 @@ module RuboCop
   module Cop
     module Sorbet
       class ForbidSuperclassConstLiteral < RuboCop::Cop::Cop
-        MSG = 'Superclasses must only contain constant literals'
+        MSG = "Superclasses must only contain constant literals"
 
         def_node_matcher :not_lit_const_superclass?, <<-PATTERN
           (class

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop disallows using `T.unsafe` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.unsafe(foo)
+      #
+      #   # good
+      #   foo
+      class ForbidTUnsafe < RuboCop::Cop::Cop
+        def_node_matcher(:t_unsafe?, "(send (const nil? :T) :unsafe _)")
+
+        def on_send(node)
+          add_offense(node, message: "Do not use `T.unsafe`.") if t_unsafe?(node)
+        end
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # encoding: utf-8
 # frozen_string_literal: true
 
-require 'rubocop'
+require "rubocop"
 
 module RuboCop
   module Cop
@@ -23,7 +23,7 @@ module RuboCop
       #     prop :bar, T.nilable(String)
       #   end
       class ForbidUntypedStructProps < RuboCop::Cop::Cop
-        MSG = 'Struct props cannot be T.untyped'
+        MSG = "Struct props cannot be T.untyped"
 
         def_node_matcher :t_struct, <<~PATTERN
           (const (const nil? :T) :Struct)

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

@@ -0,0 +1,75 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop ensures one ancestor per requires_ancestor line
+      # rather than chaining them as a comma-separated list.
+      #
+      # @example
+      #
+      #   # bad
+      #   module SomeModule
+      #     requires_ancestor Kernel, Minitest::Assertions
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     requires_ancestor Kernel
+      #     requires_ancestor Minitest::Assertions
+      #   end
+      class OneAncestorPerLine < RuboCop::Cop::Cop
+        MSG = "Cannot require more than one ancestor per line"
+
+        def_node_search :requires_ancestors, <<~PATTERN
+          (send nil? :requires_ancestor ...)
+        PATTERN
+
+        def_node_matcher :more_than_one_ancestor, <<~PATTERN
+          (send nil? :requires_ancestor const const+)
+        PATTERN
+
+        def_node_search :abstract?, <<~PATTERN
+          (send nil? :abstract!)
+        PATTERN
+
+        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
+            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)
+          end
+        end
+
+        private
+
+        def process_node(node)
+          requires_ancestors(node).each do |ra|
+            add_offense(ra.child_nodes[1]) if more_than_one_ancestor(ra)
+          end
+        end
+
+        def new_ra_line(indent_count)
+          indents = " " * indent_count
+          indented_ra_call = "#{indents}requires_ancestor "
+          "\n#{indented_ra_call}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop ensures RBI shims do not include a call to extend T::Sig
+      # or to extend T::Helpers
+      #
+      # @example
+      #
+      #   # bad
+      #   module SomeModule
+      #     extend T::Sig
+      #     extend T::Helpers
+      #
+      #     sig { returns(String) }
+      #     def foo; end
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     sig { returns(String) }
+      #     def foo; end
+      #   end
+      class ForbidExtendTSigHelpersInShims < RuboCop::Cop::Cop
+        include RangeHelp
+
+        MSG = "Extending T::Sig or T::Helpers in a shim is unnecessary"
+        RESTRICT_ON_SEND = [:extend]
+
+        def_node_matcher :extend_t_sig?, <<~PATTERN
+          (send nil? :extend (const (const nil? :T) :Sig))
+        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)
+        end
+      end
+    end
+  end
+end