Reify type params on map literals

test/codegen_expected/matcher/matcher.js

 dart_library.library('matcher', null, /* Imports */[
   'dart_sdk'
 ], function load__matcher(exports, dart_sdk) {
   'use strict';
   const core = dart_sdk.core;
   const mirrors = dart_sdk.mirrors;
   const _interceptors = dart_sdk._interceptors;
   const dart = dart_sdk.dart;
   const dartx = dart_sdk.dartx;
   const matcher = Object.create(null);
@@ skipping 128 matching lines @@
       this[_featureName] = featureName;
       this[_matcher] = src__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__util.addStateInfo(matchState, dart.map({feature: f}));
+      src__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__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 118 matching lines @@
   src__core_matchers._ReturnsNormally = class _ReturnsNormally extends src__interfaces.Matcher {
     new() {
       super.new();
     }
     matches(f, matchState) {
       try {
         dart.dcall(f);
         return true;
       } catch (e) {
         let s = dart.stackTrace(e);
-        src__util.addStateInfo(matchState, dart.map({exception: e, stack: s}));
+        src__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 587 matching lines @@
       this[_name$] = name;
       this[_matcher$] = matcher;
       super.new();
     }
     matches(item, matchState) {
       let mirror = mirrors.reflect(item);
       let classMirror = mirror.type;
       let symbol = core.Symbol.new(this[_name$]);
       let candidate = classMirror.declarations[dartx.get](symbol);
       if (candidate == null) {
-        src__util.addStateInfo(matchState, dart.map({reason: dart.str`has no property named "${this[_name$]}"`}));
+        src__util.addStateInfo(matchState, dart.map({reason: dart.str`has no property named "${this[_name$]}"`}, core.String, core.String));
         return false;
       }
       let isInstanceField = mirrors.VariableMirror.is(candidate) && !dart.test(candidate.isStatic);
       let isInstanceGetter = mirrors.MethodMirror.is(candidate) && dart.test(candidate.isGetter) && !dart.test(candidate.isStatic);
       if (!(isInstanceField || isInstanceGetter)) {
-        src__util.addStateInfo(matchState, dart.map({reason: dart.str`has a member named "${this[_name$]}", but it is not an instance property`}));
+        src__util.addStateInfo(matchState, dart.map({reason: dart.str`has a member named "${this[_name$]}", but it is not an instance property`}, core.String, core.String));
         return false;
       }
       if (this[_matcher$] == null) return true;
       let result = mirror.getField(symbol);
       let resultMatches = this[_matcher$].matches(result.reflectee, matchState);
       if (!dart.test(resultMatches)) {
-        src__util.addStateInfo(matchState, dart.map({value: result.reflectee}));
+        src__util.addStateInfo(matchState, dart.map({value: result.reflectee}, core.String, dart.dynamic));
       }
       return resultMatches;
     }
     describe(description) {
       description.add(dart.str`has property "${this[_name$]}"`);
       if (this[_matcher$] != null) {
         description.add(' which matches ').addDescriptionOf(this[_matcher$]);
       }
       return description;
     }
@@ skipping 137 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__util.addStateInfo(matchState, dart.map({reason: reason}));
+      src__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 241 matching lines @@
       this[_matcher$0] = 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$0].matches(element, matchState))) {
-          src__util.addStateInfo(matchState, dart.map({index: i, element: element}));
+          src__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$0]).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__util.addStateInfo(matchState, dart.map({index: i, expected: e, actual: dart.dload(iterator, 'current')}));
+          src__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__operator_matchers._AllOf = class _AllOf extends src__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__util.addStateInfo(matchState, dart.map({matcher: matcher}));
+          src__util.addStateInfo(matchState, dart.map({matcher: matcher}, core.String, src__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 275 matching lines @@
     methods: () => ({
       matches: dart.definiteFunctionType(core.bool, [dart.dynamic, core.Map]),
       describe: dart.definiteFunctionType(src__interfaces.Description, [src__interfaces.Description])
     })
   });
   src__string_matchers._isWhitespace = function(ch) {
     return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
   };
   dart.fn(src__string_matchers._isWhitespace, StringTobool());
   src__util._Predicate = dart.typedef('_Predicate', () => dart.functionType(core.bool, [dart.dynamic]));
-  src__util._escapeMap = dart.const(dart.map({'\n': '\\n', '\r': '\\r', '\f': '\\f', '\b': '\\b', '\t': '\\t', '\v': '\\v', '': '\\x7F'}));
+  src__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__util, {
     get _escapeRegExp() {
       return core.RegExp.new(dart.str`[\\x00-\\x07\\x0E-\\x1F${src__util._escapeMap[dartx.keys][dartx.map](core.String)(src__util._getHexLiteral)[dartx.join]()}]`);
     }
   });
   src__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__util._getHexLiteral, StringToString());
   // Exports:
   exports.matcher = matcher;
   exports.mirror_matchers = mirror_matchers;
   exports.src__core_matchers = src__core_matchers;
   exports.src__description = src__description;
   exports.src__error_matchers = src__error_matchers;
   exports.src__interfaces = src__interfaces;
   exports.src__iterable_matchers = src__iterable_matchers;
   exports.src__map_matchers = src__map_matchers;
   exports.src__numeric_matchers = src__numeric_matchers;
   exports.src__operator_matchers = src__operator_matchers;
   exports.src__pretty_print = src__pretty_print;
   exports.src__string_matchers = src__string_matchers;
   exports.src__util = src__util;
 });