Implement latest spec changes regarding malformed types (see issue 14006):

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 3730 matching lines @@
     ErrorMsg(classname_pos,
              "mixin application '%s' may not be a patch class",
              class_name.ToCString());
   }
 
   AbstractType& super_type = Type::Handle();
   if ((CurrentToken() == Token::kEXTENDS) || is_mixin_declaration) {
     ConsumeToken();  // extends or =
     const intptr_t type_pos = TokenPos();
     super_type = ParseType(ClassFinalizer::kResolveTypeParameters);
-    if (super_type.IsDynamicType()) {
-      // The string 'dynamic' is not resolved yet at this point, but a malformed
-      // type mapped to dynamic can be encountered here.
+    if (super_type.IsMalformed() || super_type.IsDynamicType()) {
+      // Unlikely here, since super type is not resolved yet.
       ErrorMsg(type_pos,
-               "class '%s' may not extend a malformed type",
-               class_name.ToCString());
+               "class '%s' may not extend %s",
+               class_name.ToCString(),
+               super_type.IsMalformed() ? "a malformed type" : "'dynamic'");
     }
     if (super_type.IsTypeParameter()) {
       ErrorMsg(type_pos,
                "class '%s' may not extend type parameter '%s'",
                class_name.ToCString(),
                String::Handle(super_type.UserVisibleName()).ToCString());
     }
+    // The class finalizer will check whether the super type is malbounded.
     if (CurrentToken() == Token::kWITH) {
       super_type = ParseMixins(super_type);
     }
     if (is_mixin_declaration) {
       cls.set_is_mixin_typedef();
       cls.set_is_synthesized_class();
     }
   } else {
     // No extends clause: implicitly extend Object, unless Object itself.
     if (!cls.IsObjectClass()) {
@@ skipping 3649 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);
-        // The type is never malformed (mapped to dynamic), but it can be
-        // malbounded in checked mode.
-        ASSERT(!type.IsMalformed());
+        // In production mode, the type may be malformed.
+        // In checked mode, the type may be malformed or malbounded.
         if (((op_kind == Token::kIS) || (op_kind == Token::kISNOT) ||
              (op_kind == Token::kAS)) &&
-            type.IsMalbounded()) {
+            (type.IsMalformed() || type.IsMalbounded())) {
           // Note that a type error is thrown even if the tested value is null
           // in a type test or 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)) {
         if (Token::IsTypeTestOperator(op_kind) ||
@@ skipping 1737 matching lines @@
   AbstractType& element_type = Type::ZoneHandle(Type::DynamicType());
   AbstractTypeArguments& list_type_arguments =
       AbstractTypeArguments::ZoneHandle(type_arguments.raw());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using dynamic as the type argument for the element type.
   if (!list_type_arguments.IsNull()) {
     ASSERT(list_type_arguments.Length() > 0);
     // List literals take a single type argument.
     if (list_type_arguments.Length() == 1) {
       element_type = list_type_arguments.TypeAt(0);
+      ASSERT(!element_type.IsMalformed());  // Would be mapped to dynamic.
+      ASSERT(!element_type.IsMalbounded());  // No declared bound in List.
+      if (is_const && !element_type.IsInstantiated()) {
+        ErrorMsg(type_pos,
+                 "the type argument of a constant list literal cannot include "
+                 "a type variable");
+      }
     } else {
       if (FLAG_error_on_bad_type) {
         ErrorMsg(type_pos,
                  "a list literal takes one type argument specifying "
                  "the element type");
       }
       // Ignore type arguments.
       list_type_arguments = AbstractTypeArguments::null();
     }
-    if (is_const && !element_type.IsInstantiated()) {
-      ErrorMsg(type_pos,
-               "the type argument of a constant list literal cannot include "
-               "a type variable");
-    }
   }
-  ASSERT((list_type_arguments.IsNull() && element_type.IsDynamicType()) ||
-         ((list_type_arguments.Length() == 1) && !element_type.IsNull()));
+  ASSERT(list_type_arguments.IsNull() || (list_type_arguments.Length() == 1));
   const Class& array_class = Class::Handle(
       isolate()->object_store()->array_class());
   Type& type = Type::ZoneHandle(
       Type::New(array_class, list_type_arguments, type_pos));
   type ^= ClassFinalizer::FinalizeType(
       current_class(), type, ClassFinalizer::kCanonicalize);
   GrowableArray<AstNode*> element_list;
   // Parse the list elements. Note: there may be an optional extra
   // comma after the last element.
   if (!is_empty_literal) {
@@ skipping 156 matching lines @@
       AbstractTypeArguments::ZoneHandle(type_arguments.raw());
   // If no type argument vector is provided, leave it as null, which is
   // equivalent to using dynamic as the type argument for the both key and value
   // types.
   if (!map_type_arguments.IsNull()) {
     ASSERT(map_type_arguments.Length() > 0);
     // Map literals take two type arguments.
     if (map_type_arguments.Length() == 2) {
       key_type = map_type_arguments.TypeAt(0);
       value_type = map_type_arguments.TypeAt(1);
+      // Malformed type arguments are mapped to dynamic.
+      ASSERT(!key_type.IsMalformed() && !value_type.IsMalformed());
+      // No declared bounds in Map.
+      ASSERT(!key_type.IsMalbounded() && !value_type.IsMalbounded());
       if (is_const && !type_arguments.IsInstantiated()) {
         ErrorMsg(type_pos,
                  "the type arguments of a constant map literal cannot include "
                  "a type variable");
       }
-      if (key_type.IsMalformed()) {
-        if (FLAG_error_on_bad_type) {
-          ErrorMsg(Error::Handle(key_type.malformed_error()));
-        }
-        // Map malformed key type to dynamic.
-        key_type = Type::DynamicType();
-        map_type_arguments.SetTypeAt(0, key_type);
-      }
-      if (value_type.IsMalformed()) {
-        if (FLAG_error_on_bad_type) {
-          ErrorMsg(Error::Handle(value_type.malformed_error()));
-        }
-        // Map malformed value type to dynamic.
-        value_type = Type::DynamicType();
-        map_type_arguments.SetTypeAt(1, value_type);
-      }
     } else {
       if (FLAG_error_on_bad_type) {
         ErrorMsg(type_pos,
                  "a map literal takes two type arguments specifying "
                  "the key type and the value type");
       }
       // Ignore type arguments.
       map_type_arguments = AbstractTypeArguments::null();
     }
   }
-  ASSERT((map_type_arguments.IsNull() &&
-          key_type.IsDynamicType() && value_type.IsDynamicType()) ||
-         ((map_type_arguments.Length() == 2) &&
-          !key_type.IsMalformed() && !value_type.IsMalformed()));
+  ASSERT(map_type_arguments.IsNull() || (map_type_arguments.Length() == 2));
   map_type_arguments ^= map_type_arguments.Canonicalize();
 
   GrowableArray<AstNode*> kv_pairs_list;
   // Parse the map entries. Note: there may be an optional extra
   // comma after the last entry.
   while (CurrentToken() != Token::kRBRACE) {
     const bool saved_mode = SetAllowFunctionLiterals(true);
     const intptr_t key_pos = TokenPos();
     AstNode* key = ParseExpr(is_const, kConsumeCascades);
     if (FLAG_enable_type_checks &&
@@ skipping 163 matching lines @@
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
   }
   const intptr_t type_pos = TokenPos();
   AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle(
       ParseTypeArguments(ClassFinalizer::kCanonicalize));
+  // Malformed type arguments are mapped to dynamic, so we will not encounter
+  // them here.
   // Map and List interfaces do not declare bounds on their type parameters, so
-  // we should never see a malformed type argument mapped to dynamic here.
+  // we will not see malbounded type arguments here.
   AstNode* primary = NULL;
   if ((CurrentToken() == Token::kLBRACK) ||
       (CurrentToken() == Token::kINDEX)) {
     primary = ParseListLiteral(type_pos, is_const, type_arguments);
   } else if (CurrentToken() == Token::kLBRACE) {
     primary = ParseMapLiteral(type_pos, is_const, type_arguments);
   } else {
     ErrorMsg("unexpected token %s", Token::Str(CurrentToken()));
   }
   return primary;
@@ skipping 969 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart