Add source mappings and inlined Dart code to diff_view.

tests/compiler/dart2js/sourcemaps/output_structure.dart

 // Copyright (c) 2016, 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.output_structure;
 
+import 'dart:math' as Math;
 import 'html_parts.dart' show
-    CodeLine;
+    Annotation,
+    CodeLine,
+    JsonStrategy;
 
 // Constants used to identify the subsection of the JavaScript output. These
 // are specifically for the unminified full_emitter output.
 const String HEAD = '  var dart = [';
 const String TAIL = '  }], ';
 const String END = '  setupProgram(dart';
 
 final RegExp TOP_LEVEL_VALUE = new RegExp(r'^    (".+?"):');
 final RegExp TOP_LEVEL_FUNCTION =
     new RegExp(r'^    ([a-zA-Z0-9_$]+): \[?function');
@@ skipping 28 matching lines @@
   }
 
   OutputEntity getChild(int index) {
     return children[index];
   }
 
   accept(OutputVisitor visitor, arg);
 
   EntityKind get kind;
 
-  Map toJson();
+  Map toJson(JsonStrategy strategy);
 
   OutputEntity getEntityForLine(int line);
 }
 
 enum EntityKind {
   STRUCTURE,
   LIBRARY,
   CLASS,
   TOP_LEVEL_FUNCTION,
   TOP_LEVEL_VALUE,
@@ skipping 158 matching lines @@
       block.preprocess(lines);
     }
 
     return new OutputStructure(
         lines, headerEnd, footerStart, libraryBlocks);
   }
 
   accept(OutputVisitor visitor, arg) => visitor.visitStructure(this, arg);
 
   @override
-  Map toJson() {
+  Map toJson(JsonStrategy strategy) {
     return {
-      'lines': lines.map((line) => line.toJson()).toList(),
+      'lines': lines.map((line) => line.toJson(strategy)).toList(),
       'headerEnd': headerEnd,
       'footerStart': footerStart,
-      'children': children.map((child) => child.toJson()).toList(),
+      'children': children.map((child) => child.toJson(strategy)).toList(),
     };
   }
 
-  static OutputStructure fromJson(Map json) {
-    List<CodeLine> lines = json['lines'].map(CodeLine.fromJson).toList();
+  static OutputStructure fromJson(Map json, JsonStrategy strategy) {
+    List<CodeLine> lines =
+        json['lines'].map((l) => CodeLine.fromJson(l, strategy)).toList();
     int headerEnd = json['headerEnd'];
     int footerStart = json['footerStart'];
     List<LibraryBlock> children =
-        json['children'].map(AbstractEntity.fromJson).toList();
+        json['children']
+            .map((j) => AbstractEntity.fromJson(j, strategy))
+            .toList();
     return new OutputStructure(lines, headerEnd, footerStart, children);
   }
 }
 
 abstract class AbstractEntity extends OutputEntity {
   final String name;
   final int from;
   int to;
 
   AbstractEntity(this.name, this.from);
 
   Interval get interval => new Interval(from, to);
 
   @override
-  Map toJson() {
+  Map toJson(JsonStrategy strategy) {
     return {
       'kind': kind.index,
       'name': name,
       'from': from,
       'to': to,
-      'children': children.map((child) => child.toJson()).toList(),
+      'children': children.map((child) => child.toJson(strategy)).toList(),
       'codeSource': codeSource != null ? codeSource.toJson() : null,
     };
   }
 
-  static AbstractEntity fromJson(Map json) {
+  static AbstractEntity fromJson(Map json, JsonStrategy strategy) {
     EntityKind kind = EntityKind.values[json['kind']];
     String name = json['name'];
     int from = json['from'];
     int to = json['to'];
     CodeSource codeSource = CodeSource.fromJson(json['codeSource']);
 
     switch (kind) {
       case EntityKind.STRUCTURE:
         throw new StateError('Unexpected entity kind $kind');
       case EntityKind.LIBRARY:
         LibraryBlock lib = new LibraryBlock(name, from)
           ..to = to
           ..codeSource = codeSource;
-        json['children'].forEach((child) => lib.children.add(fromJson(child)));
+        json['children']
+            .forEach((child) => lib.children.add(fromJson(child, strategy)));
         return lib;
       case EntityKind.CLASS:
         LibraryClass cls = new LibraryClass(name, from)
             ..to = to
             ..codeSource = codeSource;
-        json['children'].forEach((child) => cls.children.add(fromJson(child)));
+        json['children']
+            .forEach((child) => cls.children.add(fromJson(child, strategy)));
         return cls;
       case EntityKind.TOP_LEVEL_FUNCTION:
         return new TopLevelFunction(name, from)
             ..to = to
             ..codeSource = codeSource;
       case EntityKind.TOP_LEVEL_VALUE:
         return new TopLevelValue(name, from)
             ..to = to
             ..codeSource = codeSource;
       case EntityKind.MEMBER_FUNCTION:
         return new MemberFunction(name, from)
             ..to = to
             ..codeSource = codeSource;
       case EntityKind.MEMBER_OBJECT:
         return new MemberObject(name, from)
             ..to = to
             ..codeSource = codeSource;
       case EntityKind.MEMBER_VALUE:
         return new MemberValue(name, from)
             ..to = to
             ..codeSource = codeSource;
       case EntityKind.STATICS:
         Statics statics = new Statics(from)
             ..to = to
             ..codeSource = codeSource;
         json['children'].forEach(
-            (child) => statics.children.add(fromJson(child)));
+            (child) => statics.children.add(fromJson(child, strategy)));
         return statics;
       case EntityKind.STATIC_FUNCTION:
         return new StaticFunction(name, from)
             ..to = to
             ..codeSource = codeSource;
     }
   }
 }
 
 /// A block defining the content of a Dart library.
 class LibraryBlock extends AbstractEntity {
   List<BasicEntity> children = <BasicEntity>[];
   int get headerEnd => from + 2;
-  int get footerStart => to - 1;
+  int get footerStart => to/* - 1*/;
 
   LibraryBlock(String name, int from) : super(name, from);
 
   @override
   EntityKind get kind => EntityKind.LIBRARY;
 
   Interval get header => new Interval(from, headerEnd);
 
   Interval get footer => new Interval(footerStart, to);
 
@@ skipping 269 matching lines @@
 }
 
 class Interval {
   final int from;
   final int to;
 
   const Interval(this.from, this.to);
 
   int get length => to - from;
 
+  bool get isEmpty => from == to;
+
   bool contains(int value) {
     return from <= value && value < to;
   }
+
+  Interval include(int index) {
+    return new Interval(Math.min(from, index), Math.max(to, index + 1));
+  }
+
+  bool inWindow(int index, {int windowSize: 0}) {
+    return from - windowSize <= index && index < to + windowSize;
+  }
+
+  String toString() => '[$from,$to[';
 }
 
 enum CodeKind {
   LIBRARY,
   CLASS,
   MEMBER,
 }
 
+class CodeLocation {
+  final Uri uri;
+  final String name;
+  final int offset;
+
+  CodeLocation(this.uri, this.name, this.offset);
+
+  String toString() => '$uri:$name:$offset';
+
+  Map toJson(JsonStrategy strategy) {
+    return {
+      'uri': uri.toString(),
+      'name': name,
+      'offset': offset,
+    };
+  }
+
+  static CodeLocation fromJson(Map json, JsonStrategy strategy) {
+    if (json == null) return null;
+    return new CodeLocation(
+        Uri.parse(json['uri']),
+        json['name'],
+        json['offset']);
+  }
+}
+
+/// A named entity in source code. This is used to serialize [Element]
+/// references without serializing the [Element] itself.
 class CodeSource {
   final CodeKind kind;
   final Uri uri;
   final String name;
   final int begin;
   final int end;
+  final List<CodeSource> members = <CodeSource>[];
 
   CodeSource(this.kind, this.uri, this.name, this.begin, this.end);
 
+  int get hashCode {
+    return
+        kind.hashCode * 13 +
+        uri.hashCode * 17 +
+        name.hashCode * 19 +
+        begin.hashCode * 23;
+  }
+
+  bool operator ==(other) {
+    if (identical(this, other)) return true;
+    if (other is! CodeSource) return false;
+    return
+        kind == other.kind &&
+        uri == other.uri &&
+        name == other.name &&
+        begin == other.begin;
+
+  }
+
   String toString() => '${toJson()}';
 
   Map toJson() {
     return {
       'kind': kind.index,
       'uri': uri.toString(),
       'name': name,
       'begin': begin,
       'end': end,
+      'members': members.map((c) => c.toJson()).toList(),
     };
   }
 
   static CodeSource fromJson(Map json) {
     if (json == null) return null;
-    return new CodeSource(
+    CodeSource codeSource = new CodeSource(
         CodeKind.values[json['kind']],
         Uri.parse(json['uri']),
         json['name'],
         json['begin'],
         json['end']);
+    json['members'].forEach((m) => codeSource.members.add(fromJson(m)));
+    return codeSource;
   }
 }