dartk: Await/Yield points during expression evaluation of assert statements

[mkustermann]

Currently the following code

main() async {
  assert(await false);
}

is compiled (with async/await transformer) to

  static method main() → dynamic /* not debuggable */ {
    final asy::Completer<dynamic> :completer = asy::Completer::sync<dynamic>();
    dynamic :return_value;
    dynamic :async_op_then;
    dynamic :async_op_error;
    dynamic :await_jump_var = 0;
    dynamic :await_ctx_var;
    function :async_op([dynamic :result, dynamic :exception, dynamic :stack_trace]) → dynamic yielding 
      try {
        #L1:
        {}
        :completer.complete(:return_value);
        return;
      }
      on dynamic catch(dynamic :exception, dynamic :stack_trace) {
        :completer.completeError(:exception, :stack_trace);
      }
    :async_op_then = asy::_asyncThenWrapperHelper(:async_op);
    :async_op_error = asy::_asyncErrorWrapperHelper(:async_op);
    asy::Future::microtask<dynamic>(:async_op);
    return :completer.future;
  }

Due to the following TODO in the pkg/kernel/lib/transformers/continuation.dart:

  TreeNode visitAssertStatement(AssertStatement stmt) {
    // TODO!
    return null;
  }

With our old block expressions this might have been easier to handle.

/cc @kmillikin & #28263

[mraleph]

@kmillikin & @asgerf: We need a way to express this in Kernel

[mraleph]

I am escalating this, I just wasted a lot of time debugging a Flutter plugin test because of assert statement was silently eaten away by the transformer.

[mraleph]

Please triage /cc @kmillikin

[kmillikin]

The issue is that the async-elimination transformer translates an expression containing await into a sequence of statements with calls to runtime support functions and a fresh expression. We need to guard this sequence of statements so it is evaluated only when assert is enabled.

We will solve this in Kernel by eliminating assert entirely and adding a simpler form which is a nullary expression AssertsEnabled. The encoding of assert(e, m) is then:

if (AssertsEnabled) if (!e) throw AssertionError(m)

We can optionally provide a mechanism for a back end to control the specific constructor that is used for the error.

[mkustermann]

To avoid the increase in binary size due to desugaring (and taking a bit of control away from backends) you could also consider something similar, namely adding a class AssertBlock extends Statement (similar to the existing Block, or adding a flag on Block).

Then the await/async transformer can work as usual.

Just a suggestion!

[dgrove]

@kmillikin Any updates on this?

[kmillikin]

I have a fix in flight, but it will have to wait until tomorrow (Tuesday) at this point.