Generated source mapping through CPS.

pkg/compiler/lib/src/tree_ir/tree_ir_builder.dart

 // Copyright (c) 2014, 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 tree_ir_builder;
 
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart';
 import '../cps_ir/cps_ir_nodes.dart' as cps_ir;
 import '../util/util.dart' show CURRENT_ELEMENT_SPANNABLE;
@@ skipping 256 matching lines @@
   }
 
   Expression visitInterceptor(cps_ir.Interceptor node) {
     return new Interceptor(getVariableUse(node.input), node.interceptedClasses);
   }
 
   Expression visitCreateInstance(cps_ir.CreateInstance node) {
     return new CreateInstance(
         node.classElement,
         translateArguments(node.arguments),
-        translateArguments(node.typeInformation));
+        translateArguments(node.typeInformation),
+        node.sourceInformation);
   }
 
   Expression visitGetField(cps_ir.GetField node) {
     return new GetField(getVariableUse(node.object), node.field);
   }
 
   Expression visitCreateBox(cps_ir.CreateBox node) {
     return new CreateBox();
   }
 
@@ skipping 60 matching lines @@
 
   Statement visitInvokeStatic(cps_ir.InvokeStatic node) {
     // Calls are translated to direct style.
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeStatic(node.target, node.selector, arguments,
                                          node.sourceInformation);
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeMethod(cps_ir.InvokeMethod node) {
-    InvokeMethod invoke = new InvokeMethod(getVariableUse(node.receiver),
-                                           node.selector,
-                                           node.mask,
-                                           translateArguments(node.arguments));
+    InvokeMethod invoke = new InvokeMethod(
+        getVariableUse(node.receiver),
+        node.selector,
+        node.mask,
+        translateArguments(node.arguments),
+        node.sourceInformation);
     invoke.receiverIsNotNull = node.receiverIsNotNull;
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeMethodDirectly(cps_ir.InvokeMethodDirectly node) {
     Expression receiver = getVariableUse(node.receiver);
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeMethodDirectly(receiver, node.target,
-        node.selector, arguments);
+        node.selector, arguments, node.sourceInformation);
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitThrow(cps_ir.Throw node) {
     Expression value = getVariableUse(node.value);
     return new Throw(value);
   }
 
   Statement visitRethrow(cps_ir.Rethrow node) {
     return new Rethrow();
@@ skipping 51 matching lines @@
     List<Expression> typeArgs = translateArguments(node.typeArguments);
     return new TypeOperator(value, node.type, typeArgs, isTypeTest: true);
   }
 
   Statement visitInvokeConstructor(cps_ir.InvokeConstructor node) {
     List<Expression> arguments = translateArguments(node.arguments);
     Expression invoke = new InvokeConstructor(
         node.type,
         node.target,
         node.selector,
-        arguments);
+        arguments,
+        node.sourceInformation);
     return continueWithExpression(node.continuation, invoke);
   }
 
   Statement visitInvokeContinuation(cps_ir.InvokeContinuation node) {
     // Invocations of the return continuation are translated to returns.
     // Other continuation invocations are replaced with assignments of the
     // arguments to formal parameter variables, followed by the body if
     // the continuation is singly reference or a break if it is multiply
     // referenced.
     cps_ir.Continuation cont = node.continuation.definition;
     if (cont == returnContinuation) {
       assert(node.arguments.length == 1);
-      return new Return(getVariableUse(node.arguments.single));
+      return new Return(getVariableUse(node.arguments.single),
+                        sourceInformation: node.sourceInformation);
     } else {
       List<Expression> arguments = translateArguments(node.arguments);
       return buildPhiAssignments(cont.parameters, arguments,
           () {
             // Translate invocations of recursive and non-recursive
             // continuations differently.
             //   * Non-recursive continuations
             //     - If there is one use, translate the continuation body
             //       inline at the invocation site.
             //     - If there are multiple uses, translate to Break.
@@ skipping 27 matching lines @@
     thenStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     cont = node.falseContinuation.definition;
     assert(cont.parameters.isEmpty);
     elseStatement =
         cont.hasExactlyOneUse ? visit(cont.body) : new Break(labels[cont]);
     return new If(condition, thenStatement, elseStatement);
   }
 
   Expression visitConstant(cps_ir.Constant node) {
-    return new Constant(node.value);
+    return new Constant(node.value, sourceInformation: node.sourceInformation);
   }
 
   Expression visitLiteralList(cps_ir.LiteralList node) {
     return new LiteralList(
             node.type,
             translateArguments(node.values));
   }
 
   Expression visitLiteralMap(cps_ir.LiteralMap node) {
     return new LiteralMap(
@@ skipping 31 matching lines @@
     // These occur as parameters or bound by LetMutable.  They are not visited
     // directly.
     unexpectedNode(node);
   }
 
   Expression visitIsTrue(cps_ir.IsTrue node) {
     return getVariableUse(node.value);
   }
 
   Expression visitReifyRuntimeType(cps_ir.ReifyRuntimeType node) {
-    return new ReifyRuntimeType(getVariableUse(node.value));
+    return new ReifyRuntimeType(
+        getVariableUse(node.value), node.sourceInformation);
   }
 
   Expression visitReadTypeVariable(cps_ir.ReadTypeVariable node) {
-    return new ReadTypeVariable(node.variable, getVariableUse(node.target));
+    return new ReadTypeVariable(
+        node.variable,
+        getVariableUse(node.target),
+        node.sourceInformation);
   }
 
   @override
   Node visitTypeExpression(cps_ir.TypeExpression node) {
     return new TypeExpression(
         node.dartType,
         node.arguments.map(getVariableUse).toList());
   }
 
   Expression visitGetStatic(cps_ir.GetStatic node) {
@@ skipping 52 matching lines @@
                         getVariableUse(node.index));
   }
 
   Expression visitSetIndex(cps_ir.SetIndex node) {
     return new SetIndex(getVariableUse(node.object),
                         getVariableUse(node.index),
                         getVariableUse(node.value));
   }
 }