Possibly incorrect desugaring of compound assignment with explicit extension method invocations

[eernstg]

Consider the following program:

class C {
  int value = 0;
}

extension Extension1 on C {
  C operator [](int index) => this..value += index + 1;
  void operator []=(int index, C other) =>
      this.value += other.value + index + 1;
  C operator -(int val) => this;
}

main() {
  C c = C();
  // Original term that produces an unexpected error.
  --Extension1(c)[42];

  // The pre-decrement desugars as follows, which is also flagged as an error.
  Extension1(c)[42] -= 1;

  // The compound assignment desugars as follows, which is accepted.
  Extension1(c)[42] = Extension1(c)[42] - 1;
}

This program is accepted by the analyzer, but rejected by dart from commit ee8d9d2, with the following error:

n056.dart:15:19: Error: A value of type 'int' can't be assigned to a variable of type 'C'.
 - 'C' is from 'n056.dart'.
  --Extension1(c)[42];
                  ^
n056.dart:18:17: Error: A value of type 'int' can't be assigned to a variable of type 'C'.
 - 'C' is from 'n056.dart'.
  Extension1(c)[42] -= 1;
                ^

The comments indicate why this should not be an error: The two-step desugaring of the pre-increment produces Extension1(c)[42] = Extension1(c)[42] - 1. This is an explicit invocation of the operator []= from Extension1; the second argument is Extension1(c)[42] - 1, which is an explicit invocation of operator [] from Extension1, yielding a result of type C, on which we call operator -(int) (an implicitly resolved method from Extension1). All the types add up as they should, and I believe this is a bug in the front end (presumably in the desugaring steps, because the manual desugaring eliminates the error).

[eernstg]

Note that the outcome is identical for the case shown above and the case where operator -(int) is an instance member.

Also worth noting: There are no errors when the program is adjusted to perform all extension method invocations implicitly:

class C {
  int value = 0;
}

extension Extension1 on C {
  C operator [](int index) => this..value += index + 1;
  void operator []=(int index, C other) =>
      this.value += other.value + index + 1;
  C operator -(int val) => this;
}

main() {
  C c = C();
  --c[42];
  c[42] -= 1;
  c[42] = c[42] - 1;
}

[franklinyow]

What is the status on this one?