Generate static calls for Object fields and methods

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() {
     }
@@ skipping 741 matching lines @@
         if (dart.equals(receiver, "")) {
           return to;
         } else {
           let result = new core.StringBuffer();
           let length = dart.as(dart.dload(receiver, 'length'), core.int);
           result.write(to);
           for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
             result.write(dart.dindex(receiver, i));
             result.write(to);
           }
-          return result.toString();
+          return dart.toString(result);

[Jennifer Messerly, 2015/04/23 21:09:30]

random thought for future:

we have an issue with template strings: `hello ${name}`. Those won't use Dart
toString. The fix is to make them "tagged template":

    dart.str `hello ${name}`

where "str" is a function call:
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_st...

         }
       } else {
         let quoter = new RegExp(ESCAPE_REGEXP, 'g');
         let quoted = from.replace(quoter, "\\$&");
         let replacer = new RegExp(quoted, 'g');
         return stringReplaceJS(receiver, replacer, to);
       }
     } else if (dart.is(from, JSSyntaxRegExp)) {
       let re = regExpGetGlobalNative(dart.as(from, JSSyntaxRegExp));
       return stringReplaceJS(receiver, re, to);
@@ skipping 23 matching lines @@
       return stringReplaceAllStringFuncUnchecked(receiver, pattern, onMatch, onNonMatch);
     }
     let buffer = new core.StringBuffer();
     let startIndex = 0;
     for (let match of dart.as(dart.dsend(pattern, 'allMatches', receiver), core.Iterable$(core.Match))) {
       buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex, match.start)));
       buffer.write(dart.dcall(onMatch, match));
       startIndex = match.end;
     }
     buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex)));
-    return buffer.toString();
+    return dart.toString(buffer);
   }
   // Function stringReplaceAllEmptyFuncUnchecked: (dynamic, dynamic, dynamic) → dynamic
   function stringReplaceAllEmptyFuncUnchecked(receiver, onMatch, onNonMatch) {
     let buffer = new core.StringBuffer();
     let length = dart.as(dart.dload(receiver, 'length'), core.int);
     let i = 0;
     buffer.write(dart.dcall(onNonMatch, ""));
     while (dart.notNull(i) < dart.notNull(length)) {
       buffer.write(dart.dcall(onMatch, new StringMatch(i, dart.as(receiver, core.String), "")));
       let code = dart.as(dart.dsend(receiver, 'codeUnitAt', i), core.int);
       if ((dart.notNull(code) & ~1023) == 55296 && dart.notNull(length) > dart.notNull(i) + 1) {
         code = dart.as(dart.dsend(receiver, 'codeUnitAt', dart.notNull(i) + 1), core.int);
         if ((dart.notNull(code) & ~1023) == 56320) {
           buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', i, dart.notNull(i) + 2)));
           i = dart.notNull(i) + 2;
           continue;
         }
       }
       buffer.write(dart.dcall(onNonMatch, dart.dindex(receiver, i)));
       i = dart.notNull(i) + 1;
     }
     buffer.write(dart.dcall(onMatch, new StringMatch(i, dart.as(receiver, core.String), "")));
     buffer.write(dart.dcall(onNonMatch, ""));
-    return buffer.toString();
+    return dart.toString(buffer);
   }
   // Function stringReplaceAllStringFuncUnchecked: (dynamic, dynamic, dynamic, dynamic) → dynamic
   function stringReplaceAllStringFuncUnchecked(receiver, pattern, onMatch, onNonMatch) {
     let patternLength = dart.as(dart.dload(pattern, 'length'), core.int);
     if (patternLength == 0) {
       return stringReplaceAllEmptyFuncUnchecked(receiver, onMatch, onNonMatch);
     }
     let length = dart.as(dart.dload(receiver, 'length'), core.int);
     let buffer = new core.StringBuffer();
     let startIndex = 0;
     while (dart.notNull(startIndex) < dart.notNull(length)) {
       let position = dart.as(dart.dsend(receiver, 'indexOf', pattern, startIndex), core.int);
       if (position == -1) {
         break;
       }
       buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex, position)));
       buffer.write(dart.dcall(onMatch, new StringMatch(position, dart.as(receiver, core.String), dart.as(pattern, core.String))));
       startIndex = dart.notNull(position) + dart.notNull(patternLength);
     }
     buffer.write(dart.dcall(onNonMatch, dart.dsend(receiver, 'substring', startIndex)));
-    return buffer.toString();
+    return dart.toString(buffer);
   }
   // Function stringReplaceFirstUnchecked: (dynamic, dynamic, dynamic, [int]) → dynamic
   function stringReplaceFirstUnchecked(receiver, from, to, startIndex) {
     if (startIndex === void 0)
       startIndex = 0;
     if (typeof from == 'string') {
       let index = dart.dsend(receiver, 'indexOf', from, startIndex);
       if (dart.dsend(index, '<', 0))
         return receiver;
       return `${dart.dsend(receiver, 'substring', 0, index)}${to}` + `${dart.dsend(receiver, 'substring', dart.dsend(index, '+', dart.dload(from, 'length')))}`;
@@ skipping 19 matching lines @@
       this[_typeName] = typeName;
       this[_unmangledName] = null;
     }
     toString() {
       if (this[_unmangledName] != null)
         return this[_unmangledName];
       let unmangledName = unmangleAllIdentifiersIfPreservedAnyways(this[_typeName]);
       return this[_unmangledName] = unmangledName;
     }
     get hashCode() {
-      return this[_typeName].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];
   class TypeVariable extends core.Object {
     TypeVariable(owner, name, bound) {
       this.owner = owner;
       this.name = name;
@@ skipping 55 matching lines @@
   function runtimeTypeToString(type, opts) {
     let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
     if (type == null) {
       return 'dynamic';
     } else if (isJsArray(type)) {
       return getRuntimeTypeAsString(type, {onTypeVariable: onTypeVariable});
     } else if (isJsFunction(type)) {
       return getConstructorName(type);
     } else if (typeof type == 'number') {
       if (onTypeVariable == null) {
-        return type.toString();
+        return dart.toString(type);
       } else {
         return onTypeVariable(dart.as(type, core.int));
       }
     } else {
       return null;
     }
   }
   // Function joinArguments: (dynamic, int, {onTypeVariable: (int) → String}) → String
   function joinArguments(types, startIndex, opts) {
     let onTypeVariable = opts && 'onTypeVariable' in opts ? opts.onTypeVariable : null;
@@ skipping 390 matching lines @@
       if (!dart.equals(value, 0)) {
         return "" + value;
       }
     } else if (dart.equals(true, value)) {
       return 'true';
     } else if (dart.equals(false, value)) {
       return 'false';
     } else if (value == null) {
       return 'null';
     }
-    let res = value.toString();
+    let res = dart.toString(value);
     if (!(typeof res == 'string'))
       throw new core.ArgumentError(value);
     return res;
   }
   // 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 createUnmangledInvocationMirror: (Symbol, dynamic, dynamic, dynamic, dynamic) → dynamic
   function createUnmangledInvocationMirror(symbol, internalName, kind, arguments$, argumentNames) {
@@ skipping 828 matching lines @@
     if ("defineProperty" in Object) {
       Object.defineProperty(wrapper, "message", {get: _foreign_helper.DART_CLOSURE_TO_JS(toStringWrapper)});
       wrapper.name = "";
     } else {
       wrapper.toString = _foreign_helper.DART_CLOSURE_TO_JS(toStringWrapper);
     }
     return wrapper;
   }
   // Function toStringWrapper: () → dynamic
   function toStringWrapper() {
-    return this.dartException.toString();
+    return dart.toString(this.dartException);
   }
   // Function throwExpression: (dynamic) → dynamic
   function throwExpression(ex) {
     throw wrapException(ex);
   }
   // Function makeLiteralListConst: (dynamic) → dynamic
   function makeLiteralListConst(list) {
     list.immutable$list = true;
     list.fixed$length = true;
     return list;
@@ skipping 306 matching lines @@
       if (typeof this[_exception] === "object") {
         trace = dart.as(this[_exception].stack, core.String);
       }
       return this[_trace] = trace == null ? '' : trace;
     }
   }
   _StackTrace[dart.implements] = () => [core.StackTrace];
   // Function objectHashCode: (dynamic) → int
   function objectHashCode(object) {
     if (dart.notNull(object == null) || typeof object != 'object') {
-      return object.hashCode;
+      return dart.hashCode(object);
     } else {
       return Primitives.objectHashCode(object);
     }
   }
   // Function fillLiteralMap: (dynamic, Map<dynamic, dynamic>) → dynamic
   function fillLiteralMap(keyValuePairs, result) {
     let index = 0;
     let length = getLength(keyValuePairs);
     while (dart.notNull(index) < dart.notNull(length)) {
       let key = getIndex(keyValuePairs, (() => {
@@ skipping 328 matching lines @@
         return true;
       if (!dart.is(other, BoundClosure))
         return false;
       return this[_self] === dart.dload(other, _self) && this[_target] === dart.dload(other, _target) && this[_receiver] === dart.dload(other, _receiver);
     }
     get hashCode() {
       let receiverHashCode = null;
       if (this[_receiver] == null) {
         receiverHashCode = Primitives.objectHashCode(this[_self]);
       } else if (typeof this[_receiver] != 'object') {
-        receiverHashCode = this[_receiver].hashCode;
+        receiverHashCode = dart.hashCode(this[_receiver]);
       } else {
         receiverHashCode = Primitives.objectHashCode(this[_receiver]);
       }
       return dart.notNull(receiverHashCode) ^ dart.notNull(Primitives.objectHashCode(this[_target]));
     }
     static selfOf(closure) {
       return closure[_self];
     }
     static targetOf(closure) {
       return closure[_target];
@@ skipping 433 matching lines @@
         return this[_check](expression, false);
       } finally {
         RuntimeFunctionType.inAssert = false;
       }
     }
     [_check](expression, isCast) {
       if (expression == null)
         return null;
       if (this[_isTest](expression))
         return expression;
-      let self = new FunctionTypeInfoDecoderRing(this.toRti()).toString();
+      let self = dart.toString(new FunctionTypeInfoDecoderRing(this.toRti()));
       if (isCast) {
         let functionTypeObject = this[_extractFunctionTypeObjectFrom](expression);
         let pretty = null;
         if (functionTypeObject != null) {
-          pretty = new FunctionTypeInfoDecoderRing(functionTypeObject).toString();
+          pretty = dart.toString(new FunctionTypeInfoDecoderRing(functionTypeObject));
         } else {
           pretty = Primitives.objectTypeName(expression);
         }
         throw new CastErrorImplementation(pretty, self);
       } else {
         throw new TypeErrorImplementation(expression, self);
       }
     }
     [_extractFunctionTypeObjectFrom](o) {
       let interceptor = _interceptors.getInterceptor(o);
@@ skipping 253 matching lines @@
       return this[_typeData].named;
     }
     toRuntimeType() {
       return dart.const(new DynamicRuntimeType());
     }
     [_convert](type) {
       let result = runtimeTypeToString(type);
       if (result != null)
         return result;
       if ("func" in type) {
-        return new FunctionTypeInfoDecoderRing(type).toString();
+        return dart.toString(new FunctionTypeInfoDecoderRing(type));
       } else {
         throw 'bad type';
       }
     }
     toString() {
       if (this[_cachedToString] != null)
         return this[_cachedToString];
       let s = "(";
       let sep = '';
       if (this[_hasArguments]) {
@@ skipping 58 matching lines @@
   // Function getIsolateAffinityTag: (String) → String
   function getIsolateAffinityTag(name) {
     let isolateTagGetter = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.GET_ISOLATE_TAG);
     return isolateTagGetter(name);
   }
   let LoadLibraryFunctionType = dart.typedef('LoadLibraryFunctionType', () => dart.functionType(async.Future$(core.Null), []));
   // Function _loadLibraryWrapper: (String) → () → Future<Null>
   function _loadLibraryWrapper(loadId) {
     return () => loadDeferredLibrary(loadId);
   }
+  let _loadingLibraries = Symbol('_loadingLibraries');
+  let _loadedLibraries = Symbol('_loadedLibraries');
   dart.defineLazyProperties(exports, {
-    get _loadingLibraries() {
+    get [_loadingLibraries]() {
       return dart.map();
     },
-    get _loadedLibraries() {
+    get [_loadedLibraries]() {
       return new (core.Set$(core.String))();
     }
   });
   let DeferredLoadCallback = dart.typedef('DeferredLoadCallback', () => dart.functionType(dart.void, []));
   exports.deferredLoadHook = null;
   // Function loadDeferredLibrary: (String) → Future<Null>
   function loadDeferredLibrary(loadId) {
     let urisMap = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.DEFERRED_LIBRARY_URIS);
     let uris = dart.as(urisMap[loadId], core.List$(core.String));
     let hashesMap = _foreign_helper.JS_EMBEDDED_GLOBAL('', _js_embedded_names.DEFERRED_LIBRARY_HASHES);
@@ skipping 337 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 || (_js_helper = {}));