"it is not possible for a single platform object to implement both interfaces"

[domenic]

Apparently two IDL interface types are distinguishable if all of the following hold

• The two identified interfaces are not the same
• It is not possible for a single platform object to implement both interfaces
• It is not the case that both are callback interfaces.

This second condition is very confusing. I can think of two possible interpretations:

Interpretation A

[NoInterfaceObject] interface Foo {};
[NoInterfaceObject] interface Bar {};

interface Baz {};
Baz implements Foo;
Baz implements Bar;

Baz implements both Foo and Bar, so Foo and Bar are not distinguishable. (Contrapositive of the given statement.)

Interpretation B

[NoInterfaceObject] interface Foo { readonly attribute x; };
[NoInterfaceObject] interface Bar { attribute x; };

interface Baz {};
Baz implements Foo;
Baz implements Bar; // not allowed

It is not possible to implement both Foo and Bar at the same time, so they are distinguishable.

Discussion

Both of these interpretations kind of suck.

Interpretation A is a very nonlocal definition. To determine if A and B are distinguishable, you have to look at all interfaces in the web platform, and find out if any of them implement both A and B. (I think something that extends A and implements B would also work, or vice-versa.) This means A and B's distinguishability can change at any time.

Interpretation B is very implicit. It comes down to finding all places in the spec that prohibit implementing a given interface. In this case I found the condition

For a given interface, there MUST NOT be any member defined on any of its consequential interfaces whose identifier is the same as any other member defined on any of those consequential interfaces or on the original interface itself.

but there are others, e.g. the no-cycles condition.

Which is it? And, is this actually implementable, or implemented by existing binding layers?

[bzbarsky]

The point here is that if two types are distinguishable, then given any object you have to be able to tell which of the two types it is.

This means that if there is an object which can claim to be of both types, they need to not be distinguishable. Therefore interpretation A is the correct one and we should adjust phrasing as needed to make that clear.

To determine if A and B are distinguishable, you have to look at all interfaces in the web platform

Yes, you do. That's necessary to achieve the "given any object" goal. I agree that this is rather annoying, but I don't see how the goal can be achieved otherwise.

And, is this actually implementable, or implemented by existing binding layers?

What Gecko's binding layer implements is the following:

Each interface has a set of interfaces associated with it. This set contains the interface itself, all interfaces inheriting from it (transitively, not directly), and all interfaces that have it as a "consequential interface" or inherit from an interface that has it as a consequential interface. So in your example above, the set associated with Baz just contains Baz itself. The set associated with Foo contains Foo and Baz. The set associated with Bar contains Bar and Baz. Two interfaces are distinguishable if their associated sets are disjoint (have no common members). I believe this is a correct implementation of your interpretation A.

[jyasskin]

Would it make sense to replace "It is not possible for a single platform object to implement both interfaces" with "No platform object implements both interfaces"? The non-local nature of the check is annoying, but at least this makes it clear.

[bzbarsky]

I think once we have proper mixins this might be a lot easier to spec, especially if we don't allow mixins to be used as types. Because at that point, the only way for two interfaces to not be distinguishable will be if one of them inherits from the other, I believe.