Provide source map info for simple async methods.

pkg/compiler/lib/src/js/rewrite_async.dart

 // Copyright (c) 2015, 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 rewrite_async;
 
 import 'dart:collection';
-import "dart:math" show max;
+import 'dart:math' show max;
 
 import 'package:js_runtime/shared/async_await_error_codes.dart' as error_codes;
 
 import '../common.dart';
+import '../io/source_information.dart' show SourceInformation;
 import '../util/util.dart' show Pair;
-import "js.dart" as js;
+import 'js.dart' as js;
 
 /// Rewrites a [js.Fun] with async/sync*/async* functions and await and yield
 /// (with dart-like semantics) to an equivalent function without these.
 /// await-for is not handled and must be rewritten before. (Currently handled
 /// in ssa/builder.dart).
 ///
 /// When generating the input to this, special care must be taken that
 /// parameters to sync* functions that are mutated in the body must be boxed.
 /// (Currently handled in closure.dart).
 ///
@@ skipping 487 matching lines @@
 
   void addFunctionExits() {
     addSuccesExit();
     addErrorExit();
   }
 
   /// Returns the rewritten function.
   js.Fun finishFunction(
       List<js.Parameter> parameters,
       js.Statement rewrittenBody,
-      js.VariableDeclarationList variableDeclarations);
+      js.VariableDeclarationList variableDeclarations,
+      SourceInformation sourceInformation);
 
   Iterable<js.VariableInitialization> variableInitializations();
 
   /// Rewrites an async/sync*/async* function to a normal Javascript function.
   ///
   /// The control flow is flattened by simulating 'goto' using a switch in a
   /// loop and a state variable [goto] inside a nested function [body]
   /// that can be called back by [asyncStarHelper]/[asyncStarHelper]/the
   /// [Iterator].
   ///
@@ skipping 165 matching lines @@
       variables.add(_makeVariableInitializer(self, js.js('this')));
     }
     variables.addAll(localVariables.map((js.VariableDeclaration declaration) {
       return new js.VariableInitialization(declaration, null);
     }));
     variables.addAll(new Iterable.generate(tempVarHighWaterMark,
         (int i) => _makeVariableInitializer(useTempVar(i + 1).name, null)));
     js.VariableDeclarationList variableDeclarations =
         new js.VariableDeclarationList(variables);
 
-    return finishFunction(node.params, rewrittenBody, variableDeclarations);
+    return finishFunction(node.params, rewrittenBody, variableDeclarations,
+        node.sourceInformation);
   }
 
   @override
   js.Expression visitFun(js.Fun node) {
     if (node.asyncModifier.isAsync || node.asyncModifier.isYielding) {
       // The translation does not handle nested functions that are generators
       // or asynchronous.  These functions should only be ones that are
       // introduced by JS foreign code from our own libraries.
       reporter.internalError(
           spannable, 'Nested function is a generator or asynchronous.');
@@ skipping 125 matching lines @@
       return;
     }
     translateJump(target, breakLabels[target]);
   }
 
   @override
   js.Expression visitCall(js.Call node) {
     bool storeTarget = node.arguments.any(shouldTransform);
     return withCallTargetExpression(node.target, (target) {
       return withExpressions(node.arguments, (List<js.Expression> arguments) {
-        return new js.Call(target, arguments);
+        return new js.Call(target, arguments)
+            .withSourceInformation(node.sourceInformation);
       });
     }, store: storeTarget);
   }
 
   @override
   void visitCase(js.Case node) {
     return unreachable(node);
   }
 
   @override
@@ skipping 533 matching lines @@
   }
 
   @override
   js.Expression visitThis(js.This node) {
     return self;
   }
 
   @override
   void visitThrow(js.Throw node) {
     withExpression(node.expression, (js.Expression expression) {
-      addStatement(new js.Throw(expression));
+      addStatement(new js.Throw(expression)
+          .withSourceInformation(node.sourceInformation));
     }, store: false);
   }
 
   setErrorHandler([int errorHandler]) {
     js.Expression label =
         (errorHandler == null) ? currentErrorHandler : js.number(errorHandler);
     addStatement(js.js.statement('# = #;', [handler, label]));
   }
 
   List<int> _finalliesUpToAndEnclosingHandler() {
@@ skipping 286 matching lines @@
   /// Returning from an async method calls [asyncStarHelper] with the result.
   /// (the result might have been stored in [returnValue] by some finally
   /// block).
   void addSuccesExit() {
     if (analysis.hasExplicitReturns) {
       beginLabel(exitLabel);
     } else {
       addStatement(new js.Comment("implicit return"));
     }
     addStatement(js.js.statement(
-        "return #runtimeHelper(#returnValue, #successCode, #completer);",
-        {
-          "runtimeHelper": asyncHelper,
-          "successCode": js.number(error_codes.SUCCESS),
-          "returnValue":
-              analysis.hasExplicitReturns ? returnValue : new js.LiteralNull(),
-          "completer": completer
-        }));
+        "return #runtimeHelper(#returnValue, #successCode, #completer);", {
+      "runtimeHelper": asyncHelper,
+      "successCode": js.number(error_codes.SUCCESS),
+      "returnValue":
+          analysis.hasExplicitReturns ? returnValue : new js.LiteralNull(),
+      "completer": completer
+    }));
   }
 
   @override
   Iterable<js.VariableInitialization> variableInitializations() {
     List<js.VariableInitialization> variables =
         new List<js.VariableInitialization>();
     variables
         .add(_makeVariableInitializer(completer, new js.New(newCompleter, [])));
     if (analysis.hasExplicitReturns) {
       variables.add(_makeVariableInitializer(returnValue, null));
@@ skipping 19 matching lines @@
           "value": value,
           "bodyName": bodyName,
           "completer": completer
         });
   }
 
   @override
   js.Fun finishFunction(
       List<js.Parameter> parameters,
       js.Statement rewrittenBody,
-      js.VariableDeclarationList variableDeclarations) {
+      js.VariableDeclarationList variableDeclarations,
+      SourceInformation sourceInformation) {
     return js.js(
         """
         function (#parameters) {
           #variableDeclarations;
           var #bodyName = #wrapBody(function (#errorCode, #result) {
             if (#errorCode === #ERROR) {
                 #currentError = #result;
                 #goto = #handler;
             }
             #rewrittenBody;
           });
           return #asyncHelper(null, #bodyName, #completer);
         }""",
         {
           "parameters": parameters,
           "variableDeclarations": variableDeclarations,
           "ERROR": js.number(error_codes.ERROR),
           "rewrittenBody": rewrittenBody,
           "bodyName": bodyName,
           "currentError": currentError,
           "goto": goto,
           "handler": handler,
           "errorCode": errorCodeName,
           "result": resultName,
           "asyncHelper": asyncHelper,
           "completer": completer,
           "wrapBody": wrapBody,
-        });
+        }).withSourceInformation(sourceInformation);
   }
 }
 
 class SyncStarRewriter extends AsyncRewriterBase {
   bool get isSyncStar => true;
 
   /// Contructor creating the Iterable for a sync* method. Called with
   /// [bodyName].
   final js.Expression newIterable;
 
@@ skipping 30 matching lines @@
           new js.Return(new js.Call(yieldStarExpression, [expression])));
     } else {
       addStatement(new js.Return(expression));
     }
   }
 
   @override
   js.Fun finishFunction(
       List<js.Parameter> parameters,
       js.Statement rewrittenBody,
-      js.VariableDeclarationList variableDeclarations) {
+      js.VariableDeclarationList variableDeclarations,
+      SourceInformation sourceInformation) {
     // Each iterator invocation on the iterable should work on its own copy of
     // the parameters.
     // TODO(sigurdm): We only need to do this copying for parameters that are
     // mutated.
     List<js.VariableInitialization> declarations =
         new List<js.VariableInitialization>();
     List<js.Parameter> renamedParameters = new List<js.Parameter>();
     for (js.Parameter parameter in parameters) {
       String name = parameter.name;
       String renamedName = freshName(name);
@@ skipping 32 matching lines @@
           "varDecl": variableDeclarations,
           "errorCode": errorCodeName,
           "newIterable": newIterable,
           "body": bodyName,
           "self": selfName,
           "result": resultName,
           "goto": goto,
           "handler": handler,
           "currentError": currentErrorName,
           "ERROR": js.number(error_codes.ERROR),
-        });
+        }).withSourceInformation(sourceInformation);
   }
 
   void addErrorExit() {
     beginLabel(rethrowLabel);
     addStatement(js.js
         .statement('return #(#);', [uncaughtErrorExpression, currentError]));
   }
 
   /// Returning from a sync* function returns an [endOfIteration] marker.
   void addSuccesExit() {
@@ skipping 118 matching lines @@
           "expression": expression,
           "bodyName": bodyName,
           "controller": controllerName,
         }));
   }
 
   @override
   js.Fun finishFunction(
       List<js.Parameter> parameters,
       js.Statement rewrittenBody,
-      js.VariableDeclarationList variableDeclarations) {
+      js.VariableDeclarationList variableDeclarations,
+      SourceInformation sourceInformation) {
     return js.js(
         """
         function (#parameters) {
           var #bodyName = #wrapBody(function (#errorCode, #result) {
             if (#hasYield) {
               switch (#errorCode) {
                 case #STREAM_WAS_CANCELED:
                   #next = #nextWhenCanceled;
                   #goto = #next.pop();
                   break;
@@ skipping 23 matching lines @@
           "currentError": currentError,
           "goto": goto,
           "handler": handler,
           "next": next,
           "nextWhenCanceled": nextWhenCanceled,
           "errorCode": errorCodeName,
           "result": resultName,
           "streamOfController": streamOfController,
           "controller": controllerName,
           "wrapBody": wrapBody,
-        });
+        }).withSourceInformation(sourceInformation);
   }
 
   @override
   void addErrorExit() {
     beginLabel(rethrowLabel);
     addStatement(js.js.statement(
         "return #asyncHelper(#currentError, #errorCode, #controller);", {
       "asyncHelper": asyncStarHelper,
       "errorCode": js.number(error_codes.ERROR),
       "currentError": currentError,
@@ skipping 497 matching lines @@
     return condition || body;
   }
 
   @override
   bool visitDartYield(js.DartYield node) {
     hasYield = true;
     visit(node.expression);
     return true;
   }
 }