Complete 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 "platform/utils.h"
 #include "vm/ast.h"
 #include "vm/bootstrap.h"
@@ skipping 6894 matching lines @@
               Library::PrivateCoreLibName(Symbols::_setupFullStackTrace()),
               no_args));
     }
 
     ParseStatementSequence();  // Parse the catch handler code.
     current_block_->statements->Add(
         new JumpNode(catch_pos, Token::kCONTINUE, end_catch_label));
     SequenceNode* catch_handler = CloseBlock();
     ExpectToken(Token::kRBRACE);
 
-    if (!exception_param.type.IsDynamicType()) {  // Has a type specification.
+    const bool is_bad_type = exception_param.type.IsMalformed() ||
+                             exception_param.type.IsMalbounded();
+    if (!is_bad_type && !exception_param.type.IsDynamicType()) {
+      // Has a type specification that is not malformed or malbounded.
       // Now form an 'if type check' as an exception type exists in the
       // catch specifier.
       if (!exception_param.type.IsInstantiated() &&
           (current_block_->scope->function_level() > 0)) {
         // Make sure that the instantiator is captured.
         CaptureInstantiator();
       }
       TypeNode* exception_type = new TypeNode(catch_pos, exception_param.type);
       AstNode* exception_value = new LoadLocalNode(catch_pos, exception_var);
       if (!exception_type->type().IsInstantiated()) {
         EnsureExpressionTemp();
       }
       AstNode* type_cond_expr = new ComparisonNode(
           catch_pos, Token::kIS, exception_value, exception_type);
       current_block_->statements->Add(
           new IfNode(catch_pos, type_cond_expr, catch_handler, NULL));
 
       // Do not add uninstantiated types (e.g. type parameter T or generic
       // type List<T>), since the debugger won't be able to instantiate it
       // when walking the stack.  This means that the debugger is not able
       // to determine whether an exception is caught if the catch clause
       // uses generic types.  It will report the exception as uncaught when
       // in fact it might be caught and handled when we unwind the stack.
       if (exception_param.type.IsInstantiated()) {
         handler_types.Add(exception_param.type);
       }
     } else {
+      if (is_bad_type) {
+        current_block_->statements->Add(ThrowTypeError(catch_pos,
+                                                       exception_param.type));
+        // We still add the dead code below to satisfy the code generator.
+      }
       // No exception type exists in the catch specifier so execute the
       // catch handler code unconditionally.
       current_block_->statements->Add(catch_handler);
       generic_catch_seen = true;
       // This catch clause will handle all exceptions. We can safely forget
       // all previous catch clause types.
       handler_types.SetLength(0);
       handler_types.Add(exception_param.type);
     }
   }
@@ skipping 1655 matching lines @@
     if (unresolved_class.library_prefix() == LibraryPrefix::null()) {
       if (!scope_class.IsNull()) {
         // First check if the type is a type parameter of the given scope class.
         const TypeParameter& type_parameter = TypeParameter::Handle(
             scope_class.LookupTypeParameter(unresolved_class_name));
         if (!type_parameter.IsNull()) {
           // A type parameter is considered to be a malformed type when
           // referenced by a static member.
           if (ParsingStaticMember()) {
             ASSERT(scope_class.raw() == current_class().raw());
-            if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-                FLAG_error_on_bad_type) {
-              *type = ClassFinalizer::NewFinalizedMalformedType(
-                  Error::Handle(),  // No previous error.
-                  script_,
-                  type->token_pos(),
-                  "type parameter '%s' cannot be referenced "
-                  "from static member",
-                  String::Handle(type_parameter.name()).ToCString());
-            } else {
-              // Map the malformed type to dynamic and ignore type arguments.
-              *type = Type::DynamicType();
-            }
+            *type = ClassFinalizer::NewFinalizedMalformedType(
+                Error::Handle(),  // No previous error.
+                script_,
+                type->token_pos(),
+                "type parameter '%s' cannot be referenced "
+                "from static member",
+                String::Handle(type_parameter.name()).ToCString());
             return;
           }
           // A type parameter cannot be parameterized, so make the type
           // malformed if type arguments have previously been parsed.
           if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
-            if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-                FLAG_error_on_bad_type) {
-              *type = ClassFinalizer::NewFinalizedMalformedType(
-                  Error::Handle(),  // No previous error.
-                  script_,
-                  type_parameter.token_pos(),
-                  "type parameter '%s' cannot be parameterized",
-                  String::Handle(type_parameter.name()).ToCString());
-            } else {
-              // Map the malformed type to dynamic and ignore type arguments.
-              *type = Type::DynamicType();
-            }
+            *type = ClassFinalizer::NewFinalizedMalformedType(
+                Error::Handle(),  // No previous error.
+                script_,
+                type_parameter.token_pos(),
+                "type parameter '%s' cannot be parameterized",
+                String::Handle(type_parameter.name()).ToCString());
             return;
           }
           *type = type_parameter.raw();
           return;
         }
       }
       // The referenced class may not have been parsed yet. It would be wrong
       // to resolve it too early to an imported class of the same name.
       if (finalization > ClassFinalizer::kResolveTypeParameters) {
         // Resolve classname in the scope of the current library.
         resolved_type_class = ResolveClassInCurrentLibraryScope(
             unresolved_class_name);
       }
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Resolve class name in the scope of the library prefix.
       resolved_type_class =
           ResolveClassInPrefixScope(lib_prefix, unresolved_class_name);
     }
     // At this point, we can only have a parameterized_type.
     const Type& parameterized_type = Type::Cast(*type);
     if (!resolved_type_class.IsNull()) {
       // Replace unresolved class with resolved type class.
       parameterized_type.set_type_class(resolved_type_class);
     } else if (finalization >= ClassFinalizer::kCanonicalize) {
-      if ((finalization == ClassFinalizer::kCanonicalizeWellFormed) ||
-          FLAG_error_on_bad_type) {
-        ClassFinalizer::FinalizeMalformedType(
-            Error::Handle(),  // No previous error.
-            script_,
-            parameterized_type,
-            "type '%s' is not loaded",
-            String::Handle(parameterized_type.UserVisibleName()).ToCString());
-      } else {
-        // Map the malformed type to dynamic and ignore type arguments.
-        *type = Type::DynamicType();
-      }
+      ClassFinalizer::FinalizeMalformedType(
+          Error::Handle(),  // No previous error.
+          script_,
+          parameterized_type,
+          "type '%s' is not loaded",
+          String::Handle(parameterized_type.UserVisibleName()).ToCString());
       return;
     }
   }
   // Resolve type arguments, if any.
   const AbstractTypeArguments& arguments =
       AbstractTypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     const intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       AbstractType& type_argument = AbstractType::Handle(arguments.TypeAt(i));
@@ skipping 583 matching lines @@
     }
     SkipQualIdent();
   } else {
     ParseQualIdent(&type_name);
     // An identifier cannot be resolved in a local scope when top level parsing.
     if (!is_top_level_ &&
         (type_name.lib_prefix == NULL) &&
         ResolveIdentInLocalScope(type_name.ident_pos, *type_name.ident, NULL)) {
       // The type is malformed. Skip over its type arguments.
       ParseTypeArguments(ClassFinalizer::kIgnore);
-      if (finalization == ClassFinalizer::kCanonicalizeWellFormed) {
-        return ClassFinalizer::NewFinalizedMalformedType(
-            Error::Handle(),  // No previous error.
-            script_,
-            type_name.ident_pos,
-            "using '%s' in this context is invalid",
-            type_name.ident->ToCString());
-      }
-      return Type::DynamicType();
+      return ClassFinalizer::NewFinalizedMalformedType(
+          Error::Handle(),  // No previous error.
+          script_,
+          type_name.ident_pos,
+          "using '%s' in this context is invalid",
+          type_name.ident->ToCString());
     }
   }
   Object& type_class = Object::Handle(isolate());
   // Leave type_class as null if type finalization mode is kIgnore.
   if (finalization != ClassFinalizer::kIgnore) {
     LibraryPrefix& lib_prefix = LibraryPrefix::Handle(isolate());
     if (type_name.lib_prefix != NULL) {
       lib_prefix = type_name.lib_prefix->raw();
     }
     type_class = UnresolvedClass::New(lib_prefix,
@@ skipping 1443 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart