Fix 2172: report 'int' instead of Smi, Mint and Bigint when throwing TypeError.

runtime/vm/code_generator.cc

 // Copyright (c) 2011, 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/code_index_table.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 395 matching lines @@
         String::New(malformed_error.ToErrorCString()));
     const String& no_name = String::Handle(String::NewSymbol(""));
     Exceptions::CreateAndThrowTypeError(
         location, no_name, no_name, no_name, malformed_error_message);
     UNREACHABLE();
   }
   arguments.SetReturn(result);
 }
 
 
+// For error reporting simplify type name, e.g, all integer types (Smi, Mint,
+// Bigint) a re reported as 'int'.
+static RawString* GetSimpleTypeName(const Instance& value) {
+  if (value.IsInteger()) {
+    return String::NewSymbol("int");
+  } 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: index of the token of the assignment (source location).
 // Arg1: instance being assigned.
 // Arg2: type being assigned to.
 // Arg3: type arguments of the instantiator of the type being assigned to.
 // Arg4: name of variable being assigned to.
 // Return value: instance if a subtype, otherwise throw a TypeError.
 DEFINE_RUNTIME_ENTRY(TypeCheck, 5) {
   ASSERT(arguments.Count() == kTypeCheckRuntimeEntry.argument_count());
@@ skipping 33 matching lines @@
                 String::Handle(dst_type.Name()).ToCString());
     }
     DartFrameIterator iterator;
     DartFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     const Function& function = Function::Handle(
         caller_frame->LookupDartFunction());
     OS::Print(" -> Function %s\n", function.ToFullyQualifiedCString());
   }
   if (!is_instance_of) {
-    const Type& src_type = Type::Handle(src_instance.GetType());
-    const String& src_type_name = String::Handle(src_type.Name());
+    String& src_type_name = String::Handle(GetSimpleTypeName(src_instance));
     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(dst_type_instantiator));
       dst_type_name = instantiated_dst_type.Name();
     } else {
       dst_type_name = dst_type.Name();
     }
     String& malformed_error_message =  String::Handle();
@@ skipping 14 matching lines @@
 // Arg1: bad object.
 // Return value: none, throws a TypeError.
 DEFINE_RUNTIME_ENTRY(ConditionTypeError, 2) {
   ASSERT(arguments.Count() ==
       kConditionTypeErrorRuntimeEntry.argument_count());
   // TODO(regis): Get the token index from the PcDesc (via DartFrame).
   intptr_t location = Smi::CheckedHandle(arguments.At(0)).Value();
   const Instance& src_instance = Instance::CheckedHandle(arguments.At(1));
   ASSERT(src_instance.IsNull() || !src_instance.IsBool());
   const Type& bool_interface = Type::Handle(Type::BoolInterface());
-  const Type& src_type = Type::Handle(src_instance.GetType());
-  const String& src_type_name = String::Handle(src_type.Name());
+  const String& src_type_name = String::Handle(GetSimpleTypeName(src_instance));
   const String& bool_type_name = String::Handle(bool_interface.Name());
   const String& expr = String::Handle(String::NewSymbol("boolean expression"));
   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: index of the token of the failed type check.
 // Arg1: src value.
 // Arg2: name of instance being assigned to.
 // Arg3: malformed type error message.
 // Return value: none, throws an exception.
 DEFINE_RUNTIME_ENTRY(MalformedTypeError, 4) {
   ASSERT(arguments.Count() ==
       kMalformedTypeErrorRuntimeEntry.argument_count());
   // TODO(regis): Get the token index from the PcDesc (via DartFrame).
   intptr_t location = Smi::CheckedHandle(arguments.At(0)).Value();
   const Instance& src_value = Instance::CheckedHandle(arguments.At(1));
   const String& dst_name = String::CheckedHandle(arguments.At(2));
   const String& malformed_error = String::CheckedHandle(arguments.At(3));
   const String& dst_type_name = String::Handle(String::NewSymbol("malformed"));
-  const String& src_type_name =
-      String::Handle(Type::Handle(src_value.GetType()).Name());
+  const String& src_type_name = String::Handle(GetSimpleTypeName(src_value));
   Exceptions::CreateAndThrowTypeError(location, src_type_name,
                                       dst_type_name, dst_name, malformed_error);
   UNREACHABLE();
 }
 
 
 // TODO(regis): Function rest arguments are not supported anymore, but they may
 // come back.
 // Check that the type of each element of the given array is assignable to the
 // given type.
@@ skipping 25 matching lines @@
     // The previous successful type check may have set malformed_error.
     // Note that a returned malformed_error is ignored if a type check succeeds.
     malformed_error = Error::null();
     if (!elem.IsNull() && !elem.IsInstanceOf(element_type,
                                              element_type_instantiator,
                                              &malformed_error)) {
       // Allocate and throw a new instance of TypeError.
       char buf[256];
       OS::SNPrint(buf, sizeof(buf), "%s[%d]",
                   rest_name.ToCString(), static_cast<int>(i));
-      const String& src_type_name =
-          String::Handle(Type::Handle(elem.GetType()).Name());
+      const String& src_type_name = String::Handle(GetSimpleTypeName(elem));
       String& dst_type_name = String::Handle();
       if (!element_type.IsInstantiated()) {
         // Instantiate element_type before reporting the error.
         const AbstractType& instantiated_element_type = AbstractType::Handle(
             element_type.InstantiateFrom(element_type_instantiator));
         dst_type_name = instantiated_element_type.Name();
       } else {
         dst_type_name = element_type.Name();
       }
       const String& dst_name = String::Handle(String::New(buf));
@@ skipping 849 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart