Add MultiSourceInformationStrategy

pkg/compiler/lib/src/io/position_information.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.
 
 /// Source information system mapping that attempts a semantic mapping between
 /// offsets of JavaScript code points to offsets of Dart code points.
 
 library dart2js.source_information.position;
 
 import '../common.dart';
 import '../elements/elements.dart'
     show AstElement, ResolvedAst, ResolvedAstKind;
 import '../js/js.dart' as js;
 import '../js/js_debug.dart';
 import '../js/js_source_mapping.dart';
 import '../tree/tree.dart' show Node, Send;
-import 'code_output.dart' show CodeBuffer;
+import 'code_output.dart' show BufferedCodeOutput;
 import 'source_file.dart';
 import 'source_information.dart';
 
 /// [SourceInformation] that consists of an offset position into the source
 /// code.
 class PositionSourceInformation extends SourceInformation {
   @override
   final SourceLocation startPosition;
 
   @override
@@ skipping 71 matching lines @@
 class PositionSourceInformationStrategy
     implements JavaScriptSourceInformationStrategy {
   const PositionSourceInformationStrategy();
 
   @override
   SourceInformationBuilder createBuilderForContext(ResolvedAst resolvedAst) {
     return new PositionSourceInformationBuilder(resolvedAst);
   }
 
   @override
-  SourceInformationProcessor createProcessor(SourceMapper mapper) {
-    return new PositionSourceInformationProcessor(mapper);
+  SourceInformationProcessor createProcessor(
+      SourceMapperProvider provider, SourceInformationReader reader) {
+    return new PositionSourceInformationProcessor(provider, reader);
   }
 
   @override
   void onComplete() {}
 
   @override
   SourceInformation buildSourceMappedMarker() {
     return const SourceMappedMarker();
   }
 }
@@ skipping 298 matching lines @@
   ///     foo: function() { return 0; }
   ///                                  ^       // the function end position
   ///                                ^         // the return end position
   ///
   END,
 }
 
 /// Processor that associates [SourceLocation]s from [SourceInformation] on
 /// [js.Node]s with the target offsets in a [SourceMapper].
 class PositionSourceInformationProcessor extends SourceInformationProcessor {
+  /// The id for this source information engine.
+  ///
+  /// The id is added to the source map file in an extra "engine" property and
+  /// serves as a version number for the engine.
+  ///
+  /// The version history of this engine is:
+  ///
+  ///   v2: The initial version with an id.
+  static const String id = 'v2';
+
   final CodePositionRecorder codePositionRecorder = new CodePositionRecorder();
+  final SourceInformationReader reader;
   CodePositionMap codePositionMap;
   List<TraceListener> traceListeners;
 
-  PositionSourceInformationProcessor(SourceMapper sourceMapper,
+  PositionSourceInformationProcessor(SourceMapperProvider provider, this.reader,
       [Coverage coverage]) {
     codePositionMap = coverage != null
         ? new CodePositionCoverage(codePositionRecorder, coverage)
         : codePositionRecorder;
-    traceListeners = [new PositionTraceListener(sourceMapper)];
+    traceListeners = [
+      new PositionTraceListener(provider.createSourceMapper(id), reader)
+    ];
     if (coverage != null) {
-      traceListeners.add(new CoverageListener(coverage));
+      traceListeners.add(new CoverageListener(coverage, reader));
     }
   }
 
-  void process(js.Node node, CodeBuffer codeBuffer) {
-    new JavaScriptTracer(codePositionMap, traceListeners).apply(node);
+  void process(js.Node node, BufferedCodeOutput code) {
+    new JavaScriptTracer(codePositionMap, reader, traceListeners).apply(node);
   }
 
   @override
   void onPositions(
       js.Node node, int startPosition, int endPosition, int closingPosition) {
     codePositionRecorder.registerPositions(
         node, startPosition, endPosition, closingPosition);
   }
 }
 
 /// Visitor that computes [SourceInformation] for a [js.Node] using information
 /// attached to the node itself or alternatively from child nodes.
 class NodeSourceInformation extends js.BaseVisitor<SourceInformation> {
-  const NodeSourceInformation();
+  final SourceInformationReader reader;
+
+  const NodeSourceInformation(this.reader);
 
   SourceInformation visit(js.Node node) => node?.accept(this);
 
   @override
-  SourceInformation visitNode(js.Node node) => node.sourceInformation;
+  SourceInformation visitNode(js.Node node) =>
+      reader.getSourceInformation(node);
 
   @override
   SourceInformation visitExpressionStatement(js.ExpressionStatement node) {
-    if (node.sourceInformation != null) {
-      return node.sourceInformation;
+    SourceInformation sourceInformation = reader.getSourceInformation(node);
+    if (sourceInformation != null) {
+      return sourceInformation;
     }
     return visit(node.expression);
   }
 
   @override
   SourceInformation visitVariableDeclarationList(
       js.VariableDeclarationList node) {
-    if (node.sourceInformation != null) {
-      return node.sourceInformation;
+    SourceInformation sourceInformation = reader.getSourceInformation(node);
+    if (sourceInformation != null) {
+      return sourceInformation;
     }
     for (js.Node declaration in node.declarations) {
       SourceInformation sourceInformation = visit(declaration);
       if (sourceInformation != null) {
         return sourceInformation;
       }
     }
     return null;
   }
 
   @override
   SourceInformation visitVariableInitialization(
       js.VariableInitialization node) {
-    if (node.sourceInformation != null) {
-      return node.sourceInformation;
+    SourceInformation sourceInformation = reader.getSourceInformation(node);
+    if (sourceInformation != null) {
+      return sourceInformation;
     }
     return visit(node.value);
   }
 
   @override
   SourceInformation visitAssignment(js.Assignment node) {
-    if (node.sourceInformation != null) {
-      return node.sourceInformation;
+    SourceInformation sourceInformation = reader.getSourceInformation(node);
+    if (sourceInformation != null) {
+      return sourceInformation;
     }
     return visit(node.value);
   }
 }
 
 /// Mixin that add support for computing [SourceInformation] for a [js.Node].
-class NodeToSourceInformationMixin {
+abstract class NodeToSourceInformationMixin {
+  SourceInformationReader get reader;
+
   SourceInformation computeSourceInformation(js.Node node) {
-    return const NodeSourceInformation().visit(node);
+    return new NodeSourceInformation(reader).visit(node);
   }
 }
 
 /// [TraceListener] that register [SourceLocation]s with a [SourceMapper].
 class PositionTraceListener extends TraceListener
     with NodeToSourceInformationMixin {
   final SourceMapper sourceMapper;
+  final SourceInformationReader reader;
 
-  PositionTraceListener(this.sourceMapper);
+  PositionTraceListener(this.sourceMapper, this.reader);
 
   @override
   void onStep(js.Node node, Offset offset, StepKind kind) {
     int codeLocation = offset.value;
     if (codeLocation == null) return;
 
     if (kind == StepKind.NO_INFO) {
       sourceMapper.register(node, codeLocation, const NoSourceLocationMarker());
       return;
     }
@@ skipping 211 matching lines @@
 
   /// Called when [node] defines a step of the given [kind] at the given
   /// [offset] when the generated JavaScript code.
   void onStep(js.Node node, Offset offset, StepKind kind) {}
 }
 
 /// Visitor that computes the [js.Node]s the are part of the JavaScript
 /// steppable execution and thus needs source mapping locations.
 class JavaScriptTracer extends js.BaseVisitor {
   final CodePositionMap codePositions;
+  final SourceInformationReader reader;
   final List<TraceListener> listeners;
 
   /// The steps added by subexpressions.
   List steps = [];
 
   /// The offset of the current statement.
   int statementOffset;
 
   /// The current offset in left-to-right progression.
   int leftToRightOffset;
 
   /// The offset of the surrounding statement, used for the first subexpression.
   int offsetPosition;
 
   bool active;
 
-  JavaScriptTracer(this.codePositions, this.listeners, {this.active: false});
+  JavaScriptTracer(this.codePositions, this.reader, this.listeners,
+      {this.active: false});
 
   void notifyStart(js.Node node) {
     listeners.forEach((listener) => listener.onStart(node));
   }
 
   void notifyEnd(js.Node node) {
     listeners.forEach((listener) => listener.onEnd(node));
   }
 
   void notifyPushBranch(BranchKind kind, [value]) {
@@ skipping 48 matching lines @@
       for (js.Node node in nodeList) {
         visit(node);
       }
     }
   }
 
   @override
   visitFun(js.Fun node) {
     bool activeBefore = active;
     if (!active) {
-      active = node.sourceInformation != null;
+      active = reader.getSourceInformation(node) != null;
     }
     leftToRightOffset =
         statementOffset = getSyntaxOffset(node, kind: CodePositionKind.START);
     Offset entryOffset = getOffsetForNode(node, statementOffset);
     notifyStep(node, entryOffset, StepKind.FUN_ENTRY);
 
     visit(node.body);
 
     leftToRightOffset =
         statementOffset = getSyntaxOffset(node, kind: CodePositionKind.CLOSING);
@@ skipping 425 matching lines @@
     }
     return sb.toString();
   }
 
   String toString() => getCoverageReport();
 }
 
 /// [TraceListener] that registers [onStep] callbacks with [coverage].
 class CoverageListener extends TraceListener with NodeToSourceInformationMixin {
   final Coverage coverage;
+  final SourceInformationReader reader;
 
-  CoverageListener(this.coverage);
+  CoverageListener(this.coverage, this.reader);
 
   @override
   void onStep(js.Node node, Offset offset, StepKind kind) {
     SourceInformation sourceInformation = computeSourceInformation(node);
     if (sourceInformation != null) {
       coverage.registerNodeWithInfo(node);
     } else {
       coverage.registerNodeWithoutInfo(node);
     }
   }
@@ skipping 13 matching lines @@
 
   @override
   CodePosition operator [](js.Node node) {
     CodePosition codePosition = codePositions[node];
     if (codePosition == null) {
       coverage.registerNodesWithoutOffset(node);
     }
     return codePosition;
   }
 }