VM instantiated tear-offs of instance methods ignores the instantiation type in equality checks.

[lrhn]

Example:

class C {
  T foo<T>(T value) => value;
}
void main() {
  var c = C();
  num Function(num) f0 = c.foo;
  int Function(int) f1 = c.foo;
  print(f0 == f1); // true
  print(f0.runtimeType); // (num) => num
  print(f1.runtimeType); // (int) => int
}

It seems inconsistent that two functions with different types should be equal. It's true that they have the same underlying behavior, and calling them with the same valid argument will give the same result, but it allows surprising equalities to be true, and if code does different things depending on the run-time type of the function they're passed, then it might make a difference whether a set of function can hold both or not.

[eernstg]

We do specify that equality must hold (according to operator ==) when the generic function instantiation is applied to the same function declaration with the same type arguments (whether constant or not), and argue that equality cannot hold with different type arguments. A similar rule is given for generic method instantiation.

[lrhn]

That text specifies when instantiated instance method tear-offs must be equal (allowing them to be identical, which no-one does).
It doesn't actually say when they must not be equal, so the VM is technically correct. It just says that it wouldn't make sense to say that they are equal when type arguments are different, but that's in the rationale, not normative text.
(Also, it depends on the phrase "the same type" which is historically underspecified. I think that got better with null safety, now it probably means "normalizes to the syntactically same type, up to alpha equivalence of bound type variables").

(Rule of thumb, when you need to prefix something with "technically", it really means "not actually").

[eernstg]

It doesn't actually say when they must not be equal

When we specify that the function objects must compare equal according to operator == with "the same" type arguments, and mention in rationale that it would not make sense to consider them equal when the type arguments are "not the same", it's a really long shot to say that it's OK to return true from that operator == when the type arguments are different.

(.. when you need to prefix something with "technically", it really means "not actually").

Exactly! 😄

[a-siva]

/cc @crelier