Const error when chaning method invocations

[dnfield]

I'm not sure if this is a bug or not, but it seems strange to me. The following program will fail to compile:

class Foo {
  const Foo();
  
  void resolve() {
    print('resolve');
  }
}

void main() {
  const Foo foo = Foo()..resolve();
}

But final Foo foo = const Foo()..resolve(); is ok, and const Foo foo = const Foo(); foo.resolve(); are both ok. I would expect the compiler to desugar the failing version into the last version there.

[dnfield]

Duplicate of dart-lang/language#542 (comment)

[lrhn]

I don't think this is a duplicate of #542, but it is similar.

The reason this program does not compile is that Foo()..resolve() is not a compile-time constant expression. It cannot be because calling a method never is.

The problem is not (as in #542) that the initializer refers to the new variable foo before it's initialized. There is also no risk that the const Foo() object is seen in an uninitialized state because it is immutable when created.

Rather, the problem is that const declarations really do not occur as part of the normal evaluation flow.

For a local variable, we could perhaps find a way to split Foo()..resolve() into a constant part and a run-time part which is evaluated ... every time the declaration is evaluated? Even if we find a way to specify it meaningfully, it's a very specialized feature which is unlikely to pay for its own complexity cost.
It would not work for a top-level const variable. If you did const foo = Foo()..resolve(); at top-level (or as a static), it's very, very unclear when and how often the resolve would get called.

[dnfield]

I assumed because of how constant evaluation is described in the linked issue, this would require the other