make dart2js_info strong-mode clean

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, AllInfo> {
+class JsonToAllInfoConverter extends Converter<Map<String, dynamic>, AllInfo> {
   Map<String, Info> registry;
 
-  AllInfo convert(Map json) {
+  AllInfo convert(Map<String, dynamic> json) {
     registry = <String, Info>{};
 
     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));
+    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.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.values.map(parseConstant));
+      result.constants.addAll((constants as Map).values.map(parseConstant));
     }
 
-    var idMap = {};
+    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) {
       var src = idMap[k];
       assert(src != null);
       for (var dep in deps) {
         var target = idMap[dep['id']];
         assert(target != null);
-        src.uses.add(new DependencyInfo(target, dep['mask']));
+        (src as CodeInfo).uses.add(new DependencyInfo(target, dep['mask']));
       }
     });
 
-    json['dependencies']?.forEach((k, deps) {
+    json['dependencies']?.forEach((String k, List<String> deps) {
       result.dependencies[idMap[k]] = deps.map((d) => idMap[d]).toList();
     });
 
-    result.outputUnits.addAll(json['outputUnits'].map(parseOutputUnit));
+    result.outputUnits
+        .addAll((json['outputUnits'] as List).map(parseOutputUnit));
 
     result.program = parseProgram(json['program']);
     // todo: version, etc
     return result;
   }
 
   OutputUnitInfo parseOutputUnit(Map json) {
     OutputUnitInfo result = parseId(json['id']);
     result
       ..name = json['name']
       ..size = json['size'];
-    result.imports.addAll(json['imports'] ?? const []);
+    result.imports
+        .addAll((json['imports'] as List).map((s) => s as String) ?? const []);
     return result;
   }
 
   LibraryInfo parseLibrary(Map json) {
     LibraryInfo result = parseId(json['id']);
     result
       ..name = json['name']
       ..uri = Uri.parse(json['canonicalUri'])
       ..outputUnit = parseId(json['outputUnit'])
       ..size = json['size'];
@@ skipping 38 matching lines @@
       ..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();
+      ..closures = (json['children'] as List).map(parseId).toList();
   }
 
   ConstantInfo parseConstant(Map json) {
     ConstantInfo result = parseId(json['id']);
     return result
       ..code = json['code']
       ..size = json['size'];
   }
 
   TypedefInfo parseTypedef(Map json) {
@@ skipping 13 matching lines @@
     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()
+      ..parameters = (json['parameters'] as List).map(parseParameter).toList()
       ..code = json['code']
       ..sideEffects = json['sideEffects']
-      ..modifiers = parseModifiers(json['modifiers'])
-      ..closures = json['children'].map(parseId).toList()
+      ..modifiers =
+          parseModifiers(new Map<String, bool>.from(json['modifiers']))
+      ..closures = (json['children'] as List).map(parseId).toList()
       ..measurements = parseMeasurements(json['measurements']);
   }
 
   ParameterInfo parseParameter(Map json) =>
       new ParameterInfo(json['name'], json['type'], json['declaredType']);
 
   Measurements parseMeasurements(Map json) {
     if (json == null) return null;
     var uri = json['sourceFile'];
     var res = new Measurements(uri == null ? null : Uri.parse(uri));
@@ skipping 128 matching lines @@
 
   Map _visitBasicInfo(BasicInfo info) {
     var res = {
       'id': info.serializedId,
       'kind': kindToString(info.kind),
       'name': info.name,
       'size': info.size,
     };
     // TODO(sigmund): Omit this also when outputUnit.id == 0 (most code is in
     // the main output unit by default).
-    if (info.outputUnit != null) res['outputUnit'] =
-        info.outputUnit.serializedId;
+    if (info.outputUnit != null) {
+      res['outputUnit'] = info.outputUnit.serializedId;
+    }
     if (info.coverageId != null) res['coverageId'] = info.coverageId;
     if (info.parent != null) res['parent'] = info.parent.serializedId;
     return res;
   }
 
   Map visitLibrary(LibraryInfo info) {
     return _visitBasicInfo(info)
       ..addAll({
         'children': []
           ..addAll(info.topLevelFunctions.map((f) => f.serializedId))
@@ skipping 18 matching lines @@
   Map visitField(FieldInfo info) {
     var result = _visitBasicInfo(info)
       ..addAll({
         'children': info.closures.map((i) => i.serializedId).toList(),
         'inferredType': info.inferredType,
         'code': info.code,
         'type': info.type,
       });
     if (info.isConst) {
       result['const'] = true;
-      if (info.initializer != null) result['initializer'] =
-          info.initializer.serializedId;
+      if (info.initializer != null) {
+        result['initializer'] = info.initializer.serializedId;
+      }
     }
     return result;
   }
 
   Map visitConstant(ConstantInfo info) =>
       _visitBasicInfo(info)..addAll({'code': info.code});
 
   // TODO(sigmund): exclude false values (requires bumping the format version):
   //     var res = <String, bool>{};
   //     if (isStatic) res['static'] = true;
   //     if (isConst) res['const'] = true;
   //     if (isFactory) res['factory'] = true;
   //     if (isExternal) res['external'] = true;
   //     return res;
   Map _visitFunctionModifiers(FunctionModifiers mods) => {
         'static': mods.isStatic,
         'const': mods.isConst,
         'factory': mods.isFactory,
         'external': mods.isExternal,
       };
 
   Map _visitParameterInfo(ParameterInfo info) =>
       {'name': info.name, 'type': info.type, 'declaredType': info.declaredType};
 
   String _visitMetric(Metric metric) => metric.name;
 
   Map _visitMeasurements(Measurements measurements) {
     if (measurements == null) return null;
-    var jsonEntries = <String, List<Map>>{};
+    var jsonEntries = <String, List<int>>{};
     measurements.entries.forEach((metric, values) {
       jsonEntries[_visitMetric(metric)] =
           values.expand((e) => [e.begin, e.end]).toList();
     });
-    var json = {'entries': jsonEntries};
+    var json = <String, dynamic>{'entries': jsonEntries};
     // TODO(sigmund): encode uri as an offset of the URIs available in the parts
     // of the library info.
     if (measurements.uri != null) json['sourceFile'] = '${measurements.uri}';
     if (measurements.counters[Metric.functions] != null) {
       json[_visitMetric(Metric.functions)] =
           measurements.counters[Metric.functions];
     }
     if (measurements.counters[Metric.reachableFunctions] != null) {
       json[_visitMetric(Metric.reachableFunctions)] =
           measurements.counters[Metric.reachableFunctions];
@@ skipping 23 matching lines @@
   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();
 }