Tear-off equality for extensions and extension types

[sgrekhov]

See Dart specification "17.22.3 Instance Method Closurization":

Assume that o1 and o2 are objects, m is an identifier, and c1 and c2 are function objects obtained by closurization of m on o1 respectively o2. Then c1 == c2 evaluates to true if and only if o1 and o2 is the same object.

So, we have:

class C {
  num m(int r1, {String p1 = ""}) => r1;
}

main() {
  C c = C();
  final fc1 = c.m;
  final fc2 = c.m;
  final fc3 = C().m;
  print(fc1 == fc2); // true
  print(fc1 == fc3); // false
}

That's Ok, it is according to the statement above. The same is true for mixins and enums. But for extensions and extension types we have different results.

class A {}
extension Ext on A {
  num m(int r1, {String p1 = ""}) => r1;
}

extension type ET1(int _) {
  num m(int r1, {p1 = ""}) => r1;
}

extension type ET2(int _) implements int{
  num m(int r1, {p1 = ""}) => r1;
}

main() {
  A a = A();
  final fa1 = a.m;
  final fa2 = a.m;
  final fa3 = A().m;
  print(fa1 == fa2); // false
  print(fa1 == fa3); // false

  ET1 et1 = ET1(0);
  final fet1 = et1.m;
  final fet2 = et1.m;
  final fet3 = ET1(0).m;
  print(fet1 == fet2); // false
  print(fet1 == fet3); // false

  ET2 et2 = ET2(0);
  final fet4 = et2.m;
  final fet5 = et2.m;
  final fet6 = ET2(0).m;
  print(fet4 == fet5); // false
  print(fet4 == fet6); // false
}

Why we have different results for extensions and extension types? Is there a special treatment for them?

cc @eernstg to confirm the expected result.

Dart SDK version: 3.8.0-66.0.dev (dev) (Sun Feb 2 20:05:47 2025 -0800) on "windows_x64"

[FMorschel]

I'm not 100% sure, but to me, it sounds like every call to an extension method, it thinks we have an implicit Ext(instance) (wrapper) around.

I am not sure this is the same for extension types but since at runtime these objects are non-existent, I'd guess the same is happening. Not sure why another wrapper would do that, but this is simply my guess.

[eernstg]

this is simply my guess.

Good guess!

Extension instance methods do get a different treatment than class instance methods: The section Extension method closurization specifies that tear-offs of such methods are equivalent to function literals, and this implies that they are never equal unless they are identical.

In particular, it is not enough that they have the same receiver, and it's the same method, and the type arguments are the same, and whatnot. They just have to be the same function object.

By the way, this is also mentioned in commentary in that section:

Two extension instance method closurizations are never equal unless they are identical. Note that this differs from closurizations of class instance methods, which are equal when they tear off the same method of the same receiver.

Extension type instance method tear-offs have the same semantics, as stated in Dynamic semantics of an extension type member invocation:

The operator == of the closurization returns true if and only if the operand is the same object.

[sgrekhov]

Thank you! The current behavior is in accordance with the spec, then. Closing this issue.