Move over "Enhanced Type Promotion" proposal.

[munificent]

Was originally at: dart-lang/sdk#29624

[mdebbar]

Do we expect types to be promoted into closures?

class Foo {
  void foo() => print('foo');
}

var action;
if (x is Foo) {
  action = () {
    x.foo(); // Is this ok?
  }
} else {
  action = () => null;
}
scheduleMicrotask(action);

Type promotion in the above scenario is safe if x is final, but is dangerous otherwise because x could be reassigned another value before action is invoked.

[mdebbar]

Do you think it's worth explicitly mentioning in the proposal that it doesn't cover members? Like the following:

if (foo.bar is String) {
  print(foo.bar.length); // Unsafe because `.bar` could be a getter.
}

[mdebbar]

It would be great to elaborate a bit here. Under what conditions do we consider a variable safe to type-promote?

void foo(x) async {
  closure() {
    x = 123;
  }

  if (x is String) {
    print(x.length); // Safe
  }

  if (x is String) {
    if (something) closure();
    print(x.length); // Unsafe
  }

  if (x is String) {
    await something;
    print(x.length); // Unsafe
  }
}

[mdebbar]

Another example, a bit contrived:

var x = 'abc';

class A {
  bool get foo {
    x = 123;
    return true;
  }
}

void main() {
  var a = A();
  if (x is String && a.foo) {
    print(x.length); // Unsafe!
  }
}

[munificent]

Yeah, these are good points. This proposal isn't quite active right now and I'm not the author, so I don't think we'll tweak it right now. But if we summon it back to life, I think we should be more explicit about the things you bring up.

[bwilkerson]

Line 120 says that the definition of which variables are safe to type promote is unchanged by this proposal, so it's what the spec says:

The static type system ascribes a static type to every expression. In some cases, the type of a local variable (which can be a formal parameter) may be promoted from the declared type, based on control flow.

With the following caveat added in many places:

... then the type of v is known to be T in s2, unless any of the following are true

• v is potentially mutated in s1,
• v is potentially mutated within a function other than the one where v is declared, or
• v is accessed by a function defined in s1 and v is potentially mutated anywhere in the scope of v.

[lrhn]

Landing this, if for nothing else, then as background material.