Generated source mapping through CPS.

pkg/compiler/lib/src/js_backend/codegen/codegen.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 code_generator;
 
 import 'glue.dart';
 
 import '../../tree_ir/tree_ir_nodes.dart' as tree_ir;
 import '../../tree_ir/tree_ir_nodes.dart' show BuiltinOperator;
@@ skipping 33 matching lines @@
       new Maplet<VariableElement, String>();
 
   /// Variable names that have already been used. Used to avoid name clashes.
   Set<String> usedVariableNames = new Set<String>();
 
   final tree_ir.FallthroughStack fallthrough = new tree_ir.FallthroughStack();
 
   /// Stacks whose top element is the current target of an unlabeled break
   /// or continue. For continues, this is the loop node itself.
   final tree_ir.FallthroughStack shortBreak = new tree_ir.FallthroughStack();
-  final tree_ir.FallthroughStack shortContinue = 
+  final tree_ir.FallthroughStack shortContinue =
       new tree_ir.FallthroughStack();
 
   Set<tree_ir.Label> usedLabels = new Set<tree_ir.Label>();
 
   List<js.Statement> accumulator = new List<js.Statement>();
 
   CodeGenerator(this.glue, this.registry);
 
   /// Generates JavaScript code for the body of [function].
   js.Fun buildFunction(tree_ir.FunctionDefinition function) {
@@ skipping 111 matching lines @@
   }
 
   @override
   js.Expression visitConditional(tree_ir.Conditional node) {
     return new js.Conditional(
         visitExpression(node.condition),
         visitExpression(node.thenExpression),
         visitExpression(node.elseExpression));
   }
 
-  js.Expression buildConstant(ConstantValue constant) {
+  js.Expression buildConstant(ConstantValue constant,
+                              {SourceInformation sourceInformation}) {
     registry.registerCompileTimeConstant(constant);
-    return glue.constantReference(constant);
+    return glue.constantReference(constant)
+        .withSourceInformation(sourceInformation);
   }
 
   @override
   js.Expression visitConstant(tree_ir.Constant node) {
-    return buildConstant(node.value);
+    return buildConstant(
+        node.value,
+        sourceInformation: node.sourceInformation);
   }
 
   js.Expression compileConstant(ParameterElement parameter) {
     return buildConstant(glue.getConstantValueForVariable(parameter));
   }
 
   js.Expression buildStaticInvoke(Element target,
                                   List<js.Expression> arguments,
                                   {SourceInformation sourceInformation}) {
     registry.registerStaticInvocation(target.declaration);
     js.Expression elementAccess = glue.staticFunctionAccess(target);
     return new js.Call(elementAccess, arguments,
         sourceInformation: sourceInformation);
   }
 
   @override
   js.Expression visitInvokeConstructor(tree_ir.InvokeConstructor node) {
     if (node.constant != null) return giveup(node);
 
     registry.registerInstantiatedType(node.type);
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitExpressionList(node.arguments);
-    return buildStaticInvoke(target, arguments);
+    return buildStaticInvoke(
+        target, arguments, sourceInformation: node.sourceInformation);
   }
 
   void registerMethodInvoke(tree_ir.InvokeMethod node) {
     Selector selector = node.selector;
     TypeMask mask = node.mask;
     if (selector.isGetter) {
       registry.registerDynamicGetter(new UniverseSelector(selector, mask));
     } else if (selector.isSetter) {
       registry.registerDynamicSetter(new UniverseSelector(selector, mask));
     } else {
       assert(invariant(CURRENT_ELEMENT_SPANNABLE,
           selector.isCall || selector.isOperator ||
           selector.isIndex || selector.isIndexSet,
           message: 'unexpected kind ${selector.kind}'));
       // TODO(sigurdm): We should find a better place to register the call.
       Selector call = new Selector.callClosureFrom(selector);
       registry.registerDynamicInvocation(new UniverseSelector(call, null));
       registry.registerDynamicInvocation(new UniverseSelector(selector, mask));
     }
   }
 
   @override
   js.Expression visitInvokeMethod(tree_ir.InvokeMethod node) {
     registerMethodInvoke(node);
     return js.propertyCall(visitExpression(node.receiver),
                            glue.invocationName(node.selector),
-                           visitExpressionList(node.arguments));
+                           visitExpressionList(node.arguments))
+        .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitInvokeStatic(tree_ir.InvokeStatic node) {
     FunctionElement target = node.target;
     List<js.Expression> arguments = visitExpressionList(node.arguments);
     return buildStaticInvoke(target, arguments,
           sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitInvokeMethodDirectly(tree_ir.InvokeMethodDirectly node) {
     registry.registerDirectInvocation(node.target.declaration);
     if (node.target is ConstructorBodyElement) {
       // A constructor body cannot be overriden or intercepted, so we can
       // use the short form for this invocation.
       return js.js('#.#(#)',
           [visitExpression(node.receiver),
            glue.instanceMethodName(node.target),
-           visitExpressionList(node.arguments)]);
+           visitExpressionList(node.arguments)])
+          .withSourceInformation(node.sourceInformation);
     }
     return js.js('#.#.call(#, #)',
         [glue.prototypeAccess(node.target.enclosingClass),
          glue.invocationName(node.selector),
          visitExpression(node.receiver),
-         visitExpressionList(node.arguments)]);
+         visitExpressionList(node.arguments)])
+        .withSourceInformation(node.sourceInformation);
   }
 
   @override
   js.Expression visitLiteralList(tree_ir.LiteralList node) {
     registry.registerInstantiatedClass(glue.listClass);
     List<js.Expression> entries = visitExpressionList(node.values);
     return new js.ArrayInitializer(entries);
   }
 
   @override
@@ skipping 138 matching lines @@
   }
 
   @override
   void visitBreak(tree_ir.Break node) {
     if (isEffectiveBreakTarget(node, fallthrough.target)) {
       // Fall through to break target or to equivalent break.
       fallthrough.use();
     } else if (isEffectiveBreakTarget(node, shortBreak.target)) {
       // Unlabeled break to the break target or to an equivalent break.
       shortBreak.use();
-      accumulator.add(new js.Break(null)); 
+      accumulator.add(new js.Break(null));
     } else {
       usedLabels.add(node.target);
       accumulator.add(new js.Break(node.target.name));
     }
   }
 
   @override
   void visitExpressionStatement(tree_ir.ExpressionStatement node) {
     accumulator.add(new js.ExpressionStatement(
         visitExpression(node.expression)));
@@ skipping 101 matching lines @@
     return node is tree_ir.Constant && node.value.isNull;
   }
 
   @override
   void visitReturn(tree_ir.Return node) {
     if (isNull(node.value) && fallthrough.target == null) {
       // Do nothing. Implicitly return JS undefined by falling over the end.
       registry.registerCompileTimeConstant(new NullConstantValue());
       fallthrough.use();
     } else {
-      accumulator.add(new js.Return(visitExpression(node.value)));
+      accumulator.add(new js.Return(visitExpression(node.value))
+            .withSourceInformation(node.sourceInformation));
     }
   }
 
   @override
   void visitThrow(tree_ir.Throw node) {
     accumulator.add(new js.Throw(visitExpression(node.value)));
   }
 
   @override
   void visitRethrow(tree_ir.Rethrow node) {
@@ skipping 28 matching lines @@
     // TODO(asgerf): To allow inlining of InvokeConstructor, CreateInstance must
     //               carry a DartType so we can register the instantiated type
     //               with its type arguments. Otherwise dataflow analysis is
     //               needed to reconstruct the instantiated type.
     registry.registerInstantiatedClass(classElement);
     if (classElement is ClosureClassElement) {
       registry.registerInstantiatedClosure(classElement.methodElement);
     }
     js.Expression instance = new js.New(
         glue.constructorAccess(classElement),
-        visitExpressionList(node.arguments));
+        visitExpressionList(node.arguments))
+        .withSourceInformation(node.sourceInformation);
 
     List<tree_ir.Expression> typeInformation = node.typeInformation;
     assert(typeInformation.isEmpty ||
         typeInformation.length == classElement.typeVariables.length);
     if (typeInformation.isNotEmpty) {
       FunctionElement helper = glue.getAddRuntimeTypeInformation();
       js.Expression typeArguments = new js.ArrayInitializer(
           visitExpressionList(typeInformation));
       return buildStaticHelperInvocation(helper,
-          <js.Expression>[instance, typeArguments]);
+          <js.Expression>[instance, typeArguments],
+          sourceInformation: node.sourceInformation);
     } else {
       return instance;
     }
   }
 
   @override
   js.Expression visitCreateInvocationMirror(
       tree_ir.CreateInvocationMirror node) {
     js.Expression name = js.string(node.selector.name);
     js.Expression internalName =
@@ skipping 77 matching lines @@
   }
 
   @override
   js.Expression visitSetIndex(tree_ir.SetIndex node) {
     return js.js('#[#] = #',
         [visitExpression(node.object),
          visitExpression(node.index),
          visitExpression(node.value)]);
   }
 
-  js.Expression buildStaticHelperInvocation(FunctionElement helper,
-                                            List<js.Expression> arguments) {
+  js.Expression buildStaticHelperInvocation(
+      FunctionElement helper,
+      List<js.Expression> arguments,
+      {SourceInformation sourceInformation}) {
     registry.registerStaticUse(helper);
-    return buildStaticInvoke(helper, arguments);
+    return buildStaticInvoke(
+        helper, arguments, sourceInformation: sourceInformation);
   }
 
   @override
   js.Expression visitReifyRuntimeType(tree_ir.ReifyRuntimeType node) {
-    FunctionElement createType = glue.getCreateRuntimeType();
-    FunctionElement typeToString = glue.getRuntimeTypeToString();
-    return buildStaticHelperInvocation(createType,
-        [buildStaticHelperInvocation(typeToString,
-            [visitExpression(node.value)])]);
+    js.Expression typeToString = buildStaticHelperInvocation(
+        glue.getRuntimeTypeToString(),
+        [visitExpression(node.value)],
+        sourceInformation: node.sourceInformation);
+    return buildStaticHelperInvocation(
+        glue.getCreateRuntimeType(),
+        [typeToString],
+        sourceInformation: node.sourceInformation);
   }
 
   @override
   js.Expression visitReadTypeVariable(tree_ir.ReadTypeVariable node) {
     ClassElement context = node.variable.element.enclosingClass;
     js.Expression index = js.number(glue.getTypeVariableIndex(node.variable));
     if (glue.needsSubstitutionForTypeVariableAccess(context)) {
       js.Expression typeName = glue.getRuntimeTypeName(context);
       return buildStaticHelperInvocation(
           glue.getRuntimeTypeArgument(),
-          [visitExpression(node.target), typeName, index]);
+          [visitExpression(node.target), typeName, index],
+          sourceInformation: node.sourceInformation);
     } else {
       return buildStaticHelperInvocation(
           glue.getTypeArgumentByIndex(),
-          [visitExpression(node.target), index]);
+          [visitExpression(node.target), index],
+          sourceInformation: node.sourceInformation);
     }
   }
 
   @override
   js.Expression visitTypeExpression(tree_ir.TypeExpression node) {
     List<js.Expression> arguments = visitExpressionList(node.arguments);
     return glue.generateTypeRepresentation(node.dartType, arguments);
   }
 
   js.Node handleForeignCode(tree_ir.ForeignCode node) {
@@ skipping 61 matching lines @@
         return js.js("typeof # === 'number' && Math.floor(#) === #", args);
     }
   }
 
   visitFunctionExpression(tree_ir.FunctionExpression node) {
     // FunctionExpressions are currently unused.
     // We might need them if we want to emit raw JS nested functions.
     throw 'FunctionExpressions should not be used';
   }
 }