Report use of malbounded interface in type test.

runtime/vm/code_generator.cc

 // 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.
 
 #include "vm/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/bigint_operations.h"
 #include "vm/code_patcher.h"
@@ skipping 166 matching lines @@
     ASSERT(type_arguments.IsNull() ||
            (type_arguments.IsInstantiated() &&
             (type_arguments.Length() >= cls.NumTypeArguments())));
   } else {
     // A still uninstantiated type argument vector must have the correct length.
     ASSERT(!type_arguments.IsInstantiated() &&
            (type_arguments.Length() == cls.NumTypeArguments()));
     const AbstractTypeArguments& instantiator =
         AbstractTypeArguments::CheckedHandle(arguments.ArgAt(2));
     ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
-    Error& malformed_error = Error::Handle();
+    Error& bound_error = Error::Handle();
     // Code inlined in the caller should have optimized the case where the
     // instantiator can be reused as type argument vector.
   ASSERT(instantiator.IsNull() || !type_arguments.IsUninstantiatedIdentity());
-    type_arguments = type_arguments.InstantiateFrom(instantiator,
-                                                    &malformed_error);
-    if (!malformed_error.IsNull()) {
+    type_arguments = type_arguments.InstantiateFrom(instantiator, &bound_error);
+    if (!bound_error.IsNull()) {
       // Throw a dynamic type error.
       const intptr_t location = GetCallerLocation();
-      String& malformed_error_message =  String::Handle(
-          String::New(malformed_error.ToErrorCString()));
+      String& bound_error_message =  String::Handle(
+          String::New(bound_error.ToErrorCString()));
       Exceptions::CreateAndThrowTypeError(
           location, Symbols::Empty(), Symbols::Empty(),
-          Symbols::Empty(), malformed_error_message);
+          Symbols::Empty(), bound_error_message);
       UNREACHABLE();
     }
   }
   ASSERT(type_arguments.IsNull() || type_arguments.IsInstantiated());
   instance.SetTypeArguments(type_arguments);
 }
 
 
 // Instantiate type.
 // Arg0: uninstantiated type.
 // Arg1: instantiator type arguments.
 // Return value: instantiated type.
 DEFINE_RUNTIME_ENTRY(InstantiateType, 2) {
   AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(0));
   const AbstractTypeArguments& instantiator =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(1));
   ASSERT(!type.IsNull() && !type.IsInstantiated());
   ASSERT(instantiator.IsNull() || instantiator.IsInstantiated());
-  Error& malformed_error = Error::Handle();
-  type = type.InstantiateFrom(instantiator, &malformed_error);
-  if (!malformed_error.IsNull()) {
+  Error& bound_error = Error::Handle();
+  type = type.InstantiateFrom(instantiator, &bound_error);
+  if (!bound_error.IsNull()) {
     // Throw a dynamic type error.
     const intptr_t location = GetCallerLocation();
-    String& malformed_error_message =  String::Handle(
-        String::New(malformed_error.ToErrorCString()));
+    String& bound_error_message =  String::Handle(
+        String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(
         location, Symbols::Empty(), Symbols::Empty(),
-        Symbols::Empty(), malformed_error_message);
+        Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   ASSERT(!type.IsNull() && type.IsInstantiated());
   arguments.SetReturn(type);
 }
 
 
 // Instantiate type arguments.
 // Arg0: uninstantiated type arguments.
 // Arg1: instantiator type arguments.
@@ skipping 100 matching lines @@
     OS::PrintErr("%s: '%s' %" Pd " %s '%s' %" Pd " (pc: %#" Px ").\n",
                  message,
                  String::Handle(instance_type.Name()).ToCString(),
                  Class::Handle(instance_type.type_class()).id(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(type.Name()).ToCString(),
                  Class::Handle(type.type_class()).id(),
                  caller_frame->pc());
   } else {
     // Instantiate type before printing.
-    Error& malformed_error = Error::Handle();
+    Error& bound_error = Error::Handle();
     const AbstractType& instantiated_type = AbstractType::Handle(
-        type.InstantiateFrom(instantiator_type_arguments, &malformed_error));
+        type.InstantiateFrom(instantiator_type_arguments, &bound_error));
     OS::PrintErr("%s: '%s' %s '%s' instantiated from '%s' (pc: %#" Px ").\n",
                  message,
                  String::Handle(instance_type.Name()).ToCString(),
                  (result.raw() == Bool::True().raw()) ? "is" : "is !",
                  String::Handle(instantiated_type.Name()).ToCString(),
                  String::Handle(type.Name()).ToCString(),
                  caller_frame->pc());
-    if (!malformed_error.IsNull()) {
-      OS::Print("  malformed error: %s\n", malformed_error.ToErrorCString());
+    if (!bound_error.IsNull()) {
+      OS::Print("  bound error: %s\n", bound_error.ToErrorCString());
     }
   }
   const Function& function = Function::Handle(
       caller_frame->LookupDartFunction());
   OS::PrintErr(" -> Function %s\n", function.ToFullyQualifiedCString());
 }
 
 
 // Converts InstantiatedTypeArguments to TypeArguments and stores it
 // into the instance. The assembly code can handle only type arguments of
@@ skipping 12 matching lines @@
   bool replaced = false;
   if (type_arguments.IsInstantiatedTypeArguments()) {
     AbstractTypeArguments& uninstantiated = AbstractTypeArguments::Handle();
     AbstractTypeArguments& instantiator = AbstractTypeArguments::Handle();
     do {
       const InstantiatedTypeArguments& instantiated_type_arguments =
           InstantiatedTypeArguments::Cast(type_arguments);
       uninstantiated =
           instantiated_type_arguments.uninstantiated_type_arguments();
       instantiator = instantiated_type_arguments.instantiator_type_arguments();
-      Error& malformed_error = Error::Handle();
+      Error& bound_error = Error::Handle();
       type_arguments = uninstantiated.InstantiateFrom(instantiator,
-                                                      &malformed_error);
-      ASSERT(malformed_error.IsNull());  // Malformed types are not optimized.
+                                                      &bound_error);
+      ASSERT(bound_error.IsNull());  // Malbounded types are not optimized.
     } while (type_arguments.IsInstantiatedTypeArguments());
     AbstractTypeArguments& new_type_arguments = AbstractTypeArguments::Handle();
     new_type_arguments = type_arguments.Canonicalize();
     instance.SetTypeArguments(new_type_arguments);
     replaced = true;
   } else if (!type_arguments.IsCanonical()) {
     AbstractTypeArguments& new_type_arguments = AbstractTypeArguments::Handle();
     new_type_arguments = type_arguments.Canonicalize();
     instance.SetTypeArguments(new_type_arguments);
     replaced = true;
@@ skipping 82 matching lines @@
   }
   if (!instantiator_type_arguments.IsInstantiatedTypeArguments()) {
     new_cache.AddCheck(instance_class.id(),
                        instance_type_arguments,
                        instantiator_type_arguments,
                        result);
   }
   if (FLAG_trace_type_checks) {
     AbstractType& test_type = AbstractType::Handle(type.raw());
     if (!test_type.IsInstantiated()) {
-      Error& malformed_error = Error::Handle();
+      Error& bound_error = Error::Handle();
       test_type = type.InstantiateFrom(instantiator_type_arguments,
-                                       &malformed_error);
-      ASSERT(malformed_error.IsNull());  // Malformed types are not optimized.
+                                       &bound_error);
+      ASSERT(bound_error.IsNull());  // Malbounded types are not optimized.
     }
     OS::PrintErr("  Updated test cache %p ix: %" Pd " with "
         "(cid: %" Pd ", type-args: %p, instantiator: %p, result: %s)\n"
         "    instance  [class: (%p '%s' cid: %" Pd "),    type-args: %p %s]\n"
         "    test-type [class: (%p '%s' cid: %" Pd "), in-type-args: %p %s]\n",
         new_cache.raw(),
         len,
 
         instance_class.id(),
         instance_type_arguments.raw(),
@@ skipping 26 matching lines @@
 // Return value: true or false, or may throw a type error in checked mode.
 DEFINE_RUNTIME_ENTRY(Instanceof, 5) {
   const Instance& instance = Instance::CheckedHandle(arguments.ArgAt(0));
   const AbstractType& type = AbstractType::CheckedHandle(arguments.ArgAt(1));
   const Instance& instantiator = Instance::CheckedHandle(arguments.ArgAt(2));
   const AbstractTypeArguments& instantiator_type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(arguments.ArgAt(4));
   ASSERT(type.IsFinalized());
-  Error& malformed_error = Error::Handle();
+  Error& bound_error = Error::Handle();
   const Bool& result =
       Bool::Get(instance.IsInstanceOf(type,
                                       instantiator_type_arguments,
-                                      &malformed_error));
+                                      &bound_error));
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("InstanceOf",
         instance, type, instantiator_type_arguments, result);
   }
-  if (!result.value() && !malformed_error.IsNull()) {
+  if (!result.value() && !bound_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     const intptr_t location = GetCallerLocation();
-    String& malformed_error_message =  String::Handle(
-        String::New(malformed_error.ToErrorCString()));
+    String& bound_error_message =  String::Handle(
+        String::New(bound_error.ToErrorCString()));
     Exceptions::CreateAndThrowTypeError(
         location, Symbols::Empty(), Symbols::Empty(),
-        Symbols::Empty(), malformed_error_message);
+        Symbols::Empty(), bound_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(instance, type, instantiator,
                       instantiator_type_arguments, result, cache);
   arguments.SetReturn(result);
 }
 
 
 // Check that the type of the given instance is a subtype of the given type and
 // can therefore be assigned.
@@ skipping 13 matching lines @@
   const AbstractTypeArguments& instantiator_type_arguments =
       AbstractTypeArguments::CheckedHandle(arguments.ArgAt(3));
   const String& dst_name = String::CheckedHandle(arguments.ArgAt(4));
   const SubtypeTestCache& cache =
       SubtypeTestCache::CheckedHandle(arguments.ArgAt(5));
   ASSERT(!dst_type.IsDynamicType());  // No need to check assignment.
   ASSERT(!dst_type.IsMalformed());  // Already checked in code generator.
   ASSERT(!dst_type.IsMalbounded());  // Already checked in code generator.
   ASSERT(!src_instance.IsNull());  // Already checked in inlined code.
 
-  Error& malformed_error = Error::Handle();
+  Error& bound_error = Error::Handle();
   const bool is_instance_of = src_instance.IsInstanceOf(
-      dst_type, instantiator_type_arguments, &malformed_error);
+      dst_type, instantiator_type_arguments, &bound_error);
 
   if (FLAG_trace_type_checks) {
     PrintTypeCheck("TypeCheck",
                    src_instance, dst_type, instantiator_type_arguments,
                    Bool::Get(is_instance_of));
   }
   if (!is_instance_of) {
     // Throw a dynamic type error.
     const intptr_t location = GetCallerLocation();
     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, NULL));
-      // Note that instantiated_dst_type may be malformed.
+      // Note that instantiated_dst_type may be malbounded.
       dst_type_name = instantiated_dst_type.UserVisibleName();
     } else {
       dst_type_name = dst_type.UserVisibleName();
     }
-    String& malformed_error_message =  String::Handle();
-    if (!malformed_error.IsNull()) {
+    String& bound_error_message =  String::Handle();
+    if (!bound_error.IsNull()) {
       ASSERT(FLAG_enable_type_checks);
-      malformed_error_message = String::New(malformed_error.ToErrorCString());
+      bound_error_message = String::New(bound_error.ToErrorCString());
     }
     Exceptions::CreateAndThrowTypeError(location, src_type_name, dst_type_name,
-                                        dst_name, malformed_error_message);
+                                        dst_name, bound_error_message);
     UNREACHABLE();
   }
   UpdateTypeTestCache(src_instance, dst_type,
                       dst_instantiator, instantiator_type_arguments,
                       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) {
   const intptr_t location = GetCallerLocation();
   const Instance& src_instance = Instance::CheckedHandle(arguments.ArgAt(0));
   ASSERT(src_instance.IsNull() || !src_instance.IsBool());
   const Type& bool_interface = Type::Handle(Type::BoolType());
   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& no_malformed_type_error = String::Handle();
+  const String& no_bound_error = String::Handle();
   Exceptions::CreateAndThrowTypeError(location, src_type_name, bool_type_name,
                                       Symbols::BooleanExpression(),
-                                      no_malformed_type_error);
+                                      no_bound_error);
   UNREACHABLE();
 }
 
 
+// TODO(regis): Is this entry still used for malformed types or just malbounded
+// types? Revisit.
 // 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) {
   const intptr_t location = GetCallerLocation();
   const Instance& src_value = Instance::CheckedHandle(arguments.ArgAt(0));
   const String& dst_name = String::CheckedHandle(arguments.ArgAt(1));
-  const String& malformed_error = String::CheckedHandle(arguments.ArgAt(2));
+  const String& bound_error = String::CheckedHandle(arguments.ArgAt(2));
   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,
                                       Symbols::Malformed(),
-                                      dst_name, malformed_error);
+                                      dst_name, bound_error);
   UNREACHABLE();
 }
 
 
 DEFINE_RUNTIME_ENTRY(Throw, 1) {
   const Instance& exception = Instance::CheckedHandle(arguments.ArgAt(0));
   Exceptions::Throw(exception);
 }
 
 
@@ skipping 1018 matching lines @@
   field.UpdateCid(cid);
   intptr_t list_length = Field::kNoFixedLength;
   if ((field.guarded_cid() != kDynamicCid) &&
       field.is_final() && RawObject::IsBuiltinListClassId(cid)) {
     list_length = GetListLength(value);
   }
   field.UpdateLength(list_length);
 }
 
 }  // namespace dart