Distinguish between malformed and malbounded types more efficiently using the

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 "platform/utils.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 3864 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.IsMalformed() || super_type.IsDynamicType()) {
+    if (super_type.IsMalformedOrMalbounded()) {
+      ErrorMsg(Error::Handle(super_type.error()));
+    }
+    if (super_type.IsDynamicType()) {
       // Unlikely here, since super type is not resolved yet.
       ErrorMsg(type_pos,
-               "class '%s' may not extend %s",
-               class_name.ToCString(),
-               super_type.IsMalformed() ? "a malformed type" : "'dynamic'");
+               "class '%s' may not extend 'dynamic'",
+               class_name.ToCString());
     }
     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);
@@ skipping 3516 matching lines @@
   // 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 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);
-  }
+  const Error& error = Error::Handle(type.error());
+  ASSERT(!error.IsNull());
   arguments->Add(new LiteralNode(type_pos, String::ZoneHandle(
       Symbols::New(error.ToErrorCString()))));
   return MakeStaticCall(Symbols::TypeError(),
                         Library::PrivateCoreLibName(Symbols::ThrowNew()),
                         arguments);
 }
 
 
 AstNode* Parser::ThrowNoSuchMethodError(intptr_t call_pos,
                                         const Class& cls,
@@ skipping 103 matching lines @@
         if (!type.IsInstantiated() &&
             (current_block_->scope->function_level() > 0)) {
           // Make sure that the instantiator is captured.
           CaptureInstantiator();
         }
         right_operand = new TypeNode(type_pos, type);
         // 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.IsMalformed() || type.IsMalbounded())) {
+            type.IsMalformedOrMalbounded()) {
           // 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 2215 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()) {
-    if (type.IsTypeParameter() || type.IsDynamicType()) {
-      // Replace the type with a malformed type.
-      type = ClassFinalizer::NewFinalizedMalformedType(
-          Error::Handle(),  // No previous error.
-          script_,
-          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_bad_type) {
-      Error& bound_error = Error::Handle();
-      if (type.IsMalboundedWithError(&bound_error)) {
-        // Replace the type with a malformed type.
-        type = ClassFinalizer::NewFinalizedMalformedType(
-            bound_error,
-            script_,
-            type_pos,
-            "malbounded type '%s' cannot be instantiated",
-            String::Handle(type.UserVisibleName()).ToCString());
-      }
-    }
+  if (!type.IsMalformed() && (type.IsTypeParameter() || type.IsDynamicType())) {
+    // Replace the type with a malformed type.
+    type = ClassFinalizer::NewFinalizedMalformedType(
+        Error::Handle(),  // No previous error.
+        script_,
+        type_pos,
+        "%s'%s' cannot be instantiated",
+        type.IsTypeParameter() ? "type parameter " : "",
+        type.IsTypeParameter() ?
+            String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
   }
 
   // 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");
   }
 
   // Parse constructor parameters.
   CheckToken(Token::kLPAREN);
   intptr_t call_pos = TokenPos();
   ArgumentListNode* arguments = ParseActualParameters(NULL, is_const);
 
-  // Parsing is complete, so we can return a throw in case of a malformed type
-  // or report a compile-time error if the constructor is const.
-  if (type.IsMalformed()) {
+  // Parsing is complete, so we can return a throw in case of a malformed or
+  // malbounded type or report a compile-time error if the constructor is const.
+  if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
-      const Error& error = Error::Handle(type.malformed_error());
+      const Error& error = Error::Handle(type.error());
       ErrorMsg(error);
     }
     return ThrowTypeError(type_pos, type);
   }
 
   // Resolve the type and optional identifier to a constructor or factory.
   Class& type_class = Class::Handle(type.type_class());
   String& type_class_name = String::Handle(type_class.Name());
   AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::ZoneHandle(type.arguments());
@@ skipping 20 matching lines @@
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       if (is_const) {
         type = ClassFinalizer::NewFinalizedMalformedType(
             Error::Handle(),  // No previous error.
             script_,
             call_pos,
             "class '%s' has no constructor or factory named '%s'",
             String::Handle(type_class.Name()).ToCString(),
             external_constructor_name.ToCString());
-        const Error& error = Error::Handle(type.malformed_error());
-        ErrorMsg(error);
+        ErrorMsg(Error::Handle(type.error()));
       }
       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());
-      Error& error = Error::Handle();
-      if (!redirect_type.IsMalformed() && !redirect_type.IsMalbounded() &&
+      if (!redirect_type.IsMalformedOrMalbounded() &&
           !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& error = Error::Handle();
         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() ||
-          redirect_type.IsMalboundedWithError(&error)) {
+      if (redirect_type.IsMalformedOrMalbounded()) {
         if (is_const) {
-          if (redirect_type.IsMalformed()) {
-            error = type.malformed_error();
-          }
-          ErrorMsg(error);
+          ErrorMsg(Error::Handle(redirect_type.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 44 matching lines @@
     }
     return ThrowNoSuchMethodError(call_pos,
                                   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.
-  Error& error = Error::Handle();
-  if (type.IsMalformed() || type.IsMalboundedWithError(&error)) {
+  // Return a throw in case of a malformed or malbounded type or report a
+  // compile-time error if the constructor is const.
+  if (type.IsMalformedOrMalbounded()) {
     if (is_const) {
-      if (type.IsMalformed()) {
-        error = type.malformed_error();
-      }
-      ErrorMsg(error);
+      ErrorMsg(Error::Handle(type.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 =
           (named_constructor ? constructor_name : type_class_name);
@@ skipping 702 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart