[Kernel] replace function debuggable field with originalAsyncMarker field

runtime/vm/kernel_to_il.cc

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include <map>
 #include <set>
 #include <string>
 
 #include "vm/kernel_to_il.h"
 
@@ skipping 6038 matching lines @@
   instructions += TranslateExpression(node->expression());
   instructions += Return(TokenPosition::kNoSource);
 
   // Note: DropTempsInstr serves as an anchor instruction. It will not
   // be linked into the resulting graph.
   DropTempsInstr* anchor = new (Z) DropTempsInstr(0, NULL);
   yield_continuations_.Add(YieldContinuation(anchor, CurrentTryIndex()));
 
   Fragment continuation(instructions.entry, anchor);
 
   // TODO(27590): we need a better way to detect if we need to check for an

[Kevin Millikin (Google), 2017/02/22 07:59:59]

If we set it correctly, can't we instead ask here if
parsed_function_->function() IsAsyncClosure() or IsAsyncGenClosure(), removing
the TODO?

[jensj, 2017/02/22 10:36:45]

That makes sence.
I've tried, and it seems to pass all tests.

   // exception after yield or not.
   if (parsed_function_->function().NumOptionalPositionalParameters() == 3) {
     // If function takes three parameters then the second and the third
     // are exception and stack_trace. Check if exception is non-null
     // and rethrow it.
     //
     //   :async_op([:result, :exception, :stack_trace]) {
     //     ...
     //     Continuation<index>:
     //       if (:exception != null) rethrow(:exception, :stack_trace);
@@ skipping 55 matching lines @@
       if (parent->IsFunctionExpression()) {
         name = &Symbols::AnonymousClosure();
       } else {
         ASSERT(parent->IsFunctionDeclaration());
         name = &H.DartSymbol(
             FunctionDeclaration::Cast(parent)->variable()->name());
       }
       // NOTE: This is not TokenPosition in the general sense!
       function = Function::NewClosureFunction(
           *name, parsed_function_->function(), position);
-      function.set_is_debuggable(node->debuggable());
+      function.set_is_debuggable(node->original_async_marker() ==

[Kevin Millikin (Google), 2017/02/22 07:59:59]

Why not set the function to be correctly sync*/async/async*?

We should also (probably) set SyncYielding functions to be is_generated_body so
they get the correct SyncGenClosure/AsyncClosure/AsyncGenClosure status.

[jensj, 2017/02/22 10:36:45]

Done.

+                                 FunctionNode::kSync);
       function.set_end_token_pos(node->end_position());
       LocalScope* scope = scopes_->function_scopes[i].scope;
       const ContextScope& context_scope =
           ContextScope::Handle(Z, scope->PreserveOuterScope(context_depth_));
       function.set_context_scope(context_scope);
       function.set_kernel_function(node);
       KernelReader::SetupFunctionParameters(H, T, dart::Class::Handle(Z),
                                             function, node,
                                             false,  // is_method
                                             true);  // is_closure
@@ skipping 135 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)