Implement abstract classes

Author: amomchilov

lib/type_toolkit.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require_relative "type_toolkit/version"
+require_relative "type_toolkit/abstract_class"
 require_relative "type_toolkit/interface"
 require_relative "type_toolkit/dsl"
 require_relative "type_toolkit/method_def_recorder"
@@ -23,5 +24,23 @@ def make_interface!(mod)
       mod.extend(TypeToolkit::MethodDefRecorder)
       mod.extend(TypeToolkit::HasAbstractMethods)
     end
+
+    #: (Module[top]) -> void
+    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."
+      end
+    end
   end
 end

lib/type_toolkit/abstract_class.rb

@@ -0,0 +1,71 @@
+# typed: true
+# frozen_string_literal: true
+
+module TypeToolkit
+  # This module is extended onto every class marked `abstract!`.
+  # Abstract classes can't be instantiated, only subclassed.
+  # They should contain abstract methods, which must be implemented by subclasses.
+  #
+  # Example:
+  #
+  #   class Widget
+  #     abstract!
+  #
+  #     #: -> void
+  #     abstract def draw; end
+  #   end
+  #
+  #   class Button < Widget
+  #     # @override
+  #     #: -> void
+  #     def draw
+  #       ...
+  #     end
+  #   end
+  #
+  #   class TextField < Widget
+  #     # @override
+  #     #: -> void
+  #     def draw
+  #       ...
+  #     end
+  #   end
+  #
+  module AbstractClass
+    # An override of `new` which prevents instantiation of the class.
+    # This needs to be overridden again in subclasses, to restore the real `.new` implementation.
+    def new(...) # :nodoc:
+      #: self as Class[top]
+
+      if respond_to?(:__original_new_impl) # This is true for the abstract classes themselves, and false for their subclasses.
+        raise CannotInstantiateAbstractClassError, "#{self.class.name} is declared as abstract; it cannot be instantiated"
+      end
+
+      # This is hit in the uncommon case where a subclass of an abstract class overrides `.new` and calls `super`.
+      super
+    end
+
+    # Restores the original `.new` implementation for the direct subclasses of an abstract class.
+    #: (Class[AbstractClass]) -> void
+    def inherited(subclass) # :nodoc:
+      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
+
+  # Raised when an attempt is made to instantiate an abstract class.
+  CannotInstantiateAbstractClassError = Class.new(Exception) # rubocop:disable Lint/InheritException
+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

lib/type_toolkit/has_abstract_methods.rb

@@ -23,27 +23,18 @@ def __register_abstract_method(method_name) # :nodoc:
     def abstract_instance_methods(include_super = true)
       #: self as Module[HasAbstractMethods]
 
-      result = @__abstract_methods
+      result = @__abstract_methods #: Set[Symbol]?
 
-      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
+      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
 
@@ -67,9 +58,14 @@ def abstract_instance_methods(include_super = true)
     def abstract_method_declared?(method_name)
       #: self as Module[top]
 
-      @__abstract_methods&.include?(method_name) ||
-        included_modules.any? { |m| m.is_a?(HasAbstractMethods) && m.abstract_method_declared?(method_name) } ||
-        (defined?(super) && super)
+      # 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.