Merge pull request #340 from Shopify/at-inline-assertions-cops

Add cops to forbid usages of `T.` inline assertions and annotations

Author: Morriar

config/default.yml

@@ -171,6 +171,36 @@ Sorbet/ForbidTStruct:
   VersionAdded: 0.7.4
   Safe: false
 
+Sorbet/ForbidTAbsurd:
+  Description: 'Forbid usage of T.absurd.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTBind:
+  Description: 'Forbid usage of T.bind.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTCast:
+  Description: 'Forbid usage of T.cast.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTLet:
+  Description: 'Forbid usage of T.let.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTMust:
+  Description: 'Forbid usage of T.must.'
+  Enabled: false
+  VersionAdded: <<next>>
+
+Sorbet/ForbidTTypeAlias:
+  Description: 'Forbid usage of T.type_alias.'
+  Enabled: false
+  VersionAdded: <<next>>
+
 Sorbet/ForbidTUnsafe:
   Description: 'Forbid usage of T.unsafe.'
   Enabled: false

lib/rubocop/cop/sorbet/forbid_t_absurd.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.absurd` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.absurd(foo)
+      #
+      #   # good
+      #   x #: absurd
+      class ForbidTAbsurd < RuboCop::Cop::Base
+        MSG = "Do not use `T.absurd`."
+        RESTRICT_ON_SEND = [:absurd].freeze
+
+        # @!method t_absurd?(node)
+        def_node_matcher(:t_absurd?, "(send (const nil? :T) :absurd _)")
+
+        def on_send(node)
+          add_offense(node) if t_absurd?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

lib/rubocop/cop/sorbet/forbid_t_bind.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.bind` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.bind(self, Integer)
+      #
+      #   # good
+      #   #: self as Integer
+      class ForbidTBind < RuboCop::Cop::Base
+        MSG = "Do not use `T.bind`."
+        RESTRICT_ON_SEND = [:bind].freeze
+
+        # @!method t_bind?(node)
+        def_node_matcher(:t_bind?, "(send (const nil? :T) :bind _ _)")
+
+        def on_send(node)
+          add_offense(node) if t_bind?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

lib/rubocop/cop/sorbet/forbid_t_cast.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.cast` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.cast(foo, Integer)
+      #
+      #   # good
+      #   foo #: as Integer
+      class ForbidTCast < RuboCop::Cop::Base
+        MSG = "Do not use `T.cast`."
+        RESTRICT_ON_SEND = [:cast].freeze
+
+        # @!method t_cast?(node)
+        def_node_matcher(:t_cast?, "(send (const nil? :T) :cast _ _)")
+
+        def on_send(node)
+          add_offense(node) if t_cast?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

lib/rubocop/cop/sorbet/forbid_t_let.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.let` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.let(foo, Integer)
+      #
+      #   # good
+      #   foo #: Integer
+      class ForbidTLet < RuboCop::Cop::Base
+        MSG = "Do not use `T.let`."
+        RESTRICT_ON_SEND = [:let].freeze
+
+        # @!method t_let?(node)
+        def_node_matcher(:t_let?, "(send (const nil? :T) :let _ _)")
+
+        def on_send(node)
+          add_offense(node) if t_let?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

lib/rubocop/cop/sorbet/forbid_t_must.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.must` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   T.must(foo)
+      #
+      #   # good
+      #   foo #: as !nil
+      class ForbidTMust < RuboCop::Cop::Base
+        MSG = "Do not use `T.must`."
+        RESTRICT_ON_SEND = [:must].freeze
+
+        # @!method t_must?(node)
+        def_node_matcher(:t_must?, "(send (const nil? :T) :must _)")
+
+        def on_send(node)
+          add_offense(node) if t_must?(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

lib/rubocop/cop/sorbet/forbid_t_type_alias.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+module RuboCop
+  module Cop
+    module Sorbet
+      # Disallows using `T.type_alias` anywhere.
+      #
+      # @example
+      #
+      #   # bad
+      #   STRING_OR_INTEGER = T.type_alias { T.any(Integer, String) }
+      #
+      #   # good
+      #   #: type string_or_integer = Integer | String
+      class ForbidTTypeAlias < RuboCop::Cop::Base
+        MSG = "Do not use `T.type_alias`."
+
+        # @!method t_type_alias?(node)
+        def_node_matcher(:t_type_alias?, "(block (call (const nil? :T) :type_alias) _ _)")
+
+        def on_block(node)
+          add_offense(node) if t_type_alias?(node)
+        end
+        alias_method :on_numblock, :on_block
+      end
+    end
+  end
+end

lib/rubocop/cop/sorbet_cops.rb

@@ -14,8 +14,14 @@
 require_relative "sorbet/forbid_untyped_struct_props"
 require_relative "sorbet/implicit_conversion_method"
 require_relative "sorbet/callback_conditionals_binding"
+require_relative "sorbet/forbid_t_absurd"
+require_relative "sorbet/forbid_t_bind"
+require_relative "sorbet/forbid_t_cast"
 require_relative "sorbet/forbid_t_enum"
+require_relative "sorbet/forbid_t_let"
+require_relative "sorbet/forbid_t_must"
 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_extend_t_sig"

manual/cops.md

@@ -27,8 +27,14 @@ In the following section you find all available cops:
 * [Sorbet/ForbidSigWithRuntime](cops_sorbet.md#sorbetforbidsigwithruntime)
 * [Sorbet/ForbidSigWithoutRuntime](cops_sorbet.md#sorbetforbidsigwithoutruntime)
 * [Sorbet/ForbidSuperclassConstLiteral](cops_sorbet.md#sorbetforbidsuperclassconstliteral)
+* [Sorbet/ForbidTAbsurd](cops_sorbet.md#sorbetforbidtabsurd)
+* [Sorbet/ForbidTBind](cops_sorbet.md#sorbetforbidtbind)
+* [Sorbet/ForbidTCast](cops_sorbet.md#sorbetforbidtcast)
 * [Sorbet/ForbidTEnum](cops_sorbet.md#sorbetforbidtenum)
+* [Sorbet/ForbidTLet](cops_sorbet.md#sorbetforbidtlet)
+* [Sorbet/ForbidTMust](cops_sorbet.md#sorbetforbidtmust)
 * [Sorbet/ForbidTStruct](cops_sorbet.md#sorbetforbidtstruct)
+* [Sorbet/ForbidTTypeAlias](cops_sorbet.md#sorbetforbidttypealias)
 * [Sorbet/ForbidTUnsafe](cops_sorbet.md#sorbetforbidtunsafe)
 * [Sorbet/ForbidTUntyped](cops_sorbet.md#sorbetforbidtuntyped)
 * [Sorbet/ForbidTypeAliasedShapes](cops_sorbet.md#sorbetforbidtypealiasedshapes)

manual/cops_sorbet.md

@@ -632,6 +632,60 @@ Name | Default value | Configurable values
 --- | --- | ---
 Exclude | `db/migrate/*.rb` | Array
 
+## Sorbet/ForbidTAbsurd
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.absurd` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.absurd(foo)
+
+# good
+x #: absurd
+```
+
+## Sorbet/ForbidTBind
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.bind` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.bind(self, Integer)
+
+# good
+#: self as Integer
+```
+
+## Sorbet/ForbidTCast
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.cast` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.cast(foo, Integer)
+
+# good
+foo #: as Integer
+```
+
 ## Sorbet/ForbidTEnum
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -659,6 +713,42 @@ class MyEnum
 end
 ```
 
+## Sorbet/ForbidTLet
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.let` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.let(foo, Integer)
+
+# good
+foo #: Integer
+```
+
+## Sorbet/ForbidTMust
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.must` anywhere.
+
+### Examples
+
+```ruby
+# bad
+T.must(foo)
+
+# good
+foo #: as !nil
+```
+
 ## Sorbet/ForbidTStruct
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
@@ -698,6 +788,24 @@ class MyStruct
 end
 ```
 
+## Sorbet/ForbidTTypeAlias
+
+Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged
+--- | --- | --- | --- | ---
+Disabled | Yes | No | <<next>> | -
+
+Disallows using `T.type_alias` anywhere.
+
+### Examples
+
+```ruby
+# bad
+STRING_OR_INTEGER = T.type_alias { T.any(Integer, String) }
+
+# good
+#: type string_or_integer = Integer | String
+```
+
 ## Sorbet/ForbidTUnsafe
 
 Enabled by default | Safe | Supports autocorrection | VersionAdded | VersionChanged