wip

Author: amomchilov

benchmark/inherited_impl_benchmark.rb

@@ -194,3 +194,5 @@ class Child < Parent
     x.compare!
   end
 end
+
+# TODO: benchmark startup performance

lib/type_toolkit.rb

@@ -4,6 +4,7 @@
 require_relative "type_toolkit/dsl"
 require_relative "type_toolkit/method_def_recorder"
 require_relative "type_toolkit/interface"
+require_relative "type_toolkit/abstract_class"
 
 # Raised when a call is made to an abstract method that never had a real implementation.
 AbstractMethodNotImplementedError = Class.new(Exception) # rubocop:disable Lint/InheritException

lib/type_toolkit/abstract_class.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Raised when an attempt is made to instantiate an abstract class.
+CannotInstantiateAbstractClassError = Class.new(Exception) # rubocop:disable Lint/InheritException
+
+module TypeToolkit
+  module AbstractClass
+    def new(...) # :nodoc:
+      raise CannotInstantiateAbstractClassError, "#{self.class.name} is declared as abstract; it cannot be instantiated"
+    end
+
+    def inherited(subclass)
+      if subclass.singleton_class.superclass.include?(TypeToolkit::AbstractClass) &&
+          !subclass.singleton_class.superclass.singleton_class.include?(TypeToolkit::AbstractClass)
+
+        # We only ned to restore the original `.new` implementation for the direct subclasses of the abstract class.
+        # That's then inherited by the indirect subclasses.
+        # TODO: test this behaviour.
+        subclass.singleton_class.alias_method(:new, :__original_new_impl)
+
+        # We don't need a reference to the original implementation anymore,
+        # so let's undef it to limit namespace pollution.
+        subclass.singleton_class.undef_method(:__original_new_impl)
+      end
+
+      super
+    end
+  end
+end

lib/type_toolkit/ext/class.rb

@@ -2,6 +2,11 @@
 
 class Class
   def abstract!
+    p(new)
+    # # We need to save the original implementation of `new`, so we can restore it on the subclasses later.
+    singleton_class.alias_method(:__original_new_impl, :new)
+
+    extend(TypeToolkit::AbstractClass)
     extend(TypeToolkit::DSL)
     extend(TypeToolkit::MethodDefRecorder)
     extend(TypeToolkit::HasAbstractMethods)

spec/abstract_class_spec.rb

@@ -10,7 +10,9 @@ class AbstractClassSpec < Minitest::Spec
     class AbstractClass
       abstract!
 
-      abstract def m1; end
+      def m1; end
+      abstract(:m1)
+
       abstract def m2; end
 
       def concrete_method = "AbstractClass#concrete_method"
@@ -45,8 +47,7 @@ def m2 = "PartiallyInheritsItsImpl#m2"
 
     describe "An abstract class" do
       it "cannot be instantiated" do
-        skip "Not implemented yet"
-        assert_raises { AbstractClass.new }
+        assert_raises(CannotInstantiateAbstractClassError) { AbstractClass.new }
       end
 
       describe ".abstract_instance_methods" do
@@ -83,9 +84,20 @@ def m2 = "PartiallyInheritsItsImpl#m2"
         @class = NonImpl
       end
 
-      it "cannot be instantiated" do
-        skip "Not implemented yet"
-        assert_raises { NonImpl.new }
+      it "can be instantiated" do
+        # ...despite not implementing all the abstract methods. This matches sorbet runtime's behaviour.
+        #
+        # The Sorbet static typechecker ensures that when you subclass an abstract class, you must either:
+        # 1. Implement all of its abstract methods.
+        # 2. Mark the subclass as abstract! as well.
+        #
+        # Attempting to call actually any of the abstract methods will still raise, like usual.
+        refute_nil @class.new
+      end
+
+      it "does not respond to .__original_new_impl" do
+        # binding.irb
+        assert_raises(NoMethodError) { @class.__original_new_impl }
       end
 
       # describe "a method with the same name as another interface's members" do