Implement abstract classes

Author: amomchilov

lib/type_toolkit.rb

@@ -5,6 +5,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
@@ -29,29 +30,20 @@ def __register_abstract_method(method_name) # :nodoc:
     # TODO: change semantics to only return methods that are actually abstract and unimplemented.
     #: (?bool) -> Array[Symbol]
     def abstract_instance_methods(include_super = true)
-      #: self as Module[HasAbstractMethods]
-
-      result = @__abstract_methods
-
-      return result.to_a unless include_super
-
-      if defined?(super) && (super_abstract_methods = super)
-        if result
-          result.merge(super_abstract_methods)
-        else
-          result = super_abstract_methods
-        end
-      end
-
-      abstract_methods_in_interfaces = included_modules.flat_map do |m|
-        m.is_a?(HasAbstractMethods) ? m.abstract_instance_methods : []
-      end
-
-      if abstract_methods_in_interfaces.any?
-        if result&.any?
-          result.merge(abstract_methods_in_interfaces)
-        else
-          result = abstract_methods_in_interfaces
+      #: self as Module[top] & HasAbstractMethods
+
+      result = @__abstract_methods #: Set[Symbol]?
+
+      if include_super
+        ancestors.each do |m|
+          methods = m.instance_variable_get(:@__abstract_methods)
+          if methods&.any?
+            if result
+              result.merge(methods)
+            else
+              result = methods
+            end
+          end
         end
       end
 
@@ -73,11 +65,16 @@ def abstract_instance_methods(include_super = true)
     #
     #: (Symbol) -> bool
     def abstract_method_declared?(method_name)
-      #: self as Module[untyped]
-
-      @__abstract_methods&.include?(method_name) ||
-        included_modules.any? { |m| m.is_a?(HasAbstractMethods) && m.abstract_method_declared?(method_name) } ||
-        (defined?(super) && super)
+      #: self as Module[top]
+
+      # FIXME: Allocating the `ancestors` array is not great.
+      # I tried a recursive approach, but that didn't quite work.
+      # There is only one implementation of `abstract_method_declared?` in the ancestor chain, so there is no `super` to call.
+      # This method always checked the ivar of the current class, which might not be set. What we actually want is to
+      # walk up the ancestor chain, and check the ivar of each ancestor.
+      ancestors.any? do |m|
+        m.instance_variable_get(:@__abstract_methods)&.include?(method_name)
+      end
     end
 
     # Returns true if the given method is abstract, and has not been implemented.
@@ -168,5 +165,24 @@ def make_interface!(mod)
       mod.extend(TypeToolkit::MethodDefRecorder)
       mod.extend(TypeToolkit::HasAbstractMethods)
     end
+
+    def make_abstract!(mod)
+      case mod
+      when Class
+        # We need to save the original implementation of `new`, so we can restore it on the subclasses later.
+        mod.singleton_class.alias_method(:__original_new_impl, :new)
+
+        mod.extend(TypeToolkit::AbstractClass)
+        mod.extend(TypeToolkit::DSL)
+        mod.extend(TypeToolkit::MethodDefRecorder)
+        mod.extend(TypeToolkit::HasAbstractMethods)
+
+        mod.include(TypeToolkit::AbstractInstanceMethodReceiver)
+      when Module
+        raise NotImplementedError, "Abstract modules are not implemented yet."
+      else
+        raise TypeError, "Expected a Class or Module, got #{mod.class}."
+      end
+    end
   end
 end

lib/type_toolkit/abstract_class.rb

@@ -0,0 +1,33 @@
+# typed: true
+# 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:
+      #: self as Class[top]
+      raise CannotInstantiateAbstractClassError, "#{self.class.name} is declared as abstract; it cannot be instantiated"
+    end
+
+    #: (Class[AbstractClass]) -> void
+    def inherited(subclass)
+      superclass = subclass.singleton_class.superclass #: as !nil
+
+      if superclass.include?(TypeToolkit::AbstractClass) &&
+          !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.
+
+        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.rb

@@ -1,5 +1,6 @@
 # typed: strong
 # frozen_string_literal: true
 
+require "type_toolkit/ext/class"
 require "type_toolkit/ext/method"
 require "type_toolkit/ext/module"

lib/type_toolkit/ext/class.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Class
+  def abstract!
+    TypeToolkit.make_abstract!(self)
+  end
+end