Add constant info to the dart2js_info model

lib/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 produced by dart2js when run with the `--dump-info` flag.
 library dart2js_info.info;
 
 /// Common interface to many pieces of information generated by the dart2js
 /// compiler.
 abstract class Info {
@@ skipping 93 matching lines @@
 
   /// Information about type defs in the program.
   List<TypedefInfo> typedefs = <TypedefInfo>[];
 
   /// Information about each class (in any library).
   List<ClassInfo> classes = <ClassInfo>[];
 
   /// Information about fields (in any class).
   List<FieldInfo> fields = <FieldInfo>[];
 
+  /// Information about constants anywhere in the program.
+  // TODO(sigmund): expand docs about canonicalization. We don't put these
+  // inside library because a single constant can be used in more than one lib,
+  // and we'll include it only once in the output.
+  List<ConstantInfo> constants = <ConstantInfo>[];
+
   /// Information about output units (should be just one entry if not using
   /// deferred loading).
   List<OutputUnitInfo> outputUnits = <OutputUnitInfo>[];
 
   /// Details about all deferred imports and what files would be loaded when the
   /// import is resolved.
   // TODO(sigmund): use a different format for dump-info. This currently emits
   // the same map that is created for the `--deferred-map` flag.
   Map<String, Map<String, dynamic>> deferredFiles;
 
@@ skipping 46 matching lines @@
     return map;
   }
 
   Map toJson() => {
         'elements': {
           'library': _listAsJsonMap(libraries),
           'class': _listAsJsonMap(classes),
           'function': _listAsJsonMap(functions),
           'typedef': _listAsJsonMap(typedefs),
           'field': _listAsJsonMap(fields),
+          'constant': _listAsJsonMap(constants),
         },
         'holding': _extractHoldingInfo(),
         'dependencies': _extractDependencies(),
         'outputUnits': outputUnits.map((u) => u.toJson()).toList(),
         'dump_version': version,
         'deferredFiles': deferredFiles,
         'dump_minor_version': '$minorVersion',
         // TODO(sigmund): change viewer to accept an int?
         'program': program.toJson(),
       };
@@ skipping 42 matching lines @@
 
   AllInfo parseAll(Map json) {
     var result = new AllInfo();
     var elements = json['elements'];
     result.libraries.addAll(elements['library'].values.map(parseLibrary));
     result.classes.addAll(elements['class'].values.map(parseClass));
     result.functions.addAll(elements['function'].values.map(parseFunction));
     result.fields.addAll(elements['field'].values.map(parseField));
     result.typedefs.addAll(elements['typedef'].values.map(parseTypedef));
 
+    // TODO(sigmund): remove null check on next breaking version
+    var constants = elements['constant'];
+    if (constants != null) {
+      result.constants.addAll(constants.values.map(parseConstant));
+    }
+
     var idMap = {};
     for (var f in result.functions) {
       idMap[f.serializedId] = f;
     }
     for (var f in result.fields) {
       idMap[f.serializedId] = f;
     }
 
     json['holding'].forEach((k, deps) {
       var src = idMap[k];
@@ skipping 57 matching lines @@
   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']
+      ..isConst = json['const'] ?? false
+      ..initializer = parseId(json['initializer'])
       ..closures = json['children'].map(parseId).toList();
   }
 
+  ConstantInfo parseConstant(Map json) {
+    ConstantInfo result = parseId(json['id']);
+    return result
+      ..code = json['code']
+      ..size = json['size'];
+  }
+
   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'];
@@ skipping 30 matching lines @@
     if (serializedId == null) {
       return null;
     } else if (serializedId.startsWith('function/')) {
       return new FunctionInfo._(serializedId);
     } else if (serializedId.startsWith('library/')) {
       return new LibraryInfo._(serializedId);
     } else if (serializedId.startsWith('class/')) {
       return new ClassInfo._(serializedId);
     } else if (serializedId.startsWith('field/')) {
       return new FieldInfo._(serializedId);
+    } else if (serializedId.startsWith('constant/')) {
+      return new ConstantInfo._(serializedId);
     } else if (serializedId.startsWith('typedef/')) {
       return new TypedefInfo._(serializedId);
     } else if (serializedId.startsWith('outputUnit/')) {
       return new OutputUnitInfo._(serializedId);
     }
     assert(false);
   });
 }
 
 /// Info associated with a library element.
@@ skipping 76 matching lines @@
       // 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))
     });
 
   void accept(InfoVisitor visitor) => visitor.visitClass(this);
 }
 
+/// Information about a constant value.
+// TODO(sigmund): add dependency data for ConstantInfo
+class ConstantInfo extends BasicInfo {
+  /// The actual generated code for the field.
+  String code;
+
+  static int _ids = 0;
+  // TODO(sigmund): Add coverage support to constants?
+  ConstantInfo(
+      {int size: 0,
+      this.code,
+      OutputUnitInfo outputUnit})
+      : super(InfoKind.constant, _ids++, null, outputUnit, size, null);
+
+  ConstantInfo._(String serializedId) : super._fromId(serializedId);
+
+  Map toJson() => super.toJson()
+    ..addAll({'code': code});
+
+  void accept(InfoVisitor visitor) => visitor.visitConstant(this);
+}
+
 /// Information about a field element.
 class FieldInfo extends BasicInfo with CodeInfo {
   /// The type of the field.
   String type;
 
   /// The type inferred by dart2js's whole program analysis
   String inferredType;
 
   /// Nested closures seen in the field initializer.
   List<FunctionInfo> closures;
 
   /// The actual generated code for the field.
   String code;
 
+  /// Whether this corresponds to a const field declaration.
+  bool isConst;
+
+  /// When [isConst] is true, the constant initializer expression.
+  ConstantInfo initializer;
+
   static int _ids = 0;
   FieldInfo(
       {String name,
       String coverageId,
       int size: 0,
       this.type,
       this.inferredType,
       this.closures,
       this.code,
-      OutputUnitInfo outputUnit})
+      OutputUnitInfo outputUnit,
+      this.isConst})
       : super(InfoKind.field, _ids++, name, outputUnit, size, coverageId);
 
   FieldInfo._(String serializedId) : super._fromId(serializedId);
 
-  Map toJson() => super.toJson()
-    ..addAll({
+  Map toJson() {
+    var result = super.toJson()..addAll({
       'children': closures.map((i) => i.serializedId).toList(),
       'inferredType': inferredType,
       'code': code,
       'type': type,
     });
+    if (isConst) {
+      result['const'] = true;
+      if (initializer != null) result['initializer'] = initializer.serializedId;
+    }
+    return result;
+  }
 
   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;
@@ skipping 138 matching lines @@
         'external': isExternal,
       };
 }
 
 /// Possible values of the `kind` field in the serialied infos.
 enum InfoKind {
   library,
   clazz,
   function,
   field,
+  constant,
   outputUnit,
   typedef,
 }
 
 String _kindToString(InfoKind kind) {
   switch(kind) {
     case InfoKind.library: return 'library';
     case InfoKind.clazz: return 'class';
     case InfoKind.function: return 'function';
     case InfoKind.field: return 'field';
+    case InfoKind.constant: return 'constant';
     case InfoKind.outputUnit: return 'outputUnit';
     case InfoKind.typedef: return 'typedef';
     default: return null;
   }
 }
 
 int _idFromSerializedId(String serializedId) =>
     int.parse(serializedId.substring(serializedId.indexOf('/') + 1));
 
 InfoKind _kindFromSerializedId(String serializedId) =>
     _kindFromString(serializedId.substring(0, serializedId.indexOf('/')));
 
 InfoKind _kindFromString(String kind) {
   switch(kind) {
     case 'library': return InfoKind.library;
     case 'class': return InfoKind.clazz;
     case 'function': return InfoKind.function;
     case 'field': return InfoKind.field;
+    case 'constant': return InfoKind.constant;
     case 'outputUnit': return InfoKind.outputUnit;
     case 'typedef': return InfoKind.typedef;
     default: return null;
   }
 }
 
 /// A simple visitor for information produced by the dart2js compiler.
 class InfoVisitor {
   visitAll(AllInfo info) {}
   visitProgram(ProgramInfo info) {}
   visitLibrary(LibraryInfo info) {}
   visitClass(ClassInfo info) {}
   visitField(FieldInfo info) {}
+  visitConstant(ConstantInfo info) {}
   visitFunction(FunctionInfo info) {}
   visitTypedef(TypedefInfo info) {}
   visitOutput(OutputUnitInfo info) {}
 }
 
 /// A visitor that recursively walks each portion of the program. Because the
 /// info representation is redundant, this visitor only walks the structure of
 /// the program and skips some redundant links. For example, even though
 /// visitAll contains references to functions, this visitor only recurses to
 /// visit libraries, then from each library we visit functions and classes, and
 /// so on.
 class RecursiveInfoVisitor extends InfoVisitor {
   visitAll(AllInfo info) {
     // Note: we don't visit functions, fields, classes, and typedefs because
     // they are reachable from the library info.
     info.libraries.forEach(visitLibrary);
+    info.constants.forEach(visitConstant);
   }
 
   visitLibrary(LibraryInfo info) {
     info.topLevelFunctions.forEach(visitFunction);
     info.topLevelVariables.forEach(visitField);
     info.classes.forEach(visitClass);
     info.typedefs.forEach(visitTypedef);
   }
 
   visitClass(ClassInfo info) {
     info.functions.forEach(visitFunction);
     info.fields.forEach(visitField);
   }
 
   visitField(FieldInfo info) {
     info.closures.forEach(visitFunction);
   }
 
   visitFunction(FunctionInfo info) {
     info.closures.forEach(visitFunction);
   }
 }