Ambiguous type references require a compile time error in some special cases

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 "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 2527 matching lines @@
   }
 
   // Parse redirecting factory constructor.
   Type& redirection_type = Type::Handle();
   String& redirection_identifier = String::Handle();
   if (method->IsFactory() && (CurrentToken() == Token::kASSIGN)) {
     ConsumeToken();
     const intptr_t type_pos = TokenPos();
     const AbstractType& type = AbstractType::Handle(
         ParseType(ClassFinalizer::kTryResolve));
-    if (type.IsTypeParameter() || type.IsDynamicType()) {
+    if (!type.IsMalformed() &&
+        (type.IsTypeParameter() || type.IsDynamicType())) {
       // 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,
           ClassFinalizer::kTryResolve,  // No compile-time error.
           "factory '%s' may not redirect to %s'%s'",
           method->name->ToCString(),
           type.IsTypeParameter() ? "type parameter " : "",
           type.IsTypeParameter() ?
@@ skipping 1175 matching lines @@
     do {
       ConsumeToken();
       type = ParseType(finalization);
       // Only keep the error for the first malformed type argument.
       if (malformed_error->IsNull() && type.IsMalformed()) {
         *malformed_error = type.malformed_error();
       }
       // Map a malformed type argument to dynamic, so that malformed types with
       // a resolved type class are handled properly in production mode.
       if (type.IsMalformed()) {
-        ASSERT(finalization != ClassFinalizer::kCanonicalizeWellFormed);
-        if (finalization == ClassFinalizer::kCanonicalizeForCreation) {
-          ErrorMsg(*malformed_error);
-        }
+        ASSERT(finalization < ClassFinalizer::kCanonicalizeWellFormed);
         type = Type::DynamicType();
       }
       types.Add(type);
     } while (CurrentToken() == Token::kCOMMA);
     Token::Kind token = CurrentToken();
     if ((token == Token::kGT) || (token == Token::kSHR)) {
       ConsumeRightAngleBracket();
     } else {
       ErrorMsg("right angle bracket expected");
     }
@@ skipping 2423 matching lines @@
   const intptr_t handler_pos = TokenPos();
   OpenBlock();  // Start the catch block sequence.
   current_block_->scope->AddLabel(end_catch_label);
   while ((CurrentToken() == Token::kCATCH) || IsLiteral("on")) {
     const intptr_t catch_pos = TokenPos();
     CatchParamDesc exception_param;
     CatchParamDesc stack_trace_param;
     catch_seen = true;
     if (IsLiteral("on")) {
       ConsumeToken();
+      // TODO(regis): The spec may change in the way a malformed 'on' type is
+      // treated. For now, we require the type to be wellformed.
       exception_param.type = &AbstractType::ZoneHandle(
           ParseType(ClassFinalizer::kCanonicalizeWellFormed));
     } else {
       exception_param.type =
           &AbstractType::ZoneHandle(Type::DynamicType());
     }
     if (CurrentToken() == Token::kCATCH) {
       ConsumeToken();  // Consume the 'catch'.
       ExpectToken(Token::kLPAREN);
       exception_param.token_pos = TokenPos();
@@ skipping 636 matching lines @@
       AstNode* right_operand = NULL;
       if ((op_kind != Token::kIS) && (op_kind != Token::kAS)) {
         right_operand = ParseBinaryExpr(current_preced + 1);
       } else {
         // For 'is' and 'as' we expect the right operand to be a type.
         if ((op_kind == Token::kIS) && (CurrentToken() == Token::kNOT)) {
           ConsumeToken();
           op_kind = Token::kISNOT;
         }
         const intptr_t type_pos = TokenPos();
-        const AbstractType& type =
-            AbstractType::ZoneHandle(ParseType(ClassFinalizer::kCanonicalize));
+        const AbstractType& type = AbstractType::ZoneHandle(
+            ParseType(ClassFinalizer::kCanonicalizeExpression));
         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 (((op_kind == Token::kIS) || (op_kind == Token::kISNOT)) &&
             type.IsMalformed()) {
           // 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
@@ skipping 945 matching lines @@
                 "type parameter '%s' cannot be parameterized",
                 String::Handle(type_parameter.name()).ToCString());
             return;
           }
           *type = type_parameter.raw();
           return;
         }
       }
       // Resolve classname in the scope of the current library.
       Error& error = Error::Handle();
-      resolved_type_class =
-          ResolveClassInCurrentLibraryScope(unresolved_class.token_pos(),
-                                            unresolved_class_name,
-                                            &error);
+      // If we finalize a type expression, as opposed to a type annotation, we
+      // tell the resolver (by passing NULL) to immediately report an ambiguous
+      // type as a compile time error.
+      resolved_type_class = ResolveClassInCurrentLibraryScope(
+          unresolved_class.token_pos(),
+          unresolved_class_name,
+          finalization >= ClassFinalizer::kCanonicalizeExpression ?
+              NULL : &error);
       if (!error.IsNull()) {
         *type = ClassFinalizer::NewFinalizedMalformedType(
             error,
             scope_class,
             unresolved_class.token_pos(),
             finalization,
             "cannot resolve class '%s'",
             unresolved_class_name.ToCString());
         return;
       }
     } else {
       LibraryPrefix& lib_prefix =
           LibraryPrefix::Handle(unresolved_class.library_prefix());
       // Resolve class name in the scope of the library prefix.
       Error& error = Error::Handle();
-      resolved_type_class =
-          ResolveClassInPrefixScope(unresolved_class.token_pos(),
-                                    lib_prefix,
-                                    unresolved_class_name,
-                                    &error);
+      // If we finalize a type expression, as opposed to a type annotation, we
+      // tell the resolver (by passing NULL) to immediately report an ambiguous
+      // type as a compile time error.
+      resolved_type_class = ResolveClassInPrefixScope(
+          unresolved_class.token_pos(),
+          lib_prefix,
+          unresolved_class_name,
+          finalization >= ClassFinalizer::kCanonicalizeExpression ?
+              NULL : &error);
       if (!error.IsNull()) {
         *type = ClassFinalizer::NewFinalizedMalformedType(
             error,
             scope_class,
             unresolved_class.token_pos(),
             finalization,
             "cannot resolve class '%s'",
             unresolved_class_name.ToCString());
         return;
       }
@@ skipping 1252 matching lines @@
   TRACE_PARSER("ParseNewOperator");
   const intptr_t new_pos = TokenPos();
   ASSERT((CurrentToken() == Token::kNEW) || (CurrentToken() == Token::kCONST));
   bool is_const = (CurrentToken() == Token::kCONST);
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = TokenPos();
   AbstractType& type = AbstractType::Handle(
-      ParseType(ClassFinalizer::kCanonicalizeForCreation));
+      ParseType(ClassFinalizer::kCanonicalizeExpression));
   // In case the type is malformed, throw a dynamic type error after finishing
   // parsing the instance creation expression.
-  if (type.IsTypeParameter() || type.IsDynamicType()) {
-    ASSERT(!type.IsMalformed());
+  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,
         ClassFinalizer::kTryResolve,  // No compile-time error.
         "%s'%s' cannot be instantiated",
         type.IsTypeParameter() ? "type parameter " : "",
         type.IsTypeParameter() ?
             String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
@@ skipping 913 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart