type_toolkit 0.0.4 → 0.0.6

data/sorbet/rbi/shims/core.rbi

@@ -0,0 +1,19 @@
+# typed: strict
+# frozen_string_literal: true
+
+# A shim module representing (a subset of) the common interface between Method and UnboundMethod.
+module MethodOrUnboundMethod
+  sig { returns(T::Module[T.untyped]) }
+  def owner; end
+
+  sig { returns(Symbol) }
+  def name; end
+end
+
+class Method
+  include MethodOrUnboundMethod
+end
+
+class UnboundMethod
+  include MethodOrUnboundMethod
+end

data/sorbet/rbi/shims/minitest.rbi

@@ -35,9 +35,12 @@ module Minitest
       def it(desc = T.unsafe(nil), &block); end
 
       sig do
-        params(block: T.proc.bind(T.attached_class).void).void
+        params(
+          type: T.anything,
+          block: T.proc.bind(T.attached_class).void,
+        ).void
       end
-      def before(&block); end
+      def before(type = T.unsafe(nil), &block); end
     end
   end
 end

data/spec/interface_spec.rb

@@ -0,0 +1,405 @@
+# typed: ignore
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module TypeToolkit
+  class InterfaceSpec < Minitest::Spec
+    module SimpleInterface
+      interface!
+
+      abstract def m1 = assert_never_called!
+      abstract def m2 = assert_never_called!
+    end
+
+    # A normal class that's completely unrelated `SimpleInterface`.
+    class NonImpl
+      def m1 = "NonImpl#m1"
+      # Does not implement `m2`
+    end
+
+    # A class that implements some but not all of the SimpleInterface's abstract methods.
+    class PartialImpl
+      include SimpleInterface
+
+      def m1 = "PartialImpl#m1"
+      # Does not provide an implementation for `m2`
+    end
+
+    # A class that implements all of the SimpleInterface's abstract methods.
+    class FullImpl
+      include SimpleInterface
+
+      def initialize
+        @a = 1
+        @b = 2
+      end
+
+      def m1 = "FullImpl#m1"
+      def m2 = "FullImpl#m2"
+    end
+
+    # A class that provides a partial implementation of `SimpleInterface` for `PartiallyInheritsItsImpl`.
+    class PartialParent
+      def m1 = "PartialParent#m1"
+      # Does not implement `m2`
+    end
+
+    # A class that implements all of the SimpleInterface's abstract methods, some via inheritance, and some via direct implementation.
+    class PartiallyInheritsItsImpl < PartialParent
+      include SimpleInterface
+
+      def m2 = "PartiallyInheritsItsImpl#m2"
+    end
+
+    describe "An interface" do
+      describe ".abstract macro" do
+        it "returns the method name" do
+          test_context = self
+
+          Module.new do
+            interface!
+
+            test_context.assert_equal(:the_method_name, abstract(def the_method_name; end))
+          end
+        end
+
+        it "raises when it sees a different method name than what MethodDefRecorder recorded" do
+          error = assert_raises(RuntimeError) do
+            Module.new do
+              interface!
+
+              # Simulate a conflicting `method_added` call by sneaking in a method definition
+              # between the `def` and the `abstract` call.
+              def m1; end
+
+              def something_else; end
+
+              abstract(:m1)
+            end
+          end
+
+          # Do not rely on this message content! Its content is subject to change!
+          assert_equal <<~EXPECTED.chomp, error.message
+            `abstract` expected to see `#m1`, but the last recorded method was called `something_else`.
+            This can happen when `abstract` is combined with other metaprogramming.
+            If you think this is a bug, please open an issue: https://github.com/Shopify/type_toolkit/issues
+          EXPECTED
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "contains all declared abstract methods" do
+          assert_equal [:m1, :m2], SimpleInterface.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], SimpleInterface.declared_abstract_instance_methods(true)
+          assert_equal [:m1, :m2], SimpleInterface.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "only contains unimplemented abstract methods" do
+          assert_equal [:m1, :m2], SimpleInterface.abstract_instance_methods
+          assert_equal [:m1, :m2], SimpleInterface.abstract_instance_methods(true)
+          assert_equal [:m1, :m2], SimpleInterface.abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns true for abstract methods" do
+          assert SimpleInterface.abstract_method?(:m1)
+          assert SimpleInterface.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute SimpleInterface.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "returns true for abstract methods" do
+          assert SimpleInterface.abstract_method_declared?(:m1)
+          assert SimpleInterface.abstract_method_declared?(:m2)
+        end
+      end
+    end
+
+    describe "A class that does not implement the interface" do
+      describe "a method with the same name as another interface's members" do
+        # These tests sanity-check that our runtime trickery didn't accidentally change the
+        # normal behaviour of method calling and `method_missing` for unrelated classes.
+
+        before do
+          @class = NonImpl
+          @x = NonImpl.new
+        end
+
+        it "#respond_to? returns true" do
+          assert_respond_to @x, :m1
+        end
+
+        it "can be called like normal" do
+          assert_equal "NonImpl#m1", @x.m1
+        end
+
+        describe "a Method object for it" do
+          it "can be called like normal" do
+            assert_equal "NonImpl#m1", @x.method(:m1).call
+          end
+
+          it "is not abstract" do
+            refute_predicate @x.method(:m1), :abstract?
+          end
+        end
+
+        describe "an UnboundMethod object for it" do
+          before { @um = @x.method(:m1).unbind }
+          it "can be called like normal" do
+            assert_equal "NonImpl#m1", @um.bind_call(@x)
+          end
+
+          it "is not abstract" do
+            refute_predicate @um, :abstract?
+          end
+        end
+
+        it "calls a defined method like normal" do
+          assert_respond_to @x, :m1
+          assert_equal "NonImpl#m1", @x.m1
+          assert_equal "NonImpl#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+        end
+
+        it "raises NoMethodError for an undefined method like normal" do
+          refute_respond_to @x, :m2
+          assert_raises(NoMethodError) { @x.m2 }
+        end
+      end
+
+      it "does not respond to .abstract_method?" do
+        refute_respond_to @class, :abstract_method?
+        assert_raises(NoMethodError) { @class.abstract_method?(:m1) }
+      end
+
+      it "does not respond to .abstract_method_declared?" do
+        refute_respond_to @class, :abstract_method_declared?
+        assert_raises(NoMethodError) { @class.abstract_method_declared?(:m1) }
+      end
+
+      it "does not respond to .declared_abstract_instance_methods" do
+        refute_respond_to @class, :declared_abstract_instance_methods
+        assert_raises(NoMethodError) { @class.declared_abstract_instance_methods }
+      end
+
+      it "does not respond to .abstract_instance_methods" do
+        refute_respond_to @class, :abstract_instance_methods
+        assert_raises(NoMethodError) { @class.abstract_instance_methods }
+      end
+    end
+
+    describe "A class that partially implements the interface" do
+      before do
+        @class = PartialImpl
+        @x = PartialImpl.new
+      end
+
+      describe "calling an implemented abstract method" do
+        it "calls the concrete implementation" do
+          assert_respond_to @x, :m1
+          assert_equal "PartialImpl#m1", @x.m1
+          assert_equal "PartialImpl#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+        end
+      end
+
+      describe "calling an unimplemented abstract method" do
+        it "raises AbstractMethodNotImplementedError" do
+          assert_respond_to @x, :m2
+
+          # Notice it's not `NoMethodError`, so we can give a better error message.
+          e = assert_abstract { @x.m2 }
+
+          # Do not rely on this message content! Its content is subject to change!
+          # We only test it to ensure it's formatted correctly.
+          assert_equal "Abstract method `#m2` was never implemented.", e.message
+
+          m2 = @x.method(:m2)
+          assert_kind_of Method, m2
+          assert_predicate m2, :abstract?
+          assert_predicate m2.unbind, :abstract?
+        end
+      end
+
+      describe "calling a non-abstract method" do
+        it "calls the concrete implementation" do
+          assert_respond_to @x, :inspect
+          assert_kind_of String, @x.inspect
+          assert_kind_of String, @x.method(:inspect).call
+          refute_predicate @x.method(:inspect), :abstract?
+          refute_predicate @x.method(:inspect).unbind, :abstract?
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns false for abstract methods that have been implemented" do
+          refute @class.abstract_method?(:m1)
+        end
+
+        it "returns true for abstract methods that have not been implemented" do
+          assert @class.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute @class.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "is true for all abstract methods" do
+          assert @class.abstract_method_declared?(:m1) # Even the one that's been implemented
+          assert @class.abstract_method_declared?(:m2)
+        end
+
+        it "is false for non-abstract methods" do
+          assert @class.public_method_defined?(:inspect) # precondition
+          refute @class.abstract_method_declared?(:inspect)
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "returns all declared abstract methods, even those that have been implemented" do
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods(true)
+          assert_equal [], @class.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "returns only unimplemented abstract methods" do
+          assert_equal [:m2], @class.abstract_instance_methods
+          assert_equal [:m2], @class.abstract_instance_methods(true)
+          assert_equal [], @class.abstract_instance_methods(false)
+        end
+      end
+    end
+
+    describe "A class that fully implements the interface" do
+      before do
+        @class = FullImpl
+        @x = FullImpl.new
+      end
+
+      describe "calling an implemented abstract method" do
+        it "calls the concrete implementation" do
+          assert_respond_to @x, :m1
+          assert_equal "FullImpl#m1", @x.m1
+          assert_equal "FullImpl#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+
+          assert_respond_to @x, :m2
+          assert_equal "FullImpl#m2", @x.m2
+          assert_equal "FullImpl#m2", @x.method(:m2).call
+          refute_predicate @x.method(:m2), :abstract?
+          refute_predicate @x.method(:m2).unbind, :abstract?
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns false for abstract methods that have been implemented" do
+          refute @class.abstract_method?(:m1)
+          refute @class.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute @class.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "returns true for all abstract methods" do
+          assert @class.abstract_method_declared?(:m1)
+          assert @class.abstract_method_declared?(:m2)
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "returns all declared abstract methods, even those that have been implemented" do
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods(true)
+          assert_equal [], @class.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "returns only unimplemented abstract methods" do
+          assert_equal [], @class.abstract_instance_methods
+          assert_equal [], @class.abstract_instance_methods(true)
+          assert_equal [], @class.abstract_instance_methods(false)
+        end
+      end
+    end
+
+    describe "A class that fully implements the interface, partially via inheritance" do
+      before do
+        @class = PartiallyInheritsItsImpl
+        @x = PartiallyInheritsItsImpl.new
+      end
+
+      describe "calling an abstract method with an inherited implementation" do
+        it "calls the inherited implementation" do
+          assert_respond_to @x, :m1
+          assert_equal "PartialParent#m1", @x.m1
+          assert_equal "PartialParent#m1", @x.method(:m1).call
+          refute_predicate @x.method(:m1), :abstract?
+          refute_predicate @x.method(:m1).unbind, :abstract?
+        end
+      end
+
+      describe "calling an abstract method with defined in the child implementation" do
+        it "calls the child implementation" do
+          assert_respond_to @x, :m2
+          assert_equal "PartiallyInheritsItsImpl#m2", @x.m2
+          assert_equal "PartiallyInheritsItsImpl#m2", @x.method(:m2).call
+          refute_predicate @x.method(:m2), :abstract?
+          refute_predicate @x.method(:m2).unbind, :abstract?
+        end
+      end
+
+      describe ".abstract_method?" do
+        it "returns false for abstract methods that have been implemented" do
+          refute @class.abstract_method?(:m1)
+          refute @class.abstract_method?(:m2)
+        end
+
+        it "returns false for non-abstract methods" do
+          refute @class.abstract_method?(:inspect)
+        end
+      end
+
+      describe ".abstract_method_declared?" do
+        it "returns true for all abstract methods" do
+          assert @class.abstract_method_declared?(:m1)
+          assert @class.abstract_method_declared?(:m2)
+        end
+      end
+
+      describe ".declared_abstract_instance_methods" do
+        it "returns all declared abstract methods, even those that have been implemented" do
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods
+          assert_equal [:m1, :m2], @class.declared_abstract_instance_methods(true)
+          assert_equal [], @class.declared_abstract_instance_methods(false)
+        end
+      end
+
+      describe ".abstract_instance_methods" do
+        it "returns only unimplemented abstract methods" do
+          assert_equal [], @class.abstract_instance_methods
+          assert_equal [], @class.abstract_instance_methods(true)
+          assert_equal [], @class.abstract_instance_methods(false)
+        end
+      end
+    end
+  end
+end

data/spec/rubocop/cop/type_toolkit/prefer_not_nil_spec.rb

@@ -0,0 +1,229 @@
+# typed: true
+# frozen_string_literal: true
+
+require "spec_helper"
+require "rubocop"
+require "rubocop/minitest/assert_offense"
+require "rubocop-type_toolkit"
+
+module RuboCop
+  module Cop
+    module TypeToolkit
+      class PreferNotNilSpec < ::Minitest::Spec
+        include RuboCop::Minitest::AssertOffense
+
+        MSG = "TypeToolkit/PreferNotNil: Use `.not_nil!` instead of `T.must()`."
+
+        before do
+          @cop = PreferNotNil.new
+        end
+
+        it "autocorrects T.must" do
+          assert_offense(<<~RUBY)
+            value = T.must(foo)
+                    ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!
+          RUBY
+        end
+
+        it "autocorrects ::T.must" do
+          assert_offense(<<~RUBY)
+            value = ::T.must(foo)
+                    ^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!
+          RUBY
+        end
+
+        it "autocorrects inside string interpolation" do
+          assert_offense(<<~RUBY)
+            string = "\#{T.must(foo)}"
+                        ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            string = "\#{foo.not_nil!}"
+          RUBY
+        end
+
+        it "preserves the precedence of conditional and range expressions" do
+          assert_offense(<<~RUBY)
+            conditional = T.must(condition ? foo : bar)
+                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+            range = T.must(foo..bar)
+                    ^^^^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            conditional = (condition ? foo : bar).not_nil!
+            range = (foo..bar).not_nil!
+          RUBY
+        end
+
+        it "parenthesizes every expression that requires it" do
+          assert_offense(<<~RUBY)
+            operator = T.must(foo + bar)
+                       ^^^^^^^^^^^^^^^^^ #{MSG}
+            logical = T.must(foo || bar)
+                      ^^^^^^^^^^^^^^^^^^ #{MSG}
+            grouped = T.must((foo || bar))
+                      ^^^^^^^^^^^^^^^^^^^^ #{MSG}
+            assignment = T.must(foo = bar)
+                         ^^^^^^^^^^^^^^^^^ #{MSG}
+            block_value = T.must(foo { bar })
+                          ^^^^^^^^^^^^^^^^^^^ #{MSG}
+            defined_value = T.must(defined?(foo))
+                            ^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+            def example
+              T.must(yield foo)
+              ^^^^^^^^^^^^^^^^^ #{MSG}
+            end
+            def implicit_super
+              T.must(super)
+              ^^^^^^^^^^^^^ #{MSG}
+            end
+            def explicit_super
+              T.must(super(foo))
+              ^^^^^^^^^^^^^^^^^^ #{MSG}
+            end
+          RUBY
+
+          assert_correction(<<~RUBY)
+            operator = (foo + bar).not_nil!
+            logical = (foo || bar).not_nil!
+            grouped = (foo || bar).not_nil!
+            assignment = (foo = bar).not_nil!
+            block_value = (foo { bar }).not_nil!
+            defined_value = (defined?(foo)).not_nil!
+            def example
+              (yield foo).not_nil!
+            end
+            def implicit_super
+              (super).not_nil!
+            end
+            def explicit_super
+              (super(foo)).not_nil!
+            end
+          RUBY
+        end
+
+        it "preserves the precedence of command calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(fetch value)
+                    ^^^^^^^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (fetch value).not_nil!
+          RUBY
+        end
+
+        it "does not add unnecessary parentheses to parenthesized calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(fetch(value))
+                    ^^^^^^^^^^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = fetch(value).not_nil!
+          RUBY
+        end
+
+        it "preserves comments in multiline calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(
+                    ^^^^^^^ #{MSG}
+              # Proven non-nil by validation.
+              foo,
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              # Proven non-nil by validation.
+              foo
+            ).not_nil!
+          RUBY
+        end
+
+        it "autocorrects multiline calls with whitespace before the method" do
+          assert_offense(<<~RUBY)
+            first = T .must(
+                    ^^^^^^^^ #{MSG}
+              foo,
+            )
+            second = T
+                     ^ #{MSG}
+              .must(
+                bar,
+              )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            first = (
+              foo
+            ).not_nil!
+            second = (
+                bar
+              ).not_nil!
+          RUBY
+        end
+
+        it "removes a trailing comma before an inline comment" do
+          assert_offense(<<~RUBY)
+            value = T.must(
+                    ^^^^^^^ #{MSG}
+              foo, # Proven non-nil.
+            )
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = (
+              foo # Proven non-nil.
+            ).not_nil!
+          RUBY
+        end
+
+        it "autocorrects nested T.must calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(T.must(foo).bar)
+                    ^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+                           ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!.bar.not_nil!
+          RUBY
+        end
+
+        it "autocorrects three nested T.must calls" do
+          assert_offense(<<~RUBY)
+            value = T.must(T.must(T.must(foo).bar).baz)
+                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+                           ^^^^^^^^^^^^^^^^^^^^^^^ #{MSG}
+                                  ^^^^^^^^^^^ #{MSG}
+          RUBY
+
+          assert_correction(<<~RUBY)
+            value = foo.not_nil!.bar.not_nil!.baz.not_nil!
+          RUBY
+        end
+
+        it "ignores other receivers, methods, and argument counts" do
+          assert_no_offenses(<<~RUBY)
+            Other::T.must(foo)
+            object.must(foo)
+            T.let(foo, String)
+            T.must(foo, bar)
+            T.must(*values)
+          RUBY
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -6,3 +6,17 @@ require "type_toolkit"
 
 require "minitest/autorun"
 require "minitest/spec"
+
+module Minitest
+  class Spec
+    #: () { () -> void } -> TypeToolkit::AbstractMethodNotImplementedError
+    def assert_abstract(&block)
+      assert_raises(TypeToolkit::AbstractMethodNotImplementedError, &block)
+    end
+  end
+end
+
+#: -> bot
+def assert_never_called!
+  raise Minitest::Assertion, "This should never be called"
+end