Rethinking the default class hierarchy: Milestone 1, Week 1

[Petar]

On Friday, 24 September 2021 at 20:17:51 UTC, Ali Çehreli wrote:
> On 9/23/21 3:15 AM, Robert Aron wrote:
>
> > `ProtoObject` defines no methods
>
> > `object monitor`
>
> Can ProtoObject get rid of monitor as well?
>
> Ali

Since there's no default base class in C++ (like 
`object.Object`), `extern (C++) class`-es defined in D don't 
inherit one implicitly as well, which is obviously necessary for 
ABI compatibility. This means that D already supports truly empty 
non-abstract classes (like the proposed `ProtoObject`), but only 
if they're declared as `extern (C++)`. Essentially, this proposal 
is about removing this limitation, so that an `extern (D)` class 
can also be empty.

Luckily, most of Druntime and Phobos are oblivious to the fact 
that D's classes have monitors, as monitors are only needed for 
thread synchronization. (That's because D made the right choice 
by making `shared` memory explicit in the type system.) When is 
the last time you saw a Druntime, Phobos, or in general, D 
function that took a `shared` class reference? (Not a completely 
rhetorical question - I'd be interested to know if people have 
such instances in their projects.) Outside of `core.sync.*`, 
`std.concurrency` and `std.parallelism` nothing deals with 
`shared` classes.

AFAIU, inserting `ProtoObject` as the base class of `Object` 
should be backwards compatible change as far as most library / 
application code is concerned, outside of specific 
meta-programming related code, like [this][1]. I think the 
biggest challenge would be ironing all the type-system related 
details, e.g. basic things like this:

```
// Should print `ProtoObject`?
pragma (msg,
	typeof((
     	new class {
         	auto getParent() { return super; }
     	}).getParent()
	)
);
```
https://run.dlang.io/is/DvVcn9


```
class A {}
class B {}

// Object[]
pragma (msg, typeof([ new A, new B]));

extern (C++) class C {}
extern (C++) class D {}

// Error: incompatible types for `(new C) : (new D)`: 
`onlineapp.C` and `onlineapp.D`
// _error_ (ICE?)
pragma (msg, typeof([ new C, new D]));

class E : ProtoObject {}
class F {}

// should print: `ProtoObject[]`
pragma (msg, typeof([ new E, new F]));
```
https://run.dlang.io/is/LpmnfR

[1]: 
https://dlang.org/phobos/std_traits#.AllImplicitConversionTargets