[RFC] Metaclasses of abstract types should not themselves be abstract

Follow-up to https://github.com/crystal-lang/crystal/issues/5956#issuecomment-731856760.

There is no such thing as an abstract base metaclass in Crystal; as long as you can name a type, that type is already an instance of its metaclass, even if the user never explicitly instantiates the type object. Besides, code like this is perfectly legal:

abstract class Foo
  abstract def f
  class_property x = 1
end

Foo.x += 1 # => 2

Thus it is erroneous to declare Foo.class itself as an abstract type.

The differences become apparent when virtual types involving metaclasses are resolved into concrete types. Suppose we have

abstract class Base
end

class Derived < Base
  def self.foo
  end
end

(true ? Base : Derived).foo

When Base.class is abstract,

typeof(Base, Derived) is the virtual type Base.class+.
The concrete types of Base.class+ include only Derived.class, because they cannot contain Base.class, which is abstract.
Derived.class#foo is defined, therefore Base.class+#foo is fully defined. Thus the code compiles even though Base.foo leads to undefined behaviour.

When Base.class is not abstract,

typeof(Base, Derived) is the virtual type Base+.class.
The concrete types of Base+.class are Base.class and Derived.class.
Base.class#foo is not defined, therefore calling Base+.class#foo is a compile-time error.

Now also consider the example from #3835:

abstract class Foo
end

a = [Foo] of Foo.class
a[0].new

Suppose Foo.class#new is not defined (the compiler detects the Foo.new errors through a different mechanism). The code would still compile, since Foo.class is abstract and the concrete types of Foo.class+ must all define #new. But if a[0] is typed to be Foo+.class, then due to our supposition the code would fail to compile, because the last line requires a definition of Foo.class#new.

This will be a breaking change but I can't think of a scenario where the current behaviour is desirable.

crystal-lang / crystal

[RFC] Metaclasses of abstract types should not themselves be abstract #9959