Use short array syntax in method signatures

lib/runtime/dart/_js_helper.js

 var _js_helper = dart.defineLibrary(_js_helper, {});
 var core = dart.import(core);
 var collection = dart.import(collection);
 var _internal = dart.import(_internal);
 var _foreign_helper = dart.import(_foreign_helper);
 var _js_embedded_names = dart.import(_js_embedded_names);
 var _interceptors = dart.lazyImport(_interceptors);
 var _js_names = dart.import(_js_names);
 var async = dart.import(async);
 var _isolate_helper = dart.lazyImport(_isolate_helper);
@@ skipping 61 matching lines @@
       }
       addAll(other) {
         dart.as(other, core.Map$(K, V));
         return this[_throwUnmodifiable]();
       }
     }
     ConstantMap[dart.implements] = () => [core.Map$(K, V)];
     dart.defineNamedConstructor(ConstantMap, '_');
     dart.setSignature(ConstantMap, {
       methods: () => ({
-        toString: dart.functionType(core.String, []),
-        [_throwUnmodifiable]: dart.functionType(dart.dynamic, []),
-        set: dart.functionType(dart.void, [K, V]),
-        putIfAbsent: dart.functionType(V, [K, dart.functionType(V, [])]),
-        remove: dart.functionType(V, [core.Object]),
-        clear: dart.functionType(dart.void, []),
-        addAll: dart.functionType(dart.void, [core.Map$(K, V)])
+        toString: [core.String, []],
+        [_throwUnmodifiable]: [dart.dynamic, []],
+        set: [dart.void, [K, V]],
+        putIfAbsent: [V, [K, dart.functionType(V, [])]],
+        remove: [V, [core.Object]],
+        clear: [dart.void, []],
+        addAll: [dart.void, [core.Map$(K, V)]]
       })
     });
     return ConstantMap;
   });
   let ConstantMap = ConstantMap$();
   let _jsObject = Symbol('_jsObject');
   let _keys = Symbol('_keys');
   let _fetch = Symbol('_fetch');
   let ConstantStringMap$ = dart.generic(function(K, V) {
     class ConstantStringMap extends ConstantMap$(K, V) {
@@ skipping 33 matching lines @@
         return new (_ConstantMapKeyIterable$(K))(this);
       }
       get values() {
         return new (_internal.MappedIterable$(K, V))(this[_keys], dart.fn((key => dart.as(this[_fetch](key), V)).bind(this), V, [dart.dynamic]));
       }
     }
     ConstantStringMap[dart.implements] = () => [_internal.EfficientLength];
     dart.defineNamedConstructor(ConstantStringMap, '_');
     dart.setSignature(ConstantStringMap, {
       methods: () => ({
-        containsValue: dart.functionType(core.bool, [core.Object]),
-        containsKey: dart.functionType(core.bool, [core.Object]),
-        get: dart.functionType(V, [core.Object]),
-        [_fetch]: dart.functionType(dart.dynamic, [dart.dynamic]),
-        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [K, V])])
+        containsValue: [core.bool, [core.Object]],
+        containsKey: [core.bool, [core.Object]],
+        get: [V, [core.Object]],
+        [_fetch]: [dart.dynamic, [dart.dynamic]],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]]
       })
     });
     return ConstantStringMap;
   });
   let ConstantStringMap = ConstantStringMap$();
   let _protoValue = Symbol('_protoValue');
   let ConstantProtoMap$ = dart.generic(function(K, V) {
     class ConstantProtoMap extends ConstantStringMap$(K, V) {
       _(length, jsObject, keys, protoValue) {
         this[_protoValue] = protoValue;
         super._(dart.as(length, core.int), jsObject, dart.as(keys, core.List$(K)));
       }
       containsKey(key) {
         if (!(typeof key == 'string'))
           return false;
         if (dart.equals('__proto__', key))
           return true;
         return jsHasOwnProperty(this[_jsObject], dart.as(key, core.String));
       }
       [_fetch](key) {
         return dart.equals('__proto__', key) ? this[_protoValue] : jsPropertyAccess(this[_jsObject], dart.as(key, core.String));
       }
     }
     dart.defineNamedConstructor(ConstantProtoMap, '_');
     dart.setSignature(ConstantProtoMap, {
       methods: () => ({
-        containsKey: dart.functionType(core.bool, [core.Object]),
-        [_fetch]: dart.functionType(dart.dynamic, [dart.dynamic])
+        containsKey: [core.bool, [core.Object]],
+        [_fetch]: [dart.dynamic, [dart.dynamic]]
       })
     });
     return ConstantProtoMap;
   });
   let ConstantProtoMap = ConstantProtoMap$();
   let _map = Symbol('_map');
   let _ConstantMapKeyIterable$ = dart.generic(function(K) {
     class _ConstantMapKeyIterable extends collection.IterableBase$(K) {
       _ConstantMapKeyIterable(map) {
         this[_map] = map;
@@ skipping 43 matching lines @@
       }
       get values() {
         return this[_getMap]().values;
       }
       get length() {
         return this[_getMap]().length;
       }
     }
     dart.setSignature(GeneralConstantMap, {
       methods: () => ({
-        [_getMap]: dart.functionType(core.Map$(K, V), []),
-        containsValue: dart.functionType(core.bool, [core.Object]),
-        containsKey: dart.functionType(core.bool, [core.Object]),
-        get: dart.functionType(V, [core.Object]),
-        forEach: dart.functionType(dart.void, [dart.functionType(dart.void, [K, V])])
+        [_getMap]: [core.Map$(K, V), []],
+        containsValue: [core.bool, [core.Object]],
+        containsKey: [core.bool, [core.Object]],
+        get: [V, [core.Object]],
+        forEach: [dart.void, [dart.functionType(dart.void, [K, V])]]
       })
     });
     return GeneralConstantMap;
   });
   let GeneralConstantMap = GeneralConstantMap$();
   function contains(userAgent, name) {
     return userAgent.indexOf(name) != -1;
   }
   dart.fn(contains, core.bool, [core.String, core.String]);
   function arrayLength(array) {
@@ skipping 377 matching lines @@
     get isMultiLine() {
       return this[_isMultiLine];
     }
     get isCaseSensitive() {
       return this[_isCaseSensitive];
     }
   }
   JSSyntaxRegExp[dart.implements] = () => [core.RegExp];
   dart.setSignature(JSSyntaxRegExp, {
     methods: () => ({
-      toString: dart.functionType(core.String, []),
-      firstMatch: dart.functionType(core.Match, [core.String]),
-      hasMatch: dart.functionType(core.bool, [core.String]),
-      stringMatch: dart.functionType(core.String, [core.String]),
-      allMatches: dart.functionType(core.Iterable$(core.Match), [core.String], [core.int]),
-      [_execGlobal]: dart.functionType(core.Match, [core.String, core.int]),
-      [_execAnchored]: dart.functionType(core.Match, [core.String, core.int]),
-      matchAsPrefix: dart.functionType(core.Match, [core.String], [core.int])
+      toString: [core.String, []],
+      firstMatch: [core.Match, [core.String]],
+      hasMatch: [core.bool, [core.String]],
+      stringMatch: [core.String, [core.String]],
+      allMatches: [core.Iterable$(core.Match), [core.String], [core.int]],
+      [_execGlobal]: [core.Match, [core.String, core.int]],
+      [_execAnchored]: [core.Match, [core.String, core.int]],
+      matchAsPrefix: [core.Match, [core.String], [core.int]]
     }),
-    statics: () => ({makeNative: dart.functionType(dart.dynamic, [core.String, core.bool, core.bool, core.bool])}),
+    statics: () => ({makeNative: [dart.dynamic, [core.String, core.bool, core.bool, core.bool]]}),
     names: ['makeNative']
   });
   let _match = Symbol('_match');
   class _MatchImplementation extends core.Object {
     _MatchImplementation(pattern, match) {
       this.pattern = pattern;
       this[_match] = match;
       dart.assert(typeof this[_match].input == 'string');
       dart.assert(typeof this[_match].index == 'number');
     }
@@ skipping 19 matching lines @@
       let out = dart.setType([], core.List$(core.String));
       for (let i of groups) {
         out[core.$add](this.group(i));
       }
       return out;
     }
   }
   _MatchImplementation[dart.implements] = () => [core.Match];
   dart.setSignature(_MatchImplementation, {
     methods: () => ({
-      group: dart.functionType(core.String, [core.int]),
-      get: dart.functionType(core.String, [core.int]),
-      groups: dart.functionType(core.List$(core.String), [core.List$(core.int)])
+      group: [core.String, [core.int]],
+      get: [core.String, [core.int]],
+      groups: [core.List$(core.String), [core.List$(core.int)]]
     })
   });
   let _re = Symbol('_re');
   let _string = Symbol('_string');
   let _start = Symbol('_start');
   class _AllMatchesIterable extends collection.IterableBase$(core.Match) {
     _AllMatchesIterable(re, string, start) {
       this[_re] = re;
       this[_string] = string;
       this[_start] = start;
@@ skipping 32 matching lines @@
           return true;
         }
       }
       this[_current] = null;
       this[_string] = null;
       return false;
     }
   }
   _AllMatchesIterator[dart.implements] = () => [core.Iterator$(core.Match)];
   dart.setSignature(_AllMatchesIterator, {
-    methods: () => ({moveNext: dart.functionType(core.bool, [])})
+    methods: () => ({moveNext: [core.bool, []]})
   });
   function firstMatchAfter(regExp, string, start) {
     return regExp[_execGlobal](string, start);
   }
   dart.fn(firstMatchAfter, core.Match, [JSSyntaxRegExp, core.String, core.int]);
   class StringMatch extends core.Object {
     StringMatch(start, input, pattern) {
       this.start = start;
       this.input = input;
       this.pattern = pattern;
@@ skipping 17 matching lines @@
       let result = new (core.List$(core.String))();
       for (let g of groups_) {
         result[core.$add](this.group(g));
       }
       return result;
     }
   }
   StringMatch[dart.implements] = () => [core.Match];
   dart.setSignature(StringMatch, {
     methods: () => ({
-      get: dart.functionType(core.String, [core.int]),
-      group: dart.functionType(core.String, [core.int]),
-      groups: dart.functionType(core.List$(core.String), [core.List$(core.int)])
+      get: [core.String, [core.int]],
+      group: [core.String, [core.int]],
+      groups: [core.List$(core.String), [core.List$(core.int)]]
     })
   });
   function allMatchesInStringUnchecked(needle, haystack, startIndex) {
     let result = new (core.List$(core.Match))();
     let length = haystack.length;
     let patternLength = needle.length;
     while (true) {
       let position = haystack.indexOf(needle, startIndex);
       if (position == -1) {
         break;
@@ skipping 183 matching lines @@
     get hashCode() {
       return dart.hashCode(this[_typeName]);
     }
     ['=='](other) {
       return dart.is(other, TypeImpl) && dart.equals(this[_typeName], dart.dload(other, _typeName));
     }
   }
   TypeImpl[dart.implements] = () => [core.Type];
   dart.setSignature(TypeImpl, {
     methods: () => ({
-      toString: dart.functionType(core.String, []),
-      '==': dart.functionType(core.bool, [dart.dynamic])
+      toString: [core.String, []],
+      '==': [core.bool, [dart.dynamic]]
     })
   });
   class TypeVariable extends core.Object {
     TypeVariable(owner, name, bound) {
       this.owner = owner;
       this.name = name;
       this.bound = bound;
     }
   }
   dart.setSignature(TypeVariable, {});
@@ skipping 616 matching lines @@
       } else {
         return dart.dsend(cached, 'invokeOn', victim, invocation[_arguments]);
       }
     }
     static getCachedInvocation(invocation, victim) {
       return invocation[_getCachedInvocation](victim);
     }
   }
   JSInvocationMirror[dart.implements] = () => [core.Invocation];
   dart.setSignature(JSInvocationMirror, {
-    methods: () => ({[_getCachedInvocation]: dart.functionType(dart.dynamic, [core.Object])}),
+    methods: () => ({[_getCachedInvocation]: [dart.dynamic, [core.Object]]}),
     statics: () => ({
-      invokeFromMirror: dart.functionType(dart.dynamic, [JSInvocationMirror, core.Object]),
-      getCachedInvocation: dart.functionType(dart.dynamic, [JSInvocationMirror, core.Object])
+      invokeFromMirror: [dart.dynamic, [JSInvocationMirror, core.Object]],
+      getCachedInvocation: [dart.dynamic, [JSInvocationMirror, core.Object]]
     }),
     names: ['invokeFromMirror', 'getCachedInvocation']
   });
   JSInvocationMirror.METHOD = 0;
   JSInvocationMirror.GETTER = 1;
   JSInvocationMirror.SETTER = 2;
   class CachedInvocation extends core.Object {
     CachedInvocation(mangledName, jsFunction, isIntercepted, cachedInterceptor) {
       this.mangledName = mangledName;
       this.jsFunction = jsFunction;
@@ skipping 15 matching lines @@
         let _ = [victim];
         _[core.$addAll](arguments$);
         arguments$ = _;
         if (this.cachedInterceptor != null)
           receiver = this.cachedInterceptor;
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
   dart.setSignature(CachedInvocation, {
-    methods: () => ({invokeOn: dart.functionType(dart.dynamic, [core.Object, core.List])})
+    methods: () => ({invokeOn: [dart.dynamic, [core.Object, core.List]]})
   });
   class CachedCatchAllInvocation extends CachedInvocation {
     CachedCatchAllInvocation(name, jsFunction, isIntercepted, cachedInterceptor) {
       this.info = new ReflectionInfo(jsFunction);
       super.CachedInvocation(name, jsFunction, isIntercepted, cachedInterceptor);
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, arguments$) {
@@ skipping 25 matching lines @@
       } else if (dart.notNull(providedArgumentCount) > dart.notNull(fullParameterCount)) {
         throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${providedArgumentCount} arguments (too many).`);
       }
       for (let i = providedArgumentCount; dart.notNull(i) < dart.notNull(fullParameterCount); i = dart.notNull(i) + 1) {
         arguments$[core.$add](getMetadata(this.info.defaultValue(i)));
       }
       return this.jsFunction.apply(receiver, arguments$);
     }
   }
   dart.setSignature(CachedCatchAllInvocation, {
-    methods: () => ({invokeOn: dart.functionType(dart.dynamic, [core.Object, core.List])})
+    methods: () => ({invokeOn: [dart.dynamic, [core.Object, core.List]]})
   });
   class CachedNoSuchMethodInvocation extends core.Object {
     CachedNoSuchMethodInvocation(interceptor) {
       this.interceptor = interceptor;
     }
     get isNoSuchMethod() {
       return true;
     }
     get isGetterStub() {
       return false;
     }
     invokeOn(victim, invocation) {
       let receiver = this.interceptor == null ? victim : this.interceptor;
       return dart.dsend(receiver, 'noSuchMethod', invocation);
     }
   }
   dart.setSignature(CachedNoSuchMethodInvocation, {
-    methods: () => ({invokeOn: dart.functionType(dart.dynamic, [core.Object, core.Invocation])})
+    methods: () => ({invokeOn: [dart.dynamic, [core.Object, core.Invocation]]})
   });
   class ReflectionInfo extends core.Object {
     internal(jsFunction, data, isAccessor, requiredParameterCount, optionalParameterCount, areOptionalParametersNamed, functionType) {
       this.jsFunction = jsFunction;
       this.data = data;
       this.isAccessor = isAccessor;
       this.requiredParameterCount = requiredParameterCount;
       this.optionalParameterCount = optionalParameterCount;
       this.areOptionalParametersNamed = areOptionalParametersNamed;
       this.functionType = functionType;
@@ skipping 87 matching lines @@
         throw new RuntimeError('Unexpected function type');
       }
     }
     get reflectionName() {
       return this.jsFunction.$reflectionName;
     }
   }
   dart.defineNamedConstructor(ReflectionInfo, 'internal');
   dart.setSignature(ReflectionInfo, {
     methods: () => ({
-      parameterName: dart.functionType(core.String, [core.int]),
-      parameterMetadataAnnotations: dart.functionType(core.List$(core.int), [core.int]),
-      defaultValue: dart.functionType(core.int, [core.int]),
-      defaultValueInOrder: dart.functionType(core.int, [core.int]),
-      parameterNameInOrder: dart.functionType(core.String, [core.int]),
-      sortedIndex: dart.functionType(core.int, [core.int]),
-      computeFunctionRti: dart.functionType(dart.dynamic, [dart.dynamic])
+      parameterName: [core.String, [core.int]],
+      parameterMetadataAnnotations: [core.List$(core.int), [core.int]],
+      defaultValue: [core.int, [core.int]],
+      defaultValueInOrder: [core.int, [core.int]],
+      parameterNameInOrder: [core.String, [core.int]],
+      sortedIndex: [core.int, [core.int]],
+      computeFunctionRti: [dart.dynamic, [dart.dynamic]]
     })
   });
   ReflectionInfo.REQUIRED_PARAMETERS_INFO = 0;
   ReflectionInfo.OPTIONAL_PARAMETERS_INFO = 1;
   ReflectionInfo.FUNCTION_TYPE_INDEX = 2;
   ReflectionInfo.FIRST_DEFAULT_ARGUMENT = 3;
   function getMetadata(index) {
     let metadata = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.METADATA);
     return metadata[index];
   }
@@ skipping 386 matching lines @@
     }
     static identicalImplementation(a, b) {
       return a == null ? b == null : a === b;
     }
     static extractStackTrace(error) {
       return getTraceFromException(error.$thrownJsError);
     }
   }
   dart.setSignature(Primitives, {
     statics: () => ({
-      initializeStatics: dart.functionType(dart.void, [core.int]),
-      objectHashCode: dart.functionType(core.int, [dart.dynamic]),
-      _throwFormatException: dart.functionType(dart.dynamic, [core.String]),
-      parseInt: dart.functionType(core.int, [core.String, core.int, dart.functionType(core.int, [core.String])]),
-      parseDouble: dart.functionType(core.double, [core.String, dart.functionType(core.double, [core.String])]),
-      formatType: dart.functionType(core.String, [core.String, core.List]),
-      objectTypeName: dart.functionType(core.String, [core.Object]),
-      objectToString: dart.functionType(core.String, [core.Object]),
-      dateNow: dart.functionType(core.num, []),
-      initTicker: dart.functionType(dart.void, []),
-      currentUri: dart.functionType(core.String, []),
-      _fromCharCodeApply: dart.functionType(core.String, [core.List$(core.int)]),
-      stringFromCodePoints: dart.functionType(core.String, [dart.dynamic]),
-      stringFromCharCodes: dart.functionType(core.String, [dart.dynamic]),
-      stringFromCharCode: dart.functionType(core.String, [dart.dynamic]),
-      stringConcatUnchecked: dart.functionType(core.String, [core.String, core.String]),
-      flattenString: dart.functionType(core.String, [core.String]),
-      getTimeZoneName: dart.functionType(core.String, [dart.dynamic]),
-      getTimeZoneOffsetInMinutes: dart.functionType(core.int, [dart.dynamic]),
-      valueFromDecomposedDate: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]),
-      patchUpY2K: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic]),
-      lazyAsJsDate: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getYear: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getMonth: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getDay: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getHours: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getMinutes: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getSeconds: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getMilliseconds: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getWeekday: dart.functionType(dart.dynamic, [dart.dynamic]),
-      valueFromDateString: dart.functionType(dart.dynamic, [dart.dynamic]),
-      getProperty: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic]),
-      setProperty: dart.functionType(dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]),
-      functionNoSuchMethod: dart.functionType(dart.dynamic, [dart.dynamic, core.List, core.Map$(core.String, dart.dynamic)]),
-      applyFunction: dart.functionType(dart.dynamic, [core.Function, core.List, core.Map$(core.String, dart.dynamic)]),
-      applyFunctionWithPositionalArguments: dart.functionType(dart.dynamic, [core.Function, core.List]),
-      applyFunctionWithNamedArguments: dart.functionType(dart.dynamic, [core.Function, core.List, core.Map$(core.String, dart.dynamic)]),
-      _mangledNameMatchesType: dart.functionType(dart.dynamic, [core.String, TypeImpl]),
-      identicalImplementation: dart.functionType(core.bool, [dart.dynamic, dart.dynamic]),
-      extractStackTrace: dart.functionType(core.StackTrace, [core.Error])
+      initializeStatics: [dart.void, [core.int]],
+      objectHashCode: [core.int, [dart.dynamic]],
+      _throwFormatException: [dart.dynamic, [core.String]],
+      parseInt: [core.int, [core.String, core.int, dart.functionType(core.int, [core.String])]],
+      parseDouble: [core.double, [core.String, dart.functionType(core.double, [core.String])]],
+      formatType: [core.String, [core.String, core.List]],
+      objectTypeName: [core.String, [core.Object]],
+      objectToString: [core.String, [core.Object]],
+      dateNow: [core.num, []],
+      initTicker: [dart.void, []],
+      currentUri: [core.String, []],
+      _fromCharCodeApply: [core.String, [core.List$(core.int)]],
+      stringFromCodePoints: [core.String, [dart.dynamic]],
+      stringFromCharCodes: [core.String, [dart.dynamic]],
+      stringFromCharCode: [core.String, [dart.dynamic]],
+      stringConcatUnchecked: [core.String, [core.String, core.String]],
+      flattenString: [core.String, [core.String]],
+      getTimeZoneName: [core.String, [dart.dynamic]],
+      getTimeZoneOffsetInMinutes: [core.int, [dart.dynamic]],
+      valueFromDecomposedDate: [dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic, dart.dynamic]],
+      patchUpY2K: [dart.dynamic, [dart.dynamic, dart.dynamic, dart.dynamic]],
+      lazyAsJsDate: [dart.dynamic, [dart.dynamic]],
+      getYear: [dart.dynamic, [dart.dynamic]],
+      getMonth: [dart.dynamic, [dart.dynamic]],
+      getDay: [dart.dynamic, [dart.dynamic]],
+      getHours: [dart.dynamic, [dart.dynamic]],
+      getMinutes: [dart.dynamic, [dart.dynamic]],
+      getSeconds: [dart.dynamic, [dart.dynamic]],
+      getMilliseconds: [dart.dynamic, [dart.dynamic]],
+      getWeekday: [dart.dynamic, [dart.dynamic]],
+      valueFromDateString: [dart.dynamic, [dart.dynamic]],
+      getProperty: [dart.dynamic, [dart.dynamic, dart.dynamic]],
+      setProperty: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
+      functionNoSuchMethod: [dart.dynamic, [dart.dynamic, core.List, core.Map$(core.String, dart.dynamic)]],
+      applyFunction: [dart.dynamic, [core.Function, core.List, core.Map$(core.String, dart.dynamic)]],
+      applyFunctionWithPositionalArguments: [dart.dynamic, [core.Function, core.List]],
+      applyFunctionWithNamedArguments: [dart.dynamic, [core.Function, core.List, core.Map$(core.String, dart.dynamic)]],
+      _mangledNameMatchesType: [dart.dynamic, [core.String, TypeImpl]],
+      identicalImplementation: [core.bool, [dart.dynamic, dart.dynamic]],
+      extractStackTrace: [core.StackTrace, [core.Error]]
     }),
     names: ['initializeStatics', 'objectHashCode', '_throwFormatException', 'parseInt', 'parseDouble', 'formatType', 'objectTypeName', 'objectToString', 'dateNow', 'initTicker', 'currentUri', '_fromCharCodeApply', 'stringFromCodePoints', 'stringFromCharCodes', 'stringFromCharCode', 'stringConcatUnchecked', 'flattenString', 'getTimeZoneName', 'getTimeZoneOffsetInMinutes', 'valueFromDecomposedDate', 'patchUpY2K', 'lazyAsJsDate', 'getYear', 'getMonth', 'getDay', 'getHours', 'getMinutes', 'getSeconds', 'getMilliseconds', 'getWeekday', 'valueFromDateString', 'getProperty', 'setProperty', 'functionNoSuchMethod', 'applyFunction', 'applyFunctionWithPositionalArguments', 'applyFunctionWithNamedArguments', '_mangledNameMatchesType', 'identicalImplementation', 'extractStackTrace']
   });
   Primitives.mirrorFunctionCacheName = '$cachedFunction';
   Primitives.mirrorInvokeCacheName = '$cachedInvocation';
   Primitives.DOLLAR_CHAR_VALUE = 36;
   Primitives.timerFrequency = null;
   Primitives.timerTicks = null;
   dart.defineLazyProperties(Primitives, {
     get constructorNameFallback() {
@@ skipping 20 matching lines @@
     }
     static fetch(cache, key) {
       return cache[key];
     }
     static update(cache, key, value) {
       cache[key] = value;
     }
   }
   dart.setSignature(JsCache, {
     statics: () => ({
-      allocate: dart.functionType(dart.dynamic, []),
-      fetch: dart.functionType(dart.dynamic, [dart.dynamic, core.String]),
-      update: dart.functionType(dart.void, [dart.dynamic, core.String, dart.dynamic])
+      allocate: [dart.dynamic, []],
+      fetch: [dart.dynamic, [dart.dynamic, core.String]],
+      update: [dart.void, [dart.dynamic, core.String, dart.dynamic]]
     }),
     names: ['allocate', 'fetch', 'update']
   });
   function iae(argument) {
     throw new core.ArgumentError(argument);
   }
   dart.fn(iae);
   function ioore(receiver, index) {
     if (receiver == null)
       dart.dload(receiver, 'length');
@@ skipping 205 matching lines @@
           (void 0).$method$;
         } catch (e) {
           return e.message;
         }
 
       };
       return func();
     }
   }
   dart.setSignature(TypeErrorDecoder, {
-    methods: () => ({matchTypeError: dart.functionType(dart.dynamic, [dart.dynamic])}),
+    methods: () => ({matchTypeError: [dart.dynamic, [dart.dynamic]]}),
     statics: () => ({
-      buildJavaScriptObject: dart.functionType(dart.dynamic, []),
-      buildJavaScriptObjectWithNonClosure: dart.functionType(dart.dynamic, []),
-      extractPattern: dart.functionType(dart.dynamic, [core.String]),
-      provokeCallErrorOn: dart.functionType(core.String, [dart.dynamic]),
-      provokeCallErrorOnNull: dart.functionType(core.String, []),
-      provokeCallErrorOnUndefined: dart.functionType(core.String, []),
-      provokePropertyErrorOn: dart.functionType(core.String, [dart.dynamic]),
-      provokePropertyErrorOnNull: dart.functionType(core.String, []),
-      provokePropertyErrorOnUndefined: dart.functionType(core.String, [])
+      buildJavaScriptObject: [dart.dynamic, []],
+      buildJavaScriptObjectWithNonClosure: [dart.dynamic, []],
+      extractPattern: [dart.dynamic, [core.String]],
+      provokeCallErrorOn: [core.String, [dart.dynamic]],
+      provokeCallErrorOnNull: [core.String, []],
+      provokeCallErrorOnUndefined: [core.String, []],
+      provokePropertyErrorOn: [core.String, [dart.dynamic]],
+      provokePropertyErrorOnNull: [core.String, []],
+      provokePropertyErrorOnUndefined: [core.String, []]
     }),
     names: ['buildJavaScriptObject', 'buildJavaScriptObjectWithNonClosure', 'extractPattern', 'provokeCallErrorOn', 'provokeCallErrorOnNull', 'provokeCallErrorOnUndefined', 'provokePropertyErrorOn', 'provokePropertyErrorOnNull', 'provokePropertyErrorOnUndefined']
   });
   dart.defineLazyProperties(TypeErrorDecoder, {
     get noSuchMethodPattern() {
       return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOn(TypeErrorDecoder.buildJavaScriptObject())), TypeErrorDecoder);
     },
     get notClosurePattern() {
       return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOn(TypeErrorDecoder.buildJavaScriptObjectWithNonClosure())), TypeErrorDecoder);
     },
@@ skipping 30 matching lines @@
       super.Error();
     }
     toString() {
       if (this[_method] == null)
         return `NullError: ${this[_message]}`;
       return `NullError: Cannot call "${this[_method]}" on null`;
     }
   }
   NullError[dart.implements] = () => [core.NoSuchMethodError];
   dart.setSignature(NullError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   class JsNoSuchMethodError extends core.Error {
     JsNoSuchMethodError(message, match) {
       this[_message] = message;
       this[_method] = match == null ? null : dart.as(match.method, core.String);
       this[_receiver] = match == null ? null : dart.as(match.receiver, core.String);
       super.Error();
     }
     toString() {
       if (this[_method] == null)
         return `NoSuchMethodError: ${this[_message]}`;
       if (this[_receiver] == null) {
         return `NoSuchMethodError: Cannot call "${this[_method]}" (${this[_message]})`;
       }
       return `NoSuchMethodError: Cannot call "${this[_method]}" on "${this[_receiver]}" ` + `(${this[_message]})`;
     }
   }
   JsNoSuchMethodError[dart.implements] = () => [core.NoSuchMethodError];
   dart.setSignature(JsNoSuchMethodError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   class UnknownJsTypeError extends core.Error {
     UnknownJsTypeError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return this[_message].isEmpty ? 'Error' : `Error: ${this[_message]}`;
     }
   }
   dart.setSignature(UnknownJsTypeError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   function unwrapException(ex) {
     let saveStackTrace = error => {
       if (dart.is(error, core.Error)) {
         let thrownStackTrace = error.$thrownJsError;
         if (thrownStackTrace == null) {
           error.$thrownJsError = ex;
         }
       }
       return error;
@@ skipping 79 matching lines @@
         return this[_trace];
       let trace = null;
       if (typeof this[_exception] === "object") {
         trace = dart.as(this[_exception].stack, core.String);
       }
       return this[_trace] = trace == null ? '' : trace;
     }
   }
   _StackTrace[dart.implements] = () => [core.StackTrace];
   dart.setSignature(_StackTrace, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   function objectHashCode(object) {
     if (dart.notNull(object == null) || typeof object != 'object') {
       return dart.hashCode(object);
     } else {
       return Primitives.objectHashCode(object);
     }
   }
   dart.fn(objectHashCode, core.int, [dart.dynamic]);
   function fillLiteralMap(keyValuePairs, result) {
@@ skipping 289 matching lines @@
         Closure.functionCounter = dart.notNull(x) + 1;
         return x;
       })()}` + '}')();
     }
     toString() {
       return "Closure";
     }
   }
   Closure[dart.implements] = () => [core.Function];
   dart.setSignature(Closure, {
-    methods: () => ({toString: dart.functionType(core.String, [])}),
+    methods: () => ({toString: [core.String, []]}),
     statics: () => ({
-      fromTearOff: dart.functionType(dart.dynamic, [dart.dynamic, core.List, core.List, core.bool, dart.dynamic, core.String]),
-      cspForwardCall: dart.functionType(dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]),
-      forwardCallTo: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic, core.bool]),
-      cspForwardInterceptedCall: dart.functionType(dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]),
-      forwardInterceptedCallTo: dart.functionType(dart.dynamic, [dart.dynamic, dart.dynamic])
+      fromTearOff: [dart.dynamic, [dart.dynamic, core.List, core.List, core.bool, dart.dynamic, core.String]],
+      cspForwardCall: [dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]],
+      forwardCallTo: [dart.dynamic, [dart.dynamic, dart.dynamic, core.bool]],
+      cspForwardInterceptedCall: [dart.dynamic, [core.int, core.bool, core.String, dart.dynamic]],
+      forwardInterceptedCallTo: [dart.dynamic, [dart.dynamic, dart.dynamic]]
     }),
     names: ['fromTearOff', 'cspForwardCall', 'forwardCallTo', 'cspForwardInterceptedCall', 'forwardInterceptedCallTo']
   });
   Closure.FUNCTION_INDEX = 0;
   Closure.NAME_INDEX = 1;
   Closure.CALL_NAME_INDEX = 2;
   Closure.REQUIRED_PARAMETER_INDEX = 3;
   Closure.OPTIONAL_PARAMETER_INDEX = 4;
   Closure.DEFAULT_ARGUMENTS_INDEX = 5;
   Closure.functionCounter = 0;
@@ skipping 64 matching lines @@
       let names = _interceptors.JSArray.markFixedList(dart.as(Object.getOwnPropertyNames(template), core.List));
       for (let i = 0; dart.notNull(i) < dart.notNull(names[core.$length]); i = dart.notNull(i) + 1) {
         let name = names[core.$get](i);
         if (template[name] === fieldName) {
           return name;
         }
       }
     }
   }
   dart.setSignature(BoundClosure, {
-    methods: () => ({'==': dart.functionType(core.bool, [dart.dynamic])}),
+    methods: () => ({'==': [core.bool, [dart.dynamic]]}),
     statics: () => ({
-      selfOf: dart.functionType(dart.dynamic, [BoundClosure]),
-      targetOf: dart.functionType(dart.dynamic, [BoundClosure]),
-      receiverOf: dart.functionType(dart.dynamic, [BoundClosure]),
-      nameOf: dart.functionType(dart.dynamic, [BoundClosure]),
-      selfFieldName: dart.functionType(core.String, []),
-      receiverFieldName: dart.functionType(core.String, []),
-      computeFieldNamed: dart.functionType(core.String, [core.String])
+      selfOf: [dart.dynamic, [BoundClosure]],
+      targetOf: [dart.dynamic, [BoundClosure]],
+      receiverOf: [dart.dynamic, [BoundClosure]],
+      nameOf: [dart.dynamic, [BoundClosure]],
+      selfFieldName: [core.String, []],
+      receiverFieldName: [core.String, []],
+      computeFieldNamed: [core.String, [core.String]]
     }),
     names: ['selfOf', 'targetOf', 'receiverOf', 'nameOf', 'selfFieldName', 'receiverFieldName', 'computeFieldNamed']
   });
   BoundClosure.selfFieldNameCache = null;
   BoundClosure.receiverFieldNameCache = null;
   function jsHasOwnProperty(jsObject, property) {
     return jsObject.hasOwnProperty(property);
   }
   dart.fn(jsHasOwnProperty, core.bool, [dart.dynamic, core.String]);
   function jsPropertyAccess(jsObject, property) {
@@ skipping 301 matching lines @@
       this.message = message;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   TypeErrorImplementation[dart.implements] = () => [core.TypeError];
   dart.defineNamedConstructor(TypeErrorImplementation, 'fromMessage');
   dart.setSignature(TypeErrorImplementation, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   class CastErrorImplementation extends core.Error {
     CastErrorImplementation(actualType, expectedType) {
       this.message = `CastError: Casting value of type ${actualType} to` + ` incompatible type ${expectedType}`;
       super.Error();
     }
     toString() {
       return this.message;
     }
   }
   CastErrorImplementation[dart.implements] = () => [core.CastError];
   dart.setSignature(CastErrorImplementation, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   class FallThroughErrorImplementation extends core.FallThroughError {
     FallThroughErrorImplementation() {
       super.FallThroughError();
     }
     toString() {
       return "Switch case fall-through.";
     }
   }
   dart.setSignature(FallThroughErrorImplementation, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   function assertHelper(condition) {
     if (!(typeof condition == 'boolean')) {
       if (dart.is(condition, core.Function))
         condition = dart.dcall(condition);
       if (!(typeof condition == 'boolean')) {
         throw new TypeErrorImplementation(condition, 'bool');
       }
     }
     if (!dart.equals(true, condition))
@@ skipping 12 matching lines @@
   class RuntimeError extends core.Error {
     RuntimeError(message) {
       this.message = message;
       super.Error();
     }
     toString() {
       return `RuntimeError: ${this.message}`;
     }
   }
   dart.setSignature(RuntimeError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   class DeferredNotLoadedError extends core.Error {
     DeferredNotLoadedError(libraryName) {
       this.libraryName = libraryName;
       super.Error();
     }
     toString() {
       return `Deferred library ${this.libraryName} was not loaded.`;
     }
   }
   DeferredNotLoadedError[dart.implements] = () => [core.NoSuchMethodError];
   dart.setSignature(DeferredNotLoadedError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   class RuntimeType extends core.Object {
     RuntimeType() {
     }
   }
   dart.setSignature(RuntimeType, {});
   let _isTest = Symbol('_isTest');
   let _extractFunctionTypeObjectFrom = Symbol('_extractFunctionTypeObjectFrom');
   let _asCheck = Symbol('_asCheck');
   let _check = Symbol('_check');
@@ skipping 129 matching lines @@
           needsComma = true;
         }
         result = dart.notNull(result) + '}';
       }
       result = dart.notNull(result) + `) -> ${this.returnType}`;
       return result;
     }
   }
   dart.setSignature(RuntimeFunctionType, {
     methods: () => ({
-      [_isTest]: dart.functionType(core.bool, [dart.dynamic]),
-      [_asCheck]: dart.functionType(dart.dynamic, [dart.dynamic]),
-      [_assertCheck]: dart.functionType(dart.dynamic, [dart.dynamic]),
-      [_check]: dart.functionType(dart.dynamic, [dart.dynamic, core.bool]),
-      [_extractFunctionTypeObjectFrom]: dart.functionType(dart.dynamic, [dart.dynamic]),
-      toRti: dart.functionType(dart.dynamic, []),
-      toString: dart.functionType(core.String, [])
+      [_isTest]: [core.bool, [dart.dynamic]],
+      [_asCheck]: [dart.dynamic, [dart.dynamic]],
+      [_assertCheck]: [dart.dynamic, [dart.dynamic]],
+      [_check]: [dart.dynamic, [dart.dynamic, core.bool]],
+      [_extractFunctionTypeObjectFrom]: [dart.dynamic, [dart.dynamic]],
+      toRti: [dart.dynamic, []],
+      toString: [core.String, []]
     }),
-    statics: () => ({listToRti: dart.functionType(dart.dynamic, [dart.dynamic])}),
+    statics: () => ({listToRti: [dart.dynamic, [dart.dynamic]]}),
     names: ['listToRti']
   });
   RuntimeFunctionType.inAssert = false;
   function buildFunctionType(returnType, parameterTypes, optionalParameterTypes) {
     return new RuntimeFunctionType(dart.as(returnType, RuntimeType), dart.as(parameterTypes, core.List$(RuntimeType)), dart.as(optionalParameterTypes, core.List$(RuntimeType)), null);
   }
   dart.fn(buildFunctionType, RuntimeFunctionType, [dart.dynamic, dart.dynamic, dart.dynamic]);
   function buildNamedFunctionType(returnType, parameterTypes, namedParameters) {
     return new RuntimeFunctionType(dart.as(returnType, RuntimeType), dart.as(parameterTypes, core.List$(RuntimeType)), null, namedParameters);
   }
@@ skipping 12 matching lines @@
     }
     toString() {
       return 'dynamic';
     }
     toRti() {
       return null;
     }
   }
   dart.setSignature(DynamicRuntimeType, {
     methods: () => ({
-      toString: dart.functionType(core.String, []),
-      toRti: dart.functionType(dart.dynamic, [])
+      toString: [core.String, []],
+      toRti: [dart.dynamic, []]
     })
   });
   function getDynamicRuntimeType() {
     return dart.const(new DynamicRuntimeType());
   }
   dart.fn(getDynamicRuntimeType, RuntimeType, []);
   class VoidRuntimeType extends RuntimeType {
     VoidRuntimeType() {
       super.RuntimeType();
     }
     toString() {
       return 'void';
     }
     toRti() {
       return dart.throw_('internal error');
     }
   }
   dart.setSignature(VoidRuntimeType, {
     methods: () => ({
-      toString: dart.functionType(core.String, []),
-      toRti: dart.functionType(dart.dynamic, [])
+      toString: [core.String, []],
+      toRti: [dart.dynamic, []]
     })
   });
   function getVoidRuntimeType() {
     return dart.const(new VoidRuntimeType());
   }
   dart.fn(getVoidRuntimeType, RuntimeType, []);
   function functionTypeTestMetaHelper() {
     let dyn = x;
     let dyn2 = x;
     let fixedListOrNull = dart.as(x, core.List);
@@ skipping 42 matching lines @@
       if (rti == null)
         throw `no type for '${this.name}'`;
       return rti;
     }
     toString() {
       return this.name;
     }
   }
   dart.setSignature(RuntimeTypePlain, {
     methods: () => ({
-      toRti: dart.functionType(dart.dynamic, []),
-      toString: dart.functionType(core.String, [])
+      toRti: [dart.dynamic, []],
+      toString: [core.String, []]
     })
   });
   class RuntimeTypeGeneric extends RuntimeType {
     RuntimeTypeGeneric(name, arguments$, rti) {
       this.name = name;
       this.arguments = arguments$;
       this.rti = rti;
       super.RuntimeType();
     }
     toRti() {
       if (this.rti != null)
         return this.rti;
       let allClasses = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.ALL_CLASSES);
       let result = [allClasses[this.name]];
       if (dart.dindex(result, 0) == null) {
         throw `no type for '${this.name}<...>'`;
       }
       for (let argument of this.arguments) {
         result.push(argument.toRti());
       }
       return this.rti = result;
     }
     toString() {
       return `${this.name}<${this.arguments[core.$join](", ")}>`;
     }
   }
   dart.setSignature(RuntimeTypeGeneric, {
     methods: () => ({
-      toRti: dart.functionType(dart.dynamic, []),
-      toString: dart.functionType(core.String, [])
+      toRti: [dart.dynamic, []],
+      toString: [core.String, []]
     })
   });
   let _typeData = Symbol('_typeData');
   let _cachedToString = Symbol('_cachedToString');
   let _hasReturnType = Symbol('_hasReturnType');
   let _returnType = Symbol('_returnType');
   let _isVoid = Symbol('_isVoid');
   let _hasArguments = Symbol('_hasArguments');
   let _hasOptionalArguments = Symbol('_hasOptionalArguments');
   let _optionalArguments = Symbol('_optionalArguments');
@@ skipping 84 matching lines @@
       } else if (this[_hasReturnType]) {
         s = dart.notNull(s) + dart.notNull(this[_convert](this[_returnType]));
       } else {
         s = dart.notNull(s) + 'dynamic';
       }
       return this[_cachedToString] = `${s}`;
     }
   }
   dart.setSignature(FunctionTypeInfoDecoderRing, {
     methods: () => ({
-      toRuntimeType: dart.functionType(RuntimeType, []),
-      [_convert]: dart.functionType(core.String, [dart.dynamic]),
-      toString: dart.functionType(core.String, [])
+      toRuntimeType: [RuntimeType, []],
+      [_convert]: [core.String, [dart.dynamic]],
+      toString: [core.String, []]
     })
   });
   class UnimplementedNoSuchMethodError extends core.Error {
     UnimplementedNoSuchMethodError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return `Unsupported operation: ${this[_message]}`;
     }
   }
   UnimplementedNoSuchMethodError[dart.implements] = () => [core.NoSuchMethodError];
   dart.setSignature(UnimplementedNoSuchMethodError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   function random64() {
     let int32a = Math.random() * 0x100000000 >>> 0;
     let int32b = Math.random() * 0x100000000 >>> 0;
     return dart.notNull(int32a) + dart.notNull(int32b) * 4294967296;
   }
   dart.fn(random64, core.int, []);
   function jsonEncodeNative(string) {
     return JSON.stringify(string);
   }
@@ skipping 117 matching lines @@
     MainError(message) {
       this[_message] = message;
       super.Error();
     }
     toString() {
       return `NoSuchMethodError: ${this[_message]}`;
     }
   }
   MainError[dart.implements] = () => [core.NoSuchMethodError];
   dart.setSignature(MainError, {
-    methods: () => ({toString: dart.functionType(core.String, [])})
+    methods: () => ({toString: [core.String, []]})
   });
   function missingMain() {
     throw new MainError("No top-level function named 'main'.");
   }
   dart.fn(missingMain, dart.void, []);
   function badMain() {
     throw new MainError("'main' is not a function.");
   }
   dart.fn(badMain, dart.void, []);
   function mainHasTooManyParameters() {
@@ skipping 228 matching lines @@
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.getIsolateAffinityTag = getIsolateAffinityTag;
   exports.LoadLibraryFunctionType = LoadLibraryFunctionType;
   exports.DeferredLoadCallback = DeferredLoadCallback;
   exports.loadDeferredLibrary = loadDeferredLibrary;
   exports.MainError = MainError;
   exports.missingMain = missingMain;
   exports.badMain = badMain;
   exports.mainHasTooManyParameters = mainHasTooManyParameters;
 })(_js_helper, core, collection, _internal, _foreign_helper, _js_embedded_names, _interceptors, _js_names, async, _isolate_helper);