Reify type params on map literals

test/codegen_expected/unittest/unittest.js

 dart_library.library('unittest', null, /* Imports */[
   'dart_sdk',
   'stack_trace'
 ], function load__unittest(exports, dart_sdk, stack_trace) {
   'use strict';
   const core = dart_sdk.core;
   const collection = dart_sdk.collection;
   const async = dart_sdk.async;
   const _interceptors = dart_sdk._interceptors;
   const isolate = dart_sdk.isolate;
@@ skipping 399 matching lines @@
     }
   };
   dart.fn(unittest._setTestEnabledState, int__Tovoid());
   unittest._requireNotRunning = function() {
     if (src__test_environment.environment.currentTestCaseIndex == -1) return;
     dart.throw(new core.StateError('Not allowed when tests are running.'));
   };
   dart.fn(unittest._requireNotRunning, VoidTovoid$());
   let const$;
   unittest.withTestEnvironment = function(callback) {
-    return async.runZoned(dart.dynamic)(callback, {zoneValues: dart.map([const$ || (const$ = dart.const(core.Symbol.new('unittest.environment'))), new src__test_environment.TestEnvironment()])});
+    return async.runZoned(dart.dynamic)(callback, {zoneValues: dart.map([const$ || (const$ = dart.const(core.Symbol.new('unittest.environment'))), new src__test_environment.TestEnvironment()], core.Symbol, src__test_environment.TestEnvironment)});
   };
   dart.fn(unittest.withTestEnvironment, FnTodynamic());
   let const$0;
   src__configuration.Configuration = class Configuration extends core.Object {
     static new() {
       return new src__simple_configuration.SimpleConfiguration();
     }
     blank() {
       this.autoStart = true;
       this.timeout = const$0 || (const$0 = dart.const(new core.Duration({minutes: 2})));
@@ skipping 102 matching lines @@
       this[_featureName] = featureName;
       this[_matcher] = src__matcher__util.wrapMatcher(matcher);
       super.new();
     }
     featureValueOf(actual) {
       return actual;
     }
     matches(item, matchState) {
       let f = this.featureValueOf(item);
       if (dart.test(this[_matcher].matches(f, matchState))) return true;
-      src__matcher__util.addStateInfo(matchState, dart.map({feature: f}));
+      src__matcher__util.addStateInfo(matchState, dart.map({feature: f}, core.String, dart.dynamic));
       return false;
     }
     describe(description) {
       return description.add(this[_featureDescription]).add(' ').addDescriptionOf(this[_matcher]);
     }
     describeMismatch(item, mismatchDescription, matchState, verbose) {
       mismatchDescription.add('has ').add(this[_featureName]).add(' with value ').addDescriptionOf(matchState[dartx.get]('feature'));
       let innerDescription = new src__matcher__description.StringDescription();
       this[_matcher].describeMismatch(matchState[dartx.get]('feature'), innerDescription, core.Map._check(matchState[dartx.get]('state')), verbose);
       if (dart.notNull(innerDescription.length) > 0) {
@@ skipping 200 matching lines @@
         return true;
       }
       try {
         dart.dcall(item);
         return false;
       } catch (e) {
         let s = dart.stackTrace(e);
         if (this[_matcher$] == null || dart.test(this[_matcher$].matches(e, matchState))) {
           return true;
         } else {
-          src__matcher__util.addStateInfo(matchState, dart.map({exception: e, stack: s}));
+          src__matcher__util.addStateInfo(matchState, dart.map({exception: e, stack: s}, core.String, dart.dynamic));
           return false;
         }
       }
 
     }
     describe(description) {
       if (this[_matcher$] == null) {
         return description.add("throws");
       } else {
         return description.add('throws ').addDescriptionOf(this[_matcher$]);
@@ skipping 161 matching lines @@
   src__matcher__core_matchers._ReturnsNormally = class _ReturnsNormally extends src__matcher__interfaces.Matcher {
     new() {
       super.new();
     }
     matches(f, matchState) {
       try {
         dart.dcall(f);
         return true;
       } catch (e) {
         let s = dart.stackTrace(e);
-        src__matcher__util.addStateInfo(matchState, dart.map({exception: e, stack: s}));
+        src__matcher__util.addStateInfo(matchState, dart.map({exception: e, stack: s}, core.String, dart.dynamic));
         return false;
       }
 
     }
     describe(description) {
       return description.add("return normally");
     }
     describeMismatch(item, mismatchDescription, matchState, verbose) {
       mismatchDescription.add('threw ').addDescriptionOf(matchState[dartx.get]('exception'));
       if (dart.test(verbose)) {
@@ skipping 944 matching lines @@
       let reason = null;
       if (dart.test(dart.dsend(dart.dload(rp[dartx.get](0), 'length'), '>', 0))) {
         if (dart.test(dart.dsend(dart.dload(rp[dartx.get](1), 'length'), '>', 0))) {
           reason = dart.str`${rp[dartx.get](0)} at location ${rp[dartx.get](1)}`;
         } else {
           reason = rp[dartx.get](0);
         }
       } else {
         reason = '';
       }
-      src__matcher__util.addStateInfo(matchState, dart.map({reason: reason}));
+      src__matcher__util.addStateInfo(matchState, dart.map({reason: reason}, core.String, dart.dynamic));
       return core.String._check(reason);
     }
     matches(item, matchState) {
       return this[_match](this[_expected], item, matchState) == null;
     }
     describe(description) {
       return description.addDescriptionOf(this[_expected]);
     }
     describeMismatch(item, mismatchDescription, matchState, verbose) {
       let reason = matchState[dartx.get]('reason');
@@ skipping 287 matching lines @@
       return "?";
     }
 
   };
   dart.fn(src__matcher__pretty_print._typeName, dynamicToString());
   src__matcher__pretty_print._escapeString = function(source) {
     return src__matcher__util.escape(source)[dartx.replaceAll]("'", "\\'");
   };
   dart.fn(src__matcher__pretty_print._escapeString, StringToString());
   src__matcher__util._Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [dart.dynamic]));
-  src__matcher__util._escapeMap = dart.const(dart.map({'\n': '\\n', '\r': '\\r', '\f': '\\f', '\b': '\\b', '\t': '\\t', '\v': '\\v', '': '\\x7F'}));
+  src__matcher__util._escapeMap = dart.const(dart.map({'\n': '\\n', '\r': '\\r', '\f': '\\f', '\b': '\\b', '\t': '\\t', '\v': '\\v', '': '\\x7F'}, core.String, core.String));
   dart.defineLazy(src__matcher__util, {
     get _escapeRegExp() {
       return core.RegExp.new(dart.str`[\\x00-\\x07\\x0E-\\x1F${src__matcher__util._escapeMap[dartx.keys][dartx.map](core.String)(src__matcher__util._getHexLiteral)[dartx.join]()}]`);
     }
   });
   src__matcher__util._getHexLiteral = function(input) {
     let rune = input[dartx.runes].single;
     return '\\x' + dart.notNull(rune[dartx.toRadixString](16)[dartx.toUpperCase]()[dartx.padLeft](2, '0'));
   };
   dart.fn(src__matcher__util._getHexLiteral, StringToString());
@@ skipping 35 matching lines @@
       this[_matcher$1] = matcher;
       super.new();
     }
     matches(item, matchState) {
       if (!core.Iterable.is(item)) {
         return false;
       }
       let i = 0;
       for (let element of core.Iterable._check(item)) {
         if (!dart.test(this[_matcher$1].matches(element, matchState))) {
-          src__matcher__util.addStateInfo(matchState, dart.map({index: i, element: element}));
+          src__matcher__util.addStateInfo(matchState, dart.map({index: i, element: element}, core.String, dart.dynamic));
           return false;
         }
         ++i;
       }
       return true;
     }
     describe(description) {
       return description.add('every element(').addDescriptionOf(this[_matcher$1]).add(')');
     }
     describeMismatch(item, mismatchDescription, matchState, verbose) {
@@ skipping 147 matching lines @@
       super.new();
     }
     matches(item, matchState) {
       if (!core.Iterable.is(item)) return false;
       if (!dart.equals(dart.dload(item, 'length'), this[_expected$][dartx.length])) return false;
       let iterator = dart.dload(item, 'iterator');
       let i = 0;
       for (let e of this[_expected$]) {
         dart.dsend(iterator, 'moveNext');
         if (!dart.test(dart.dcall(this[_comparator], e, dart.dload(iterator, 'current')))) {
-          src__matcher__util.addStateInfo(matchState, dart.map({index: i, expected: e, actual: dart.dload(iterator, 'current')}));
+          src__matcher__util.addStateInfo(matchState, dart.map({index: i, expected: e, actual: dart.dload(iterator, 'current')}, core.String, dart.dynamic));
           return false;
         }
         i++;
       }
       return true;
     }
     describe(description) {
       return description.add(dart.str`pairwise ${this[_description$]} `).addDescriptionOf(this[_expected$]);
     }
     describeMismatch(item, mismatchDescription, matchState, verbose) {
@@ skipping 170 matching lines @@
   });
   const _matchers = Symbol('_matchers');
   src__matcher__operator_matchers._AllOf = class _AllOf extends src__matcher__interfaces.Matcher {
     new(matchers) {
       this[_matchers] = matchers;
       super.new();
     }
     matches(item, matchState) {
       for (let matcher of this[_matchers]) {
         if (!dart.test(matcher.matches(item, matchState))) {
-          src__matcher__util.addStateInfo(matchState, dart.map({matcher: matcher}));
+          src__matcher__util.addStateInfo(matchState, dart.map({matcher: matcher}, core.String, src__matcher__interfaces.Matcher));
           return false;
         }
       }
       return true;
     }
     describeMismatch(item, mismatchDescription, matchState, verbose) {
       let matcher = matchState[dartx.get]('matcher');
       dart.dsend(matcher, 'describeMismatch', item, mismatchDescription, matchState[dartx.get]('state'), verbose);
       return mismatchDescription;
     }
@@ skipping 1086 matching lines @@
   exports.src__internal_test_case = src__internal_test_case;
   exports.src__test_environment = src__test_environment;
   exports.src__group_context = src__group_context;
   exports.src__utils = src__utils;
   exports.src__test_case = src__test_case;
   exports.src__expected_function = src__expected_function;
   exports.html_config = html_config;
   exports.html_individual_config = html_individual_config;
   exports.html_enhanced_config = html_enhanced_config;
 });