The `noSuchMethod` invocation instance isn't fine-grained enough.

[lrhn]

When tearing-off a non-existing member of an object, the noSuchMethod of the object is called, but with insufficient information for the method to recognize it as a tear-off.

The spec says:

Otherwise, a new instance im of the predefined class Invocation is created, such that :

• If m is a setter name, im.isSetter evaluates to true; otherwise im.isMethod evaluates to true.
• im.memberName evaluates to ’m’.
• im.positionalArguments evaluates to the value of const [].
• im.namedArguments evaluates to the value of const {}.

This means that tearing off a getter and a method are indistinguishable from calling a method.
This makes it impossible for the object to emulate the tear-off with noSuchMethod.
A method tear-off like o#foo should be emulated by returning a function, but calling the method o.foo() should execute the emulated function instead. The two accesses have the same Invocation instance, and cannot be distinguished.

Changing the invocation to im.isGetter instead won't fix that, because it breaks getter access/tear-off instead.

[lrhn]

There is no simple solution. There are now five possible ways to access an object (getter, setter, methodcall, tearoff getter/method, tearoff setter) instead of three, and the Invocation object must be able to represent all five, without necessarily causing existing noSuchMethod methods to fail badly.

On option is to add more bits to the Invocation, but that's not necessarily backwards compatible.

Another option is to mangle the memberName for tear-offs. Maybe introduce "tearoff-symbols" with a leading "#", so the member-name of o#foo is "#foo" (literal: ##foo) instead of "foo".
That requires introducing more symbols.

An alternative to modifying Invocation is to have the tear-off throw when the property isn't there, and not go through the object's noSuchMethod. This reserves the noSuchMethod for implementing actual calls, and tear-offs can't be emulated (but they can't with the current proposal either).

Yet another alternative could be to make the tear-off work even when there is no property with the requested name, but have the invocation of the function then invoke the noSuchMethod of the object (likely as a getter). That is: if foo is not a member of o, then "o#foo" returns something like "new _NSMForwarder(o, #foo)" with

class _NSMForwarder implements Function {
final _object;
final Symbol _memberName;
NSMForwarder(this._object, this._memberName);
noSuchMethod(invocation) {
if (invocation.memberName == #call) {
return _object.noSuchMethod(new _Invocation.update(invocation, memberName: _memberName));
}
return super.noSuchMethod(invocation);
}
}