Add ClosureInfo for closures.

lib/json_info_codec.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.
 
 /// Converters and codecs for converting between JSON and [Info] classes.
 part of dart2js_info.info;
 
 // TODO(sigmund): add unit tests.
 class JsonToAllInfoConverter extends Converter<Map<String, dynamic>, AllInfo> {
-  Map<String, Info> registry;
+  Map<String, Info> registry = <String, Info>{};
 
   AllInfo convert(Map<String, dynamic> json) {
-    registry = <String, Info>{};
+    registry.clear();
 
     var result = new AllInfo();
     var elements = json['elements'];
     result.libraries
         .addAll((elements['library'] as Map).values.map(parseLibrary));
     result.classes.addAll((elements['class'] as Map).values.map(parseClass));
     result.functions
         .addAll((elements['function'] as Map).values.map(parseFunction));
+    result.closures
+        .addAll((elements['closure'] as Map).values.map(parseClosure));
     result.fields.addAll((elements['field'] as Map).values.map(parseField));
     result.typedefs
         .addAll((elements['typedef'] as Map).values.map(parseTypedef));
-
-    // TODO(sigmund): remove null check on next breaking version
-    var constants = elements['constant'];
-    if (constants != null) {
-      result.constants.addAll((constants as Map).values.map(parseConstant));
-    }
+    result.constants
+        .addAll((elements['constant'] as Map).values.map(parseConstant));
 
     var idMap = <String, Info>{};
     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) {
@@ skipping 160 matching lines @@
   }
 
   FunctionModifiers parseModifiers(Map<String, bool> json) {
     return new FunctionModifiers(
         isStatic: json['static'] == true,
         isConst: json['const'] == true,
         isFactory: json['factory'] == true,
         isExternal: json['external'] == true);
   }
 
+  ClosureInfo parseClosure(Map json) {
+    ClosureInfo result = parseId(json['id']);
+    return result
+      ..name = json['name']
+      ..parent = parseId(json['parent'])
+      ..outputUnit = parseId(json['outputUnit'])
+      ..size = json['size']
+      ..function = parseId(json['function']);
+  }
+
   Info parseId(String serializedId) => registry.putIfAbsent(serializedId, () {
         if (serializedId == null) {
           return null;
         } else if (serializedId.startsWith('function/')) {
           return new FunctionInfo._(serializedId);
+        } else if (serializedId.startsWith('closure/')) {
+          return new ClosureInfo._(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);
@@ skipping 16 matching lines @@
     return map;
   }
 
   Map _visitAllInfoElements(AllInfo info) {
     var jsonLibraries = _visitList(info.libraries);
     var jsonClasses = _visitList(info.classes);
     var jsonFunctions = _visitList(info.functions);
     var jsonTypedefs = _visitList(info.typedefs);
     var jsonFields = _visitList(info.fields);
     var jsonConstants = _visitList(info.constants);
+    var jsonClosures = _visitList(info.closures);
     return {
       'library': jsonLibraries,
       'class': jsonClasses,
       'function': jsonFunctions,
       'typedef': jsonTypedefs,
       'field': jsonFields,
-      'constant': jsonConstants
+      'constant': jsonConstants,
+      'closure': jsonClosures,
     };
   }
 
   Map _visitDependencyInfo(DependencyInfo info) =>
       {'id': info.target.serializedId, 'mask': info.mask};
 
   Map _visitAllInfoHolding(AllInfo allInfo) {
     var map = <String, List>{};
     void helper(CodeInfo info) {
       if (info.uses.isEmpty) return;
@@ skipping 157 matching lines @@
         'sideEffects': info.sideEffects,
         'inlinedCount': info.inlinedCount,
         'code': info.code,
         'type': info.type,
         'measurements': _visitMeasurements(info.measurements),
         // Note: version 3.2 of dump-info serializes `uses` in a section called
         // `holding` at the top-level.
       });
   }
 
+  Map visitClosure(ClosureInfo info) {
+    return _visitBasicInfo(info)
+      ..addAll({'function': info.function.serializedId});
+  }
+
   visitTypedef(TypedefInfo info) => _visitBasicInfo(info)..['type'] = info.type;
 
   visitOutput(OutputUnitInfo info) =>
       _visitBasicInfo(info)..['imports'] = info.imports;
 }
 
 class AllInfoJsonCodec extends Codec<AllInfo, Map> {
   final Converter<AllInfo, Map> encoder = new AllInfoToJsonConverter();
   final Converter<Map, AllInfo> decoder = new JsonToAllInfoConverter();
 }