dart2js: Cleanups and renames in runtime code that thouches types.

sdk/lib/_internal/compiler/js_lib/js_helper.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library _js_helper;
 
 import 'dart:_async_await_error_codes' as async_error_codes;
 
 import 'dart:_js_embedded_names' show
     DEFERRED_LIBRARY_URIS,
@@ skipping 69 matching lines @@
 part 'regexp_helper.dart';
 part 'string_helper.dart';
 part 'js_rti.dart';
 part 'linked_hash_map.dart';
 
 /// Marks the internal map in dart2js, so that internal libraries can is-check
 /// them.
 abstract class InternalMap {
 }
 
-/// Extracts the classname from the isCheckProperty.
+/// Extracts the JavaScript-constructor name from the given isCheckProperty.
 // TODO(floitsch): move this to foreign_helper.dart or similar.
 @ForceInline()
-String classNameFromIsCheckProperty(String isCheckProperty) {
+String isCheckPropertyToJsConstructorName(String isCheckProperty) {
   return JS_BUILTIN('returns:String;depends:none;effects:none',
-                    JsBuiltin.classNameFromIsCheckProperty,
+                    JsBuiltin.isCheckPropertyToJsConstructorName,
                     isCheckProperty);
 }
 
 /// Returns true if the given [type] is a function type object.
 // TODO(floitsch): move this to foreign_helper.dart or similar.
 @ForceInline()
 bool isDartFunctionType(Object type) {
   return JS_BUILTIN('returns:bool;effects:none;depends:none',
                     JsBuiltin.isFunctionType, type);
 }
 
 
 /// Creates a function type object.
 // TODO(floitsch): move this to foreign_helper.dart or similar.
 @ForceInline()
-createDartFunctionType() {
+createDartFunctionTypeRti() {
   return JS_BUILTIN('returns:=Object;effects:none;depends:none',
-                    JsBuiltin.createFunctionType);
+                    JsBuiltin.createFunctionTypeRti);
 }
 
 /// Retrieves the class name from type information stored on the constructor of
 /// [type].
 // TODO(floitsch): move this to foreign_helper.dart or similar.
 @ForceInline()
-String getDartTypeName(Object type) {
-  return JS_BUILTIN('String', JsBuiltin.typeName, type);
+String rawRtiToJsConstructorName(Object rti) {
+  return JS_BUILTIN('String', JsBuiltin.rawRtiToJsConstructorName, rti);
+}
+
+/// Returns the rti from the given [constructorName].
+// TODO(floitsch): make this a builtin.
+jsConstructorNameToRti(String constructorName) {
+  var getTypeFromName = JS_EMBEDDED_GLOBAL('', GET_TYPE_FROM_NAME);
+  return JS('', '#(#)', getTypeFromName, constructorName);
 }
 
 /// Returns the raw runtime type of the given object [o].
 ///
 /// The argument [o] must be the interceptor for primitive types. If
 /// necessary run it through [getInterceptor] first.
 // TODO(floitsch): move this to foreign_helper.dart or similar.
 // TODO(floitsch): we should call getInterceptor ourselves, but currently
 //    getInterceptor is not GVNed.
 @ForceInline()
@@ skipping 29 matching lines @@
 
 /// Returns whether the given type is _the_ null type.
 // TODO(floitsch): move this to foreign_helper.dart or similar.
 @ForceInline()
 bool isNullTypeRti(type) {
   return JS_BUILTIN('returns:bool;effects:none;depends:none',
                     JsBuiltin.isNullTypeRti, type);
 }
 
 /// Returns the metadata of the given [index].
+// TODO(floitsch): move this to foreign_helper.dart or similar.
 @ForceInline()
 getMetadata(int index) {
   return JS_BUILTIN('returns:var;effects:none;depends:none',
                     JsBuiltin.getMetadata, index);
 }
 
 /// Returns the type of the given [index].
+// TODO(floitsch): move this to foreign_helper.dart or similar.
 @ForceInline()
 getType(int index) {
   return JS_BUILTIN('returns:var;effects:none;depends:none',
                     JsBuiltin.getType, index);
 }
 
 /// No-op method that is called to inform the compiler that preambles might
 /// be needed when executing the resulting JS file in a command-line
 /// JS engine.
 requiresPreamble() {}
@@ skipping 596 matching lines @@
     return result;
   }
 
   /** [: r"$".codeUnitAt(0) :] */
   static const int DOLLAR_CHAR_VALUE = 36;
 
   /// Creates a string containing the complete type for the class [className]
   /// with the given type arguments.
   ///
   /// In minified mode, uses the unminified names if available.
+  ///
+  /// The given [className] string generally contains the name of the JavaScript
+  /// constructor of the given class.
   static String formatType(String className, List typeArguments) {
     return unmangleAllIdentifiersIfPreservedAnyways
         ('$className${joinArguments(typeArguments, 0)}');
   }
 
   /// Returns the type of [object] as a string (including type arguments).
   ///
   /// In minified mode, uses the unminified names if available.
   static String objectTypeName(Object object) {
     String name = constructorNameFallback(getInterceptor(object));
@@ skipping 10 matching lines @@
     }
     // TODO(kasperl): If the namer gave us a fresh global name, we may
     // want to remove the numeric suffix that makes it unique too.
     if (name.length > 1 && identical(name.codeUnitAt(0), DOLLAR_CHAR_VALUE)) {
       name = name.substring(1);
     }
     return formatType(name, getRuntimeTypeInfo(object));
   }
 
   /// In minified mode, uses the unminified names if available.
-  static String objectToString(Object object) {
+  static String objectToHumanReadableString(Object object) {
     String name = objectTypeName(object);
     return "Instance of '$name'";
   }
 
   static num dateNow() => JS('int', r'Date.now()');
 
   static void initTicker() {
     if (timerFrequency != null) return;
     // Start with low-resolution. We overwrite the fields if we find better.
     timerFrequency = 1000;
@@ skipping 503 matching lines @@
       }
     });
     if (bad) {
       return functionNoSuchMethod(
           function, positionalArguments, namedArguments);
     }
     positionalArguments.addAll(defaultArguments.values);
     return JS('', '#.apply(#, #)', jsFunction, function, positionalArguments);
   }
 
-  static _mangledNameMatchesType(String mangledName, TypeImpl type) {
-    return JS('bool', '# == #', mangledName, type._typeName);
-  }
-
   static bool identicalImplementation(a, b) {
     return JS('bool', '# == null', a)
       ? JS('bool', '# == null', b)
       : JS('bool', '# === #', a, b);
   }
 
   static StackTrace extractStackTrace(Error error) {
     return getTraceFromException(JS('', r'#.$thrownJsError', error));
   }
 }
@@ skipping 603 matching lines @@
         return saveStackTrace(
             new NullError('$message (Error $ieErrorCode)', null));
       }
     }
   }
 
   if (JS('bool', r'# instanceof TypeError', ex)) {
     var match;
     // Using JS to give type hints to the compiler to help tree-shaking.
     // TODO(ahe): That should be unnecessary due to type inference.
-    var nsme =
-        JS('TypeErrorDecoder', '#', TypeErrorDecoder.noSuchMethodPattern);
-    var notClosure =
-        JS('TypeErrorDecoder', '#', TypeErrorDecoder.notClosurePattern);
-    var nullCall =
-        JS('TypeErrorDecoder', '#', TypeErrorDecoder.nullCallPattern);
-    var nullLiteralCall =
-        JS('TypeErrorDecoder', '#', TypeErrorDecoder.nullLiteralCallPattern);
-    var undefCall =
-        JS('TypeErrorDecoder', '#', TypeErrorDecoder.undefinedCallPattern);
-    var undefLiteralCall =
-        JS('TypeErrorDecoder', '#',
-           TypeErrorDecoder.undefinedLiteralCallPattern);
-    var nullProperty =
-        JS('TypeErrorDecoder', '#', TypeErrorDecoder.nullPropertyPattern);
-    var nullLiteralProperty =
-        JS('TypeErrorDecoder', '#',
-           TypeErrorDecoder.nullLiteralPropertyPattern);
-    var undefProperty =
-        JS('TypeErrorDecoder', '#', TypeErrorDecoder.undefinedPropertyPattern);
+    var nsme = TypeErrorDecoder.noSuchMethodPattern;
+    var notClosure = TypeErrorDecoder.notClosurePattern;
+    var nullCall = TypeErrorDecoder.nullCallPattern;
+    var nullLiteralCall = TypeErrorDecoder.nullLiteralCallPattern;
+    var undefCall = TypeErrorDecoder.undefinedCallPattern;
+    var undefLiteralCall = TypeErrorDecoder.undefinedLiteralCallPattern;
+    var nullProperty = TypeErrorDecoder.nullPropertyPattern;
+    var nullLiteralProperty = TypeErrorDecoder.nullLiteralPropertyPattern;
+    var undefProperty = TypeErrorDecoder.undefinedPropertyPattern;
     var undefLiteralProperty =
-        JS('TypeErrorDecoder', '#',
-           TypeErrorDecoder.undefinedLiteralPropertyPattern);
+        TypeErrorDecoder.undefinedLiteralPropertyPattern;
     if ((match = nsme.matchTypeError(message)) != null) {
       return saveStackTrace(new JsNoSuchMethodError(message, match));
     } else if ((match = notClosure.matchTypeError(message)) != null) {
       // notClosure may match "({c:null}).c()" or "({c:1}).c()", so we
       // cannot tell if this an attempt to invoke call on null or a
       // non-function object.
       // But we do know the method name is "call".
       JS('', '#.method = "call"', match);
       return saveStackTrace(new JsNoSuchMethodError(message, match));
     } else if ((match = nullCall.matchTypeError(message)) != null ||
@@ skipping 201 matching lines @@
       BoundClosure.receiverOf(JS('BoundClosure', 'void 0'));
       BoundClosure.selfOf(JS('BoundClosure', 'void 0'));
     });
     // TODO(ahe): All the place below using \$ should be rewritten to go
     // through the namer.
     var function = JS('', '#[#]', functions, 0);
     String name = JS('String|Null', '#.\$stubName', function);
     String callName = JS('String|Null', '#[#]', function,
         JS_GET_NAME(JsGetName.CALL_NAME_PROPERTY));
 
+    // This variable holds either an index into the types-table, or a function
+    // that can compute a function-rti. (The latter is necessary if the type
+    // is dependent on generic arguments).
     var functionType;
     if (reflectionInfo is List) {
       JS('', '#.\$reflectionInfo = #', function, reflectionInfo);
       ReflectionInfo info = new ReflectionInfo(function);
       functionType = info.functionType;
     } else {
       functionType = reflectionInfo;
     }
 
 
@@ skipping 414 matching lines @@
     } else {
       // A bound closure on an intercepted native class, just use the
       // identity hash code.
       receiverHashCode = Primitives.objectHashCode(_receiver);
     }
     return receiverHashCode ^ Primitives.objectHashCode(_target);
   }
 
   toString() {
     var receiver = _receiver == null ? _self : _receiver;
-    return "Closure '$_name' of ${Primitives.objectToString(receiver)}";
+    return "Closure '$_name' of ${Primitives.objectToHumanReadableString(receiver)}";
   }
 
   @NoInline()
   static selfOf(BoundClosure closure) => closure._self;
 
   static targetOf(BoundClosure closure) => closure._target;
 
   @NoInline()
   static receiverOf(BoundClosure closure) => closure._receiver;
 
@@ skipping 197 matching lines @@
   throw new TypeErrorImplementation(value, 'int');
 }
 
 intTypeCast(value) {
   if (value is int || value == null) return value;
   throw new CastErrorImplementation(
       Primitives.objectTypeName(value), 'int');
 }
 
 void propertyTypeError(value, property) {
-  String name = classNameFromIsCheckProperty(property);
+  String name = isCheckPropertyToJsConstructorName(property);
   throw new TypeErrorImplementation(value, name);
 }
 
 void propertyTypeCastError(value, property) {
   // Cuts the property name to the class name.
   String actualType = Primitives.objectTypeName(value);
   String expectedType = property.substring(3, property.length);
   throw new CastErrorImplementation(actualType, expectedType);
 }
 
@@ skipping 339 matching lines @@
   }
 
   _extractFunctionTypeObjectFrom(o) {
     var interceptor = getInterceptor(o);
     return JS('bool', '# in #', JS_SIGNATURE_NAME(), interceptor)
         ? JS('', '#[#]()', interceptor, JS_SIGNATURE_NAME())
         : null;
   }
 
   toRti() {
-    var result = createDartFunctionType();
+    var result = createDartFunctionTypeRti();
     if (isVoid) {
       JS('', '#[#] = true', result, JS_FUNCTION_TYPE_VOID_RETURN_TAG());
     } else {
       if (returnType is! DynamicRuntimeType) {
         JS('', '#[#] = #', result, JS_FUNCTION_TYPE_RETURN_TYPE_TAG(),
            returnType.toRti());
       }
     }
     if (parameterTypes != null && !parameterTypes.isEmpty) {
       JS('', '#[#] = #', result, JS_FUNCTION_TYPE_REQUIRED_PARAMETERS_TAG(),
@@ skipping 85 matching lines @@
                                            parameterTypes,
                                            namedParameters) {
   return new RuntimeFunctionType(
       returnType,
       parameterTypes,
       null,
       namedParameters);
 }
 
 RuntimeType buildInterfaceType(rti, typeArguments) {
-  String name = JS('String', r'#.name', rti);
+  String jsConstructorName = rawRtiToJsConstructorName(rti);
   if (typeArguments == null || typeArguments.isEmpty) {
-    return new RuntimeTypePlain(name);
+    return new RuntimeTypePlain(jsConstructorName);
   }
-  return new RuntimeTypeGeneric(name, typeArguments, null);
+  return new RuntimeTypeGeneric(jsConstructorName, typeArguments, null);
 }
 
 class DynamicRuntimeType extends RuntimeType {
   const DynamicRuntimeType();
 
   String toString() => 'dynamic';
 
   toRti() => null;
 }
 
@@ skipping 51 matching lines @@
   } else if (JS('bool', '"func" in #', rti)) {
     return new FunctionTypeInfoDecoderRing(rti).toRuntimeType();
   } else {
     throw new RuntimeError(
         "Cannot convert "
         "'${JS('String', 'JSON.stringify(#)', rti)}' to RuntimeType.");
   }
 }
 
 class RuntimeTypePlain extends RuntimeType {
-  final String name;
+  /// The constructor name of this raw type.
+  final String _jsConstructorName;
 
-  RuntimeTypePlain(this.name);
+  RuntimeTypePlain(this._jsConstructorName);
 
   toRti() {
-    var getTypeFromName = JS_EMBEDDED_GLOBAL('', GET_TYPE_FROM_NAME);
-    var rti = JS('', '#(#)', getTypeFromName, name);
-    if (rti == null) throw "no type for '$name'";
+    var rti = jsConstructorNameToRti(_jsConstructorName);
+    if (rti == null) throw "no type for '$_jsConstructorName'";
     return rti;
   }
 
-  String toString() => name;
+  String toString() => _jsConstructorName;
 }
 
 class RuntimeTypeGeneric extends RuntimeType {
-  final String name;
+  /// The constructor name of the raw type for this generic type.
+  final String _jsConstructorName;
   final List<RuntimeType> arguments;
   var rti;
 
-  RuntimeTypeGeneric(this.name, this.arguments, this.rti);
+  RuntimeTypeGeneric(this._jsConstructorName, this.arguments, this.rti);
 
   toRti() {
     if (rti != null) return rti;
-    var getTypeFromName = JS_EMBEDDED_GLOBAL('', GET_TYPE_FROM_NAME);
-    var result = JS('JSExtendableArray', '[#(#)]', getTypeFromName, name);
+    var result = [jsConstructorNameToRti(_jsConstructorName)];
     if (result[0] == null) {
-      throw "no type for '$name<...>'";
+      throw "no type for '$_jsConstructorName<...>'";
     }
     for (RuntimeType argument in arguments) {
-      JS('', '#.push(#)', result, argument.toRti());
+      result.add(argument.toRti());
     }
     return rti = result;
   }
 
-  String toString() => '$name<${arguments.join(", ")}>';
+  String toString() => '$_jsConstructorName<${arguments.join(", ")}>';
 }
 
 class FunctionTypeInfoDecoderRing {
   final _typeData;
   String _cachedToString;
 
   FunctionTypeInfoDecoderRing(this._typeData);
 
   bool get _hasReturnType => JS('bool', '"ret" in #', _typeData);
   get _returnType => JS('', '#.ret', _typeData);
@@ skipping 10 matching lines @@
   get _namedArguments => JS('=Object', '#.named', _typeData);
 
   RuntimeType toRuntimeType() {
     // TODO(ahe): Implement this (and update return type).
     return const DynamicRuntimeType();
   }
 
   String _convert(type) {
     String result = runtimeTypeToString(type);
     if (result != null) return result;
+    // Currently the [runtimeTypeToString] method doesn't handle function rtis.
     if (JS('bool', '"func" in #', type)) {
       return new FunctionTypeInfoDecoderRing(type).toString();
     } else {
       throw 'bad type';
     }
   }
 
   String toString() {
     if (_cachedToString != null) return _cachedToString;
     var s = "(";
@@ skipping 601 matching lines @@
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
   // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }