[Kernel] replace function debuggable field with originalAsyncMarker field

pkg/kernel/lib/transformations/method_call.dart

 // Copyright (c) 2017, 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.method_call;
 
 import 'dart:math' as math;
 
 import '../ast.dart';
 import '../class_hierarchy.dart';
@@ skipping 743 matching lines @@
     final newParameters =
         new List<VariableDeclaration>.from(function.positionalParameters);
     final named = new List<VariableDeclaration>.from(function.namedParameters);
     named.sort((a, b) => a.name.compareTo(b.name));
     newParameters.addAll(named);
     final functionNode = new FunctionNode(function.body,
         positionalParameters: newParameters,
         namedParameters: [],
         requiredParameterCount: newParameters.length,
         returnType: function.returnType,
-        asyncMarker: function.asyncMarker);
+        asyncMarker: function.asyncMarker,
+        originalAsyncMarker: function.originalAsyncMarker);
     return functionNode;
   }
 
   /// Creates new variables, moving old initializers into them
   ///
   /// Specifically: Given lists for output, create new variables based on
   /// original parameters. Any new variable will receive the original variables
   /// initializer, and the original variable will have its initializer set to
   /// null.
   /// Named parameters have been sorted in [newParameterVariableGets].
@@ skipping 86 matching lines @@
     final expression = new DirectMethodInvocation(
         new ThisExpression(), noSuchMethod, argumentsToNoSuchMethod);
     statement = new ReturnStatement(expression);
 
     // Build procedure
     final functionNode = new FunctionNode(statement,
         positionalParameters: newParameterDeclarations,
         namedParameters: [],
         requiredParameterCount: newParameterDeclarations.length,
         returnType: existing.function.returnType,
-        asyncMarker: existing.function.asyncMarker);
+        asyncMarker: existing.function.asyncMarker,
+        originalAsyncMarker: existing.function.originalAsyncMarker);
     final procedure = new Procedure(
         procedureName, ProcedureKind.Method, functionNode,
         isStatic: existing.isStatic, fileUri: existing.fileUri);
 
     // Add procedure to the code
     _addMember(existing, procedure);
 
     // Mark the new procedure as visited already (i.e. don't rewrite it again!)
     _visited.add(procedure);
 
@@ skipping 104 matching lines @@
           realTarget, new Arguments(newParameterVariableGets));
       statement = new ReturnStatement(expression);
     }
 
     // Build procedure
     final functionNode = new FunctionNode(statement,
         positionalParameters: newParameterDeclarations,
         namedParameters: [],
         requiredParameterCount: newParameterDeclarations.length,
         returnType: target.function.returnType,
-        asyncMarker: target.function.asyncMarker);
+        asyncMarker: target.function.asyncMarker,
+        originalAsyncMarker: target.function.originalAsyncMarker);
     final procedure = new Procedure(
         _createName(target.name, argumentsSignature),
         ProcedureKind.Method,
         functionNode,
         isAbstract: target.isAbstract,
         isStatic: target.isStatic,
         isConst: target.isConst,
         fileUri: target.fileUri);
 
     // Add procedure to the code
@@ skipping 36 matching lines @@
     final newParameterVariableGets = <Expression>[];
     _extractAndCreateParameters(positionalCount, newParameterDeclarations,
         newParameterVariableGets, target, givenNamedParameters);
 
     // Build constructor
     final functionNode = new FunctionNode(null,
         positionalParameters: newParameterDeclarations,
         namedParameters: [],
         requiredParameterCount: newParameterDeclarations.length,
         returnType: target.function.returnType,
-        asyncMarker: target.function.asyncMarker);
+        asyncMarker: target.function.asyncMarker,
+        originalAsyncMarker: target.function.originalAsyncMarker);
     final constructor = new Constructor(functionNode,
         name: _createName(target.name, argumentsSignature),
         isConst: target.isConst,
         isExternal: target.isExternal,
         initializers: [
           new RedirectingInitializer(
               realTarget, new Arguments(newParameterVariableGets))
         ]);
 
     // Add procedure to the code
@@ skipping 239 matching lines @@
     return printStackTrace;
   }
 }
 
 class _Pair<K, V> {
   final K key;
   final V value;
 
   _Pair(this.key, this.value);
 }