dart2js: add function coverage tracking in dart2js output, dumpinfo, and

pkg/compiler/lib/src/info/info.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.
 
 /// Data collected by the dump-info task.
 library compiler.src.lib.info;
 
 // Note: this file intentionally doesn't import anything from the compiler. That
 // should make it easier for tools to depend on this library. The idea is that
 // by using this library, tools can consume the information in the same way it
 // is produced by the compiler.
 // TODO(sigmund): make this a proper public API (export this explicitly at the
 // lib folder level.)
 
 /// Common interface to many pieces of information generated by the compiler.
 abstract class Info {
   /// An identifier for the kind of information.
   InfoKind get kind;
 
   /// Name of the element associated with this info.
   String name;
 
   /// An id to uniquely identify this info among infos of the same [kind].
   int get id;
 
   /// A globally unique id combining [kind] and [id] together.
   String get serializedId;
 
+  /// Id used by the compiler when instrumenting code for code coverage.
+  // TODO(sigmund): unify all ids.
+  String coverageId;
+
   /// Bytes used in the generated code for the corresponding element.
   int size;
 
   /// Info of the enclosing element.
   Info parent;
 
   /// Serializes the information into a JSON format.
   // TODO(sigmund): refactor and put toJson outside the class, so we can have 2
   // different serializer/deserializers at once.
   Map toJson();
 
   void accept(InfoVisitor visitor);
 }
 
 /// Common information used for most kind of elements.
 // TODO(sigmund): add more:
 //  - inputSize: bytes used in the Dart source program
 abstract class BasicInfo implements Info {
   final InfoKind kind;
   final int id;
+  String coverageId;
   int size;
   Info parent;
 
   String get serializedId => '${_kindToString(kind)}/$id';
 
   String name;
 
   /// If using deferred libraries, where the element associated with this info
   /// is generated.
   OutputUnitInfo outputUnit;
 
-  BasicInfo(this.kind, this.id, this.name, this.outputUnit, this.size);
+  BasicInfo(this.kind, this.id, this.name, this.outputUnit, this.size,
+      this.coverageId);
 
   BasicInfo._fromId(String serializedId)
      : kind = _kindFromSerializedId(serializedId),
        id = _idFromSerializedId(serializedId);
 
   Map toJson() {
     var res = {
       'id': serializedId,
       'kind': _kindToString(kind),
       'name': name,
       'size': size,
     };
     // TODO(sigmund): omit this also when outputUnit.id == 0
     // (most code is by default in the main output unit)
     if (outputUnit != null) res['outputUnit'] = outputUnit.serializedId;
+    if (coverageId != null) res['coverageId'] = coverageId;
     if (parent != null) res['parent'] = parent.serializedId;
     return res;
   }
 
   String toString() => '$serializedId $name [$size]';
 }
 
 /// Info associated with elements containing executable code (like fields and
 /// methods)
 abstract class CodeInfo implements Info {
@@ skipping 215 matching lines @@
         result.fields.add(child);
       }
     }
     return result;
   }
 
   FieldInfo parseField(Map json) {
     FieldInfo result = parseId(json['id']);
     return result..name = json['name']
       ..parent = parseId(json['parent'])
+      ..coverageId = json['coverageId']
       ..outputUnit = parseId(json['outputUnit'])
       ..size = json['size']
       ..type = json['type']
       ..inferredType = json['inferredType']
       ..code = json['code']
       ..closures = json['children'].map(parseId).toList();
   }
 
   TypedefInfo parseTypedef(Map json) {
     TypedefInfo result = parseId(json['id']);
     return result..name = json['name']
       ..parent = parseId(json['parent'])
       ..type = json['type']
       ..size = 0;
   }
 
   ProgramInfo parseProgram(Map json) =>
       new ProgramInfo()..size = json['size'];
 
   FunctionInfo parseFunction(Map json) {
     FunctionInfo result = parseId(json['id']);
     return result..name = json['name']
       ..parent = parseId(json['parent'])
+      ..coverageId = json['coverageId']
       ..outputUnit = parseId(json['outputUnit'])
       ..size = json['size']
       ..type = json['type']
       ..returnType = json['returnType']
       ..inferredReturnType = json['inferredReturnType']
       ..parameters = json['parameters'].map(parseParameter).toList()
       ..code = json['code']
       ..sideEffects = json['sideEffects']
       ..modifiers = parseModifiers(json['modifiers'])
       ..closures = json['children'].map(parseId).toList();
@@ skipping 47 matching lines @@
   /// Typedefs defined within the library.
   final List<TypedefInfo> typedefs = <TypedefInfo>[];
 
   static int _id = 0;
 
   /// Whether there is any information recorded for this library.
   bool get isEmpty =>
       topLevelFunctions.isEmpty && topLevelVariables.isEmpty && classes.isEmpty;
 
   LibraryInfo(String name, this.uri, OutputUnitInfo outputUnit, int size)
-      : super(InfoKind.library, _id++, name, outputUnit, size);
+      : super(InfoKind.library, _id++, name, outputUnit, size, null);
 
   LibraryInfo._(String serializedId) : super._fromId(serializedId);
 
   Map toJson() => super.toJson()
     ..addAll({
       'children': []
         ..addAll(topLevelFunctions.map((f) => f.serializedId))
         ..addAll(topLevelVariables.map((v) => v.serializedId))
         ..addAll(classes.map((c) => c.serializedId))
         ..addAll(typedefs.map((t) => t.serializedId)),
       'canonicalUri': '$uri',
     });
 
   void accept(InfoVisitor visitor) => visitor.visitLibrary(this);
 }
 
 /// Information about an output unit. Normally there is just one for the entire
 /// program unless the application uses deferred imports, in which case there
 /// would be an additional output unit per deferred chunk.
 class OutputUnitInfo extends BasicInfo {
   static int _ids = 0;
   OutputUnitInfo(String name, int size)
-      : super(InfoKind.outputUnit, _ids++, name, null, size);
+      : super(InfoKind.outputUnit, _ids++, name, null, size, null);
 
   OutputUnitInfo._(String serializedId) : super._fromId(serializedId);
 
   void accept(InfoVisitor visitor) => visitor.visitOutput(this);
 }
 
 /// Information about a class element.
 class ClassInfo extends BasicInfo {
   /// Whether the class is abstract.
   bool isAbstract;
 
   // TODO(sigmund): split static vs instance vs closures
   /// Functions (static or instance) defined in the class.
   final List<FunctionInfo> functions = <FunctionInfo>[];
 
   /// Fields defined in the class.
   // TODO(sigmund): currently appears to only be populated with instance fields,
   // but this should be fixed.
   final List<FieldInfo> fields = <FieldInfo>[];
   static int _ids = 0;
 
   ClassInfo(
       {String name, this.isAbstract, OutputUnitInfo outputUnit, int size: 0})
-      : super(InfoKind.clazz, _ids++, name, outputUnit, size);
+      : super(InfoKind.clazz, _ids++, name, outputUnit, size, null);
 
   ClassInfo._(String serializedId) : super._fromId(serializedId);
 
   Map toJson() => super.toJson()
     ..addAll({
       // TODO(sigmund): change format, include only when abstract is true.
       'modifiers': {'abstract': isAbstract},
       'children': []
         ..addAll(fields.map((f) => f.serializedId))
         ..addAll(functions.map((m) => m.serializedId))
@@ skipping 12 matching lines @@
 
   /// Nested closures seen in the field initializer.
   List<FunctionInfo> closures;
 
   /// The actual generated code for the field.
   String code;
 
   static int _ids = 0;
   FieldInfo(
       {String name,
+      String coverageId,
       int size: 0,
       this.type,
       this.inferredType,
       this.closures,
       this.code,
       OutputUnitInfo outputUnit})
-      : super(InfoKind.field, _ids++, name, outputUnit, size);
+      : super(InfoKind.field, _ids++, name, outputUnit, size, coverageId);
 
   FieldInfo._(String serializedId) : super._fromId(serializedId);
 
   Map toJson() => super.toJson()
     ..addAll({
       'children': closures.map((i) => i.serializedId).toList(),
       'inferredType': inferredType,
       'code': code,
       'type': type,
     });
 
   void accept(InfoVisitor visitor) => visitor.visitField(this);
 }
 
 /// Information about a typedef declaration.
 class TypedefInfo extends BasicInfo {
   /// The declared type.
   String type;
 
   static int _ids = 0;
   TypedefInfo(String name, this.type, OutputUnitInfo outputUnit)
-      : super(InfoKind.typedef, _ids++, name, outputUnit, 0);
+      : super(InfoKind.typedef, _ids++, name, outputUnit, 0, null);
 
   TypedefInfo._(String serializedId) : super._fromId(serializedId);
 
   Map toJson() => super.toJson()..['type'] = '$type';
 
   void accept(InfoVisitor visitor) => visitor.visitTypedef(this);
 }
 
 /// Information about a function or method.
 class FunctionInfo extends BasicInfo with CodeInfo {
@@ skipping 29 matching lines @@
   String sideEffects;
 
   /// How many function calls were inlined into this function.
   int inlinedCount;
 
   /// The actual generated code.
   String code;
 
   FunctionInfo(
       {String name,
+      String coverageId,
       OutputUnitInfo outputUnit,
       int size: 0,
       this.functionKind,
       this.modifiers,
       this.closures,
       this.type,
       this.returnType,
       this.inferredReturnType,
       this.parameters,
       this.sideEffects,
       this.inlinedCount,
       this.code})
-      : super(InfoKind.function, _ids++, name, outputUnit, size);
+      : super(InfoKind.function, _ids++, name, outputUnit, size, coverageId);
 
   FunctionInfo._(String serializedId) : super._fromId(serializedId);
 
   Map toJson() => super.toJson()
     ..addAll({
       'children': closures.map((i) => i.serializedId).toList(),
       'modifiers': modifiers.toJson(),
       'returnType': returnType,
       'inferredReturnType': inferredReturnType,
       'parameters': parameters.map((p) => p.toJson()).toList(),
@@ skipping 142 matching lines @@
   }
 
   visitField(FieldInfo info) {
     info.closures.forEach(visitFunction);
   }
 
   visitFunction(FunctionInfo info) {
     info.closures.forEach(visitFunction);
   }
 }