[Kernel] replace function debuggable field with originalAsyncMarker field

pkg/kernel/lib/ast.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.
 
 /// -----------------------------------------------------------------------
 ///                           ERROR HANDLING
 /// -----------------------------------------------------------------------
 ///
 /// As a rule of thumb, errors that can be detected statically are handled by
 /// the frontend, typically by translating the erroneous code into a 'throw' or
@@ skipping 1132 matching lines @@
 /// A function declares parameters and has a body.
 ///
 /// This may occur in a procedure, constructor, function expression, or local
 /// function declaration.
 class FunctionNode extends TreeNode {
   /// End offset in the source file it comes from. Valid values are from 0 and
   /// up, or -1 ([TreeNode.noOffset]) if the file end offset is not available
   /// (this is the default if none is specifically set).
   int fileEndOffset = TreeNode.noOffset;
 
+  /// Current async marker for the function.
   AsyncMarker asyncMarker;
-  bool debuggable = true;
+
+  /// Original async marker for the function.
+  ///
+  /// In source code, a function can for instance be marked as async.

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

I wouldn't discuss all these imperative details (specifically, one might just
build a new function and this discussion of updating fields doesn't make any
sense).  Instead of "current" and "original" I would adopt naming something like
dartAsyncMarker and kernelAsyncMarker and then make the comment declarative:

"A Kernel function can represent a Dart function with a different async marker."

If we need an example we can write: "For example, when async/await is translated
away, a Dart async function might be represented by a Kernel sync function."

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

Done.

+  /// This will make the async marker be [Async]. A kernel transformation can
+  /// however transform this code at mark it as [Sync]. Such a transformation
+  /// should update this field to indicate the original async status.
+  /// This way, for instance, the VM, can still behave slightly different
+  /// (e.g. make stacktraces more readable).
+  AsyncMarker originalAsyncMarker;
   List<TypeParameter> typeParameters;
   int requiredParameterCount;
   List<VariableDeclaration> positionalParameters;
   List<VariableDeclaration> namedParameters;
   InferredValue inferredReturnValue; // May be null.
   DartType returnType; // Not null.
   Statement body;
 
   FunctionNode(this.body,
       {List<TypeParameter> typeParameters,
       List<VariableDeclaration> positionalParameters,
       List<VariableDeclaration> namedParameters,
       int requiredParameterCount,
       this.returnType: const DynamicType(),
       this.inferredReturnValue,
-      this.asyncMarker: AsyncMarker.Sync})
+      this.asyncMarker: AsyncMarker.Sync,
+      this.originalAsyncMarker: AsyncMarker.Sync})
       : this.positionalParameters =
             positionalParameters ?? <VariableDeclaration>[],
         this.requiredParameterCount =
             requiredParameterCount ?? positionalParameters?.length ?? 0,
         this.namedParameters = namedParameters ?? <VariableDeclaration>[],
         this.typeParameters = typeParameters ?? <TypeParameter>[] {
     assert(returnType != null);
     setParents(this.typeParameters, this);
     setParents(this.positionalParameters, this);
     setParents(this.namedParameters, this);
@@ skipping 2564 matching lines @@
     }
   }
 }
 
 class Source {
   final List<int> lineStarts;
   final String source;
 
   Source(this.lineStarts, this.source);
 }