Hide names of internal classes from the user by mapping them to the documented

runtime/vm/object.cc

 // Copyright (c) 2012, 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.
 
 #include "vm/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 412 matching lines @@
   const String& name = String::Handle(String::NewSymbol(cname));
   const Class& cls = Class::Handle(
       Class::NewInterface(name, script, Scanner::kDummyTokenIndex));
   lib.AddClass(cls);
   return cls.raw();
 }
 
 
 void Object::RegisterClass(const Class& cls,
                            const char* cname,
+                           const char* user_visible_cname,
                            const Script& script,
                            const Library& lib) {
   const String& name = String::Handle(String::NewSymbol(cname));
   cls.set_name(name);
+  const String& user_visible_name =
+      String::Handle(String::NewSymbol(user_visible_cname));
+  cls.set_user_visible_name(user_visible_name);
   cls.set_script(script);
   lib.AddClass(cls);
 }
 
 
 void Object::RegisterPrivateClass(const Class& cls,
                                   const char* public_class_name,
+                                  const char* user_visible_cname,
                                   const Script& script,
                                   const Library& lib) {
   String& str = String::Handle();
   str = String::NewSymbol(public_class_name);
   str = lib.PrivateName(str);
   cls.set_name(str);
+  const String& user_visible_name =
+      String::Handle(String::NewSymbol(user_visible_cname));
+  cls.set_user_visible_name(user_visible_name);
   cls.set_script(script);
   lib.AddClass(cls);
 }
 
 
 RawError* Object::Init(Isolate* isolate) {
   TIMERSCOPE(time_bootstrap);
   ObjectStore* object_store = isolate->object_store();
 
   Class& cls = Class::Handle();
@@ skipping 58 matching lines @@
   object_store->set_pending_classes(pending_classes);
 
   Context& context = Context::Handle(Context::New(0, Heap::kOld));
   object_store->set_empty_context(context);
 
   // Now that the symbol table is initialized and that the core dictionary as
   // well as the core implementation dictionary have been setup, preallocate
   // remaining classes and register them by name in the dictionaries.
   const Script& impl_script = Script::Handle(Bootstrap::LoadImplScript());
 
+  cls = Class::New<Integer>();
+  object_store->set_integer_implementation_class(cls);
+  RegisterClass(cls, "IntegerImplementation", "int",
+                impl_script, core_impl_lib);
+  pending_classes.Add(cls, Heap::kOld);
+
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
-  RegisterClass(cls, "Smi", impl_script, core_impl_lib);
+  RegisterClass(cls, "Smi", "int", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
-  RegisterClass(cls, "Mint", impl_script, core_impl_lib);
+  RegisterClass(cls, "Mint", "int", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Bigint>();
   object_store->set_bigint_class(cls);
-  RegisterClass(cls, "Bigint", impl_script, core_impl_lib);
+  RegisterClass(cls, "Bigint", "int", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
-  RegisterClass(cls, "Double", impl_script, core_impl_lib);
+  RegisterClass(cls, "Double", "double", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Bool>();
   object_store->set_bool_class(cls);
-  RegisterClass(cls, "Bool", impl_script, core_impl_lib);
+  RegisterClass(cls, "Bool", "bool", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->array_class();  // Was allocated above.
-  RegisterClass(cls, "ObjectArray", impl_script, core_impl_lib);
+  RegisterClass(cls, "ObjectArray", "List", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->growable_object_array_class();  // Was allocated above.
-  RegisterClass(cls, "GrowableObjectArray", impl_script, core_impl_lib);
+  RegisterClass(cls, "GrowableObjectArray", "List", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<ImmutableArray>();
   object_store->set_immutable_array_class(cls);
   cls.set_type_arguments_instance_field_offset(Array::type_arguments_offset());
   ASSERT(object_store->immutable_array_class() != object_store->array_class());
-  RegisterClass(cls, "ImmutableArray", impl_script, core_impl_lib);
+  RegisterClass(cls, "ImmutableArray", "List", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = object_store->one_byte_string_class();  // Was allocated above.
-  RegisterClass(cls, "OneByteString", impl_script, core_impl_lib);
+  RegisterClass(cls, "OneByteString", "String", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<TwoByteString>();
   object_store->set_two_byte_string_class(cls);
-  RegisterClass(cls, "TwoByteString", impl_script, core_impl_lib);
+  RegisterClass(cls, "TwoByteString", "String", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<FourByteString>();
   object_store->set_four_byte_string_class(cls);
-  RegisterClass(cls, "FourByteString", impl_script, core_impl_lib);
+  RegisterClass(cls, "FourByteString", "String", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<ExternalOneByteString>();
   object_store->set_external_one_byte_string_class(cls);
-  RegisterClass(cls, "ExternalOneByteString", impl_script, core_impl_lib);
+  RegisterClass(cls, "ExternalOneByteString", "String",
+                impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<ExternalTwoByteString>();
   object_store->set_external_two_byte_string_class(cls);
-  RegisterClass(cls, "ExternalTwoByteString", impl_script, core_impl_lib);
+  RegisterClass(cls, "ExternalTwoByteString", "String",
+                impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<ExternalFourByteString>();
   object_store->set_external_four_byte_string_class(cls);
-  RegisterClass(cls, "ExternalFourByteString", impl_script, core_impl_lib);
+  RegisterClass(cls, "ExternalFourByteString", "String",
+                impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   cls = Class::New<Stacktrace>();
   object_store->set_stacktrace_class(cls);
-  RegisterClass(cls, "Stacktrace", impl_script, core_impl_lib);
+  RegisterClass(cls, "Stacktrace", "Stacktrace", impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
   // Super type set below, after Object is allocated.
 
   cls = Class::New<JSRegExp>();
   object_store->set_jsregexp_class(cls);
-  RegisterClass(cls, "JSSyntaxRegExp", impl_script, core_impl_lib);
+  RegisterClass(cls, "JSSyntaxRegExp", "JSSyntaxRegExp",
+                impl_script, core_impl_lib);
   pending_classes.Add(cls, Heap::kOld);
 
   // Initialize the base interfaces used by the core VM classes.
   const Script& script = Script::Handle(Bootstrap::LoadScript());
 
   // Allocate and initialize the Object class and type.  The Object
   // class and ByteArray subclasses are the only pre-allocated,
   // non-interface classes in the core library.
   cls = Class::New<Instance>();
   object_store->set_object_class(cls);
   cls.set_name(String::Handle(String::NewSymbol("Object")));
+  cls.set_user_visible_name(String::Handle(String::NewSymbol("Object")));
   cls.set_script(script);
   cls.set_is_prefinalized();
   core_lib.AddClass(cls);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_object_type(type);
 
   cls = Class::New<Int8Array>();
   object_store->set_int8_array_class(cls);
-  RegisterPrivateClass(cls, "_Int8Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Int8Array", "Int8List", script, core_lib);
 
   cls = Class::New<Uint8Array>();
   object_store->set_uint8_array_class(cls);
-  RegisterPrivateClass(cls, "_Uint8Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Uint8Array", "Uint8List", script, core_lib);
 
   cls = Class::New<Int16Array>();
   object_store->set_int16_array_class(cls);
-  RegisterPrivateClass(cls, "_Int16Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Int16Array", "Int16List", script, core_lib);
 
   cls = Class::New<Uint16Array>();
   object_store->set_uint16_array_class(cls);
-  RegisterPrivateClass(cls, "_Uint16Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Uint16Array", "Uint16List", script, core_lib);
 
   cls = Class::New<Int32Array>();
   object_store->set_int32_array_class(cls);
-  RegisterPrivateClass(cls, "_Int32Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Int32Array", "Int32List", script, core_lib);
 
   cls = Class::New<Uint32Array>();
   object_store->set_uint32_array_class(cls);
-  RegisterPrivateClass(cls, "_Uint32Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Uint32Array", "Uint32List", script, core_lib);
 
   cls = Class::New<Int64Array>();
   object_store->set_int64_array_class(cls);
-  RegisterPrivateClass(cls, "_Int64Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Int64Array", "Int64List", script, core_lib);
 
   cls = Class::New<Uint64Array>();
   object_store->set_uint64_array_class(cls);
-  RegisterPrivateClass(cls, "_Uint64Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Uint64Array", "Uint64List", script, core_lib);
 
   cls = Class::New<Float32Array>();
   object_store->set_float32_array_class(cls);
-  RegisterPrivateClass(cls, "_Float32Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Float32Array", "Float32List", script, core_lib);
 
   cls = Class::New<Float64Array>();
   object_store->set_float64_array_class(cls);
-  RegisterPrivateClass(cls, "_Float64Array", script, core_lib);
+  RegisterPrivateClass(cls, "_Float64Array", "Float64List", script, core_lib);
 
   cls = Class::New<ExternalInt8Array>();
   object_store->set_external_int8_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalInt8Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalInt8Array", "Int8List", script, core_lib);
 
   cls = Class::New<ExternalUint8Array>();
   object_store->set_external_uint8_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalUint8Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalUint8Array", "Uint8List",
+                       script, core_lib);
 
   cls = Class::New<ExternalInt16Array>();
   object_store->set_external_int16_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalInt16Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalInt16Array", "Int16List",
+                       script, core_lib);
 
   cls = Class::New<ExternalUint16Array>();
   object_store->set_external_uint16_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalUint16Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalUint16Array", "Uint16List",
+                       script, core_lib);
 
   cls = Class::New<ExternalInt32Array>();
   object_store->set_external_int32_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalInt32Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalInt32Array", "Int32List",
+                       script, core_lib);
 
   cls = Class::New<ExternalUint32Array>();
   object_store->set_external_uint32_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalUint32Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalUint32Array", "Uint32List",
+                       script, core_lib);
 
   cls = Class::New<ExternalInt64Array>();
   object_store->set_external_int64_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalInt64Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalInt64Array", "Int64List",
+                       script, core_lib);
 
   cls = Class::New<ExternalUint64Array>();
   object_store->set_external_uint64_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalUint64Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalUint64Array", "Uint64List",
+                       script, core_lib);
 
   cls = Class::New<ExternalFloat32Array>();
   object_store->set_external_float32_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalFloat32Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalFloat32Array", "Float32List",
+                       script, core_lib);
 
   cls = Class::New<ExternalFloat64Array>();
   object_store->set_external_float64_array_class(cls);
-  RegisterPrivateClass(cls, "_ExternalFloat64Array", script, core_lib);
+  RegisterPrivateClass(cls, "_ExternalFloat64Array", "Float64List",
+                       script, core_lib);
 
   // Set the super type of class Stacktrace to Object type so that the
   // 'toString' method is implemented.
   cls = object_store->stacktrace_class();
   cls.set_super_type(type);
 
   cls = CreateAndRegisterInterface("Function", script, core_lib);
   pending_classes.Add(cls, Heap::kOld);
   type = Type::NewNonParameterizedType(cls);
   object_store->set_function_interface(type);
@@ skipping 188 matching lines @@
 
   cls = Class::New<ExternalUint64Array>();
   object_store->set_external_uint64_array_class(cls);
 
   cls = Class::New<ExternalFloat32Array>();
   object_store->set_external_float32_array_class(cls);
 
   cls = Class::New<ExternalFloat64Array>();
   object_store->set_external_float64_array_class(cls);
 
+  cls = Class::New<Integer>();
+  object_store->set_integer_implementation_class(cls);
+
   cls = Class::New<Smi>();
   object_store->set_smi_class(cls);
 
   cls = Class::New<Mint>();
   object_store->set_mint_class(cls);
 
   cls = Class::New<Double>();
   object_store->set_double_class(cls);
 
   cls = Class::New<Bigint>();
@@ skipping 118 matching lines @@
 RawString* Class::Name() const {
   if (raw_ptr()->name_ != String::null()) {
     return raw_ptr()->name_;
   }
   ASSERT(class_class() != Class::null());  // class_class_ should be set up.
   intptr_t index = GetSingletonClassIndex(raw());
   return String::NewSymbol(GetSingletonClassName(index));
 }
 
 
+RawString* Class::UserVisibleName() const {
+  if (raw_ptr()->user_visible_name_ != String::null()) {
+    return raw_ptr()->user_visible_name_;
+  }
+  return Name();
+}
+
+
 RawType* Class::SignatureType() const {
   ASSERT(IsSignatureClass());
   const Function& function = Function::Handle(signature_function());
   ASSERT(!function.IsNull());
   if (function.signature_class() != raw()) {
     // This class is a function type alias. Return the canonical signature type.
     const Class& canonical_class = Class::Handle(function.signature_class());
     return canonical_class.SignatureType();
   }
   // Return the first canonical signature type if already computed.
@@ skipping 261 matching lines @@
                                              intptr_t token_pos) const {
   ASSERT(!type_name.IsNull());
   const TypeArguments& type_params = TypeArguments::Handle(type_parameters());
   if (!type_params.IsNull()) {
     intptr_t num_type_params = type_params.Length();
     TypeParameter& type_param = TypeParameter::Handle();
     String& type_param_name = String::Handle();
     AbstractType& bound = AbstractType::Handle();
     for (intptr_t i = 0; i < num_type_params; i++) {
       type_param ^= type_params.TypeAt(i);
-      type_param_name = type_param.Name();
+      type_param_name = type_param.name();
       if (type_param_name.Equals(type_name)) {
         intptr_t index = type_param.index();
         bound = type_param.bound();
         // Create a non-finalized new TypeParameter with the given token_pos.
         if (type_param.IsFinalized()) {
           // The index was adjusted during finalization. Revert.
           index -= NumTypeArguments() - num_type_params;
         } else {
           ASSERT(type_param.index() == i);
         }
@@ skipping 105 matching lines @@
   return result.raw();
 }
 
 
 template <class FakeInstance>
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
   Class& result = Class::Handle(New<FakeInstance>(kIllegalObjectKind));
   result.set_name(name);
+  result.set_user_visible_name(name);
   result.set_script(script);
   result.set_token_pos(token_pos);
   return result.raw();
 }
 
 
 RawClass* Class::New(const String& name,
                      const Script& script,
                      intptr_t token_pos) {
   Class& result = Class::Handle(New<Instance>(name, script, token_pos));
@@ skipping 63 matching lines @@
   const Array& new_canonical_types = Array::Handle(Array::New(1, Heap::kOld));
   new_canonical_types.SetAt(0, signature_type);
   result.set_canonical_types(new_canonical_types);
   return result.raw();
 }
 
 
 RawClass* Class::GetClass(ObjectKind kind) {
   ObjectStore* object_store = Isolate::Current()->object_store();
   switch (kind) {
+    case kInteger:
+      ASSERT(object_store->integer_implementation_class() != Class::null());
+      return object_store->integer_implementation_class();
     case kSmi:
       ASSERT(object_store->smi_class() != Class::null());
       return object_store->smi_class();
     case kMint:
       ASSERT(object_store->mint_class() != Class::null());
       return object_store->mint_class();
     case kBigint:
       ASSERT(object_store->bigint_class() != Class::null());
       return object_store->bigint_class();
     case kDouble:
@@ skipping 130 matching lines @@
   }
 }
 
 
 void Class::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
+void Class::set_user_visible_name(const String& value) const {
+  ASSERT(value.IsSymbol());
+  StorePointer(&raw_ptr()->user_visible_name_, value.raw());
+}
+
+
 void Class::set_script(const Script& value) const {
   StorePointer(&raw_ptr()->script_, value.raw());
 }
 
 
 void Class::set_token_pos(intptr_t token_pos) const {
   ASSERT(token_pos >= 0);
   raw_ptr()->token_pos_ = token_pos;
 }
 
@@ skipping 604 matching lines @@
 }
 
 
 RawAbstractType* AbstractType::Canonicalize() const {
   // AbstractType is an abstract class.
   UNREACHABLE();
   return NULL;
 }
 
 
-// TODO(regis): Investigate if we can safely map internal integer types (Smi,
-// Mint, and Bigint) to 'int' and internal String types (OneByteString, etc...)
-// to 'String' here. It may be too early. Also consider the upcoming type()
-// method.
-RawString* AbstractType::Name() const {
+RawString* AbstractType::BuildName(NameVisibility name_visibility) const {
+  if (IsTypeParameter()) {
+    return TypeParameter::Cast(*this).name();
+  }
   // If the type is still being finalized, we may be reporting an error about
-  // an illformed type, so proceed with caution.
+  // a malformed type, so proceed with caution.
   const AbstractTypeArguments& args =
       AbstractTypeArguments::Handle(arguments());
   const intptr_t num_args = args.IsNull() ? 0 : args.Length();
   String& class_name = String::Handle();
   intptr_t first_type_param_index;
   intptr_t num_type_params;  // Number of type parameters to print.
   if (HasResolvedTypeClass()) {
     const Class& cls = Class::Handle(type_class());
-    class_name = cls.Name();
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
+    if (name_visibility == kInternalName) {
+      class_name = cls.Name();
+    } else {
+      ASSERT(name_visibility == kUserVisibleName);
+      // Map internal types to their corresponding public interfaces.
+      class_name = cls.UserVisibleName();
+    }
     if (num_type_params > num_args) {
       first_type_param_index = 0;
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
-        // Most probably an illformed type. Do not fill up with "Dynamic",
+        // Most probably a malformed type. Do not fill up with "Dynamic",
         // but use actual vector.
         num_type_params = num_args;
       } else {
         ASSERT(num_args == 0);  // Type is raw.
         // No need to fill up with "Dynamic".
         num_type_params = 0;
       }
     } else {
       first_type_param_index = num_args - num_type_params;
     }
     if (cls.IsSignatureClass()) {
-      // We may be reporting an error about an illformed function type. In that
+      // We may be reporting an error about a malformed function type. In that
       // case, avoid instantiating the signature, since it may lead to cycles.
       if (!IsFinalized() || IsBeingFinalized() || IsMalformed()) {
         return class_name.raw();
       }
-      if (num_type_params > 0) {
+      // In order to avoid cycles, print the name of a typedef (non-canonical
+      // signature class) as a regular, possibly parameterized, class.
+      if (cls.IsCanonicalSignatureClass()) {
         const Function& signature_function = Function::Handle(
-            cls.signature_function());
+             cls.signature_function());
         // Signature classes have no super type.
         ASSERT(first_type_param_index == 0);
-        return signature_function.InstantiatedSignatureFrom(args);
+        return signature_function.InstantiatedSignatureFrom(args,
+                                                            name_visibility);
       }
     }
   } else {
     const UnresolvedClass& cls = UnresolvedClass::Handle(unresolved_class());
     class_name = cls.Name();
     num_type_params = num_args;
     first_type_param_index = 0;
   }
   String& type_name = String::Handle();
   if (num_type_params == 0) {
     type_name = class_name.raw();
   } else {
     const String& args_name = String::Handle(
-        args.SubvectorName(first_type_param_index, num_type_params));
+        args.SubvectorName(first_type_param_index,
+                           num_type_params,
+                           name_visibility));
     type_name = String::Concat(class_name, args_name);
   }
   // The name is only used for type checking and debugging purposes.
   // Unless profiling data shows otherwise, it is not worth caching the name in
   // the type.
   return String::NewSymbol(type_name);
 }
 
 
 RawString* AbstractType::ClassName() const {
@@ skipping 487 matching lines @@
   const TypeParameter& other_type_param = TypeParameter::Cast(other);
   if (IsFinalized() != other_type_param.IsFinalized()) {
     return false;
   }
   if (parameterized_class() != other_type_param.parameterized_class()) {
     return false;
   }
   if (index() != other_type_param.index()) {
     return false;
   }
-  const String& name = String::Handle(Name());
-  const String& other_type_param_name = String::Handle(other_type_param.Name());
-  return name.Equals(other_type_param_name);
+  const String& type_param_name = String::Handle(name());
+  const String& other_type_param_name = String::Handle(other_type_param.name());
+  return type_param_name.Equals(other_type_param_name);
 }
 
 
 bool TypeParameter::IsIdentical(const AbstractType& other,
                                 bool check_type_parameter_bound) const {
   if (raw() == other.raw()) {
     return true;
   }
   if (!other.IsTypeParameter()) {
     return false;
   }
   const TypeParameter& other_type_param = TypeParameter::Cast(other);
   // IsIdentical may be called on type parameters belonging to different
   // classes, e.g. to an interface and to its default factory class.
   // Therefore, both type parameters may have different parameterized classes
   // and different indices. Compare the type parameter names only, and their
   // bounds if requested.
-  String& name = String::Handle(Name());
-  String& other_name = String::Handle(other_type_param.Name());
-  if (!name.Equals(other_name)) {
+  String& type_param_name = String::Handle(name());
+  String& other_type_param_name = String::Handle(other_type_param.name());
+  if (!type_param_name.Equals(other_type_param_name)) {
     return false;
   }
   if (check_type_parameter_bound) {
     AbstractType& this_bound = AbstractType::Handle(bound());
     AbstractType& other_bound = AbstractType::Handle(other_type_param.bound());
     // Bounds are only checked at the top level.
     const bool check_type_parameter_bounds = false;
     if (!this_bound.IsIdentical(other_bound, check_type_parameter_bounds)) {
       return false;
     }
@@ skipping 120 matching lines @@
 }
 
 
 bool AbstractTypeArguments::IsUninstantiatedIdentity() const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
-RawString* AbstractTypeArguments::SubvectorName(intptr_t from_index,
-                                                intptr_t len) const {
+RawString* AbstractTypeArguments::SubvectorName(
+    intptr_t from_index,
+    intptr_t len,
+    NameVisibility name_visibility) const {
   ASSERT(from_index + len <= Length());
   String& name = String::Handle();
   const intptr_t num_strings = 2*len + 1;  // "<""T"", ""T"">".
   const Array& strings = Array::Handle(Array::New(num_strings));
   intptr_t s = 0;
   strings.SetAt(s++, String::Handle(String::NewSymbol("<")));
   const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
   AbstractType& type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(from_index + i);
-    name = type.Name();
+    name = type.BuildName(name_visibility);
     strings.SetAt(s++, name);
     if (i < len - 1) {
       strings.SetAt(s++, kCommaSpace);
     }
   }
   strings.SetAt(s++, String::Handle(String::NewSymbol(">")));
   ASSERT(s == num_strings);
   name = String::ConcatAll(strings);
   return String::NewSymbol(name);
 }
@@ skipping 145 matching lines @@
       if (bound.IsMalformed()) {
         malformed_bound_error = bound.malformed_error();
       } else if (!bound.IsInstantiated()) {
         bound = bound.InstantiateFrom(bounds_instantiator);
       }
       if (!malformed_bound_error.IsNull() ||
           !this_type_arg.IsSubtypeOf(bound, malformed_error)) {
         // Ignore this bound error if another malformed error was already
         // reported for this type test.
         if (malformed_error->IsNull()) {
-          const String& type_arg_name = String::Handle(this_type_arg.Name());
+          const String& type_arg_name =
+              String::Handle(this_type_arg.UserVisibleName());
           const String& class_name = String::Handle(cls.Name());
-          const String& bound_name = String::Handle(bound.Name());
+          const String& bound_name = String::Handle(bound.UserVisibleName());
           const Script& script = Script::Handle(cls.script());
           // Since the bound was canonicalized, its token index was lost,
           // therefore, use the token index of the corresponding type parameter.
           *malformed_error ^= FormatError(malformed_bound_error,
                                           script, cls_type_param.token_pos(),
                                           "type argument '%s' does not "
                                           "extend bound '%s' of '%s'\n",
                                           type_arg_name.ToCString(),
                                           bound_name.ToCString(),
                                           class_name.ToCString());
@@ skipping 886 matching lines @@
   }
   ASSERT(closure_function.signature_class() == signature_class.raw());
   set_implicit_closure_function(closure_function);
   ASSERT(closure_function.IsImplicitClosureFunction());
   return closure_function.raw();
 }
 
 
 RawString* Function::BuildSignature(
     bool instantiate,
+    NameVisibility name_visibility,
     const AbstractTypeArguments& instantiator) const {
   const GrowableObjectArray& pieces =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   const String& kCommaSpace = String::Handle(String::NewSymbol(", "));
   const String& kColonSpace = String::Handle(String::NewSymbol(": "));
   const String& kLParen = String::Handle(String::NewSymbol("("));
   const String& kRParen = String::Handle(String::NewSymbol(") => "));
   const String& kLBracket = String::Handle(String::NewSymbol("["));
   const String& kRBracket = String::Handle(String::NewSymbol("]"));
   String& name = String::Handle();
   if (!instantiate && !is_static()) {
+    // Prefix the signature with its type parameters, if any (e.g. "<K, V>").
+    // The signature of static functions cannot be type parameterized.
     const String& kSpaceExtendsSpace =
         String::Handle(String::NewSymbol(" extends "));
     const String& kLAngleBracket = String::Handle(String::NewSymbol("<"));
     const String& kRAngleBracket = String::Handle(String::NewSymbol(">"));
     const Class& function_class = Class::Handle(owner());
     ASSERT(!function_class.IsNull());
     const TypeArguments& type_parameters = TypeArguments::Handle(
         function_class.type_parameters());
     if (!type_parameters.IsNull()) {
       intptr_t num_type_parameters = type_parameters.Length();
       pieces.Add(kLAngleBracket);
       TypeParameter& type_parameter = TypeParameter::Handle();
       AbstractType& bound = AbstractType::Handle();
       for (intptr_t i = 0; i < num_type_parameters; i++) {
         type_parameter ^= type_parameters.TypeAt(i);
-        name = type_parameter.Name();
+        name = type_parameter.name();
         pieces.Add(name);
         bound = type_parameter.bound();
         if (!bound.IsNull() && !bound.IsDynamicType()) {
           pieces.Add(kSpaceExtendsSpace);
-          name = bound.Name();
+          name = bound.BuildName(name_visibility);
           pieces.Add(name);
         }
         if (i < num_type_parameters - 1) {
           pieces.Add(kCommaSpace);
         }
       }
       pieces.Add(kRAngleBracket);
     }
   }
   AbstractType& param_type = AbstractType::Handle();
   const intptr_t num_params = NumberOfParameters();
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   ASSERT((num_fixed_params + num_opt_params) == num_params);
   pieces.Add(kLParen);
   for (intptr_t i = 0; i < num_fixed_params; i++) {
     param_type = ParameterTypeAt(i);
     ASSERT(!param_type.IsNull());
     if (instantiate && !param_type.IsInstantiated()) {
       param_type = param_type.InstantiateFrom(instantiator);
     }
-    name = param_type.Name();
+    name = param_type.BuildName(name_visibility);
     pieces.Add(name);
     if (i != (num_params - 1)) {
       pieces.Add(kCommaSpace);
     }
   }
   if (num_opt_params > 0) {
     pieces.Add(kLBracket);
     for (intptr_t i = num_fixed_params; i < num_params; i++) {
       name = ParameterNameAt(i);
       pieces.Add(name);
       pieces.Add(kColonSpace);
       param_type = ParameterTypeAt(i);
       if (instantiate && !param_type.IsInstantiated()) {
         param_type = param_type.InstantiateFrom(instantiator);
       }
       ASSERT(!param_type.IsNull());
-      name = param_type.Name();
+      name = param_type.BuildName(name_visibility);
       pieces.Add(name);
       if (i != (num_params - 1)) {
         pieces.Add(kCommaSpace);
       }
     }
     pieces.Add(kRBracket);
   }
   pieces.Add(kRParen);
   AbstractType& res_type = AbstractType::Handle(result_type());
   if (instantiate && !res_type.IsInstantiated()) {
     res_type = res_type.InstantiateFrom(instantiator);
   }
-  name = res_type.Name();
+  name = res_type.BuildName(name_visibility);
   pieces.Add(name);
   const Array& strings = Array::Handle(Array::MakeArray(pieces));
   return String::NewSymbol(String::Handle(String::ConcatAll(strings)));
 }
 
 
 bool Function::HasInstantiatedSignature() const {
   AbstractType& type = AbstractType::Handle(result_type());
   if (!type.IsInstantiated()) {
     return false;
@@ skipping 6559 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart