Context type intentionally different from parameter type in non-standard ==?

[eernstg]

Consider the following program:

X getContextType<X>() {
  print(X);
  throw 0;
}

class A {
  bool operator ==(covariant A other) => identical(this, other);
}

void main() {
  A() == getContextType(); // Prints 'dynamic'.
}

I would expect the context type to be A?.

[eernstg]

@stereotype441, @johnniwinther, what would you expect?

[stereotype441]

@stereotype441, @johnniwinther, what would you expect?

I can't find the behaviour specified anywhere (https://github.com/dart-lang/language/blob/main/resources/type-system/inference.md doesn't appear to say anything), but A? seems totally reasonable to me based on this reasoning:

• In general, a op b is interpereted as a.operator op(b).
• In general, for a.m(b), b is type inferred using a context that comes from the parameter type accepted by b.
• For the special case of operator ==, we know that null can appear on the RHS, regardless of the signature of operator ==.
• Therefore, since A.operator == has a parameter type of A, it makes sense for the context to be A?.

I ran some experiments with the analyzer and it looks like it behaves consistently with the CFE (it uses the context dynamic regardless of the type on the LHS of ==).

I would be open to changing this so that the context is A?. But since the analyzer and the CFE agree, I think we should consider this a language issue, and if we decide to address it, either make it a language-versioned change, or follow the breaking change process. So I'm going to go ahead and transfer this issue to the language repo.

Note that if we decide to change this behaviour so that the context type in Erik's example is A?, that begs the question of what we want the context type of the RHS of == to be when the parameter type of operator== is Object, Object?, or dynamic. For consistency, it would make sense to use dynamic when the parameter type is dynamic and Object? when the parameter type is Object or Object?. However, since Object.operator== is defined with a parameter type of Object, this would affect the type inference behaviour of nearly every equality check in all of Dart.