language: allow static members on interfaces, implemented by default class or factory provider

[rakudrama]

This is a request to allow any static member to be declared in the interface provided it is implemented via the class named in the interface's 'default' clause.

Interfaces currently permit one kind of static member: constructors, which may be implemented the default implementation class or a factory constructor in a factory provider class.

[rakudrama]

In the html library we make extensive use of the factory provider pattern and some of the interfaces have static methods. Supporting interface static methods with the factory provider pattern would be most useful.

If the interface static method maps directly to the identically named default class method we may have more factory provider classes, since today we have some factory provider classes that service many client interfaces. Some of these 'kitchen sink' factory provider classes would have to be split to permit each client interface to have static methods with the same name. A more compact scheme would be for the single factory provider to name the interfaces, e.g.

interface I1 default _D { I1(); static foo(); }
interface I2 default _D { I2(); static foo(); }

class _D {
  factory I1() {...}
  factory I2() {...}
  static I1.foo() {...}
  static I2.foo() {...}
  // shared implementation code.
}

The call I2.foo() is compiled as _D.foo()

[munificent]

Why would they need to be implemented in the default class and not in the interface itself? Static members are statically dispatched, and not called through an instance of the interface type. How would the default class come into play?

[gbracha]

Set owner to @gbracha.
Added Accepted label.

[rakudrama]

Bob: in dart:html the static methods have different implementations for dart2js vs dartium.

[munificent]

Bob: in dart:html the static methods have different implementations for dart2js vs dartium.

That's fine. In cases like that you could implement it in the interface through forwarding:

interface Blah default _Blah {
  static foo() => _Blah.realFoo();
}

By not requiring this to go through default classes, it means you don't have to go through that indirection in the cases where it isn't needed.

[gbracha]

We'll figure out what to do here in not too long.

---

Added this to the M1 milestone.

[gbracha]

No need for this, as the interface elimination proposal solves this nicely. Abstract classes can contain static members while serving as interfaces.

---

Added WontFix label.

[gbracha]

Marked this as blocking #679.