Add Dart code to diff_view

tests/compiler/dart2js/sourcemaps/sourcemap_helper.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.
 
 library sourcemap.helper;
 
 import 'dart:async';
+import 'dart:io';
 import 'package:compiler/compiler_new.dart';
 import 'package:compiler/src/apiimpl.dart' as api;
 import 'package:compiler/src/null_compiler_output.dart' show NullSink;
 import 'package:compiler/src/elements/elements.dart';
 import 'package:compiler/src/helpers/helpers.dart';
 import 'package:compiler/src/filenames.dart';
 import 'package:compiler/src/io/code_output.dart';
 import 'package:compiler/src/io/source_file.dart';
 import 'package:compiler/src/io/source_information.dart';
 import 'package:compiler/src/io/position_information.dart';
@@ skipping 278 matching lines @@
 
   /// Creates a processor for the Dart file [filename].
   SourceMapProcessor(String filename, {this.outputToFile: false}) {
     inputUri = Uri.base.resolve(nativeToUriPath(filename));
     jsPath = 'out.js';
     targetUri = Uri.base.resolve(jsPath);
     sourceMapFileUri = Uri.base.resolve('${jsPath}.map');
   }
 
   /// Computes the [SourceMapInfo] for the compiled elements.
-  Future<List<SourceMapInfo>> process(
+  Future<SourceMaps> process(
       List<String> options,
       {bool verbose: true,
-       bool perElement: true}) async {
+       bool perElement: true,
+       bool forMain: false}) async {
     OutputProvider outputProvider = outputToFile
         ? new CloningOutputProvider(targetUri, sourceMapFileUri)
         : new OutputProvider();
     if (options.contains(USE_NEW_SOURCE_INFO)) {
       if (verbose) print('Using the new source information system.');
       useNewSourceInfo = true;
     }
     api.CompilerImpl compiler = await compilerFor(
         outputProvider: outputProvider,
         // TODO(johnniwinther): Use [verbose] to avoid showing diagnostics.
         options: ['--out=$targetUri', '--source-map=$sourceMapFileUri']
             ..addAll(options));
     if (options.contains(DISABLE_INLINING)) {
       if (verbose) print('Inlining disabled');
       compiler.disableInlining = true;
     }
 
     JavaScriptBackend backend = compiler.backend;
     var handler = compiler.handler;
     SourceFileProvider sourceFileProvider = handler.provider;
     sourceFileManager = new ProviderSourceFileManager(
         sourceFileProvider,
         outputProvider);
     RecordingSourceInformationStrategy strategy =
         new RecordingSourceInformationStrategy(backend.sourceInformationStrategy);
     backend.sourceInformationStrategy = strategy;
     await compiler.run(inputUri);
 
-    List<SourceMapInfo> infoList = <SourceMapInfo>[];
+    SourceMapInfo mainSourceMapInfo;
+    Map<Element, SourceMapInfo> elementSourceMapInfos =
+        <Element, SourceMapInfo>{};
     if (perElement) {
       backend.generatedCode.forEach((Element element, js.Expression node) {
         RecordedSourceInformationProcess subProcess =
             strategy.subProcessForNode(node);
         if (subProcess == null) {
           // TODO(johnniwinther): Find out when this is happening and if it
           // is benign. (Known to happen for `bool#fromString`)
           print('No subProcess found for $element');
           return;
         }
         LocationMap nodeMap = subProcess.nodeToSourceLocationsMap;
         String code = subProcess.code;
         CodePositionRecorder codePositions = subProcess.codePositions;
         CodePointComputer visitor =
             new CodePointComputer(sourceFileManager, code, nodeMap);
-        visitor.apply(node);
+        new JavaScriptTracer(codePositions, [visitor]).apply(node);
         List<CodePoint> codePoints = visitor.codePoints;
-        infoList.add(new SourceMapInfo(
-            element, code, node,
+        elementSourceMapInfos[element] = new SourceMapInfo(
+            element,
+            code,
+            node,
             codePoints,
-            codePositions/*strategy.codePositions*/,
-            nodeMap));
+            codePositions,
+            nodeMap);
       });
-    } else {
+    }
+    if (forMain) {
       // TODO(johnniwinther): Supported multiple output units.
       RecordedSourceInformationProcess process = strategy.processMap.keys.first;
       js.Node node = strategy.processMap[process];
       String code;
       LocationMap nodeMap;
       CodePositionRecorder codePositions;
       nodeMap = process.nodeToSourceLocationsMap;
       code = process.code;
       codePositions = process.codePositions;
       CodePointComputer visitor =
           new CodePointComputer(sourceFileManager, code, nodeMap);
-      visitor.apply(node);
+      new JavaScriptTracer(codePositions, [visitor]).apply(node);
       List<CodePoint> codePoints = visitor.codePoints;
-      infoList.add(new SourceMapInfo(
+      mainSourceMapInfo = new SourceMapInfo(
           null, code, node,
           codePoints,
           codePositions,
-          nodeMap));
+          nodeMap);
     }
 
-    return infoList;
+    return new SourceMaps(
+        sourceFileManager, mainSourceMapInfo, elementSourceMapInfos);
   }
 }
 
+class SourceMaps {
+  final SourceFileManager sourceFileManager;
+  // TODO(johnniwinther): Supported multiple output units.
+  final SourceMapInfo mainSourceMapInfo;
+  final Map<Element, SourceMapInfo> elementSourceMapInfos;
+
+  SourceMaps(
+      this.sourceFileManager,
+      this.mainSourceMapInfo,
+          this.elementSourceMapInfos);
+}
+
 /// Source mapping information for the JavaScript code of an [Element].
 class SourceMapInfo {
   final String name;
   final Element element;
   final String code;
   final js.Node node;
   final List<CodePoint> codePoints;
   final CodePositionMap jsCodePositions;
   final LocationMap nodeMap;
 
@@ skipping 53 matching lines @@
 
   Iterable<js.Node> get nodes => map.nodes.where((n) => _nodes.contains(n));
 
   Map<int, List<SourceLocation>> operator[] (js.Node node) {
     return map[node];
   }
 }
 
 
 /// Visitor that computes the [CodePoint]s for source mapping locations.
-class CodePointComputer extends js.BaseVisitor {
+class CodePointComputer extends TraceListener {
   final SourceFileManager sourceFileManager;
   final String code;
   final LocationMap nodeMap;
   List<CodePoint> codePoints = [];
 
   CodePointComputer(this.sourceFileManager, this.code, this.nodeMap);
 
   String nodeToString(js.Node node) {
     js.JavaScriptPrintingOptions options = new js.JavaScriptPrintingOptions(
         shouldCompressOutput: true,
         preferSemicolonToNewlineInMinifiedOutput: true);
     LenientPrintingContext printingContext = new LenientPrintingContext();
     new js.Printer(options, printingContext).visit(node);
     return printingContext.buffer.toString();
   }
 
   String positionToString(int position) {
     String line = code.substring(position);
     int nl = line.indexOf('\n');
     if (nl != -1) {
       line = line.substring(0, nl);
     }
     return line;
   }
 
+  /// 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) {
+    register('$kind', node);
+  }
+
   void register(String kind, js.Node node, {bool expectInfo: true}) {
 
     String dartCodeFromSourceLocation(SourceLocation sourceLocation) {
       SourceFile sourceFile =
            sourceFileManager.getSourceFile(sourceLocation.sourceUri);
+      if (sourceFile == null) {
+        return sourceLocation.shortText;
+      }
       return sourceFile.getLineText(sourceLocation.line)
           .substring(sourceLocation.column).trim();
     }
 
     void addLocation(SourceLocation sourceLocation, String jsCode) {
       if (sourceLocation == null) {
         if (expectInfo) {
           SourceInformation sourceInformation = node.sourceInformation;
           SourceLocation sourceLocation;
           String dartCode;
@@ skipping 15 matching lines @@
       addLocation(null, nodeToString(node));
     } else {
       locationMap.forEach((int targetOffset, List<SourceLocation> locations) {
         String jsCode = nodeToString(node);
         for (SourceLocation location in locations) {
           addLocation(location, jsCode);
         }
       });
     }
   }
-
-  void apply(js.Node node) {
-    node.accept(this);
-  }
-
-  void visitNode(js.Node node) {
-    register('${node.runtimeType}', node, expectInfo: false);
-    super.visitNode(node);
-  }
-
-  @override
-  void visitNew(js.New node) {
-    node.arguments.forEach(apply);
-    register('New', node);
-  }
-
-  @override
-  void visitReturn(js.Return node) {
-    if (node.value != null) {
-      apply(node.value);
-    }
-    register('Return', node);
-  }
-
-  @override
-  void visitCall(js.Call node) {
-    apply(node.target);
-    node.arguments.forEach(apply);
-    register('Call (${node.target.runtimeType})', node);
-  }
-
-  @override
-  void visitFun(js.Fun node) {
-    node.visitChildren(this);
-    register('Fun', node);
-  }
-
-  @override
-  visitExpressionStatement(js.ExpressionStatement node) {
-    node.visitChildren(this);
-  }
-
-  @override
-  visitBinary(js.Binary node) {
-    node.visitChildren(this);
-  }
-
-  @override
-  visitAccess(js.PropertyAccess node) {
-    node.visitChildren(this);
-  }
 }
 
 /// A JavaScript code point and its mapped dart source location.
 class CodePoint {
   final String kind;
   final String jsCode;
   final SourceLocation sourceLocation;
   final String dartCode;
   final bool isMissing;
 
   CodePoint(
       this.kind,
       this.jsCode,
       this.sourceLocation,
       this.dartCode,
       {this.isMissing: false});
 
   String toString() {
     return 'CodePoint[kind=$kind,js=$jsCode,dart=$dartCode,'
                      'location=$sourceLocation]';
   }
 }
+
+class IOSourceFileManager implements SourceFileManager {
+  final Uri base;
+
+  Map<Uri, SourceFile> sourceFiles = <Uri, SourceFile>{};
+
+  IOSourceFileManager(this.base);
+
+  SourceFile getSourceFile(var uri) {
+    Uri absoluteUri;
+    if (uri is Uri) {
+      absoluteUri = base.resolveUri(uri);
+    } else {
+      absoluteUri = base.resolve(uri);
+    }
+    return sourceFiles.putIfAbsent(absoluteUri, () {
+      String text = new File.fromUri(absoluteUri).readAsStringSync();
+      return new StringSourceFile.fromUri(absoluteUri, text);
+    });
+  }
+}