Front end must infer top level types before filling in type inference details for top level initializers

[stereotype441]

Consider the following code:

class A implements B {
  var x;
  A.constructor(this.x);
  List<num> f() => [];
}
class B {
  var x = new A.constructor([1]).f();
}

The following pieces of information must be inferred by type inference, in order:

• The type of B.x is List<num>
• The type of A.x is List<num> (inherited from B.x because A implements B)
• The type of A.constructor's x parameter is List<num> (determined by A.x because initializing formals without an explicit type get their type from the field)
• The implicit type argument of the list [1] in B.x's initializer is <num> (determined by the type of A.constructor's x parameter)

Note that B.x appears both at the top and the bottom of the above list. This means that we can't do the type inference for B.x all at once. We have to do top level type inference first. Then at a later pass we can fill in type inference for subexpressions appearing in B.x's initializer.

This is going to require some rework of the front end type inference algorithm, since it currently assumes that it doesn't have to visit any field's initializer more than once.

[jensjoha]

Compiling the code with --strong gives me the following:

library;
import self as self;
import "dart:core" as core;

class A extends core::Object implements self::B {
  field core::List<core::num> x;
  constructor constructor(core::List<core::num> x) → void
    : self::A::x = x, super core::Object::•()
    ;
  method f() → core::List<core::num>
    return <core::num>[];
}
class B extends core::Object {
  field core::List<core::num> x = new self::A::constructor(<core::num>[1]).{self::A::f}();
  default constructor •() → void
    : super core::Object::•()
    ;
}

which makes it seem like this issue is fixed. Can we close?

[stereotype441]

Yes, this issue has been addressed and adequately regression tested.