Pass SourceInformation through the CPS IR.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.dart

 // Copyright (c) 2013, 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.
 
 part of dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
  *
  * The functionality of the IrNodes is added gradually, therefore elements might
  * have an IR or not, depending on the language features that are used. For
  * elements that do have an IR, the tree [ast.Node]s and the [Token]s are not
  * used in the rest of the compilation. This is ensured by setting the element's
  * cached tree to `null` and also breaking the token stream to crash future
  * attempts to parse.
  *
  * The type inferrer works on either IR nodes or tree nodes. The IR nodes are
  * then translated into the SSA form for optimizations and code generation.
  * Long-term, once the IR supports the full language, the backend can be
  * re-implemented to work directly on the IR.
  */
 class IrBuilderTask extends CompilerTask {
   final Map<Element, ir.ExecutableDefinition> nodes =
       <Element, ir.ExecutableDefinition>{};
+  final bool generateSourceMap;
 
-  IrBuilderTask(Compiler compiler) : super(compiler);
+  IrBuilderTask(Compiler compiler, {this.generateSourceMap: true})
+      : super(compiler);
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
   ir.ExecutableDefinition getIr(ExecutableElement element) {
     return nodes[element.implementation];
   }
 
   ir.ExecutableDefinition buildNode(AstElement element) {
     if (!canBuild(element)) return null;
+
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
-      SourceFile sourceFile = elementSourceFile(element);
+      SourceInformationBuilder sourceInformationBuilder = generateSourceMap
+          ? new PositionSourceInformationBuilder(element)
+          : const SourceInformationBuilder();
+
       IrBuilderVisitor builder =
           compiler.backend is JavaScriptBackend
-          ? new JsIrBuilderVisitor(elementsMapping, compiler, sourceFile)
-          : new DartIrBuilderVisitor(elementsMapping, compiler, sourceFile);
-      return builder.buildExecutable(element);
+          ? new JsIrBuilderVisitor(
+              elementsMapping, compiler, sourceInformationBuilder)
+          : new DartIrBuilderVisitor(
+              elementsMapping, compiler, sourceInformationBuilder);
+      ir.ExecutableDefinition definition =
+            builder.buildExecutable(element);
+      if (definition != null) {
+        nodes[element] = definition;
+      }
+      return definition;
     });
   }
 
   void buildNodes() {
     measure(() {
       Set<Element> resolved = compiler.enqueuer.resolution.resolvedElements;
-      resolved.forEach((AstElement element) {
-        ir.ExecutableDefinition definition = buildNode(element);
-        if (definition != null) {
-          nodes[element] = definition;
-        }
-      });
+      resolved.forEach(buildNode);
     });
   }
 
   bool canBuild(Element element) {
     if (element is TypedefElement) return false;
     if (element is FunctionElement) {
       // TODO(sigurdm): Support native functions for dart2js.
       assert(invariant(element, !element.isNative));
 
       if (element is ConstructorElement) {
@@ skipping 37 matching lines @@
 }
 
 /**
  * A tree visitor that builds [IrNodes]. The visit methods add statements using
  * to the [builder] and return the last added statement for trees that represent
  * an expression.
  */
 abstract class IrBuilderVisitor extends ResolvedVisitor<ir.Primitive>
     with IrBuilderMixin<ast.Node> {
   final Compiler compiler;
-  final SourceFile sourceFile;
+  final SourceInformationBuilder sourceInformationBuilder;
 
   // In SSA terms, join-point continuation parameters are the phis and the
   // continuation invocation arguments are the corresponding phi inputs.  To
   // support name introduction and renaming for source level variables, we use
   // nested (delimited) visitors for constructing subparts of the IR that will
   // need renaming.  Each source variable is assigned an index.
   //
   // Each nested visitor maintains a list of free variable uses in the body.
   // These are implemented as a list of parameters, each with their own use
   // list of references.  When the delimited subexpression is plugged into the
   // surrounding context, the free occurrences can be captured or become free
   // occurrences in the next outer delimited subexpression.
   //
   // Each nested visitor maintains a list that maps indexes of variables
   // assigned in the delimited subexpression to their reaching definition ---
   // that is, the definition in effect at the hole in 'current'.  These are
   // used to determine if a join-point continuation needs to be passed
   // arguments, and what the arguments are.
 
   /// Construct a top-level visitor.
-  IrBuilderVisitor(TreeElements elements, this.compiler, this.sourceFile)
+  IrBuilderVisitor(TreeElements elements,
+                   this.compiler,
+                   this.sourceInformationBuilder)
       : super(elements);
 
   /**
    * Builds the [ir.ExecutableDefinition] for an executable element. In case the
    * function uses features that cannot be expressed in the IR, this element
    * returns `null`.
    */
   ir.ExecutableDefinition buildExecutable(ExecutableElement element);
 
   ClosureScope getClosureScopeForNode(ast.Node node);
@@ skipping 496 matching lines @@
             irBuilder.buildDynamicInvocation(receiver, selector, arguments);
       }
     } else if (element.isField || element.isGetter || element.isErroneous ||
                element.isSetter) {
       // TODO(johnniwinther): Change handling of setter selectors.
       // Access to a static field or getter (non-static case handled above).
       // Even if there is only a setter, we compile as if it was a getter,
       // so the vm can fail at runtime.
       assert(selector.kind == SelectorKind.GETTER ||
              selector.kind == SelectorKind.SETTER);
-      result = irBuilder.buildStaticGet(element, selector);
+      result = irBuilder.buildStaticGet(element, selector,
+          sourceInformation: sourceInformationBuilder.buildGet(node));
     } else if (Elements.isStaticOrTopLevelFunction(element)) {
       // Convert a top-level or static function to a function object.
       result = translateConstant(node);
     } else {
       throw "Unexpected SendSet getter: $node, $element";
     }
     return new _GetterElements(
         result: result,index: index, receiver: receiver);
   }
 
@@ skipping 78 matching lines @@
       return irBuilder.buildCallInvocation(receiver, call, arguments);
     } else if (selector.isGetter) {
       // We are reading a static field or invoking a static getter.
       return irBuilder.buildStaticGet(element, selector);
     } else {
       // We are invoking a static method.
       assert(selector.isCall);
       assert(element is FunctionElement);
       List<ir.Primitive> arguments = node.arguments.mapToList(visit);
       arguments = normalizeStaticArguments(selector, element, arguments);
-      return irBuilder.buildStaticInvocation(element, selector, arguments);
+      return irBuilder.buildStaticInvocation(element, selector, arguments,
+          sourceInformation: sourceInformationBuilder.buildCall(node));
     }
   }
 
   ir.Primitive visitSuperSend(ast.Send node) {
     assert(irBuilder.isOpen);
     Selector selector = elements.getSelector(node);
     Element target = elements[node];
 
     if (selector.isCall && (target.isGetter || target.isField)) {
       // We are invoking a field or getter as if it was a method, e.g:
@@ skipping 305 matching lines @@
     currentFunction = oldFunction;
   }
 }
 
 /// IR builder specific to the Dart backend, coupled to the [DartIrBuilder].
 class DartIrBuilderVisitor extends IrBuilderVisitor {
   /// Promote the type of [irBuilder] to [DartIrBuilder].
   DartIrBuilder get irBuilder => super.irBuilder;
 
   DartIrBuilderVisitor(TreeElements elements,
-                   Compiler compiler,
-                   SourceFile sourceFile)
-      : super(elements, compiler, sourceFile);
+                       Compiler compiler,
+                       SourceInformationBuilder sourceInformationBuilder)
+      : super(elements, compiler, sourceInformationBuilder);
 
   DartIrBuilder makeIRBuilder(ast.Node node, ExecutableElement element) {
     DartCapturedVariables closures = new DartCapturedVariables(elements);
     if (!element.isSynthesized) {
       closures.visit(node);
     }
     return new DartIrBuilder(compiler.backend.constantSystem,
                              element,
                              closures);
   }
@@ skipping 104 matching lines @@
   /// Will be initialized upon entering the body of a function.
   /// It is computed by the [ClosureTranslator].
   ClosureClassMap closureMap;
 
   /// During construction of a constructor factory, [fieldValues] maps fields
   /// to the primitive containing their initial value.
   Map<FieldElement, ir.Primitive> fieldValues = <FieldElement, ir.Primitive>{};
 
   JsIrBuilderVisitor(TreeElements elements,
                      Compiler compiler,
-                     SourceFile sourceFile)
-      : super(elements, compiler, sourceFile);
+                     SourceInformationBuilder sourceInformationBuilder)
+      : super(elements, compiler, sourceInformationBuilder);
 
   /// Builds the IR for creating an instance of the closure class corresponding
   /// to the given nested function.
   ClosureClassElement makeSubFunction(ast.FunctionExpression node) {
     ClosureClassMap innerMap =
         compiler.closureToClassMapper.getMappingForNestedFunction(node);
     ClosureClassElement closureClass = innerMap.closureClassElement;
     return closureClass;
   }
 
@@ skipping 90 matching lines @@
   }
 
   /// Builds the IR for an [expression] taken from a different [context].
   ///
   /// Such expressions need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineExpression(AstElement context, ast.Expression expression) {
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
         compiler,
-        elementSourceFile(context));
+        sourceInformationBuilder.forContext(context));
     return visitor.withBuilder(irBuilder, () => visitor.visit(expression));
   }
 
   /// Builds the IR for a constant taken from a different [context].
   ///
   /// Such constants need to be compiled with a different [sourceFile] and
   /// [elements] mapping.
   ir.Primitive inlineConstant(AstElement context, ast.Expression exp) {
     JsIrBuilderVisitor visitor = new JsIrBuilderVisitor(
         context.resolvedAst.elements,
         compiler,
-        elementSourceFile(context));
+        sourceInformationBuilder.forContext(context));
     return visitor.withBuilder(irBuilder, () => visitor.translateConstant(exp));
   }
 
   /// Builds the IR for a given constructor.
   ///
   /// 1. Evaluates all own or inherited field initializers.
   /// 2. Creates the object and assigns its fields.
   /// 3. Calls constructor body and super constructor bodies.
   /// 4. Returns the created object.
   ir.FunctionDefinition buildConstructor(ConstructorElement constructor) {
@@ skipping 361 matching lines @@
     for (int i=0; i < selector.positionalArgumentCount; i++) {
       result.add(arguments[i]);
     }
     for (String argName in selector.getOrderedNamedArguments()) {
       int nameIndex = selector.namedArguments.indexOf(argName);
       int translatedIndex = selector.positionalArgumentCount + nameIndex;
       result.add(arguments[translatedIndex]);
     }
     return result;
   }
-
 }
 
+/// Interface for generating [SourceInformation] for the CPS.
+class SourceInformationBuilder {
+  const SourceInformationBuilder();
+
+  /// Create a [SourceInformationBuilder] for [element].
+  SourceInformationBuilder forContext(AstElement element) => this;
+
+  /// Generate [SourceInformation] for the read access in [node].
+  SourceInformation buildGet(ast.Node node) => null;

[floitsch, 2015/02/24 19:58:12]

The "build" reads redundant at the use-sites, but I guess removing them wouldn't
be great either... :(

+
+  /// Generate [SourceInformation] for the invocation in [node].
+  SourceInformation buildCall(ast.Node node) => null;
+}
+
+/// [SourceInformationBuilder] that generates [PositionSourceInformation].
+class PositionSourceInformationBuilder implements SourceInformationBuilder {
+  final SourceFile sourceFile;
+  final String name;
+
+  PositionSourceInformationBuilder(AstElement element)
+      : sourceFile = element.compilationUnit.script.file,
+        name = element.name;
+
+  @override
+  SourceInformation buildGet(ast.Node node) {
+    return new PositionSourceInformation(
+        new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
+  }
+
+  @override
+  SourceInformation buildCall(ast.Node node) {
+    return new PositionSourceInformation(
+        new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
+  }
+
+  @override
+  SourceInformationBuilder forContext(AstElement element) {

[floitsch, 2015/02/24 19:58:12]

I'm not sure I like this. Is this just to avoid having a
"createSourceInformationBuilderFor(element)" function?

Or does the returned builder have a relationship to the current builder?

[Johnni Winther, 2015/02/26 10:21:34]

It is made to handle the choice of strategy at one point. A
[createSourceInformationBuilderFor] doesn't work since the decision should be
taken in the IrBuilderTask but new SourceInformatioBuilder object needs to be
created by the visitor.

+    return new PositionSourceInformationBuilder(element);
+  }
+}