Distinguish between malformed and malbounded types (fix issues 12552 and 12554).

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 2978 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.
           current_class(),
           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?
       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 2436 matching lines @@
   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()));
   }
 
@@ skipping 1654 matching lines @@
     if (node != NULL) {
       sequence->Add(node);
     }
     return sequence;
   }
   return node->AsSequenceNode();
 }
 
 
 AstNode* Parser::ThrowTypeError(intptr_t type_pos, const AbstractType& type) {
-  ASSERT(type.IsMalformed());
   ArgumentListNode* arguments = new ArgumentListNode(type_pos);
   // Location argument.
   arguments->Add(new LiteralNode(
       type_pos, Integer::ZoneHandle(Integer::New(type_pos))));
   // Src value argument.
   arguments->Add(new LiteralNode(type_pos, Instance::ZoneHandle()));
   // Dst type name argument.
   arguments->Add(new LiteralNode(type_pos, Symbols::Malformed()));
   // Dst name argument.
   arguments->Add(new LiteralNode(type_pos, Symbols::Empty()));
-  // Malformed type error.
-  const Error& error = Error::Handle(type.malformed_error());
+  // Malformed type error or malbounded type error.
+  Error& error = Error::Handle();
+  if (type.IsMalformed()) {
+    error = type.malformed_error();
+  } else {
+    const bool is_malbounded = type.IsMalboundedWithError(&error);
+    ASSERT(is_malbounded);
+  }
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(Symbols::TypeError(),
                         PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 // TODO(regis): Providing the argument values is not always feasible, since
 // evaluating them could throw an error.
@@ skipping 79 matching lines @@
         }
         const intptr_t type_pos = TokenPos();
         const AbstractType& type = AbstractType::ZoneHandle(
             ParseType(ClassFinalizer::kCanonicalize));
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
         right_operand = new TypeNode(type_pos, type);
-        // If the type is malformed, it is actually malbounded in checked mode.
-        ASSERT(!type.IsMalformed() || FLAG_enable_type_checks);
+        // The type is never malformed (mapped to dynamic), but it can be
+        // malbounded in checked mode.
+        ASSERT(!type.IsMalformed());
         if (((op_kind == Token::kIS) || (op_kind == Token::kISNOT)) &&
-            type.IsMalformed()) {
+            type.IsMalbounded()) {
           // Note that a type error is thrown even if the tested value is null
           // in a type test. However, no cast exception is thrown if the value
           // is null in a type cast.
           return ThrowTypeError(type_pos, type);
         }
       }
       if (Token::IsRelationalOperator(op_kind)
           || Token::IsTypeTestOperator(op_kind)
           || Token::IsTypeCastOperator(op_kind)
           || Token::IsEqualityOperator(op_kind)) {
@@ skipping 2344 matching lines @@
   ASSERT((op_kind == Token::kNEW) || (op_kind == Token::kCONST));
   bool is_const = (op_kind == Token::kCONST);
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = TokenPos();
   AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kCanonicalizeWellFormed));
   // In case the type is malformed, throw a dynamic type error after finishing
   // parsing the instance creation expression.
-  if (!type.IsMalformed() && (type.IsTypeParameter() || type.IsDynamicType())) {
-    // Replace the type with a malformed type.
-    type = ClassFinalizer::NewFinalizedMalformedType(
-        Error::Handle(),  // No previous error.
-        current_class(),
-        type_pos,
-        "%s'%s' cannot be instantiated",
-        type.IsTypeParameter() ? "type parameter " : "",
-        type.IsTypeParameter() ?
-            String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
+  if (!type.IsMalformed()) {
+    if (type.IsTypeParameter() || type.IsDynamicType()) {
+      // Replace the type with a malformed type.
+      type = ClassFinalizer::NewFinalizedMalformedType(
+          Error::Handle(),  // No previous error.
+          current_class(),
+          type_pos,
+          "%s'%s' cannot be instantiated",
+          type.IsTypeParameter() ? "type parameter " : "",
+          type.IsTypeParameter() ?
+              String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
+    } else if (FLAG_enable_type_checks || FLAG_error_on_malformed_type) {
+      Error& bound_error = Error::Handle();
+      if (type.IsMalboundedWithError(&bound_error)) {
+        // Replace the type with a malformed type.
+        type = ClassFinalizer::NewFinalizedMalformedType(
+            bound_error,
+            current_class(),
+            type_pos,
+            "malbounded type '%s' cannot be instantiated",
+            String::Handle(type.UserVisibleName()).ToCString());
+      }
+    }
   }
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
   // is a named constructor. Note that ParseType() above will not consume it as
   // part of a misinterpreted qualified identifier, because only a valid library
   // prefix is accepted as qualifier.
   String* named_constructor = NULL;
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();
     named_constructor = ExpectIdentifier("name of constructor expected");
@@ skipping 770 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart