[kernel] set dartAsyncMarker to Sync for continuations

pkg/kernel/lib/transformations/continuation.dart

 // 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.
 
 library kernel.transformations.continuation;
 
 import 'dart:math' as math;
 
 import '../ast.dart';
 import '../core_types.dart';
@@ skipping 106 matching lines @@
 
   SyncStarFunctionRewriter(helper, enclosingFunction)
       : iteratorVariable = new VariableDeclaration(':iterator')
           ..type = helper.iteratorClass.rawType,
         super(helper, enclosingFunction);
 
   FunctionNode rewrite() {
     // :sync_body(:iterator) {
     //     modified <node.body>;
     // }
+
+    // Note: SyncYielding functions have no Dart equivalent. Since they are
+    // synchronous, we use Sync. (Note also that the Dart VM backend uses the
+    // Dart async marker to decide if functions are debuggable.)
     final nestedClosureVariable = new VariableDeclaration(":sync_op");
     final function = new FunctionNode(buildClosureBody(),
         positionalParameters: [iteratorVariable],
         requiredParameterCount: 1,
-        asyncMarker: AsyncMarker.SyncYielding)
+        asyncMarker: AsyncMarker.SyncYielding,
+        dartAsyncMarker: AsyncMarker.Sync)
       ..fileOffset = enclosingFunction.fileOffset
       ..fileEndOffset = enclosingFunction.fileEndOffset
       ..returnType = helper.coreTypes.boolClass.rawType;
 
     final closureFunction =
         new FunctionDeclaration(nestedClosureVariable, function)
           ..fileOffset = enclosingFunction.parent.fileOffset;
 
     // return new _SyncIterable(:sync_body);
     final arguments = new Arguments([new VariableGet(nestedClosureVariable)]);
@@ skipping 74 matching lines @@
     statements.add(catchErrorContinuationVariable);
 
     // :async_op([:result, :exception, :stack_trace]) {
     //     modified <node.body>;
     // }
     final parameters = <VariableDeclaration>[
       expressionRewriter.asyncResult,
       new VariableDeclaration(':exception'),
       new VariableDeclaration(':stack_trace'),
     ];
+
+    // Note: SyncYielding functions have no Dart equivalent. Since they are
+    // synchronous, we use Sync. (Note also that the Dart VM backend uses the
+    // Dart async marker to decide if functions are debuggable.)
     final function = new FunctionNode(buildWrappedBody(),
         positionalParameters: parameters,
         requiredParameterCount: 0,
-        asyncMarker: AsyncMarker.SyncYielding)
+        asyncMarker: AsyncMarker.SyncYielding,
+        dartAsyncMarker: AsyncMarker.Sync)
       ..fileOffset = enclosingFunction.fileOffset
       ..fileEndOffset = enclosingFunction.fileEndOffset;
 
     // The await expression lifter might have created a number of
     // [VariableDeclarations].
     // TODO(kustermann): If we didn't need any variables we should not emit
     // these.
     statements.addAll(variableDeclarations());
     statements.addAll(expressionRewriter.variables);
 
@@ skipping 664 matching lines @@
         coreTypes.getMember('dart:core', '_SyncIterable', ''),
         coreTypes.getMember('dart:async', '_StreamIterator', ''),
         coreTypes.getMember('dart:async', 'Future', 'microtask'),
         coreTypes.getMember('dart:async', '_AsyncStarStreamController', ''),
         coreTypes.getTopLevelMember('dart:async', '_asyncThenWrapperHelper'),
         coreTypes.getTopLevelMember('dart:async', '_asyncErrorWrapperHelper'),
         coreTypes.getTopLevelMember('dart:async', '_awaitHelper'),
         coreTypes);
   }
 }