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

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 570 matching lines @@
     Exceptions::CreateAndThrowTypeError(
         location, no_name, no_name, no_name, malformed_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(node_id, instance, type, instantiator,
                       instantiator_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
 
-// For error reporting, simplify type name, e.g, all integer types (Smi, Mint,
-// Bigint) are reported as 'int' and all String types are mapped to 'String'.
-static RawString* GetSimpleTypeName(const Instance& value) {
-  if (value.IsInteger()) {
-    return String::NewSymbol("int");
-  } else if (value.IsString()) {
-    return String::NewSymbol("String");
-  } else {
-    return Type::Handle(value.GetType()).Name();
-  }
-}
-
-
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
 // Arg0: node-id of the assignment.
 // Arg1: instance being assigned.
 // Arg2: type being assigned to.
 // Arg3: instantiator (or null).
 // Arg4: type arguments of the instantiator of the type being assigned to.
 // Arg5: name of variable being assigned to.
 // Arg6: SubtypeTestCache.
 // Return value: instance if a subtype, otherwise throw a TypeError.
@@ skipping 17 matching lines @@
       dst_type, instantiator_type_arguments, &malformed_error);
 
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("TypeCheck",
         src_instance, dst_type, instantiator_type_arguments,
         Bool::Handle(is_instance_of ? Bool::True() : Bool::False()));
   }
   if (!is_instance_of) {
     // Throw a dynamic type error.
     const intptr_t location = GetCallerLocation();
-    String& src_type_name = String::Handle(GetSimpleTypeName(src_instance));
+    const AbstractType& src_type = AbstractType::Handle(src_instance.GetType());
+    const String& src_type_name = String::Handle(src_type.UserVisibleName());
     String& dst_type_name = String::Handle();
     if (!dst_type.IsInstantiated()) {
       // Instantiate dst_type before reporting the error.
       const AbstractType& instantiated_dst_type = AbstractType::Handle(
           dst_type.InstantiateFrom(instantiator_type_arguments));
-      dst_type_name = instantiated_dst_type.Name();
+      dst_type_name = instantiated_dst_type.UserVisibleName();
     } else {
-      dst_type_name = dst_type.Name();
+      dst_type_name = dst_type.UserVisibleName();
     }
     String& malformed_error_message =  String::Handle();
     if (!malformed_error.IsNull()) {
       ASSERT(FLAG_enable_type_checks);
       malformed_error_message = String::New(malformed_error.ToErrorCString());
     }
     Exceptions::CreateAndThrowTypeError(location, src_type_name, dst_type_name,
                                         dst_name, malformed_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(node_id, src_instance, dst_type,
                       dst_instantiator, instantiator_type_arguments,
                       Bool::ZoneHandle(Bool::True()), cache);
   arguments.SetReturn(src_instance);
 }
 
 
 // Report that the type of the given object is not bool in conditional context.
 // Arg0: bad object.
 // Return value: none, throws a TypeError.
 DEFINE_RUNTIME_ENTRY(ConditionTypeError, 1) {
   ASSERT(arguments.Count() ==
       kConditionTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_instance = Instance::CheckedHandle(arguments.At(0));
   ASSERT(src_instance.IsNull() || !src_instance.IsBool());
   const Type& bool_interface = Type::Handle(Type::BoolInterface());
-  const String& src_type_name = String::Handle(GetSimpleTypeName(src_instance));
-  const String& bool_type_name = String::Handle(bool_interface.Name());
+  const AbstractType& src_type = AbstractType::Handle(src_instance.GetType());
+  const String& src_type_name = String::Handle(src_type.UserVisibleName());
+  const String& bool_type_name =
+      String::Handle(bool_interface.UserVisibleName());
   const String& expr = String::Handle(String::NewSymbol("boolean expression"));
-  const String& no_malformed_type_error =  String::Handle();
+  const String& no_malformed_type_error = String::Handle();
   Exceptions::CreateAndThrowTypeError(location, src_type_name, bool_type_name,
                                       expr, no_malformed_type_error);
   UNREACHABLE();
 }
 
 
 // Report that the type of the type check is malformed.
 // Arg0: src value.
 // Arg1: name of instance being assigned to.
 // Arg2: malformed type error message.
 // Return value: none, throws an exception.
 DEFINE_RUNTIME_ENTRY(MalformedTypeError, 3) {
   ASSERT(arguments.Count() ==
       kMalformedTypeErrorRuntimeEntry.argument_count());
   const intptr_t location = GetCallerLocation();
   const Instance& src_value = Instance::CheckedHandle(arguments.At(0));
   const String& dst_name = String::CheckedHandle(arguments.At(1));
   const String& malformed_error = String::CheckedHandle(arguments.At(2));
   const String& dst_type_name = String::Handle(String::NewSymbol("malformed"));
-  const String& src_type_name = String::Handle(GetSimpleTypeName(src_value));
+  const AbstractType& src_type = AbstractType::Handle(src_value.GetType());
+  const String& src_type_name = String::Handle(src_type.UserVisibleName());
   Exceptions::CreateAndThrowTypeError(location, src_type_name,
                                       dst_type_name, dst_name, malformed_error);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
   ASSERT(arguments.Count() == kThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.At(0));
   Exceptions::Throw(exception);
@@ skipping 860 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart