Generate dynamic type errors according to spec.

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 1395 matching lines @@
 
 bool Class::IsCanonicalSignatureClass() const {
   const Function& function = Function::Handle(signature_function());
   return (!function.IsNull() && (function.signature_class() == raw()));
 }
 
 
 bool Class::IsMoreSpecificThan(
     const AbstractTypeArguments& type_arguments,
     const Class& other,
-    const AbstractTypeArguments& other_type_arguments) const {
+    const AbstractTypeArguments& other_type_arguments,
+    Error* malformed_error) const {
   // Check for DynamicType.
   // The DynamicType on the lefthand side is replaced by the bottom type, which
   // is more specific than any type.
   // Any type is more specific than the DynamicType on the righthand side.
   if (IsDynamicClass() || other.IsDynamicClass()) {
     return true;
   }
   // Check for reflexivity.
   if (raw() == other.raw()) {
     const intptr_t len = NumTypeArguments();
     if (len == 0) {
       return true;
     }
     // Since we do not truncate the type argument vector of a subclass (see
     // below), we only check a prefix of the proper length.
     // Check for covariance.
     if (type_arguments.IsNull() ||
         other_type_arguments.IsNull() ||
         type_arguments.IsDynamicTypes(len) ||
         other_type_arguments.IsDynamicTypes(len)) {
       return true;
     }
-    return type_arguments.IsMoreSpecificThan(other_type_arguments, len);
+    return type_arguments.IsMoreSpecificThan(other_type_arguments,
+                                             len,
+                                             malformed_error);
   }
   // Check for two function types.
   if (IsSignatureClass() && other.IsSignatureClass()) {
     const Function& fun = Function::Handle(signature_function());
     const Function& other_fun = Function::Handle(other.signature_function());
     return fun.IsSubtypeOf(type_arguments,
                            other_fun,
-                           other_type_arguments);
+                           other_type_arguments,
+                           malformed_error);
   }
   // Check for 'direct super type' in the case of an interface and check for
   // transitivity at the same time.
   if (other.is_interface()) {
     Array& interfaces = Array::Handle(this->interfaces());
     AbstractType& interface = AbstractType::Handle();
     Class& interface_class = Class::Handle();
     AbstractTypeArguments& interface_args = AbstractTypeArguments::Handle();
     for (intptr_t i = 0; i < interfaces.Length(); i++) {
       interface ^= interfaces.At(i);
       interface_class = interface.type_class();
       interface_args = interface.arguments();
       if (!interface_args.IsNull() && !interface_args.IsInstantiated()) {
         // This type class implements an interface that is parameterized with
         // generic type(s), e.g. it implements List<T>.
         // The uninstantiated type T must be instantiated using the type
         // parameters of this type before performing the type test.
         // The type arguments of this type that are referred to by the type
         // parameters of the interface are at the end of the type vector,
         // after the type arguments of the super type of this type.
         // The index of the type parameters is adjusted upon finalization.
         ASSERT(interface.IsFinalized());
         interface_args = interface_args.InstantiateFrom(type_arguments);
         // In checked mode, verify that the instantiated interface type
         // arguments are within the bounds specified by the interface class.
         // Note that the additional bounds check in checked mode may lead to a
         // dynamic type error, but it will never change the result of the type
         // check from true in production mode to false in checked mode.
         if (FLAG_enable_type_checks && !interface_args.IsNull()) {
-          AbstractTypeArguments& interface_bounds =
-              AbstractTypeArguments::Handle(
-                  interface_class.type_parameter_bounds());
-          ASSERT(!interface_bounds.IsNull());
-          if (!interface_bounds.IsInstantiated()) {
-            interface_bounds = interface_bounds.InstantiateFrom(type_arguments);
-          }
-          const intptr_t len = interface_args.Length();
-          if (!interface_args.IsMoreSpecificThan(interface_bounds, len)) {
-            // TODO(regis): Handle malformed type error.
+          // Pass type_arguments as bounds instantiator.
+          if (!interface_args.IsWithinBoundsOf(interface_class,
+                                               type_arguments,
+                                               malformed_error)) {
             continue;
           }
         }
       }
       if (interface_class.IsMoreSpecificThan(interface_args,
                                              other,
-                                             other_type_arguments)) {
+                                             other_type_arguments,
+                                             malformed_error)) {
         return true;
       }
     }
   }
   // Check the interface case.
   if (is_interface()) {
     // We already checked the case where 'other' is an interface. Now, 'this',
     // an interface, cannot be more specific than a class, except class Object,
     // because although Object is not considered an interface by the vm, it is
     // one. In other words, all classes implementing this interface also extend
     // class Object. An interface is also more specific than the DynamicType.
     return (other.IsDynamicClass() || other.IsObjectClass());
   }
   const Class& super_class = Class::Handle(SuperClass());
   if (super_class.IsNull()) {
     return false;
   }
   // Instead of truncating the type argument vector to the length of the super
   // type argument vector, we make sure that the code works with a vector that
   // is longer than necessary.
   return super_class.IsMoreSpecificThan(type_arguments,
                                         other,
-                                        other_type_arguments);
+                                        other_type_arguments,
+                                        malformed_error);
 }
 
 
 bool Class::IsTopLevel() const {
   return String::Handle(Name()).Equals("::");
 }
 
 
 bool Class::TestType(TypeTestKind test,
                      const AbstractTypeArguments& type_arguments,
                      const Class& other,
-                     const AbstractTypeArguments& other_type_arguments) const {
+                     const AbstractTypeArguments& other_type_arguments,
+                     Error* malformed_error) const {
   ASSERT(is_finalized() || !ClassFinalizer::AllClassesFinalized());
   ASSERT(other.is_finalized() || !ClassFinalizer::AllClassesFinalized());
   if (test == kIsAssignableTo) {
     // The spec states that "a type T is assignable to a type S if T is a
     // subtype of S or S is a subtype of T". This is from the perspective of a
     // static checker, which does not know the actual type of the assigned
     // value. However, this type information is available at run time in checked
     // mode. We therefore apply a more restrictive subtype check, which prevents
     // heap pollution. We only keep the assignability check when assigning
     // values of a function type.
     if (IsSignatureClass() && other.IsSignatureClass()) {
       const Function& src_fun = Function::Handle(signature_function());
       const Function& dst_fun = Function::Handle(other.signature_function());
       return src_fun.IsAssignableTo(type_arguments,
                                     dst_fun,
-                                    other_type_arguments);
+                                    other_type_arguments,
+                                    malformed_error);
     }
     // Continue with a subtype test.
     test = kIsSubtypeOf;
   }
   ASSERT(test == kIsSubtypeOf);
 
   // Check for "more specific" relation.
-  return IsMoreSpecificThan(type_arguments, other, other_type_arguments);
+  return IsMoreSpecificThan(type_arguments, other, other_type_arguments,
+                            malformed_error);
 }
 
 
 RawFunction* Class::LookupDynamicFunction(const String& name) const {
   Function& function = Function::Handle(LookupFunction(name));
   if (function.IsNull() || !function.IsDynamicFunction()) {
     return Function::null();
   }
   return function.raw();
 }
@@ skipping 536 matching lines @@
       (type_class() == Type::Handle(Type::FunctionInterface()).type_class());
 }
 
 
 bool AbstractType::IsListInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::ListInterface()).type_class());
 }
 
 
-bool AbstractType::IsMoreSpecificThan(const AbstractType& other) const {
+bool AbstractType::IsMoreSpecificThan(const AbstractType& other,
+                                      Error* malformed_error) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // AbstractType parameters cannot be handled by Class::IsMoreSpecificThan().
   if (IsTypeParameter() || other.IsTypeParameter()) {
     return IsTypeParameter() && other.IsTypeParameter() &&
         (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
   return cls.IsMoreSpecificThan(
       AbstractTypeArguments::Handle(arguments()),
       Class::Handle(other.type_class()),
-      AbstractTypeArguments::Handle(other.arguments()));
+      AbstractTypeArguments::Handle(other.arguments()),
+      malformed_error);
 }
 
 
-bool AbstractType::Test(TypeTestKind test, const AbstractType& other) const {
+bool AbstractType::Test(TypeTestKind test,
+                        const AbstractType& other,
+                        Error* malformed_error) const {
   ASSERT(IsFinalized());
   ASSERT(other.IsFinalized());
   // AbstractType parameters cannot be handled by Class::TestType().
   if (IsTypeParameter() || other.IsTypeParameter()) {
     return IsTypeParameter() && other.IsTypeParameter() &&
         (Index() == other.Index());
   }
   const Class& cls = Class::Handle(type_class());
   if (test == kIsSubtypeOf) {
     return cls.IsSubtypeOf(AbstractTypeArguments::Handle(arguments()),
-                            Class::Handle(other.type_class()),
-                            AbstractTypeArguments::Handle(other.arguments()));
+                           Class::Handle(other.type_class()),
+                           AbstractTypeArguments::Handle(other.arguments()),
+                           malformed_error);
   } else {
     ASSERT(test == kIsAssignableTo);
     return cls.IsAssignableTo(AbstractTypeArguments::Handle(arguments()),
                               Class::Handle(other.type_class()),
-                              AbstractTypeArguments::Handle(other.arguments()));
+                              AbstractTypeArguments::Handle(other.arguments()),
+                              malformed_error);
   }
 }
 
 RawAbstractType* AbstractType::NewTypeParameter(
     intptr_t index, const String& name, intptr_t token_index) {
   return TypeParameter::New(index, name, token_index);
 }
 
 
 RawAbstractType* AbstractType::NewInstantiatedType(
@@ skipping 570 matching lines @@
     }
     type_class = type.type_class();
     if (!type_class.IsDynamicClass()) {
       return false;
     }
   }
   return true;
 }
 
 
+static RawError* FormatError(const Script& script,
+                             intptr_t token_index,
+                             const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  return Parser::FormatError(script, token_index, "Error", format, args);
+}
+
+
+bool AbstractTypeArguments::IsWithinBoundsOf(
+    const Class& cls,
+    const AbstractTypeArguments& bounds_instantiator,
+    Error* malformed_error) const {
+  ASSERT(FLAG_enable_type_checks);
+  ASSERT(IsInstantiated());
+  ASSERT(Length() >= cls.NumTypeArguments());
+  const intptr_t num_type_params = cls.NumTypeParameters();
+  const intptr_t offset = cls.NumTypeArguments() - num_type_params;
+  AbstractType& type = AbstractType::Handle();
+  AbstractType& bound = AbstractType::Handle();
+  const TypeArguments& bounds =
+      TypeArguments::Handle(cls.type_parameter_bounds());
+  ASSERT((bounds.IsNull() && (num_type_params == 0)) ||
+         (bounds.Length() == num_type_params));
+  for (intptr_t i = 0; i < num_type_params; i++) {
+    bound = bounds.TypeAt(i);
+    if (!bound.IsDynamicType()) {
+      type = TypeAt(offset + i);
+      if (!bound.IsInstantiated()) {
+        bound = bound.InstantiateFrom(bounds_instantiator);
+      }
+      if (!type.IsSubtypeOf(bound, malformed_error)) {
+        if (malformed_error->IsNull()) {
+          const String& type_argument_name = String::Handle(type.Name());
+          const String& class_name = String::Handle(cls.Name());
+          const String& bound_name = String::Handle(bound.Name());
+          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.
+          const TypeArguments& type_parameters =
+              TypeArguments::Handle(cls.type_parameters());
+          type = type_parameters.TypeAt(i);
+          *malformed_error ^= FormatError(script, type.token_index(),
+                                          "type argument '%s' does not "
+                                          "extend bound '%s' of '%s'\n",
+                                          type_argument_name.ToCString(),
+                                          bound_name.ToCString(),
+                                          class_name.ToCString());
+        }
+        return false;
+      }
+    }
+  }
+  const Type& super_type = Type::Handle(cls.super_type());
+  if (!super_type.IsNull()) {
+    ASSERT(super_type.IsFinalized());
+    const Class& super_class = Class::Handle(super_type.type_class());
+    if (!IsWithinBoundsOf(super_class, bounds_instantiator, malformed_error)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+
 bool AbstractTypeArguments::IsMoreSpecificThan(
     const AbstractTypeArguments& other,
-    intptr_t len) const {
+    intptr_t len,
+    Error* malformed_error) const {
   ASSERT(Length() >= len);
   ASSERT(!other.IsNull());
   ASSERT(other.Length() >= len);
   AbstractType& type = AbstractType::Handle();
   AbstractType& other_type = AbstractType::Handle();
   for (intptr_t i = 0; i < len; i++) {
     type = TypeAt(i);
     ASSERT(!type.IsNull());
     other_type = other.TypeAt(i);
     ASSERT(!other_type.IsNull());
-    if (!type.IsMoreSpecificThan(other_type)) {
+    if (!type.IsMoreSpecificThan(other_type, malformed_error)) {
       return false;
     }
   }
   return true;
 }
 
 
 const char* AbstractTypeArguments::ToCString() const {
   // AbstractTypeArguments is an abstract class.
   UNREACHABLE();
@@ skipping 529 matching lines @@
     }
   }
   return true;
 }
 
 
 bool Function::TestParameterType(
     intptr_t parameter_position,
     const AbstractTypeArguments& type_arguments,
     const Function& other,
-    const AbstractTypeArguments& other_type_arguments) const {
+    const AbstractTypeArguments& other_type_arguments,
+    Error* malformed_error) const {
   AbstractType& param_type =
       AbstractType::Handle(ParameterTypeAt(parameter_position));
   if (!param_type.IsInstantiated()) {
     param_type = param_type.InstantiateFrom(type_arguments);
   }
   if (param_type.IsDynamicType()) {
     return true;
   }
   AbstractType& other_param_type =
       AbstractType::Handle(other.ParameterTypeAt(parameter_position));
   if (!other_param_type.IsInstantiated()) {
     other_param_type = other_param_type.InstantiateFrom(other_type_arguments);
   }
   if (other_param_type.IsDynamicType()) {
     return true;
   }
-  if (!param_type.IsSubtypeOf(other_param_type) &&
-      !other_param_type.IsSubtypeOf(param_type)) {
+  if (!param_type.IsSubtypeOf(other_param_type, malformed_error) &&
+      !other_param_type.IsSubtypeOf(param_type, malformed_error)) {
     return false;
   }
   return true;
 }
 
 
 bool Function::TestType(
     TypeTestKind test,
     const AbstractTypeArguments& type_arguments,
     const Function& other,
-    const AbstractTypeArguments& other_type_arguments) const {
+    const AbstractTypeArguments& other_type_arguments,
+    Error* malformed_error) const {
   const intptr_t num_fixed_params = num_fixed_parameters();
   const intptr_t num_opt_params = num_optional_parameters();
   const intptr_t other_num_fixed_params = other.num_fixed_parameters();
   const intptr_t other_num_opt_params = other.num_optional_parameters();
   if ((num_fixed_params != other_num_fixed_params) ||
       ((test == AbstractType::kIsSubtypeOf) &&
        (num_opt_params < other_num_opt_params))) {
     return false;
   }
   // Check the result type.
   AbstractType& other_res_type = AbstractType::Handle(other.result_type());
   if (!other_res_type.IsInstantiated()) {
     other_res_type = other_res_type.InstantiateFrom(other_type_arguments);
   }
   if (!other_res_type.IsDynamicType() && !other_res_type.IsVoidType()) {
     AbstractType& res_type = AbstractType::Handle(result_type());
     if (!res_type.IsInstantiated()) {
       res_type = res_type.InstantiateFrom(type_arguments);
     }
     if (!res_type.IsDynamicType() &&
         (res_type.IsVoidType() ||
-         !(res_type.IsSubtypeOf(other_res_type) ||
-           other_res_type.IsSubtypeOf(res_type)))) {
+         !(res_type.IsSubtypeOf(other_res_type, malformed_error) ||
+           other_res_type.IsSubtypeOf(res_type, malformed_error)))) {
       return false;
     }
   }
   // Check the types of fixed parameters.
   for (intptr_t i = 0; i < num_fixed_params; i++) {
-    if (!TestParameterType(i, type_arguments, other, other_type_arguments)) {
+    if (!TestParameterType(i, type_arguments, other, other_type_arguments,
+                           malformed_error)) {
       return false;
     }
   }
   // Check the names and types of optional parameters.
   if (num_opt_params >= other_num_opt_params) {
     // Check that for each optional named parameter of type T of the other
     // function type, there is a corresponding optional named parameter of this
     // function at the same position with an identical name and with a type S
     // that is a subtype or supertype of T.
     // Note that SetParameterNameAt() guarantees that names are symbols, so we
     // can compare their raw pointers.
     const intptr_t other_num_params =
         other_num_fixed_params + other_num_opt_params;
     String& other_param_name = String::Handle();
     for (intptr_t i = other_num_fixed_params; i < other_num_params; i++) {
       other_param_name = other.ParameterNameAt(i);
       if ((ParameterNameAt(i) != other_param_name.raw()) ||
-          !TestParameterType(i, type_arguments, other, other_type_arguments)) {
+          !TestParameterType(i, type_arguments, other, other_type_arguments,
+                             malformed_error)) {
         return false;
       }
     }
     return true;
   }
   ASSERT((test == AbstractType::kIsAssignableTo) &&
          (num_opt_params < other_num_opt_params));
   // To verify that this function type is assignable to the other function type,
   // check that for each optional named parameter of type T of this function
   // type, there is a corresponding optional named parameter of the other
   // function at the same position with an identical name and with a type S that
   // is a subtype or supertype of T.
   // Note that SetParameterNameAt() guarantees that names are symbols, so we
   // can compare their raw pointers.
   const intptr_t num_params = num_fixed_params + num_opt_params;
   String& other_param_name = String::Handle();
   for (intptr_t i = num_fixed_params; i < num_params; i++) {
     other_param_name = other.ParameterNameAt(i);
     if ((ParameterNameAt(i) != other_param_name.raw()) ||
-        !TestParameterType(i, type_arguments, other, other_type_arguments)) {
+        !TestParameterType(i, type_arguments, other, other_type_arguments,
+                           malformed_error)) {
       return false;
     }
   }
   return true;
 }
 
 
 bool Function::IsImplicitClosureFunction() const {
   if (!IsClosureFunction()) {
     return false;
@@ skipping 2546 matching lines @@
 void Instance::SetTypeArguments(const AbstractTypeArguments& value) const {
   const Class& cls = Class::Handle(clazz());
   intptr_t field_offset = cls.type_arguments_instance_field_offset();
   ASSERT(field_offset != Class::kNoTypeArguments);
   *FieldAddrAtOffset(field_offset) = value.Canonicalize();
 }
 
 
 bool Instance::TestType(TypeTestKind test,
                         const AbstractType& other,
-                        const AbstractTypeArguments& other_instantiator) const {
+                        const AbstractTypeArguments& other_instantiator,
+                        Error* malformed_error) const {
   ASSERT(other.IsFinalized());
   ASSERT(!other.IsDynamicType());
   ASSERT(!other.IsVoidType());
   if (IsNull()) {
     if (test == AbstractType::kIsSubtypeOf) {
       Class& other_class = Class::Handle();
       if (other.IsTypeParameter()) {
         if (other_instantiator.IsNull()) {
           return true;  // Other type is uninstantiated, i.e. Dynamic.
         }
@@ skipping 43 matching lines @@
     other_type_arguments = instantiated_other.arguments();
   } else {
     other_class = other.type_class();
     other_type_arguments = other.arguments();
     if (!other_type_arguments.IsNull() &&
         !other_type_arguments.IsInstantiated()) {
       other_type_arguments =
           other_type_arguments.InstantiateFrom(other_instantiator);
     }
   }
-  return cls.TestType(test, type_arguments, other_class, other_type_arguments);
+  return cls.TestType(test, type_arguments, other_class, other_type_arguments,
+                      malformed_error);
 }
 
 
 bool Instance::IsValidNativeIndex(int index) const {
   const Class& cls = Class::Handle(clazz());
   return (index >= 0 && index < cls.num_native_fields());
 }
 
 
 RawInstance* Instance::New(const Class& cls, Heap::Space space) {
@@ skipping 2490 matching lines @@
   result.set_num_args_tested(num_args_tested);
   // Number of array elements in one test entry (num_args_tested + 1)
   intptr_t len = result.TestEntryLength();
   // IC data array must be null terminated (sentinel entry).
   Array& ic_data = Array::Handle(Array::New(len, Heap::kOld));
   result.set_ic_data(ic_data);
   return result.raw();
 }
 
 }  // namespace dart