[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
-  // 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.
+  if (parsed_function_->function().IsAsyncClosure() ||
+      parsed_function_->function().IsAsyncGenClosure()) {
+    // If function is async closure or async gen closure it takes three
+    // parameters where 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);
     //     ...
     //   }
     //
     LocalScope* scope = parsed_function_->node_sequence()->scope();
     LocalVariable* exception_var = scope->VariableAt(2);
@@ skipping 50 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->dart_async_marker() ==
+                                 FunctionNode::kSync);
+      switch (node->dart_async_marker()) {
+        case FunctionNode::kSyncStar:
+          function.set_modifier(RawFunction::kSyncGen);
+          break;
+        case FunctionNode::kAsync:
+          function.set_modifier(RawFunction::kAsync);
+          break;
+        case FunctionNode::kAsyncStar:
+          function.set_modifier(RawFunction::kAsyncGen);
+          break;
+        default:
+          // no special modifier
+          break;
+      }
+      function.set_is_generated_body(node->async_marker() ==
+                                     FunctionNode::kSyncYielding);
+
       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)