rubocop-sorbet 0.3.6 → 0.5.1

data/lib/rubocop-sorbet.rb

@@ -1,3 +1,11 @@
 # frozen_string_literal: true
 
-require 'rubocop_sorbet'
+require 'rubocop'
+
+require_relative 'rubocop/sorbet'
+require_relative 'rubocop/sorbet/version'
+require_relative 'rubocop/sorbet/inject'
+
+RuboCop::Sorbet::Inject.defaults!
+
+require_relative 'rubocop/cop/sorbet_cops'

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

@@ -17,7 +17,7 @@ module RuboCop
       #   FooOrBar = T.type_alias { T.any(Foo, Bar) }
       class BindingConstantWithoutTypeAlias < RuboCop::Cop::Cop
         def_node_matcher(:binding_unaliased_type?, <<-PATTERN)
-          (casgn _ _ [#not_nil? #not_t_let? #method_needing_aliasing_on_t?])
+          (casgn _ _ [#not_nil? #not_t_let? #not_dynamic_type_creation_with_block? #not_generic_parameter_decl? #method_needing_aliasing_on_t?])
         PATTERN
 
         def_node_matcher(:using_type_alias?, <<-PATTERN)
@@ -48,6 +48,21 @@ module RuboCop
           )
         PATTERN
 
+        def_node_matcher(:dynamic_type_creation_with_block?, <<-PATTERN)
+          (block
+            (send
+              const :new ...)
+              _
+              _
+          )
+        PATTERN
+
+        def_node_matcher(:generic_parameter_decl?, <<-PATTERN)
+          (
+            send nil? {:type_template :type_member} ...
+          )
+        PATTERN
+
         def_node_search(:method_needing_aliasing_on_t?, <<-PATTERN)
           (
             send
@@ -61,6 +76,14 @@ module RuboCop
           !t_let?(node)
         end
 
+        def not_dynamic_type_creation_with_block?(node)
+          !dynamic_type_creation_with_block?(node)
+        end
+
+        def not_generic_parameter_decl?(node)
+          !generic_parameter_decl?(node)
+        end
+
         def not_nil?(node)
           !node.nil?
         end

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

@@ -14,15 +14,6 @@ require 'rubocop'
 # end
 # ```
 #
-# This cop replaces them by:
-#
-# ```ruby
-# class MyClass
-#   MyClassInclude = send_expr
-#   include MyClassInclude
-# end
-# ```
-#
 # Multiple occurences of this can be found in Shopify's code base like:
 #
 # ```ruby
@@ -61,37 +52,6 @@ module RuboCop
           return unless [:module, :class, :sclass].include?(parent.type)
           add_offense(node)
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            # Find parent class node
-            parent = node.parent
-            parent = parent.parent if parent.type == :begin
-
-            # Build include variable name
-            class_name = (parent.child_nodes.first.const_name || 'Anon').split('::').last
-            include_name = find_free_name("#{class_name}Include")
-            used_names << include_name
-
-            # Apply fix
-            indent = ' ' * node.loc.column
-            fix = "#{include_name} = #{node.child_nodes.first.source}\n#{indent}"
-            corrector.insert_before(node.loc.expression, fix)
-            corrector.replace(node.child_nodes.first.loc.expression, include_name)
-          end
-        end
-
-        # Find a free local variable name
-        #
-        # Since each include uses its own local variable to store the send result,
-        # we need to ensure that we don't use the same name twice in the same
-        # module.
-        def find_free_name(base_name)
-          return base_name unless used_names.include?(base_name)
-          i = 2
-          i += 1 while used_names.include?("#{base_name}#{i}")
-          "#{base_name}#{i}"
-        end
       end
     end
   end

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

@@ -12,13 +12,6 @@ require 'rubocop'
 # class Foo < send_expr; end
 # ```
 #
-# This cop replaces them by:
-#
-# ```ruby
-# FooParent = send_expr
-# class Foo < FooParent; end
-# ```
-#
 # Multiple occurences of this can be found in Shopify's code base like:
 #
 # ```ruby
@@ -46,16 +39,6 @@ module RuboCop
           return unless not_lit_const_superclass?(node)
           add_offense(node.child_nodes[1])
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            class_name = node.parent.child_nodes.first.const_name
-            parent_name = "#{class_name}Parent"
-            indent = ' ' * node.parent.loc.column
-            corrector.insert_before(node.parent.loc.expression, "#{parent_name} = #{node.source}\n#{indent}")
-            corrector.replace(node.loc.expression, parent_name)
-          end
-        end
       end
     end
   end

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

@@ -0,0 +1,58 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'rubocop'
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # This cop disallows use of `T.untyped` or `T.nilable(T.untyped)`
+      # as a prop type for `T::Struct`.
+      #
+      # @example
+      #
+      #   # bad
+      #   class SomeClass
+      #     const :foo, T.untyped
+      #     prop :bar, T.nilable(T.untyped)
+      #   end
+      #
+      #   # good
+      #   class SomeClass
+      #     const :foo, Integer
+      #     prop :bar, T.nilable(String)
+      #   end
+      class ForbidUntypedStructProps < RuboCop::Cop::Cop
+        MSG = 'Struct props cannot be T.untyped'
+
+        def_node_matcher :t_struct, <<~PATTERN
+          (const (const nil? :T) :Struct)
+        PATTERN
+
+        def_node_matcher :t_untyped, <<~PATTERN
+          (send (const nil? :T) :untyped)
+        PATTERN
+
+        def_node_matcher :t_nilable_untyped, <<~PATTERN
+          (send (const nil? :T) :nilable {#t_untyped #t_nilable_untyped})
+        PATTERN
+
+        def_node_matcher :subclass_of_t_struct?, <<~PATTERN
+          (class (const ...) #t_struct ...)
+        PATTERN
+
+        def_node_search :untyped_props, <<~PATTERN
+          (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])
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -28,6 +28,8 @@ module RuboCop
       # Only `typed`, `(en)?coding`, `warn_indent` and `frozen_string_literal` magic comments are considered,
       # other comments or magic comments are left in the same place.
       class EnforceSigilOrder < ValidSigil
+        include RangeHelp
+
         def investigate(processed_source)
           return if processed_source.tokens.empty?
 
@@ -49,6 +51,14 @@ module RuboCop
             tokens.each_with_index do |token, index|
               corrector.replace(token.pos, expected[index].text)
             end
+
+            # Remove blank lines between the magic comments
+            lines = tokens.map(&:line).to_set
+            (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
         end
 
@@ -59,8 +69,8 @@ module RuboCop
         FROZEN_REGEX = /#\s+frozen_string_literal:(?:\s+([\w]+))?/
 
         PREFERRED_ORDER = {
-          SIGIL_REGEX => 'typed',
           CODING_REGEX => 'encoding',
+          SIGIL_REGEX => 'typed',
           INDENT_REGEX => 'warn_indent',
           FROZEN_REGEX => 'frozen_string_literal',
         }.freeze

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

@@ -37,7 +37,12 @@ module RuboCop
 
             token = processed_source.tokens.first
             replace_with = suggested_strictness_level(minimum_strictness, suggested_strictness)
-            corrector.insert_before(token.pos, "# typed: #{replace_with}\n")
+            sigil = "# typed: #{replace_with}"
+            if token.text.start_with?("#!") # shebang line
+              corrector.insert_after(token.pos, "\n#{sigil}")
+            else
+              corrector.insert_before(token.pos, "#{sigil}\n")
+            end
           end
         end
 

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

@@ -26,13 +26,9 @@ module RuboCop
 
         def on_signature(node)
           sig_params = signature_params(node).first
-          sig_params_order =
-            if sig_params.nil?
-              []
-            else
-              sig_params.arguments.first.keys.map(&:value)
-            end
 
+          sig_params_order = extract_parameters(sig_params)
+          return if sig_params_order.nil?
           method_node = node.parent.children[node.sibling_index + 1]
           return if method_node.nil? || method_node.type != :def
           method_parameters = method_node.arguments
@@ -42,6 +38,18 @@ module RuboCop
 
         private
 
+        def extract_parameters(sig_params)
+          return [] if sig_params.nil?
+
+          arguments = sig_params.arguments.first
+          return arguments.keys.map(&:value) if RuboCop::AST::HashNode === arguments
+
+          add_offense(
+            sig_params,
+            message: "Invalid signature."
+          )
+        end
+
         def check_for_inconsistent_param_ordering(sig_params_order, parameters)
           parameters.each_with_index do |param, index|
             param_name = param.children[0]

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

@@ -55,9 +55,9 @@ module RuboCop
           return nil unless can_autocorrect?
 
           lambda do |corrector|
-            nodes = call_chain(node).sort_by { |call| ORDER[call.method_name] }
-            tree =
-              nodes.reduce(nil) do |receiver, caller|
+            tree = call_chain(node_with_index_sends(node))
+              .sort_by { |call| ORDER[call.method_name] }
+              .reduce(nil) do |receiver, caller|
                 caller.updated(nil, [receiver] + caller.children.drop(1))
               end
 
@@ -70,6 +70,16 @@ module RuboCop
 
         private
 
+        def node_with_index_sends(node)
+          # This is really dirty hack to reparse the current node with index send
+          # emitting enabled, which is necessary to unparse them back as index accessors.
+          emit_index_value = RuboCop::AST::Builder.emit_index
+          RuboCop::AST::Builder.emit_index = true
+          RuboCop::AST::ProcessedSource.new(node.source, target_ruby_version, processed_source.path).ast
+        ensure
+          RuboCop::AST::Builder.emit_index = emit_index_value
+        end
+
         def can_autocorrect?
           defined?(::Unparser)
         end

data/lib/rubocop/cop/sorbet_cops.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require_relative 'sorbet/binding_constants_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/signatures/allow_incompatible_override'
+require_relative 'sorbet/signatures/checked_true_in_signature'
+require_relative 'sorbet/signatures/keyword_argument_ordering'
+require_relative 'sorbet/signatures/parameters_ordering_in_signature'
+require_relative 'sorbet/signatures/signature_build_order'
+require_relative 'sorbet/signatures/enforce_signatures'
+
+require_relative 'sorbet/sigils/valid_sigil'
+require_relative 'sorbet/sigils/has_sigil'
+require_relative 'sorbet/sigils/ignore_sigil'
+require_relative 'sorbet/sigils/false_sigil'
+require_relative 'sorbet/sigils/true_sigil'
+require_relative 'sorbet/sigils/strict_sigil'
+require_relative 'sorbet/sigils/strong_sigil'
+require_relative 'sorbet/sigils/enforce_sigil_order'

data/lib/rubocop/sorbet.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+require "rubocop/sorbet/version"
+require "yaml"
+
+module RuboCop
+  module Sorbet
+    class Error < StandardError; end
+
+    PROJECT_ROOT   = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join('config', 'default.yml').freeze
+    CONFIG         = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end

data/lib/rubocop/sorbet/inject.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# The original code is from https://github.com/rubocop-hq/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
+# See https://github.com/rubocop-hq/rubocop-rspec/blob/master/MIT-LICENSE.md
+module RuboCop
+  module Sorbet
+    # 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)
+      end
+    end
+  end
+end

data/lib/rubocop/sorbet/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module RuboCop
+  module Sorbet
+    VERSION = "0.5.1"
+  end
+end

data/manual/cops.md

@@ -0,0 +1,29 @@
+## Available cops
+
+In the following section you find all available cops:
+
+<!-- START_COP_LIST -->
+#### Department [Sorbet](cops_sorbet.md)
+
+* [Sorbet/AllowIncompatibleOverride](cops_sorbet.md#sorbetallowincompatibleoverride)
+* [Sorbet/BindingConstantWithoutTypeAlias](cops_sorbet.md#sorbetbindingconstantwithouttypealias)
+* [Sorbet/CheckedTrueInSignature](cops_sorbet.md#sorbetcheckedtrueinsignature)
+* [Sorbet/ConstantsFromStrings](cops_sorbet.md#sorbetconstantsfromstrings)
+* [Sorbet/EnforceSigilOrder](cops_sorbet.md#sorbetenforcesigilorder)
+* [Sorbet/EnforceSignatures](cops_sorbet.md#sorbetenforcesignatures)
+* [Sorbet/FalseSigil](cops_sorbet.md#sorbetfalsesigil)
+* [Sorbet/ForbidIncludeConstLiteral](cops_sorbet.md#sorbetforbidincludeconstliteral)
+* [Sorbet/ForbidSuperclassConstLiteral](cops_sorbet.md#sorbetforbidsuperclassconstliteral)
+* [Sorbet/ForbidUntypedStructProps](cops_sorbet.md#sorbetforbiduntypedstructprops)
+* [Sorbet/HasSigil](cops_sorbet.md#sorbethassigil)
+* [Sorbet/IgnoreSigil](cops_sorbet.md#sorbetignoresigil)
+* [Sorbet/KeywordArgumentOrdering](cops_sorbet.md#sorbetkeywordargumentordering)
+* [Sorbet/ParametersOrderingInSignature](cops_sorbet.md#sorbetparametersorderinginsignature)
+* [Sorbet/SignatureBuildOrder](cops_sorbet.md#sorbetsignaturebuildorder)
+* [Sorbet/SignatureCop](cops_sorbet.md#sorbetsignaturecop)
+* [Sorbet/StrictSigil](cops_sorbet.md#sorbetstrictsigil)
+* [Sorbet/StrongSigil](cops_sorbet.md#sorbetstrongsigil)
+* [Sorbet/TrueSigil](cops_sorbet.md#sorbettruesigil)
+* [Sorbet/ValidSigil](cops_sorbet.md#sorbetvalidsigil)
+
+<!-- END_COP_LIST -->

data/manual/cops_sorbet.md

@@ -0,0 +1,340 @@
+# Sorbet
+
+## Sorbet/AllowIncompatibleOverride
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop 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
+from occurring.
+
+### Examples
+
+```ruby
+# bad
+sig.override(allow_incompatible: true)
+
+# good
+sig.override
+```
+
+## Sorbet/BindingConstantWithoutTypeAlias
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.2.0 | -
+
+This cop disallows binding the return value of `T.any`, `T.all`, `T.enum`
+to a constant directly. To bind the value, one must use `T.type_alias`.
+
+### Examples
+
+```ruby
+# bad
+FooOrBar = T.any(Foo, Bar)
+
+# good
+FooOrBar = T.type_alias { T.any(Foo, Bar) }
+```
+
+## Sorbet/CheckedTrueInSignature
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop 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
+be redundant; only `checked(false)` or `soft` would change the behaviour.
+
+### Examples
+
+```ruby
+# bad
+sig { void.checked(true) }
+
+# good
+sig { void }
+```
+
+## Sorbet/ConstantsFromStrings
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop disallows the calls that are used to get constants fom Strings
+such as +constantize+, +const_get+, and +constants+.
+
+The goal of this cop is to make the code easier to statically analyze,
+more IDE-friendly, and more predictable. It leads to code that clearly
+expresses which values the constant can have.
+
+### Examples
+
+```ruby
+# bad
+class_name.constantize
+
+# bad
+constants.detect { |c| c.name == "User" }
+
+# bad
+const_get(class_name)
+
+# good
+case class_name
+when "User"
+  User
+else
+  raise ArgumentError
+end
+
+# good
+{ "User" => User }.fetch(class_name)
+```
+
+## Sorbet/EnforceSigilOrder
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.4 | -
+
+This cop checks that the Sorbet sigil comes as the first magic comment in the file.
+
+The expected order for magic comments is: typed, (en)?coding, warn_indent then frozen_string_literal.
+
+For example, the following bad ordering:
+
+```ruby
+# frozen_string_literal: true
+# typed: true
+class Foo; end
+```
+
+Will be corrected as:
+
+```ruby
+# typed: true
+# frozen_string_literal: true
+class Foo; end
+```
+
+Only `typed`, `(en)?coding`, `warn_indent` and `frozen_string_literal` magic comments are considered,
+other comments or magic comments are left in the same place.
+
+## Sorbet/EnforceSignatures
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.4 | -
+
+This cop checks that every method definition and attribute accessor has a Sorbet signature.
+
+It also suggest an autocorrect with placeholders so the following code:
+
+```
+def foo(a, b, c); end
+```
+
+Will be corrected as:
+
+```
+sig { params(a: T.untyped, b: T.untyped, c: T.untyped).returns(T.untyped)
+def foo(a, b, c); end
+```
+
+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')
+
+## Sorbet/FalseSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `false` sigil mandatory in all files.
+
+### Configurable attributes
+
+Name | Default value | Configurable values
+--- | --- | ---
+SuggestedStrictness | `true` | Boolean
+Include | `**/*.rb`, `**/*.rbi`, `**/*.rake`, `**/*.ru` | Array
+Exclude | `bin/**/*`, `db/**/*.rb`, `script/**/*` | Array
+
+## Sorbet/ForbidIncludeConstLiteral
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No  | 0.2.0 | 0.5.0
+
+No documentation
+
+## Sorbet/ForbidSuperclassConstLiteral
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No  | 0.2.0 | 0.5.0
+
+No documentation
+
+## Sorbet/ForbidUntypedStructProps
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.3.8 | -
+
+This cop disallows use of `T.untyped` or `T.nilable(T.untyped)`
+as a prop type for `T::Struct`.
+
+### Examples
+
+```ruby
+# bad
+class SomeClass
+  const :foo, T.untyped
+  prop :bar, T.nilable(T.untyped)
+end
+
+# good
+class SomeClass
+  const :foo, Integer
+  prop :bar, T.nilable(String)
+end
+```
+
+## Sorbet/HasSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet typed sigil mandatory in all files.
+
+Options:
+
+* `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
+
+If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.
+
+## Sorbet/IgnoreSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `ignore` sigil mandatory in all files.
+
+## Sorbet/KeywordArgumentOrdering
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop 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.
+
+### Examples
+
+```ruby
+# bad
+sig { params(a: Integer, b: String).void }
+def foo(a: 1, b:); end
+
+# good
+sig { params(b: String, a: Integer).void }
+def foo(b:, a: 1); end
+```
+
+## Sorbet/ParametersOrderingInSignature
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | 0.2.0 | -
+
+This cop checks for inconsistent ordering of parameters between the
+signature and the method definition. The sorbet-runtime gem raises
+when such inconsistency occurs.
+
+### Examples
+
+```ruby
+# bad
+sig { params(a: Integer, b: String).void }
+def foo(b:, a:); end
+
+# good
+sig { params(a: Integer, b: String).void }
+def foo(a:, b:); end
+```
+
+## Sorbet/SignatureBuildOrder
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.0 | -
+
+No documentation
+
+## Sorbet/SignatureCop
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | No | - | -
+
+Abstract cop specific to Sorbet signatures
+
+You can subclass it to use the `on_signature` trigger and the `signature?` node matcher.
+
+## Sorbet/StrictSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `strict` sigil mandatory in all files.
+
+## Sorbet/StrongSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `strong` sigil mandatory in all files.
+
+## Sorbet/TrueSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | Yes  | 0.3.3 | -
+
+This cop makes the Sorbet `true` sigil mandatory in all files.
+
+## Sorbet/ValidSigil
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Enabled | Yes | Yes  | 0.3.3 | -
+
+This cop checks that every Ruby file contains a valid Sorbet sigil.
+Adapted from: https://gist.github.com/clarkdave/85aca4e16f33fd52aceb6a0a29936e52
+
+Options:
+
+* `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
+
+If a `MinimumStrictness` level is specified, it will be used in offense messages and autocorrect.