Check type bounds of redirecting factories (issue 14699).

runtime/vm/class_finalizer.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/class_finalizer.h"
 
 #include "vm/flags.h"
 #include "vm/heap.h"
 #include "vm/isolate.h"
 #include "vm/longjump.h"
@@ skipping 271 matching lines @@
     if (!type.IsMalformed()) {
       const GrowableObjectArray& visited_factories =
           GrowableObjectArray::Handle(GrowableObjectArray::New());
       ResolveRedirectingFactoryTarget(cls, factory, visited_factories);
     }
     if (factory.is_const()) {
       type = factory.RedirectionType();
       if (type.IsMalformed()) {
         ReportError(Error::Handle(type.malformed_error()));
       }
+      Error& error = Error::Handle();
+      if (type.IsMalboundedWithError(&error)) {
+        ReportError(error);
+      }
     }
   }
 }
 
 
 void ClassFinalizer::ResolveRedirectingFactoryTarget(
     const Class& cls,
     const Function& factory,
     const GrowableObjectArray& visited_factories) {
   ASSERT(factory.IsRedirectingFactory());
 
   // Check for redirection cycle.
   for (intptr_t i = 0; i < visited_factories.Length(); i++) {
     if (visited_factories.At(i) == factory.raw()) {
       // A redirection cycle is reported as a compile-time error.
       const Script& script = Script::Handle(cls.script());
       ReportError(Error::Handle(),  // No previous error.
                   script, factory.token_pos(),
                   "factory '%s' illegally redirects to itself",
                   String::Handle(factory.name()).ToCString());
     }
   }
   visited_factories.Add(factory);
 
   // Check if target is already resolved.
   Type& type = Type::Handle(factory.RedirectionType());
   Function& target = Function::Handle(factory.RedirectionTarget());
-  if (type.IsMalformed()) {
-    // Already resolved to a malformed type. Will throw on usage.
+  if (type.IsMalformed() || (type.IsResolved() && type.IsMalbounded())) {
+    // Already resolved to a malformed or malbounded type. Will throw on usage.
     ASSERT(target.IsNull());
     return;
   }
   if (!target.IsNull()) {
     // Already resolved.
     return;
   }
 
   // Target is not resolved yet.
   if (FLAG_trace_class_finalization) {
     OS::Print("Resolving redirecting factory: %s\n",
               String::Handle(factory.name()).ToCString());
   }
   ResolveType(cls, type, kCanonicalize);
   type ^= FinalizeType(cls, type, kCanonicalize);
   factory.SetRedirectionType(type);
-  if (type.IsMalformed()) {
+  if (type.IsMalformed() || type.IsMalbounded()) {
     ASSERT(factory.RedirectionTarget() == Function::null());
     return;
   }
   ASSERT(!type.IsTypeParameter());  // Resolved in parser.
   if (type.IsDynamicType()) {
     // Replace the type with a malformed type and compile a throw when called.
     type = NewFinalizedMalformedType(
         Error::Handle(),  // No previous error.
         Script::Handle(cls.script()),
         factory.token_pos(),
@@ skipping 75 matching lines @@
   Type& target_type = Type::Handle(target.RedirectionType());
   Function& target_target = Function::Handle(target.RedirectionTarget());
   if (target_target.IsNull()) {
     ASSERT(target_type.IsMalformed());
   } else {
     // If the target type refers to type parameters, substitute them with the
     // type arguments of the redirection type.
     if (!target_type.IsInstantiated()) {
       const AbstractTypeArguments& type_args = AbstractTypeArguments::Handle(
           type.arguments());
-      Error& malformed_error = Error::Handle();
-      target_type ^= target_type.InstantiateFrom(type_args, &malformed_error);
-      if (malformed_error.IsNull()) {
+      Error& bound_error = Error::Handle();
+      target_type ^= target_type.InstantiateFrom(type_args, &bound_error);
+      if (bound_error.IsNull()) {
         target_type ^= FinalizeType(cls, target_type, kCanonicalize);
       } else {
+        ASSERT(target_type.IsInstantiated() && type_args.IsInstantiated());
         const Script& script = Script::Handle(target_class.script());
-        FinalizeMalformedType(malformed_error, script, target_type,
+        FinalizeMalformedType(bound_error, script, target_type,
                               "cannot resolve redirecting factory");
         target_target = Function::null();
       }
     }
   }
   factory.SetRedirectionType(target_type);
   factory.SetRedirectionTarget(target_target);
 }
 
 
@@ skipping 139 matching lines @@
     }
     const intptr_t num_super_type_params = super_class.NumTypeParameters();
     const intptr_t offset = super_class.NumTypeArguments();
     const intptr_t super_offset = offset - num_super_type_params;
     ASSERT(offset == (cls.NumTypeArguments() - cls.NumOwnTypeArguments()));
     AbstractType& super_type_arg = AbstractType::Handle(Type::DynamicType());
     for (intptr_t i = 0; super_offset + i < num_uninitialized_arguments; i++) {
       if (!super_type_args.IsNull()) {
         super_type_arg = super_type_args.TypeAt(super_offset + i);
         if (!super_type_arg.IsInstantiated()) {
-          Error& malformed_error = Error::Handle();
-          super_type_arg = super_type_arg.InstantiateFrom(arguments,
-                                                          &malformed_error);
-          if (!malformed_error.IsNull()) {
-            if (!super_type_arg.IsInstantiated()) {
-              // CheckTypeArgumentBounds will insert a BoundedType.
-            } else if (bound_error->IsNull()) {
-              *bound_error = malformed_error.raw();
+          Error& error = Error::Handle();
+          super_type_arg = super_type_arg.InstantiateFrom(arguments, &error);
+          if (!error.IsNull()) {
+            // InstantiateFrom does not report an error if the type is still
+            // uninstantiated. Instead, it will return a new BoundedType so that
+            // the check is postponed to run time.
+            ASSERT(super_type_arg.IsInstantiated());
+            // Keep only the first bound error.
+            if (bound_error->IsNull()) {
+              *bound_error = error.raw();
             }
           }
         }
         if (finalization >= kCanonicalize) {
           super_type_arg = super_type_arg.Canonicalize();
         }
       }
       arguments.SetTypeAt(super_offset + i, super_type_arg);
     }
     FinalizeTypeArguments(super_class, arguments, super_offset,
@@ skipping 41 matching lines @@
     cls_type_param = cls_type_params.TypeAt(i);
     const TypeParameter& type_param = TypeParameter::Cast(cls_type_param);
     ASSERT(type_param.IsFinalized());
     declared_bound = type_param.bound();
     if (!declared_bound.IsObjectType() && !declared_bound.IsDynamicType()) {
       if (!declared_bound.IsFinalized() && !declared_bound.IsBeingFinalized()) {
         declared_bound = FinalizeType(cls, declared_bound, kCanonicalize);
         type_param.set_bound(declared_bound);
       }
       ASSERT(declared_bound.IsFinalized() || declared_bound.IsBeingFinalized());
-      Error& malformed_error = Error::Handle();
+      Error& error = Error::Handle();
       // Note that the bound may be malformed, in which case the bound check
       // will return an error and the bound check will be postponed to run time.
       if (declared_bound.IsInstantiated()) {
         instantiated_bound = declared_bound.raw();
       } else {
-        instantiated_bound =
-            declared_bound.InstantiateFrom(arguments, &malformed_error);
+        instantiated_bound = declared_bound.InstantiateFrom(arguments, &error);
       }
       if (!instantiated_bound.IsFinalized()) {
         // The bound refers to type parameters, creating a cycle; postpone
         // bound check to run time, when the bound will be finalized.
         // The bound may not necessarily be 'IsBeingFinalized' yet, as is the
         // case with a pair of type parameters of the same class referring to
         // each other via their bounds.
         type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
         arguments.SetTypeAt(offset + i, type_arg);
         continue;
       }
-      // TODO(regis): We could simplify this code if we could differentiate
-      // between a failed bound check and a bound check that is undecidable at
-      // compile time.
       // Shortcut the special case where we check a type parameter against its
       // declared upper bound.
-      bool below_bound = true;
-      if (malformed_error.IsNull() &&
-          (!type_arg.Equals(type_param) ||
-           !instantiated_bound.Equals(declared_bound))) {
-        // Pass NULL to prevent expensive and unnecessary error formatting in
-        // the case the bound check is postponed to run time.
-        below_bound = type_param.CheckBound(type_arg, instantiated_bound, NULL);
-      }
-      if (!malformed_error.IsNull() || !below_bound) {
-        if (!type_arg.IsInstantiated() ||
-            !instantiated_bound.IsInstantiated()) {
+      if (error.IsNull() &&
+          !(type_arg.Equals(type_param) &&
+            instantiated_bound.Equals(declared_bound))) {
+        if (!type_param.CheckBound(type_arg, instantiated_bound, &error) &&
+            error.IsNull()) {
+          // The bound cannot be checked at compile time; postpone to run time.
           type_arg = BoundedType::New(type_arg, instantiated_bound, type_param);
           arguments.SetTypeAt(offset + i, type_arg);
-        } else if (bound_error->IsNull()) {
-          if (malformed_error.IsNull()) {
-            // Call CheckBound again to format error message.
-            type_param.CheckBound(type_arg,
-                                  instantiated_bound,
-                                  &malformed_error);
-          }
-          ASSERT(!malformed_error.IsNull());
-          *bound_error = malformed_error.raw();
         }
       }
+      if (!error.IsNull() && bound_error->IsNull()) {
+        *bound_error = error.raw();
+      }
     }
   }
   AbstractType& super_type = AbstractType::Handle(cls.super_type());
   if (!super_type.IsNull()) {
     const Class& super_class = Class::Handle(super_type.type_class());
     CheckTypeArgumentBounds(super_class, arguments, bound_error);
   }
 }
 
 
@@ skipping 2032 matching lines @@
   expected_name ^= String::New("_offset");
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
   field ^= fields_array.At(2);
   ASSERT(field.Offset() == TypedDataView::length_offset());
   name ^= field.name();
   ASSERT(name.Equals("length"));
 #endif
 }
 
 }  // namespace dart