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

sdk/lib/_internal/compiler/js_lib/js_rti.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.
 
 /**
  * This part contains helpers for supporting runtime type information.
  *
  * The helper use a mixture of Dart and JavaScript objects. To indicate which is
  * used where we adopt the scheme of using explicit type annotation for Dart
  * objects and 'var' or omitted return type for JavaScript objects.
@@ skipping 33 matching lines @@
 Type createRuntimeType(String name) => new TypeImpl(name);
 
 class TypeImpl implements Type {
   final String _typeName;
   String _unmangledName;
 
   TypeImpl(this._typeName);
 
   String toString() {
     if (_unmangledName != null) return _unmangledName;
-    String unmangledName = unmangleAllIdentifiersIfPreservedAnyways(_typeName);
+    String unmangledName =
+        unmangleAllIdentifiersIfPreservedAnyways(_typeName);
     return _unmangledName = unmangledName;
   }
 
   // TODO(ahe): This is a poor hashCode as it collides with its name.
   int get hashCode => _typeName.hashCode;
 
   bool operator ==(other) {
     return  (other is TypeImpl) && _typeName == other._typeName;
   }
 }
 
 /**
  * Represents a type variable.
  *
  * This class holds the information needed when reflecting on generic classes
  * and their members.
  */
 class TypeVariable {
   final Type owner;
   final String name;
   final int bound;
 
   const TypeVariable(this.owner, this.name, this.bound);
 }
 
 getMangledTypeName(TypeImpl type) => type._typeName;
 
 /**
- * Sets the runtime type information on [target]. [typeInfo] is a type
+ * Sets the runtime type information on [target]. [rti] is a type
  * representation of type 4 or 5, that is, either a JavaScript array or
  * `null`.
  */
-Object setRuntimeTypeInfo(Object target, var typeInfo) {
-  assert(typeInfo == null || isJsArray(typeInfo));
+Object setRuntimeTypeInfo(Object target, var rti) {
+  assert(rti == null || isJsArray(rti));
   // We have to check for null because factories may return null.
-  if (target != null) JS('var', r'#.$builtinTypeInfo = #', target, typeInfo);
+  if (target != null) JS('var', r'#.$builtinTypeInfo = #', target, rti);
   return target;
 }
 
 /**
  * Returns the runtime type information of [target]. The returned value is a
  * list of type representations for the type arguments.
  */
 getRuntimeTypeInfo(Object target) {
   if (target == null) return null;
   return JS('var', r'#.$builtinTypeInfo', target);
@@ skipping 26 matching lines @@
 
 void copyTypeArguments(Object source, Object target) {
   JS('var', r'#.$builtinTypeInfo = #.$builtinTypeInfo', target, source);
 }
 
 /**
  * Retrieves the class name from type information stored on the constructor
  * of [object].
  */
 String getClassName(var object) {
-  return getDartTypeName(getRawRuntimeType(getInterceptor(object)));
+  return rawRtiToJsConstructorName(getRawRuntimeType(getInterceptor(object)));
 }
 
 /**
- * Creates the string representation for the type representation [runtimeType]
+ * Creates the string representation for the type representation [rti]
  * of type 4, the JavaScript array, where the first element represents the class
  * and the remaining elements represent the type arguments.
  */
-String getRuntimeTypeAsString(var runtimeType, {String onTypeVariable(int i)}) {
-  assert(isJsArray(runtimeType));
-  String className = getDartTypeName(getIndex(runtimeType, 0));
-  return '$className'
-         '${joinArguments(runtimeType, 1, onTypeVariable: onTypeVariable)}';
+String getRuntimeTypeAsString(var rti, {String onTypeVariable(int i)}) {
+  assert(isJsArray(rti));
+  String className = rawRtiToJsConstructorName(getIndex(rti, 0));
+  return '$className${joinArguments(rti, 1, onTypeVariable: onTypeVariable)}';
 }
 
 /**
- * Returns a human-readable representation of the type representation [type].
+ * Returns a human-readable representation of the type representation [rti].
  */
-String runtimeTypeToString(var type, {String onTypeVariable(int i)}) {
-  if (type == null) {
+String runtimeTypeToString(var rti, {String onTypeVariable(int i)}) {
+  if (rti == null) {
     return 'dynamic';
-  } else if (isJsArray(type)) {
+  } else if (isJsArray(rti)) {
     // A list representing a type with arguments.
-    return getRuntimeTypeAsString(type, onTypeVariable: onTypeVariable);
-  } else if (isJsFunction(type)) {
+    return getRuntimeTypeAsString(rti, onTypeVariable: onTypeVariable);
+  } else if (isJsFunction(rti)) {
     // A reference to the constructor.
-    return getDartTypeName(type);
-  } else if (type is int) {
+    return rawRtiToJsConstructorName(rti);
+  } else if (rti is int) {
     if (onTypeVariable == null) {
-      return type.toString();
+      return rti.toString();
     } else {
-      return onTypeVariable(type);
+      return onTypeVariable(rti);
     }
   } else {
     // TODO(ahe): Handle function types, and be sure to always return a string.
     return null;
   }
 }
 
 /**
  * Creates a comma-separated string of human-readable representations of the
  * type representations in the JavaScript array [types] starting at index
@@ skipping 22 matching lines @@
 }
 
 /**
  * Returns a human-readable representation of the type of [object].
  *
  * In minified mode does *not* use unminified identifiers (even when present).
  */
 String getRuntimeTypeString(var object) {
   String className = getClassName(object);
   if (object == null) return className;
-  var typeInfo = JS('var', r'#.$builtinTypeInfo', object);
-  return "$className${joinArguments(typeInfo, 0)}";
+  var rti = JS('var', r'#.$builtinTypeInfo', object);
+  return "$className${joinArguments(rti, 0)}";
 }
 
 Type getRuntimeType(var object) {
   String type = getRuntimeTypeString(object);
   return new TypeImpl(type);
 }
 
 /**
  * Applies the [substitution] on the [arguments].
  *
@@ skipping 43 matching lines @@
   var substitution = getField(interceptor, asField);
   return checkArguments(substitution, arguments, checks);
 }
 
 /// Returns the field's type name.
 ///
 /// In minified mode, uses the unminified names if available.
 String computeTypeName(String isField, List arguments) {
   // Extract the class name from the is field and append the textual
   // representation of the type arguments.
-  return Primitives.formatType(classNameFromIsCheckProperty(isField),
+  return Primitives.formatType(isCheckPropertyToJsConstructorName(isField),
                                arguments);
 }
 
 Object subtypeCast(Object object, String isField, List checks, String asField) {
   if (object != null && !checkSubtype(object, isField, checks, asField)) {
     String actualType = Primitives.objectTypeName(object);
     String typeName = computeTypeName(isField, checks);
     // TODO(johnniwinther): Move type lookup to [CastErrorImplementation] to
     // align with [TypeErrorImplementation].
     throw new CastErrorImplementation(actualType, typeName);
@@ skipping 381 matching lines @@
  * `null` and `undefined` (which we can avoid).
  */
 bool isIdentical(var s, var t) => JS('bool', '# === #', s, t);
 
 /**
  * Returns `true` if the JavaScript values [s] and [t] are not identical. We use
  * this helper instead of [identical] because `identical` needs to merge
  * `null` and `undefined` (which we can avoid).
  */
 bool isNotIdentical(var s, var t) => JS('bool', '# !== #', s, t);