VM doesn't consider dynamic == Object.

[lrhn]

Type objects should be equal if the types are sub-types of each other. That is, when the types are indistinguishable wrt. subtyping.

That includes dynamic, Object, and void all being equal when compared as Type objects at run-time.

Example:

main() {
  print(dynamic == Object);  // prints false, should print true.
}

[rmacnak-google]

Reflection requires these to be distinct.

[natebosch]

Is this expectation part of the spec - does the spec need to be updated?

Does DDC have the same behavior as VM (it looks like dart2js does have the same behavior).

[lrhn]

There is no specification of Type.operator== apart from what it says in the SDK declaration. There is also no specification of what Type object means except that they "represent" a run-time type. The spec is silent except for creating Type objects representing types when you use a type expression as an expression.

For the equality to be useful, type objects representing the same type must be equal.
Type objects representing distinguishably different types should be different.

The issue here is that at run-time, there is nothing distinguishing dynamic and Object as types. Any object is an instance of both. Any type is a sub-type of both, even each other. The two types are not distinguishable.

Or, put differently, the idea is that dynamic is not a type at run-time at all, it exists entirely in the static type system. At run-time, there is only Object, and dynamic is just Object-with-a-flag, and the flag only exists in the static type system.

We would keep the dynamic flag around in order to display types for debugging, but it really is just Object, and hence the Type object for the type is a Type object representing Object and equal to any other such.

With that design, reflection does not need to distinguish because at run-time there is nothing to distinguish, it's all Object.

@leafpetersen @eernstg

[eernstg]

@natebosch wrote:

Is this expectation part of the spec - does the spec need to be updated?

No, the spec requires that two reified types t1 and t2 satisfy t1 == t2 whenever t1 <: t2 and t2 <: t1.

@rmacnak-google wrote:

Reflection requires these to be distinct

It is still possible for an implementation to make a distinction between the reification of a type written as dynamic and a type written as Object (and void, too), even though they must be considered equal according to operator == at run time, because they are not required to be identical. This is motivated by the wish to use the names that occur in the source code for error messages and stack traces.

Reflective operations would be able to use identical to make this distinction (assuming that canonicalization of reified types is similar to everybody's expectations, cf. dart-lang/language#95), and so I believe that there is no conflict in this area.

[lrhn]

The "equal if mutual subtypes" rule also affects other cases than top types (all, unsurprisingly, related to union types):

• FutureOr<Object> and Object,
• FutureOr<Future<Object>> and Future<Object>, (etc.)
• FutureOr<Null> and Future<Null>
  and any composite type where such equal types occur in the corresponding places.