fix for static methods and names banned in strict mode

lib/runtime/dart/_js_helper.js

 var _js_helper;
 (function(exports) {
   'use strict';
   class NoSideEffects extends core.Object {
     NoSideEffects() {
     }
   }
   class NoThrows extends core.Object {
     NoThrows() {
     }
   }
   class NoInline extends core.Object {
     NoInline() {
     }
   }
   class IrRepresentation extends core.Object {
     IrRepresentation(value) {
       this.value = value;
     }
   }
   class Native extends core.Object {
     Native(name) {
       this.name = name;
     }
   }
   let _throwUnmodifiable = Symbol('_throwUnmodifiable');
+  let _$ = Symbol('_');
   let ConstantMap$ = dart.generic(function(K, V) {
     class ConstantMap extends core.Object {
       ConstantMap$_() {
       }
       get isEmpty() {
         return this.length === 0;
       }
       get isNotEmpty() {
         return !dart.notNull(this.isEmpty);
       }
@@ skipping 12 matching lines @@
       remove(key) {
         return dart.as(this[_throwUnmodifiable](), V);
       }
       clear() {
         return this[_throwUnmodifiable]();
       }
       addAll(other) {
         return this[_throwUnmodifiable]();
       }
     }
-    dart.defineNamedConstructor(ConstantMap, '_');
+    dart.defineNamedConstructor(ConstantMap, _$);
     return ConstantMap;
   });
   let ConstantMap = ConstantMap$(dart.dynamic, dart.dynamic);
   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) {
       ConstantStringMap$_(length, jsObject$, keys$) {
         this.length = length;
@@ skipping 26 matching lines @@
           f(dart.as(key, K), dart.as(this[_fetch](key), V));
         }
       }
       get keys() {
         return new _ConstantMapKeyIterable(this);
       }
       get values() {
         return new _internal.MappedIterable(this[_keys], dart.closureWrap(((key) => this[_fetch](key)).bind(this), "(K) → V"));
       }
     }
-    dart.defineNamedConstructor(ConstantStringMap, '_');
+    dart.defineNamedConstructor(ConstantStringMap, _$);
     return ConstantStringMap;
   });
   let ConstantStringMap = ConstantStringMap$(dart.dynamic, dart.dynamic);
   let _protoValue = Symbol('_protoValue');
   let ConstantProtoMap$ = dart.generic(function(K, V) {
     class ConstantProtoMap extends ConstantStringMap$(K, V) {
       ConstantProtoMap$_(length, jsObject, keys, protoValue) {
         this[_protoValue] = protoValue;
         super.ConstantStringMap$_(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.defineNamedConstructor(ConstantProtoMap, _$);
     return ConstantProtoMap;
   });
   let ConstantProtoMap = ConstantProtoMap$(dart.dynamic, dart.dynamic);
   let _map = Symbol('_map');
   let _ConstantMapKeyIterable$ = dart.generic(function(K) {
     class _ConstantMapKeyIterable extends collection.IterableBase$(K) {
       _ConstantMapKeyIterable(map$) {
         this[_map] = map$;
         super.IterableBase();
       }
@@ skipping 332 matching lines @@
   let _execGlobal = Symbol('_execGlobal');
   let _execAnchored = Symbol('_execAnchored');
   class JSSyntaxRegExp extends core.Object {
     toString() {
       return `RegExp/${this.pattern}/`;
     }
     JSSyntaxRegExp(source, opts) {
       let multiLine = opts && 'multiLine' in opts ? opts.multiLine : false;
       let caseSensitive = opts && 'caseSensitive' in opts ? opts.caseSensitive : true;
       this.pattern = source;
-      this[_nativeRegExp] = makeNative(source, multiLine, caseSensitive, false);
+      this[_nativeRegExp] = JSSyntaxRegExp.makeNative(source, multiLine, caseSensitive, false);
       this[_nativeGlobalRegExp] = null;
       this[_nativeAnchoredRegExp] = null;
     }
     get [_nativeGlobalVersion]() {
       if (this[_nativeGlobalRegExp] !== null)
         return this[_nativeGlobalRegExp];
-      return this[_nativeGlobalRegExp] = makeNative(this.pattern, this[_isMultiLine], this[_isCaseSensitive], true);
+      return this[_nativeGlobalRegExp] = JSSyntaxRegExp.makeNative(this.pattern, this[_isMultiLine], this[_isCaseSensitive], true);
     }
     get [_nativeAnchoredVersion]() {
       if (this[_nativeAnchoredRegExp] !== null)
         return this[_nativeAnchoredRegExp];
-      return this[_nativeAnchoredRegExp] = makeNative(`${this.pattern}|()`, this[_isMultiLine], this[_isCaseSensitive], true);
+      return this[_nativeAnchoredRegExp] = JSSyntaxRegExp.makeNative(`${this.pattern}|()`, this[_isMultiLine], this[_isCaseSensitive], true);
     }
     get [_isMultiLine]() {
       return this[_nativeRegExp].multiline;
     }
     get [_isCaseSensitive]() {
       return !this[_nativeRegExp].ignoreCase;
     }
     static makeNative(source, multiLine, caseSensitive, global) {
       checkString(source);
       let m = multiLine ? 'm' : '';
@@ skipping 407 matching lines @@
       return null;
     return target.$builtinTypeInfo;
   }
   // Function getRuntimeTypeArguments: (dynamic, dynamic) → dynamic
   function getRuntimeTypeArguments(target, substitutionName) {
     let substitution = getField(target, `${_foreign_helper.JS_OPERATOR_AS_PREFIX()}${substitutionName}`);
     return substitute(substitution, getRuntimeTypeInfo(target));
   }
   // Function getRuntimeTypeArgument: (Object, String, int) → dynamic
   function getRuntimeTypeArgument(target, substitutionName, index) {
-    let arguments = getRuntimeTypeArguments(target, substitutionName);
-    return arguments === null ? null : getIndex(arguments, index);
+    let arguments$ = getRuntimeTypeArguments(target, substitutionName);
+    return arguments$ === null ? null : getIndex(arguments$, index);
   }
   // Function getTypeArgumentByIndex: (Object, int) → dynamic
   function getTypeArgumentByIndex(target, index) {
     let rti = getRuntimeTypeInfo(target);
     return rti === null ? null : getIndex(rti, index);
   }
   // Function copyTypeArguments: (Object, Object) → void
   function copyTypeArguments(source, target) {
     target.$builtinTypeInfo = source.$builtinTypeInfo;
   }
@@ skipping 61 matching lines @@
       return className;
     let typeInfo = object.$builtinTypeInfo;
     return `${className}${joinArguments(typeInfo, 0)}`;
   }
   // Function getRuntimeType: (dynamic) → Type
   function getRuntimeType(object) {
     let type = getRuntimeTypeString(object);
     return new TypeImpl(type);
   }
   // Function substitute: (dynamic, dynamic) → dynamic
-  function substitute(substitution, arguments) {
+  function substitute(substitution, arguments$) {
     dart.assert(dart.notNull(substitution === null) || dart.notNull(isJsFunction(substitution)));
-    dart.assert(dart.notNull(arguments === null) || dart.notNull(isJsArray(arguments)));
+    dart.assert(dart.notNull(arguments$ === null) || dart.notNull(isJsArray(arguments$)));
     if (isJsFunction(substitution)) {
-      substitution = invoke(substitution, arguments);
+      substitution = invoke(substitution, arguments$);
       if (isJsArray(substitution)) {
-        arguments = substitution;
+        arguments$ = substitution;
       } else if (isJsFunction(substitution)) {
-        arguments = invoke(substitution, arguments);
+        arguments$ = invoke(substitution, arguments$);
       }
     }
-    return arguments;
+    return arguments$;
   }
   // Function checkSubtype: (Object, String, List<dynamic>, String) → bool
   function checkSubtype(object, isField, checks, asField) {
     if (object === null)
       return false;
-    let arguments = getRuntimeTypeInfo(object);
+    let arguments$ = getRuntimeTypeInfo(object);
     let interceptor = _interceptors.getInterceptor(object);
     let isSubclass = getField(interceptor, isField);
     if (isSubclass === null)
       return false;
     let substitution = getField(interceptor, asField);
-    return checkArguments(substitution, arguments, checks);
+    return checkArguments(substitution, arguments$, checks);
   }
   // Function computeTypeName: (String, List<dynamic>) → String
-  function computeTypeName(isField, arguments) {
+  function computeTypeName(isField, arguments$) {
     let prefixLength = _foreign_helper.JS_OPERATOR_IS_PREFIX().length;
-    return Primitives.formatType(isField.substring(prefixLength, isField.length), arguments);
+    return Primitives.formatType(isField.substring(prefixLength, isField.length), arguments$);
   }
   // Function subtypeCast: (Object, String, List<dynamic>, String) → Object
   function subtypeCast(object, isField, checks, asField) {
     if (dart.notNull(object !== null) && !dart.notNull(checkSubtype(object, isField, checks, asField))) {
       let actualType = Primitives.objectTypeName(object);
       let typeName = computeTypeName(isField, checks);
       throw new CastErrorImplementation(actualType, typeName);
     }
     return object;
   }
   // Function assertSubtype: (Object, String, List<dynamic>, String) → Object
   function assertSubtype(object, isField, checks, asField) {
     if (dart.notNull(object !== null) && !dart.notNull(checkSubtype(object, isField, checks, asField))) {
       let typeName = computeTypeName(isField, checks);
       throw new TypeErrorImplementation(object, typeName);
     }
     return object;
   }
   // Function assertIsSubtype: (dynamic, dynamic, String) → dynamic
   function assertIsSubtype(subtype, supertype, message) {
     if (!dart.notNull(isSubtype(subtype, supertype))) {
       throwTypeError(message);
     }
   }
   // Function throwTypeError: (dynamic) → dynamic
   function throwTypeError(message) {
     throw new TypeErrorImplementation.fromMessage(dart.as(message, core.String));
   }
   // Function checkArguments: (dynamic, dynamic, dynamic) → bool
-  function checkArguments(substitution, arguments, checks) {
-    return areSubtypes(substitute(substitution, arguments), checks);
+  function checkArguments(substitution, arguments$, checks) {
+    return areSubtypes(substitute(substitution, arguments$), checks);
   }
   // Function areSubtypes: (dynamic, dynamic) → bool
   function areSubtypes(s, t) {
     if (dart.notNull(s === null) || dart.notNull(t === null))
       return true;
     dart.assert(isJsArray(s));
     dart.assert(isJsArray(t));
     dart.assert(getLength(s) === getLength(t));
     let len = getLength(s);
     for (let i = 0; dart.notNull(i) < dart.notNull(len); i = dart.notNull(i) + 1) {
@@ skipping 190 matching lines @@
         if (!dart.notNull(isAssignable(getIndex(sOptionalParameterTypes, sPos), getIndex(tOptionalParameterTypes, tPos)))) {
           return false;
         }
       }
     }
     let sNamedParameters = getField(s, `${_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG()}`);
     let tNamedParameters = getField(t, `${_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG()}`);
     return areAssignableMaps(sNamedParameters, tNamedParameters);
   }
   // Function invoke: (dynamic, dynamic) → dynamic
-  function invoke(func, arguments) {
-    return invokeOn(func, null, arguments);
+  function invoke(func, arguments$) {
+    return invokeOn(func, null, arguments$);
   }
   // Function invokeOn: (dynamic, dynamic, dynamic) → Object
-  function invokeOn(func, receiver, arguments) {
+  function invokeOn(func, receiver, arguments$) {
     dart.assert(isJsFunction(func));
-    dart.assert(dart.notNull(arguments === null) || dart.notNull(isJsArray(arguments)));
-    return func.apply(receiver, arguments);
+    dart.assert(dart.notNull(arguments$ === null) || dart.notNull(isJsArray(arguments$)));
+    return func.apply(receiver, arguments$);
   }
   // Function call: (dynamic, String) → dynamic
   function call(object, name) {
     return object[name]();
   }
   // Function getField: (dynamic, String) → dynamic
   function getField(object, name) {
     return object[name];
   }
   // Function getIndex: (dynamic, int) → dynamic
@@ skipping 67 matching lines @@
       return 'false';
     } else if (value === null) {
       return 'null';
     }
     let res = dart.dinvoke(value, 'toString');
     if (!(typeof res == string))
       throw new core.ArgumentError(value);
     return dart.as(res, core.String);
   }
   // Function createInvocationMirror: (String, dynamic, dynamic, dynamic, dynamic) → dynamic
-  function createInvocationMirror(name, internalName, kind, arguments, argumentNames) {
-    return new JSInvocationMirror(name, dart.as(internalName, core.String), dart.as(kind, core.int), dart.as(arguments, core.List), dart.as(argumentNames, core.List));
+  function createInvocationMirror(name, internalName, kind, arguments$, argumentNames) {
+    return new JSInvocationMirror(name, dart.as(internalName, core.String), dart.as(kind, core.int), dart.as(arguments$, core.List), dart.as(argumentNames, core.List));
   }
   // Function createUnmangledInvocationMirror: (Symbol, dynamic, dynamic, dynamic, dynamic) → dynamic
-  function createUnmangledInvocationMirror(symbol, internalName, kind, arguments, argumentNames) {
-    return new JSInvocationMirror(symbol, dart.as(internalName, core.String), dart.as(kind, core.int), dart.as(arguments, core.List), dart.as(argumentNames, core.List));
+  function createUnmangledInvocationMirror(symbol, internalName, kind, arguments$, argumentNames) {
+    return new JSInvocationMirror(symbol, dart.as(internalName, core.String), dart.as(kind, core.int), dart.as(arguments$, core.List), dart.as(argumentNames, core.List));
   }
   // Function throwInvalidReflectionError: (String) → void
   function throwInvalidReflectionError(memberName) {
     throw new core.UnsupportedError(`Can't use '${memberName}' in reflection ` + "because it is not included in a @MirrorsUsed annotation.");
   }
   // Function traceHelper: (String) → void
   function traceHelper(method) {
     if (!this.cache) {
       this.cache = Object.create(null);
     }
@@ skipping 67 matching lines @@
       let map = new core.Map();
       for (let i = 0; dart.notNull(i) < dart.notNull(namedArgumentCount); i = dart.notNull(i) + 1) {
         map.set(new _internal.Symbol.unvalidated(dart.as(this[_namedArgumentNames].get(i), core.String)), this[_arguments].get(dart.notNull(namedArgumentsStartIndex) + dart.notNull(i)));
       }
       return map;
     }
     [_getCachedInvocation](object) {
       let interceptor = _interceptors.getInterceptor(object);
       let receiver = object;
       let name = this[_internalName];
-      let arguments = this[_arguments];
+      let arguments$ = this[_arguments];
       let interceptedNames = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.INTERCEPTED_NAMES);
       let isIntercepted = Object.prototype.hasOwnProperty.call(interceptedNames, name);
       if (isIntercepted) {
         receiver = interceptor;
         if (object === interceptor) {
           interceptor = null;
         }
       } else {
         interceptor = null;
       }
@@ skipping 45 matching lines @@
       this.jsFunction = jsFunction;
       this.isIntercepted = isIntercepted;
       this.cachedInterceptor = cachedInterceptor;
     }
     get isNoSuchMethod() {
       return false;
     }
     get isGetterStub() {
       return !!this.jsFunction.$getterStub;
     }
-    invokeOn(victim, arguments) {
+    invokeOn(victim, arguments$) {
       let receiver = victim;
       if (!dart.notNull(this.isIntercepted)) {
-        if (!dart.is(arguments, _interceptors.JSArray))
-          arguments = new core.List.from(arguments);
+        if (!dart.is(arguments$, _interceptors.JSArray))
+          arguments$ = new core.List.from(arguments$);
       } else {
-        arguments = new List.from([victim]);
-        arguments.addAll(arguments);
+        arguments$ = new List.from([victim]);
+        arguments$.addAll(arguments$);
         if (this.cachedInterceptor !== null)
           receiver = this.cachedInterceptor;
       }
-      return this.jsFunction.apply(receiver, arguments);
+      return this.jsFunction.apply(receiver, arguments$);
     }
   }
   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) {
+    invokeOn(victim, arguments$) {
       let receiver = victim;
       let providedArgumentCount = null;
       let fullParameterCount = dart.notNull(this.info.requiredParameterCount) + dart.notNull(this.info.optionalParameterCount);
       if (!dart.notNull(this.isIntercepted)) {
-        if (dart.is(arguments, _interceptors.JSArray)) {
-          providedArgumentCount = arguments.length;
+        if (dart.is(arguments$, _interceptors.JSArray)) {
+          providedArgumentCount = arguments$.length;
           if (dart.notNull(providedArgumentCount) < dart.notNull(fullParameterCount)) {
-            arguments = new core.List.from(arguments);
+            arguments$ = new core.List.from(arguments$);
           }
         } else {
-          arguments = new core.List.from(arguments);
-          providedArgumentCount = arguments.length;
+          arguments$ = new core.List.from(arguments$);
+          providedArgumentCount = arguments$.length;
         }
       } else {
-        arguments = new List.from([victim]);
-        arguments.addAll(arguments);
+        arguments$ = new List.from([victim]);
+        arguments$.addAll(arguments$);
         if (this.cachedInterceptor !== null)
           receiver = this.cachedInterceptor;
-        providedArgumentCount = dart.notNull(arguments.length) - 1;
+        providedArgumentCount = dart.notNull(arguments$.length) - 1;
       }
       if (dart.notNull(this.info.areOptionalParametersNamed) && dart.notNull(providedArgumentCount) > dart.notNull(this.info.requiredParameterCount)) {
-        throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${arguments.length} arguments.`);
+        throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${arguments$.length} arguments.`);
       } else if (dart.notNull(providedArgumentCount) < dart.notNull(this.info.requiredParameterCount)) {
         throw new UnimplementedNoSuchMethodError(`Invocation of unstubbed method '${this.info.reflectionName}'` + ` with ${providedArgumentCount} arguments (too few).`);
       } 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.add(getMetadata(this.info.defaultValue(i)));
+        arguments$.add(getMetadata(this.info.defaultValue(i)));
       }
-      return this.jsFunction.apply(receiver, arguments);
+      return this.jsFunction.apply(receiver, arguments$);
     }
   }
   class CachedNoSuchMethodInvocation extends core.Object {
     CachedNoSuchMethodInvocation(interceptor) {
       this.interceptor = interceptor;
     }
     get isNoSuchMethod() {
       return true;
     }
     get isGetterStub() {
@@ skipping 105 matching lines @@
   dart.defineNamedConstructor(ReflectionInfo, 'internal');
   ReflectionInfo.REQUIRED_PARAMETERS_INFO = 0;
   ReflectionInfo.OPTIONAL_PARAMETERS_INFO = 1;
   ReflectionInfo.FUNCTION_TYPE_INDEX = 2;
   ReflectionInfo.FIRST_DEFAULT_ARGUMENT = 3;
   // Function getMetadata: (int) → dynamic
   function getMetadata(index) {
     let metadata = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.METADATA);
     return metadata[index];
   }
-  let _throwFormatException$ = Symbol('_throwFormatException');
-  let _fromCharCodeApply$ = Symbol('_fromCharCodeApply');
+  let _throwFormatException = Symbol('_throwFormatException');
+  let _fromCharCodeApply = Symbol('_fromCharCodeApply');
   let _mangledNameMatchesType = Symbol('_mangledNameMatchesType');
   class Primitives extends core.Object {
     static initializeStatics(id) {
-      mirrorFunctionCacheName = `_${id}`;
-      mirrorInvokeCacheName = `_${id}`;
+      Primitives.mirrorFunctionCacheName = `_${id}`;
+      Primitives.mirrorInvokeCacheName = `_${id}`;
     }
     static objectHashCode(object) {
       let hash = dart.as(object.$identityHash, core.int);
       if (hash === null) {
         hash = Math.random() * 0x3fffffff | 0;
         object.$identityHash = hash;
       }
       return hash;
     }
-    static [_throwFormatException$](string) {
+    static [_throwFormatException](string) {
       throw new core.FormatException(string);
     }
     static parseInt(source, radix, handleError) {
       if (handleError === null)
-        handleError = dart.closureWrap(_throwFormatException, "(String) → int");
+        handleError = dart.closureWrap(Primitives[_throwFormatException], "(String) → int");
       checkString(source);
       let match = /^\s*[+-]?((0x[a-f0-9]+)|(\d+)|([a-z0-9]+))\s*$/i.exec(source);
       let digitsIndex = 1;
       let hexIndex = 2;
       let decimalIndex = 3;
       let nonDecimalHexIndex = 4;
       if (radix === null) {
         radix = 10;
         if (match !== null) {
           if (dart.dindex(match, hexIndex) !== null) {
@@ skipping 31 matching lines @@
           }
         }
       }
       if (match === null)
         return handleError(source);
       return parseInt(source, radix);
     }
     static parseDouble(source, handleError) {
       checkString(source);
       if (handleError === null)
-        handleError = dart.closureWrap(_throwFormatException, "(String) → double");
+        handleError = dart.closureWrap(Primitives[_throwFormatException], "(String) → double");
       if (!/^\s*[+-]?(?:Infinity|NaN|(?:\.\d+|\d+(?:\.\d*)?)(?:[eE][+-]?\d+)?)\s*$/.test(source)) {
         return handleError(source);
       }
       let result = parseFloat(source);
       if (result.isNaN) {
         let trimmed = source.trim();
         if (dart.notNull(dart.equals(trimmed, 'NaN')) || dart.notNull(dart.equals(trimmed, '+NaN')) || dart.notNull(dart.equals(trimmed, '-NaN'))) {
           return result;
         }
         return handleError(source);
       }
       return result;
     }
     static formatType(className, typeArguments) {
       return _js_names.unmangleAllIdentifiersIfPreservedAnyways(`${className}${joinArguments(typeArguments, 0)}`);
     }
     static objectTypeName(object) {
       let name = constructorNameFallback(_interceptors.getInterceptor(object));
       if (dart.equals(name, 'Object')) {
         let decompiled = String(object.constructor).match(/^\s*function\s*(\S*)\s*\(/)[1];
         if (typeof decompiled == string)
           if (/^\w+$/.test(decompiled))
             name = dart.as(decompiled, core.String);
       }
       if (dart.notNull(name.length) > 1 && dart.notNull(core.identical(name.codeUnitAt(0), Primitives.DOLLAR_CHAR_VALUE))) {
         name = name.substring(1);
       }
-      return formatType(name, dart.as(getRuntimeTypeInfo(object), core.List));
+      return Primitives.formatType(name, dart.as(getRuntimeTypeInfo(object), core.List));
     }
     static objectToString(object) {
-      let name = objectTypeName(object);
+      let name = Primitives.objectTypeName(object);
       return `Instance of '${name}'`;
     }
     static dateNow() {
       return Date.now();
     }
     static initTicker() {
-      if (timerFrequency !== null)
+      if (Primitives.timerFrequency !== null)
         return;
-      timerFrequency = 1000;
-      timerTicks = dateNow;
+      Primitives.timerFrequency = 1000;
+      Primitives.timerTicks = Primitives.dateNow;
       if (typeof window == "undefined")
         return;
       let window = window;
       if (window === null)
         return;
       let performance = window.performance;
       if (performance === null)
         return;
       if (typeof performance.now != "function")
         return;
-      timerFrequency = 1000000;
-      timerTicks = (() => (1000 * performance.now()).floor()).bind(this);
+      Primitives.timerFrequency = 1000000;
+      Primitives.timerTicks = (() => (1000 * performance.now()).floor()).bind(this);
     }
     static get isD8() {
       return typeof version == "function" && typeof os == "object" && "system" in os;
     }
     static get isJsshell() {
       return typeof version == "function" && typeof system == "function";
     }
     static currentUri() {
       requiresPreamble();
       if (!!self.location) {
         return self.location.href;
       }
       return null;
     }
-    static [_fromCharCodeApply$](array) {
+    static [_fromCharCodeApply](array) {
       let result = "";
       let kMaxApply = 500;
       let end = array.length;
       for (let i = 0; dart.notNull(i) < dart.notNull(end); i = kMaxApply) {
         let subarray = null;
         if (dart.notNull(end) <= dart.notNull(kMaxApply)) {
           subarray = array;
         } else {
           subarray = array.slice(i, dart.notNull(i) + dart.notNull(kMaxApply) < dart.notNull(end) ? dart.notNull(i) + dart.notNull(kMaxApply) : end);
         }
         result = result + String.fromCharCode.apply(null, subarray);
       }
       return result;
     }
     static stringFromCodePoints(codePoints) {
       let a = new List.from([]);
       for (let i of codePoints) {
         if (!(typeof i == number))
           throw new core.ArgumentError(i);
         if (dart.dbinary(i, '<=', 65535)) {
           a.add(dart.as(i, core.int));
         } else if (dart.dbinary(i, '<=', 1114111)) {
           a.add(55296['+'](dart.dbinary(dart.dbinary(dart.dbinary(i, '-', 65536), '>>', 10), '&', 1023)));
           a.add(56320['+'](dart.dbinary(i, '&', 1023)));
         } else {
           throw new core.ArgumentError(i);
         }
       }
-      return _fromCharCodeApply(a);
+      return Primitives[_fromCharCodeApply](a);
     }
     static stringFromCharCodes(charCodes) {
       for (let i of charCodes) {
         if (!(typeof i == number))
           throw new core.ArgumentError(i);
         if (dart.dbinary(i, '<', 0))
           throw new core.ArgumentError(i);
         if (dart.dbinary(i, '>', 65535))
-          return stringFromCodePoints(charCodes);
+          return Primitives.stringFromCodePoints(charCodes);
       }
-      return _fromCharCodeApply(dart.as(charCodes, core.List$(core.int)));
+      return Primitives[_fromCharCodeApply](dart.as(charCodes, core.List$(core.int)));
     }
     static stringFromCharCode(charCode) {
       if (0['<='](charCode)) {
         if (dart.dbinary(charCode, '<=', 65535)) {
           return String.fromCharCode(charCode);
         }
         if (dart.dbinary(charCode, '<=', 1114111)) {
           let bits = dart.dbinary(charCode, '-', 65536);
           let low = 56320['|'](dart.dbinary(bits, '&', 1023));
           let high = 55296['|'](dart.dbinary(bits, '>>', 10));
           return String.fromCharCode(high, low);
         }
       }
       throw new core.RangeError.range(dart.as(charCode, core.num), 0, 1114111);
     }
     static stringConcatUnchecked(string1, string2) {
       return _foreign_helper.JS_STRING_CONCAT(string1, string2);
     }
     static flattenString(str) {
       return str.charCodeAt(0) == 0 ? str : str;
     }
     static getTimeZoneName(receiver) {
-      let d = lazyAsJsDate(receiver);
+      let d = Primitives.lazyAsJsDate(receiver);
       let match = dart.as(/\((.*)\)/.exec(d.toString()), core.List);
       if (match !== null)
         return dart.as(match.get(1), core.String);
       match = dart.as(/^[A-Z,a-z]{3}\s[A-Z,a-z]{3}\s\d+\s\d{2}:\d{2}:\d{2}\s([A-Z]{3,5})\s\d{4}$/.exec(d.toString()), core.List);
       if (match !== null)
         return dart.as(match.get(1), core.String);
       match = dart.as(/(?:GMT|UTC)[+-]\d{4}/.exec(d.toString()), core.List);
       if (match !== null)
         return dart.as(match.get(0), core.String);
       return "";
     }
     static getTimeZoneOffsetInMinutes(receiver) {
-      return -lazyAsJsDate(receiver).getTimezoneOffset();
+      return -Primitives.lazyAsJsDate(receiver).getTimezoneOffset();
     }
     static valueFromDecomposedDate(years, month, day, hours, minutes, seconds, milliseconds, isUtc) {
       let MAX_MILLISECONDS_SINCE_EPOCH = 8640000000000000;
       checkInt(years);
       checkInt(month);
       checkInt(day);
       checkInt(hours);
       checkInt(minutes);
       checkInt(seconds);
       checkInt(milliseconds);
       checkBool(isUtc);
       let jsMonth = dart.dbinary(month, '-', 1);
       let value = null;
       if (isUtc) {
         value = Date.UTC(years, jsMonth, day, hours, minutes, seconds, milliseconds);
       } else {
         value = new Date(years, jsMonth, day, hours, minutes, seconds, milliseconds).valueOf();
       }
       if (core.bool['||'](dart.dbinary(dart.dload(value, 'isNaN'), '||', dart.dbinary(value, '<', -dart.notNull(MAX_MILLISECONDS_SINCE_EPOCH))), dart.dbinary(value, '>', MAX_MILLISECONDS_SINCE_EPOCH))) {
         return null;
       }
       if (dart.dbinary(dart.dbinary(years, '<=', 0), '||', dart.dbinary(years, '<', 100)))
-        return patchUpY2K(value, years, isUtc);
+        return Primitives.patchUpY2K(value, years, isUtc);
       return value;
     }
     static patchUpY2K(value, years, isUtc) {
       let date = new Date(value);
       if (isUtc) {
         date.setUTCFullYear(years);
       } else {
         date.setFullYear(years);
       }
       return date.valueOf();
     }
     static lazyAsJsDate(receiver) {
       if (receiver.date === void 0) {
         receiver.date = new Date(dart.dload(receiver, 'millisecondsSinceEpoch'));
       }
       return receiver.date;
     }
     static getYear(receiver) {
-      return dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCFullYear() + 0 : lazyAsJsDate(receiver).getFullYear() + 0;
+      return dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCFullYear() + 0 : Primitives.lazyAsJsDate(receiver).getFullYear() + 0;
     }
     static getMonth(receiver) {
-      return dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCMonth() + 1 : lazyAsJsDate(receiver).getMonth() + 1;
+      return dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCMonth() + 1 : Primitives.lazyAsJsDate(receiver).getMonth() + 1;
     }
     static getDay(receiver) {
-      return dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCDate() + 0 : lazyAsJsDate(receiver).getDate() + 0;
+      return dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCDate() + 0 : Primitives.lazyAsJsDate(receiver).getDate() + 0;
     }
     static getHours(receiver) {
-      return dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCHours() + 0 : lazyAsJsDate(receiver).getHours() + 0;
+      return dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCHours() + 0 : Primitives.lazyAsJsDate(receiver).getHours() + 0;
     }
     static getMinutes(receiver) {
-      return dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCMinutes() + 0 : lazyAsJsDate(receiver).getMinutes() + 0;
+      return dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCMinutes() + 0 : Primitives.lazyAsJsDate(receiver).getMinutes() + 0;
     }
     static getSeconds(receiver) {
-      return dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCSeconds() + 0 : lazyAsJsDate(receiver).getSeconds() + 0;
+      return dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCSeconds() + 0 : Primitives.lazyAsJsDate(receiver).getSeconds() + 0;
     }
     static getMilliseconds(receiver) {
-      return dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCMilliseconds() + 0 : lazyAsJsDate(receiver).getMilliseconds() + 0;
+      return dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCMilliseconds() + 0 : Primitives.lazyAsJsDate(receiver).getMilliseconds() + 0;
     }
     static getWeekday(receiver) {
-      let weekday = dart.dload(receiver, 'isUtc') ? lazyAsJsDate(receiver).getUTCDay() + 0 : lazyAsJsDate(receiver).getDay() + 0;
+      let weekday = dart.dload(receiver, 'isUtc') ? Primitives.lazyAsJsDate(receiver).getUTCDay() + 0 : Primitives.lazyAsJsDate(receiver).getDay() + 0;
       return (dart.notNull(weekday) + 6) % 7 + 1;
     }
     static valueFromDateString(str) {
       if (!(typeof str == string))
         throw new core.ArgumentError(str);
       let value = Date.parse(str);
       if (value.isNaN)
         throw new core.ArgumentError(str);
       return value;
     }
     static getProperty(object, key) {
       if (dart.notNull(object === null) || dart.notNull(typeof object == boolean) || dart.notNull(dart.is(object, core.num)) || dart.notNull(typeof object == string)) {
         throw new core.ArgumentError(object);
       }
       return object[key];
     }
     static setProperty(object, key, value) {
       if (dart.notNull(object === null) || dart.notNull(typeof object == boolean) || dart.notNull(dart.is(object, core.num)) || dart.notNull(typeof object == string)) {
         throw new core.ArgumentError(object);
       }
       object[key] = value;
     }
     static functionNoSuchMethod(func, positionalArguments, namedArguments) {
       let argumentCount = 0;
-      let arguments = new List.from([]);
+      let arguments$ = new List.from([]);
       let namedArgumentList = new List.from([]);
       if (positionalArguments !== null) {
         argumentCount = positionalArguments.length;
-        arguments.addAll(positionalArguments);
+        arguments$.addAll(positionalArguments);
       }
       let names = '';
       if (dart.notNull(namedArguments !== null) && !dart.notNull(namedArguments.isEmpty)) {
         namedArguments.forEach(((name, argument) => {
           names = `${names}$${name}`;
           namedArgumentList.add(name);
-          arguments.add(argument);
+          arguments$.add(argument);
           argumentCount = dart.notNull(argumentCount) + 1;
         }).bind(this));
       }
       let selectorName = `${_foreign_helper.JS_GET_NAME("CALL_PREFIX")}$${argumentCount}${names}`;
-      return dart.dinvoke(func, 'noSuchMethod', createUnmangledInvocationMirror(dart.throw_("Unimplemented SymbolLiteral: #call"), selectorName, JSInvocationMirror.METHOD, arguments, namedArgumentList));
+      return dart.dinvoke(func, 'noSuchMethod', createUnmangledInvocationMirror(dart.throw_("Unimplemented SymbolLiteral: #call"), selectorName, JSInvocationMirror.METHOD, arguments$, namedArgumentList));
     }
     static applyFunction(func, positionalArguments, namedArguments) {
-      return namedArguments === null ? applyFunctionWithPositionalArguments(func, positionalArguments) : applyFunctionWithNamedArguments(func, positionalArguments, namedArguments);
+      return namedArguments === null ? Primitives.applyFunctionWithPositionalArguments(func, positionalArguments) : Primitives.applyFunctionWithNamedArguments(func, positionalArguments, namedArguments);
     }
     static applyFunctionWithPositionalArguments(func, positionalArguments) {
       let argumentCount = 0;
-      let arguments = null;
+      let arguments$ = null;
       if (positionalArguments !== null) {
         if (positionalArguments instanceof Array) {
-          arguments = positionalArguments;
+          arguments$ = positionalArguments;
         } else {
-          arguments = new core.List.from(positionalArguments);
+          arguments$ = new core.List.from(positionalArguments);
         }
-        argumentCount = arguments.length;
+        argumentCount = arguments$.length;
       } else {
-        arguments = new List.from([]);
+        arguments$ = new List.from([]);
       }
       let selectorName = `${_foreign_helper.JS_GET_NAME("CALL_PREFIX")}$${argumentCount}`;
       let jsFunction = func[selectorName];
       if (jsFunction === null) {
-        return functionNoSuchMethod(func, positionalArguments, null);
+        return Primitives.functionNoSuchMethod(func, positionalArguments, null);
       }
-      return jsFunction.apply(func, arguments);
+      return jsFunction.apply(func, arguments$);
     }
     static applyFunctionWithNamedArguments(func, positionalArguments, namedArguments) {
       if (namedArguments.isEmpty) {
-        return applyFunctionWithPositionalArguments(func, positionalArguments);
+        return Primitives.applyFunctionWithPositionalArguments(func, positionalArguments);
       }
       let interceptor = _interceptors.getInterceptor(func);
       let jsFunction = interceptor["call*"];
       if (jsFunction === null) {
-        return functionNoSuchMethod(func, positionalArguments, namedArguments);
+        return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       let info = new ReflectionInfo(jsFunction);
       if (dart.notNull(info === null) || !dart.notNull(info.areOptionalParametersNamed)) {
-        return functionNoSuchMethod(func, positionalArguments, namedArguments);
+        return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       if (positionalArguments !== null) {
         positionalArguments = new core.List.from(positionalArguments);
       } else {
         positionalArguments = new List.from([]);
       }
       if (info.requiredParameterCount !== positionalArguments.length) {
-        return functionNoSuchMethod(func, positionalArguments, namedArguments);
+        return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       let defaultArguments = new core.Map();
       for (let i = 0; dart.notNull(i) < dart.notNull(info.optionalParameterCount); i = dart.notNull(i) + 1) {
         let index = dart.notNull(i) + dart.notNull(info.requiredParameterCount);
         let parameterName = info.parameterNameInOrder(index);
         let value = info.defaultValueInOrder(index);
         let defaultValue = getMetadata(value);
         defaultArguments.set(parameterName, defaultValue);
       }
       let bad = false;
       namedArguments.forEach(((parameter, value) => {
         if (defaultArguments.containsKey(parameter)) {
           defaultArguments.set(parameter, value);
         } else {
           bad = true;
         }
       }).bind(this));
       if (bad) {
-        return functionNoSuchMethod(func, positionalArguments, namedArguments);
+        return Primitives.functionNoSuchMethod(func, positionalArguments, namedArguments);
       }
       positionalArguments.addAll(defaultArguments.values);
       return jsFunction.apply(func, positionalArguments);
     }
     static [_mangledNameMatchesType](mangledName, type) {
       return mangledName == type[_typeName];
     }
     static identicalImplementation(a, b) {
       return a == null ? b == null : a === b;
     }
@@ skipping 156 matching lines @@
           return "$receiver$";
         }
       };
     }
     static extractPattern(message) {
       message = message.replace(String({}), '$receiver$');
       message = message.replace(new RegExp(ESCAPE_REGEXP, 'g'), '\\$&');
       let match = dart.as(message.match(/\\\$[a-zA-Z]+\\\$/g), core.List$(core.String));
       if (match === null)
         match = dart.as(new List.from([]), core.List$(core.String));
-      let arguments = match.indexOf('\\$arguments\\$');
+      let arguments$ = match.indexOf('\\$arguments\\$');
       let argumentsExpr = match.indexOf('\\$argumentsExpr\\$');
       let expr = match.indexOf('\\$expr\\$');
       let method = match.indexOf('\\$method\\$');
       let receiver = match.indexOf('\\$receiver\\$');
       let pattern = message.replace('\\$arguments\\$', '((?:x|[^x])*)').replace('\\$argumentsExpr\\$', '((?:x|[^x])*)').replace('\\$expr\\$', '((?:x|[^x])*)').replace('\\$method\\$', '((?:x|[^x])*)').replace('\\$receiver\\$', '((?:x|[^x])*)');
-      return new TypeErrorDecoder(arguments, argumentsExpr, expr, method, receiver, pattern);
+      return new TypeErrorDecoder(arguments$, argumentsExpr, expr, method, receiver, pattern);
     }
     static provokeCallErrorOn(expression) {
       let func = function($expr$) {
         var $argumentsExpr$ = '$arguments$';
         try {
           $expr$.$method$($argumentsExpr$);
         } catch (e) {
           return e.message;
         }
 
@@ skipping 53 matching lines @@
         } catch (e) {
           return e.message;
         }
 
       };
       return func();
     }
   }
   dart.defineLazyProperties(TypeErrorDecoder, {
     get noSuchMethodPattern() {
-      return dart.as(extractPattern(provokeCallErrorOn(buildJavaScriptObject())), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOn(TypeErrorDecoder.buildJavaScriptObject())), TypeErrorDecoder);
     },
     get notClosurePattern() {
-      return dart.as(extractPattern(provokeCallErrorOn(buildJavaScriptObjectWithNonClosure())), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOn(TypeErrorDecoder.buildJavaScriptObjectWithNonClosure())), TypeErrorDecoder);
     },
     get nullCallPattern() {
-      return dart.as(extractPattern(provokeCallErrorOn(null)), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOn(null)), TypeErrorDecoder);
     },
     get nullLiteralCallPattern() {
-      return dart.as(extractPattern(provokeCallErrorOnNull()), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOnNull()), TypeErrorDecoder);
     },
     get undefinedCallPattern() {
-      return dart.as(extractPattern(provokeCallErrorOn(void 0)), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOn(void 0)), TypeErrorDecoder);
     },
     get undefinedLiteralCallPattern() {
-      return dart.as(extractPattern(provokeCallErrorOnUndefined()), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokeCallErrorOnUndefined()), TypeErrorDecoder);
     },
     get nullPropertyPattern() {
-      return dart.as(extractPattern(provokePropertyErrorOn(null)), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokePropertyErrorOn(null)), TypeErrorDecoder);
     },
     get nullLiteralPropertyPattern() {
-      return dart.as(extractPattern(provokePropertyErrorOnNull()), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokePropertyErrorOnNull()), TypeErrorDecoder);
     },
     get undefinedPropertyPattern() {
-      return dart.as(extractPattern(provokePropertyErrorOn(void 0)), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokePropertyErrorOn(void 0)), TypeErrorDecoder);
     },
     get undefinedLiteralPropertyPattern() {
-      return dart.as(extractPattern(provokePropertyErrorOnUndefined()), TypeErrorDecoder);
+      return dart.as(TypeErrorDecoder.extractPattern(TypeErrorDecoder.provokePropertyErrorOnUndefined()), TypeErrorDecoder);
     }
   });
   let _message = Symbol('_message');
   class NullError extends core.Error {
     NullError(message$, match) {
       this[_message] = message$;
       this[_method] = dart.as(match === null ? null : match.method, core.String);
       super.Error();
     }
     toString() {
@@ skipping 180 matching lines @@
       let func = functions[0];
       let name = dart.as(func.$stubName, core.String);
       let callName = dart.as(func.$callName, core.String);
       func.$reflectionInfo = reflectionInfo;
       let info = new ReflectionInfo(func);
       let functionType = info.functionType;
       let prototype = isStatic ? Object.create(new TearOffClosure().constructor.prototype) : Object.create(new BoundClosure(null, null, null, null).constructor.prototype);
       prototype.$initialize = prototype.constructor;
       let constructor = isStatic ? function() {
         this.$initialize();
-      } : isCsp ? function(a, b, c, d) {
+      } : Closure.isCsp ? function(a, b, c, d) {
         this.$initialize(a, b, c, d);
-      } : new Function("a", "b", "c", "d", "this.$initialize(a,b,c,d);" + ((x$) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter));
+      } : new Function("a", "b", "c", "d", "this.$initialize(a,b,c,d);" + ((x$) => Closure.functionCounter = dart.notNull(x$) + 1, x$)(Closure.functionCounter));
       prototype.constructor = constructor;
       constructor.prototype = prototype;
       let trampoline = func;
       let isIntercepted = false;
       if (!dart.notNull(isStatic)) {
         if (jsArguments.length == 1) {
           isIntercepted = true;
         }
-        trampoline = forwardCallTo(receiver, func, isIntercepted);
+        trampoline = Closure.forwardCallTo(receiver, func, isIntercepted);
         trampoline.$reflectionInfo = reflectionInfo;
       } else {
         prototype.$name = propertyName;
       }
       let signatureFunction = null;
       if (typeof functionType == "number") {
         let metadata = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.METADATA);
         signatureFunction = function(s) {
           return function() {
             return metadata[s];
           };
         }(functionType);
       } else if (!dart.notNull(isStatic) && typeof functionType == "function") {
         let getReceiver = isIntercepted ? _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.receiverOf) : _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
         signatureFunction = function(f, r) {
           return function() {
-            return f.apply({$receiver: r(this)}, arguments);
+            return f.apply({$receiver: r(this)}, arguments$);
           };
         }(functionType, getReceiver);
       } else {
         throw 'Error in reflectionInfo.';
       }
       prototype[_foreign_helper.JS_SIGNATURE_NAME()] = signatureFunction;
       prototype[callName] = trampoline;
       for (let i = 1; dart.notNull(i) < dart.notNull(functions.length); i = dart.notNull(i) + 1) {
         let stub = functions.get(i);
         let stubCallName = stub.$callName;
         if (stubCallName !== null) {
-          prototype[stubCallName] = isStatic ? stub : forwardCallTo(receiver, stub, isIntercepted);
+          prototype[stubCallName] = isStatic ? stub : Closure.forwardCallTo(receiver, stub, isIntercepted);
         }
       }
       prototype["call*"] = trampoline;
       return constructor;
     }
     static cspForwardCall(arity, isSuperCall, stubName, func) {
       let getSelf = _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
       if (isSuperCall)
         arity = -1;
       switch (arity) {
@@ skipping 29 matching lines @@
           }(stubName, getSelf);
         case 5:
           return function(n, S) {
             return function(a, b, c, d, e) {
               return S(this)[n](a, b, c, d, e);
             };
           }(stubName, getSelf);
         default:
           return function(f, s) {
             return function() {
-              return f.apply(s(this), arguments);
+              return f.apply(s(this), arguments$);
             };
           }(func, getSelf);
       }
     }
     static get isCsp() {
       return typeof dart_precompiled == "function";
     }
     static forwardCallTo(receiver, func, isIntercepted) {
       if (isIntercepted)
-        return forwardInterceptedCallTo(receiver, func);
+        return Closure.forwardInterceptedCallTo(receiver, func);
       let stubName = dart.as(func.$stubName, core.String);
       let arity = func.length;
       let lookedUpFunction = receiver[stubName];
       let isSuperCall = !dart.notNull(core.identical(func, lookedUpFunction));
-      if (dart.notNull(isCsp) || dart.notNull(isSuperCall) || dart.notNull(arity) >= 27) {
-        return cspForwardCall(arity, isSuperCall, stubName, func);
+      if (dart.notNull(Closure.isCsp) || dart.notNull(isSuperCall) || dart.notNull(arity) >= 27) {
+        return Closure.cspForwardCall(arity, isSuperCall, stubName, func);
       }
       if (arity === 0) {
-        return new Function('return function(){' + `return this.${BoundClosure.selfFieldName()}.${stubName}();` + `${((x$) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
+        return new Function('return function(){' + `return this.${BoundClosure.selfFieldName()}.${stubName}();` + `${((x$) => Closure.functionCounter = dart.notNull(x$) + 1, x$)(Closure.functionCounter)}` + '}')();
       }
       dart.assert(1 <= dart.notNull(arity) && dart.notNull(arity) < 27);
-      let arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(",");
-      return new Function(`return function(${arguments}){` + `return this.${BoundClosure.selfFieldName()}.${stubName}(${arguments});` + `${((x$) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
+      let arguments$ = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, arity).join(",");
+      return new Function(`return function(${arguments$}){` + `return this.${BoundClosure.selfFieldName()}.${stubName}(${arguments$});` + `${((x$) => Closure.functionCounter = dart.notNull(x$) + 1, x$)(Closure.functionCounter)}` + '}')();
     }
     static cspForwardInterceptedCall(arity, isSuperCall, name, func) {
       let getSelf = _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.selfOf);
       let getReceiver = _foreign_helper.RAW_DART_FUNCTION_REF(BoundClosure.receiverOf);
       if (isSuperCall)
         arity = -1;
       switch (arity) {
         case 0:
           throw new RuntimeError('Intercepted function with no arguments.');
         case 1:
@@ skipping 29 matching lines @@
         case 6:
           return function(n, s, r) {
             return function(a, b, c, d, e) {
               return s(this)[n](r(this), a, b, c, d, e);
             };
           }(name, getSelf, getReceiver);
         default:
           return function(f, s, r, a) {
             return function() {
               a = [r(this)];
-              Array.prototype.push.apply(a, arguments);
+              Array.prototype.push.apply(a, arguments$);
               return f.apply(s(this), a);
             };
           }(func, getSelf, getReceiver);
       }
     }
     static forwardInterceptedCallTo(receiver, func) {
       let selfField = BoundClosure.selfFieldName();
       let receiverField = BoundClosure.receiverFieldName();
       let stubName = dart.as(func.$stubName, core.String);
       let arity = func.length;
       let isCsp = typeof dart_precompiled == "function";
       let lookedUpFunction = receiver[stubName];
       let isSuperCall = !dart.notNull(core.identical(func, lookedUpFunction));
       if (dart.notNull(isCsp) || dart.notNull(isSuperCall) || dart.notNull(arity) >= 28) {
-        return cspForwardInterceptedCall(arity, isSuperCall, stubName, func);
+        return Closure.cspForwardInterceptedCall(arity, isSuperCall, stubName, func);
       }
       if (arity === 1) {
-        return new Function('return function(){' + `return this.${selfField}.${stubName}(this.${receiverField});` + `${((x$) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
+        return new Function('return function(){' + `return this.${selfField}.${stubName}(this.${receiverField});` + `${((x$) => Closure.functionCounter = dart.notNull(x$) + 1, x$)(Closure.functionCounter)}` + '}')();
       }
       dart.assert(1 < dart.notNull(arity) && dart.notNull(arity) < 28);
-      let arguments = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, dart.notNull(arity) - 1).join(",");
-      return new Function(`return function(${arguments}){` + `return this.${selfField}.${stubName}(this.${receiverField}, ${arguments});` + `${((x$) => functionCounter = dart.notNull(x$) + 1, x$)(functionCounter)}` + '}')();
+      let arguments$ = "abcdefghijklmnopqrstuvwxyz".split("").splice(0, dart.notNull(arity) - 1).join(",");
+      return new Function(`return function(${arguments$}){` + `return this.${selfField}.${stubName}(this.${receiverField}, ${arguments$});` + `${((x$) => Closure.functionCounter = dart.notNull(x$) + 1, x$)(Closure.functionCounter)}` + '}')();
     }
     toString() {
       return "Closure";
     }
   }
   Closure.FUNCTION_INDEX = 0;
   Closure.NAME_INDEX = 1;
   Closure.CALL_NAME_INDEX = 2;
   Closure.REQUIRED_PARAMETER_INDEX = 3;
   Closure.OPTIONAL_PARAMETER_INDEX = 4;
@@ skipping 40 matching lines @@
     static targetOf(closure) {
       return closure[_target];
     }
     static receiverOf(closure) {
       return closure[_receiver];
     }
     static nameOf(closure) {
       return closure[_name];
     }
     static selfFieldName() {
-      if (selfFieldNameCache === null) {
-        selfFieldNameCache = computeFieldNamed('self');
+      if (BoundClosure.selfFieldNameCache === null) {
+        BoundClosure.selfFieldNameCache = BoundClosure.computeFieldNamed('self');
       }
-      return selfFieldNameCache;
+      return BoundClosure.selfFieldNameCache;
     }
     static receiverFieldName() {
-      if (receiverFieldNameCache === null) {
-        receiverFieldNameCache = computeFieldNamed('receiver');
+      if (BoundClosure.receiverFieldNameCache === null) {
+        BoundClosure.receiverFieldNameCache = BoundClosure.computeFieldNamed('receiver');
       }
-      return receiverFieldNameCache;
+      return BoundClosure.receiverFieldNameCache;
     }
     static computeFieldNamed(fieldName) {
       let template = new BoundClosure('self', 'target', 'receiver', 'name');
       let names = _interceptors.JSArray.markFixedList(dart.as(Object.getOwnPropertyNames(template), core.List));
       for (let i = 0; dart.notNull(i) < dart.notNull(names.length); i = dart.notNull(i) + 1) {
         let name = names.get(i);
         if (template[name] === fieldName) {
           return name;
         }
       }
@@ skipping 335 matching lines @@
       if (dart.is(condition, core.Function))
         condition = dart.dinvokef(condition);
       if (!(typeof condition == boolean)) {
         throw new TypeErrorImplementation(condition, 'bool');
       }
     }
     if (true !== condition)
       throw new core.AssertionError();
   }
   // Function throwNoSuchMethod: (dynamic, dynamic, dynamic, dynamic) → void
-  function throwNoSuchMethod(obj, name, arguments, expectedArgumentNames) {
+  function throwNoSuchMethod(obj, name, arguments$, expectedArgumentNames) {
     let memberName = new _internal.Symbol.unvalidated(dart.as(name, core.String));
-    throw new core.NoSuchMethodError(obj, memberName, dart.as(arguments, core.List), new core.Map(), dart.as(expectedArgumentNames, core.List));
+    throw new core.NoSuchMethodError(obj, memberName, dart.as(arguments$, core.List), new core.Map(), dart.as(expectedArgumentNames, core.List));
   }
   // Function throwCyclicInit: (String) → void
   function throwCyclicInit(staticName) {
     throw new core.CyclicInitializationError(`Cyclic initialization for static ${staticName}`);
   }
   class RuntimeError extends core.Error {
     RuntimeError(message) {
       this.message = message;
       super.Error();
     }
@@ skipping 31 matching lines @@
       return dart.is(this.returnType, VoidRuntimeType);
     }
     [_isTest](expression) {
       let functionTypeObject = this[_extractFunctionTypeObjectFrom](expression);
       return functionTypeObject === null ? false : isFunctionSubtype(functionTypeObject, this.toRti());
     }
     [_asCheck](expression) {
       return this[_check](expression, true);
     }
     [_assertCheck](expression) {
-      if (inAssert)
+      if (RuntimeFunctionType.inAssert)
         return null;
-      inAssert = true;
+      RuntimeFunctionType.inAssert = true;
       try {
         return this[_check](expression, false);
       } finally {
-        inAssert = false;
+        RuntimeFunctionType.inAssert = false;
       }
     }
     [_check](expression, isCast) {
       if (expression === null)
         return null;
       if (this[_isTest](expression))
         return expression;
       let self = new FunctionTypeInfoDecoderRing(this.toRti()).toString();
       if (isCast) {
         let functionTypeObject = this[_extractFunctionTypeObjectFrom](expression);
@@ skipping 15 matching lines @@
     toRti() {
       let result = {[_foreign_helper.JS_FUNCTION_TYPE_TAG()]: "dynafunc"};
       if (this.isVoid) {
         result[_foreign_helper.JS_FUNCTION_TYPE_VOID_RETURN_TAG()] = true;
       } else {
         if (!dart.is(this.returnType, DynamicRuntimeType)) {
           result[_foreign_helper.JS_FUNCTION_TYPE_RETURN_TYPE_TAG()] = this.returnType.toRti();
         }
       }
       if (dart.notNull(this.parameterTypes !== null) && !dart.notNull(this.parameterTypes.isEmpty)) {
-        result[_foreign_helper.JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG()] = listToRti(this.parameterTypes);
+        result[_foreign_helper.JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG()] = RuntimeFunctionType.listToRti(this.parameterTypes);
       }
       if (dart.notNull(this.optionalParameterTypes !== null) && !dart.notNull(this.optionalParameterTypes.isEmpty)) {
-        result[_foreign_helper.JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG()] = listToRti(this.optionalParameterTypes);
+        result[_foreign_helper.JS_FUNCTION_TYPE_OPTIONAL_PARAMETERS_TAG()] = RuntimeFunctionType.listToRti(this.optionalParameterTypes);
       }
       if (this.namedParameters !== null) {
         let namedRti = Object.create(null);
         let keys = _js_names.extractKeys(this.namedParameters);
         for (let i = 0; dart.notNull(i) < dart.notNull(keys.length); i = dart.notNull(i) + 1) {
           let name = keys.get(i);
           let rti = dart.dinvoke(this.namedParameters[name], 'toRti');
           namedRti[name] = rti;
         }
         result[_foreign_helper.JS_FUNCTION_TYPE_NAMED_PARAMETERS_TAG()] = namedRti;
@@ skipping 120 matching lines @@
   }
   // Function convertRtiToRuntimeType: (dynamic) → RuntimeType
   function convertRtiToRuntimeType(rti) {
     if (rti === null) {
       return getDynamicRuntimeType();
     } else if (typeof rti == "function") {
       return new RuntimeTypePlain(rti.name);
     } else if (rti.constructor == Array) {
       let list = dart.as(rti, core.List);
       let name = list.get(0).name;
-      let arguments = new List.from([]);
+      let arguments$ = new List.from([]);
       for (let i = 1; dart.notNull(i) < dart.notNull(list.length); i = dart.notNull(i) + 1) {
-        arguments.add(convertRtiToRuntimeType(list.get(i)));
+        arguments$.add(convertRtiToRuntimeType(list.get(i)));
       }
-      return new RuntimeTypeGeneric(name, dart.as(arguments, core.List$(RuntimeType)), rti);
+      return new RuntimeTypeGeneric(name, dart.as(arguments$, core.List$(RuntimeType)), rti);
     } else if ("func" in rti) {
       return new FunctionTypeInfoDecoderRing(rti).toRuntimeType();
     } else {
       throw new RuntimeError("Cannot convert " + `'${JSON.stringify(rti)}' to RuntimeType.`);
     }
   }
   class RuntimeTypePlain extends RuntimeType {
     RuntimeTypePlain(name) {
       this.name = name;
       super.RuntimeType();
     }
     toRti() {
       let allClasses = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.ALL_CLASSES);
       let rti = allClasses[this.name];
       if (rti === null)
         throw `no type for '${this.name}'`;
       return rti;
     }
     toString() {
       return this.name;
     }
   }
   class RuntimeTypeGeneric extends RuntimeType {
-    RuntimeTypeGeneric(name, arguments, rti) {
+    RuntimeTypeGeneric(name, arguments$, rti) {
       this.name = name;
-      this.arguments = arguments;
+      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}<...>'`;
@@ skipping 482 matching lines @@
   exports.UnimplementedNoSuchMethodError = UnimplementedNoSuchMethodError;
   exports.random64 = random64;
   exports.jsonEncodeNative = jsonEncodeNative;
   exports.getIsolateAffinityTag = getIsolateAffinityTag;
   exports.loadDeferredLibrary = loadDeferredLibrary;
   exports.MainError = MainError;
   exports.missingMain = missingMain;
   exports.badMain = badMain;
   exports.mainHasTooManyParameters = mainHasTooManyParameters;
 })(_js_helper || (_js_helper = {}));