Add SourceInformationFactory.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../constants/expressions.dart';
 import '../dart_types.dart';
 import '../dart2jslib.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart' show SynthesizedConstructorElementX,
     ConstructorBodyElementX, FunctionSignatureX;
-import '../io/source_file.dart';
 import '../io/source_information.dart';
 import '../js_backend/js_backend.dart' show JavaScriptBackend;
 import '../resolution/semantic_visitor.dart';
 import '../resolution/operators.dart' as op;
 import '../scanner/scannerlib.dart' show Token, isUserDefinableOperator;
 import '../tree/tree.dart' as ast;
 import '../universe/universe.dart' show SelectorKind, CallStructure;
 import 'cps_ir_nodes.dart' as ir;
 import 'cps_ir_builder.dart';
 
 /**
  * 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.RootNode> nodes = <Element, ir.RootNode>{};
-  final bool generateSourceMap;
+  final SourceInformationFactory sourceInformationFactory;
 
   String bailoutMessage = null;
 
-  IrBuilderTask(Compiler compiler, {this.generateSourceMap: true})
+  IrBuilderTask(Compiler compiler, this.sourceInformationFactory)
       : super(compiler);
 
   String get name => 'IR builder';
 
   bool hasIr(Element element) => nodes.containsKey(element.implementation);
 
   ir.RootNode getIr(ExecutableElement element) {
     return nodes[element.implementation];
   }
 
   ir.RootNode buildNode(AstElement element) {
     bailoutMessage = null;
     if (!canBuild(element)) {
       bailoutMessage = 'unsupported element ${element.name}:${element.kind}';
       return null;
     }
 
     TreeElements elementsMapping = element.resolvedAst.elements;
     element = element.implementation;
     return compiler.withCurrentElement(element, () {
-      SourceInformationBuilder sourceInformationBuilder = generateSourceMap
-          ? new PositionSourceInformationBuilder(element)
-          : const SourceInformationBuilder();
+      SourceInformationBuilder sourceInformationBuilder =
+          sourceInformationFactory.forContext(element);
 
       IrBuilderVisitor builder =
           compiler.backend is JavaScriptBackend
           ? new JsIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder)
           : new DartIrBuilderVisitor(
               elementsMapping, compiler, sourceInformationBuilder);
       ir.RootNode irNode = builder.buildExecutable(element);
       if (irNode == null) {
         bailoutMessage = builder.bailoutMessage;
@@ skipping 2671 matching lines @@
     arguments = normalizeStaticArguments(
         callStructure, constructor, arguments);
     return irBuilder.buildConstructorInvocation(
         constructor.effectiveTarget,
         callStructure,
         constructor.computeEffectiveTargetType(type),
         arguments);
   }
 }
 
-/// 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;
-
-  /// 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) {
-    return new PositionSourceInformationBuilder(element);
-  }
-}
-
 /// Perform simple post-processing on the initial CPS-translated root term.
 ///
 /// This pass performs backend-independent post-processing on the translated
 /// term.  It is implemented separately from the optimization passes because
 /// it is required for correctness of the implementation.
 ///
 /// It performs the following translations:
 ///   - Replace [ir.LetPrim] binding a [ir.NonTailThrow] with a [ir.Throw]
 ///     expression.
 class CleanupPass extends ir.RecursiveVisitor {
@@ skipping 46 matching lines @@
     node.body = replacementFor(node.body);
   }
 }
 
 /// Visit a just-deleted subterm and unlink all [Reference]s in it.
 class RemovalVisitor extends ir.RecursiveVisitor {
   processReference(ir.Reference reference) {
     reference.unlink();
   }
 }
-