Check type bounds of redirecting factories (issue 14699).

runtime/vm/parser.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/parser.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 1578 matching lines @@
         }
       } else {
         signature_function.set_signature_class(signature_class);
       }
       ASSERT(signature_function.signature_class() == signature_class.raw());
       Type& signature_type = Type::ZoneHandle(signature_class.SignatureType());
       if (!is_top_level_ && !signature_type.IsFinalized()) {
         signature_type ^= ClassFinalizer::FinalizeType(
             signature_class, signature_type, ClassFinalizer::kCanonicalize);
       }
+      // A signature type itself cannot be malformed or malbounded, only its
+      // signature function's result type or parameter types may be.
+      ASSERT(!signature_type.IsMalformed());
+      ASSERT(!signature_type.IsMalbounded());
       // The type of the parameter is now the signature type.
       parameter.type = &signature_type;
     }
   }
 
   if ((CurrentToken() == Token::kASSIGN) || (CurrentToken() == Token::kCOLON)) {
     if ((!params->has_optional_positional_parameters &&
          !params->has_optional_named_parameters) ||
         !allow_explicit_default_value) {
       ErrorMsg("parameter must not specify a default value");
@@ skipping 1551 matching lines @@
     if (!type.IsMalformed() && type.IsTypeParameter()) {
       // Replace the type with a malformed type and compile a throw when called.
       redirection_type = ClassFinalizer::NewFinalizedMalformedType(
           Error::Handle(),  // No previous error.
           script_,
           type_pos,
           "factory '%s' may not redirect to type parameter '%s'",
           method->name->ToCString(),
           String::Handle(type.UserVisibleName()).ToCString());
     } else {
-      // TODO(regis): What if the redirection type is malbounded?
+      // We handle malformed and malbounded redirection type at run time.
       redirection_type ^= type.raw();
     }
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor or factory.
       ConsumeToken();
       redirection_identifier = ExpectIdentifier("identifier expected")->raw();
     }
   } else if (CurrentToken() == Token::kCOLON) {
     // Parse initializers.
     if (!method->IsConstructor()) {
@@ skipping 2484 matching lines @@
   AbstractTypeArguments& signature_type_arguments =
       AbstractTypeArguments::Handle(signature_type.arguments());
 
   if (!signature_type.IsFinalized()) {
     signature_type ^= ClassFinalizer::FinalizeType(
         signature_class, signature_type, ClassFinalizer::kCanonicalize);
 
     // The call to ClassFinalizer::FinalizeType may have
     // extended the vector of type arguments.
     signature_type_arguments = signature_type.arguments();
-    ASSERT(signature_type.IsMalformed() ||
-           signature_type_arguments.IsNull() ||
+    ASSERT(signature_type_arguments.IsNull() ||
            (signature_type_arguments.Length() ==
             signature_class.NumTypeArguments()));
 
     // The signature_class should not have changed.
-    ASSERT(signature_type.IsMalformed() ||
-           (signature_type.type_class() == signature_class.raw()));
+    ASSERT(signature_type.type_class() == signature_class.raw());
   }
 
+  // A signature type itself cannot be malformed or malbounded, only its
+  // signature function's result type or parameter types may be.
+  ASSERT(!signature_type.IsMalformed());
+  ASSERT(!signature_type.IsMalbounded());
+
   if (variable_name != NULL) {
     // Patch the function type of the variable now that the signature is known.
     function_type.set_type_class(signature_class);
     function_type.set_arguments(signature_type_arguments);
 
-    // Mark the function type as malformed if the signature type is malformed.
-    if (signature_type.IsMalformed()) {
-      const Error& error = Error::Handle(signature_type.malformed_error());
-      function_type.set_malformed_error(error);
-    }
-    // TODO(regis): What if the signature is malbounded?
-
     // The function type was initially marked as instantiated, but it may
     // actually be uninstantiated.
     function_type.ResetIsFinalized();
 
     // The function variable type should have been patched above.
     ASSERT((function_variable == NULL) ||
            (function_variable->type().raw() == function_type.raw()));
   }
 
   // The code generator does not compile the closure function when visiting
@@ skipping 4220 matching lines @@
       return ThrowNoSuchMethodError(call_pos,
                                     type_class,
                                     external_constructor_name,
                                     arguments,
                                     InvocationMirror::kConstructor,
                                     InvocationMirror::kMethod,
                                     &constructor);
     } else if (constructor.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(type_class, constructor);
       Type& redirect_type = Type::Handle(constructor.RedirectionType());
-      if (!redirect_type.IsMalformed() && !redirect_type.IsInstantiated()) {
+      Error& error = Error::Handle();
+      if (!redirect_type.IsMalformed() && !redirect_type.IsMalbounded() &&
+          !redirect_type.IsInstantiated()) {
         // The type arguments of the redirection type are instantiated from the
         // type arguments of the parsed type of the 'new' or 'const' expression.
-        Error& malformed_error = Error::Handle();
-        redirect_type ^= redirect_type.InstantiateFrom(type_arguments,
-                                                       &malformed_error);
-        if (!malformed_error.IsNull()) {
-          redirect_type.set_malformed_error(malformed_error);
+        redirect_type ^= redirect_type.InstantiateFrom(type_arguments, &error);
+        if (!error.IsNull()) {
+          redirect_type = ClassFinalizer::NewFinalizedMalformedType(
+              error,
+              script_,
+              call_pos,
+              "redirecting factory type '%s' cannot be instantiated",
+              String::Handle(redirect_type.UserVisibleName()).ToCString());
+          error = Error::null();
         }
       }
-      if (redirect_type.IsMalformed()) {
+      if (redirect_type.IsMalformed() ||
+          redirect_type.IsMalboundedWithError(&error)) {
         if (is_const) {
-          ErrorMsg(Error::Handle(redirect_type.malformed_error()));
+          if (redirect_type.IsMalformed()) {
+            error = type.malformed_error();
+          }
+          ErrorMsg(error);
         }
         return ThrowTypeError(redirect_type.token_pos(), redirect_type);
       }
       if (FLAG_enable_type_checks && !redirect_type.IsSubtypeOf(type, NULL)) {
         // Additional type checking of the result is necessary.
         type_bound = type.raw();
       }
       type = redirect_type.raw();
       type_class = type.type_class();
       type_class_name = type_class.Name();
@@ skipping 46 matching lines @@
                                   type_class,
                                   external_constructor_name,
                                   arguments,
                                   InvocationMirror::kConstructor,
                                   InvocationMirror::kMethod,
                                   &constructor);
   }
 
   // Return a throw in case of a malformed type or report a compile-time error
   // if the constructor is const.
-  if (type.IsMalformed()) {
+  Error& error = Error::Handle();
+  if (type.IsMalformed() || type.IsMalboundedWithError(&error)) {
     if (is_const) {
-      const Error& error = Error::Handle(type.malformed_error());
+      if (type.IsMalformed()) {
+        error = type.malformed_error();
+      }
       ErrorMsg(error);
     }
     return ThrowTypeError(type_pos, type);
   }
   type_arguments ^= type_arguments.Canonicalize();
   // Make the constructor call.
   AstNode* new_object = NULL;
   if (is_const) {
     if (!constructor.is_const()) {
       const String& external_constructor_name =
@@ skipping 703 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart