Ambiguous references do not necessarily cause compilation errors (issue 5736).

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 2497 matching lines @@
   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()) {
       // 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() ?
               String::Handle(type.UserVisibleName()).ToCString() : "dynamic");
     } else {
       redirection_type ^= type.raw();
     }
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor or factory.
@@ skipping 3909 matching lines @@
                               intptr_t token_pos,
                               const char* message_header,
                               const char* format,
                               va_list args) {
   const String& msg = String::Handle(
       FormatMessage(script, token_pos, message_header, format, args));
   return LanguageError::New(msg);
 }
 
 
+RawError* Parser::FormatErrorMsg(const Script& script,
+                                 intptr_t token_pos,
+                                 const char* message_header,
+                                 const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  const Error& error = Error::Handle(
+      FormatError(script, token_pos, message_header, format, args));
+  va_end(args);
+  return error.raw();
+}
+
+
 RawString* Parser::FormatMessage(const Script& script,
                                  intptr_t token_pos,
                                  const char* message_header,
                                  const char* format, va_list args) {
   String& result = String::Handle();
   const String& msg = String::Handle(String::NewFormattedV(format, args));
   if (!script.IsNull()) {
     const String& script_url = String::CheckedHandle(script.url());
     if (token_pos >= 0) {
       intptr_t line, column;
@@ skipping 1171 matching lines @@
         // 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,
                                             type->token_pos()));
         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());
             *type = ClassFinalizer::NewFinalizedMalformedType(
+                Error::Handle(),  // No previous error.
                 scope_class,
                 type->token_pos(),
+                finalization,
                 "type parameter '%s' cannot be referenced "
                 "from static member",
                 String::Handle(type_parameter.name()).ToCString());
             return;
           }
-          // TODO(regis): Should this be a malformed type as well?
-          // A type parameter cannot be parameterized, so report an error if
-          // type arguments have previously been parsed.
+          // A type parameter cannot be parameterized, so make the type
+          // malformed if type arguments have previously been parsed.

[hausner, 2012/10/23 22:02:24]

indentation

[regis, 2012/10/23 22:30:25]

Strange. I do not see this bad indentation in the source and there is no tab
character either.

           if (!AbstractTypeArguments::Handle(type->arguments()).IsNull()) {
-            ErrorMsg(type_parameter.token_pos(),
-                     "type parameter '%s' cannot be parameterized",
-                     String::Handle(type_parameter.name()).ToCString());
+            *type = ClassFinalizer::NewFinalizedMalformedType(
+                Error::Handle(),  // No previous error.
+                scope_class,
+                type_parameter.token_pos(),
+                finalization,
+                "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);
+                                            unresolved_class_name,
+                                            &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);
+                                    lib_prefix,
+                                    unresolved_class_name,
+                                    &error);
+      if (!error.IsNull()) {
+        *type = ClassFinalizer::NewFinalizedMalformedType(
+            error,
+            scope_class,
+            unresolved_class.token_pos(),
+            finalization,
+            "cannot resolve class '%s'",
+            unresolved_class_name.ToCString());
+        return;
+      }
     }
     // At this point, we can only have a parameterized_type.
     Type& parameterized_type = Type::Handle();
     parameterized_type ^= type->raw();
     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) {
       // The type is malformed.
       ClassFinalizer::FinalizeMalformedType(
@@ skipping 447 matching lines @@
 }
 
 
 // Resolve a name by checking the global scope of the current
 // library. If not found in the current library, then look in the scopes
 // of all libraries that are imported without a library prefix.
 // Issue an error if the name is not found in the global scope
 // of the current library, but is defined in more than one imported
 // library, i.e. if the name cannot be resolved unambiguously.
 RawObject* Parser::ResolveNameInCurrentLibraryScope(intptr_t ident_pos,
-                                                    const String& name) {
+                                                    const String& name,
+                                                    Error* error) {
   TRACE_PARSER("ResolveNameInCurrentLibraryScope");
   Object& obj = Object::Handle(LookupNameInLibrary(library_, name));
   if (obj.IsNull()) {
     // Name is not found in current library. Check scope of all
     // imported libraries.
     String& first_lib_url = String::Handle();
     Namespace& import = Namespace::Handle();
     intptr_t num_imports = library_.num_imports();
     Object& imported_obj = Object::Handle();
     for (int i = 0; i < num_imports; i++) {
       import ^= library_.ImportAt(i);
       imported_obj = LookupNameInImport(import, name);
       if (!imported_obj.IsNull()) {
         const Library& lib = Library::Handle(import.library());
         if (!first_lib_url.IsNull()) {
           // Found duplicate definition.
+          Error& ambiguous_ref_error = Error::Handle();
           if (first_lib_url.raw() == lib.url()) {
-            ErrorMsg(ident_pos,
-                     "ambiguous reference: "
-                     "'%s' as library '%s' is imported multiple times",
-                     name.ToCString(),
-                     first_lib_url.ToCString());
+            ambiguous_ref_error = FormatErrorMsg(
+                script_, ident_pos, "Error",
+                "ambiguous reference: "
+                "'%s' as library '%s' is imported multiple times",
+                name.ToCString(),
+                first_lib_url.ToCString());
           } else {
-            ErrorMsg(ident_pos,
-                     "ambiguous reference: "
-                     "'%s' is defined in library '%s' and also in '%s'",
-                     name.ToCString(),
-                     first_lib_url.ToCString(),
-                     String::Handle(lib.url()).ToCString());
+            ambiguous_ref_error = FormatErrorMsg(
+                script_, ident_pos, "Error",
+                "ambiguous reference: "
+                "'%s' is defined in library '%s' and also in '%s'",
+                name.ToCString(),
+                first_lib_url.ToCString(),
+                String::Handle(lib.url()).ToCString());
           }
+          if (error == NULL) {
+            // Report a compile time error since the caller is not interested
+            // in the error.
+            ErrorMsg(ambiguous_ref_error);
+          }
+          *error = ambiguous_ref_error.raw();
+          return Object::null();
         } else {
           first_lib_url = lib.url();
           obj = imported_obj.raw();
         }
       }
     }
   }
   return obj.raw();
 }
 
 
 RawClass* Parser::ResolveClassInCurrentLibraryScope(intptr_t ident_pos,
-                                                    const String& name) {
+                                                    const String& name,
+                                                    Error* error) {
   const Object& obj =
-      Object::Handle(ResolveNameInCurrentLibraryScope(ident_pos, name));
+      Object::Handle(ResolveNameInCurrentLibraryScope(ident_pos, name, error));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
 // Resolve an identifier by checking the global scope of the current
 // library. If not found in the current library, then look in the scopes
 // of all libraries that are imported without a library prefix.
 // Issue an error if the identifier is not found in the global scope
 // of the current library, but is defined in more than one imported
 // library, i.e. if the identifier cannot be resolved unambiguously.
 AstNode* Parser::ResolveIdentInCurrentLibraryScope(intptr_t ident_pos,
                                                    const String& ident) {
   TRACE_PARSER("ResolveIdentInCurrentLibraryScope");
   const Object& obj =
-    Object::Handle(ResolveNameInCurrentLibraryScope(ident_pos, ident));
+    Object::Handle(ResolveNameInCurrentLibraryScope(ident_pos, ident, NULL));
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
   } else if (obj.IsField()) {
     const Field& field = Field::Cast(obj);
     ASSERT(field.is_static());
     return GenerateStaticFieldLookup(field, ident_pos);
   } else if (obj.IsFunction()) {
     const Function& func = Function::Cast(obj);
     ASSERT(func.is_static());
@@ skipping 10 matching lines @@
   } else {
     ASSERT(obj.IsNull() || obj.IsLibraryPrefix());
   }
   // Lexically unresolved primary identifiers are referenced by their name.
   return new PrimaryNode(ident_pos, ident);
 }
 
 
 RawObject* Parser::ResolveNameInPrefixScope(intptr_t ident_pos,
                                             const LibraryPrefix& prefix,
-                                            const String& name) {
+                                            const String& name,
+                                            Error* error) {
   TRACE_PARSER("ResolveNameInPrefixScope");
   Namespace& import = Namespace::Handle();
   String& first_lib_url = String::Handle();
   Object& obj = Object::Handle();
   Object& resolved_obj = Object::Handle();
   const Array& imports = Array::Handle(prefix.imports());
   for (intptr_t i = 0; i < prefix.num_imports(); i++) {
     import ^= imports.At(i);
     resolved_obj = LookupNameInImport(import, name);
     if (!resolved_obj.IsNull()) {
       obj = resolved_obj.raw();
       const Library& lib = Library::Handle(import.library());
       if (first_lib_url.IsNull()) {
         first_lib_url = lib.url();
       } else {
         // Found duplicate definition.
+        Error& ambiguous_ref_error = Error::Handle();
         if (first_lib_url.raw() == lib.url()) {
-          ErrorMsg(ident_pos,
-                   "ambiguous reference: '%s.%s' is imported multiple times",
-                   String::Handle(prefix.name()).ToCString(),
-                   name.ToCString());
+          ambiguous_ref_error = FormatErrorMsg(
+              script_, ident_pos, "Error",
+              "ambiguous reference: '%s.%s' is imported multiple times",
+              String::Handle(prefix.name()).ToCString(),
+              name.ToCString());
         } else {
-          ErrorMsg(ident_pos,
-                   "ambiguous reference: '%s.%s' is defined in '%s' and '%s'",
-                   String::Handle(prefix.name()).ToCString(),
-                   name.ToCString(),
-                   first_lib_url.ToCString(),
-                   String::Handle(lib.url()).ToCString());
+          ambiguous_ref_error = FormatErrorMsg(
+              script_, ident_pos, "Error",
+              "ambiguous reference: '%s.%s' is defined in '%s' and '%s'",
+              String::Handle(prefix.name()).ToCString(),
+              name.ToCString(),
+              first_lib_url.ToCString(),
+              String::Handle(lib.url()).ToCString());
         }
+        if (error == NULL) {
+          // Report a compile time error since the caller is not interested
+          // in the error.
+          ErrorMsg(ambiguous_ref_error);
+        }
+        *error = ambiguous_ref_error.raw();
+        return Object::null();
       }
     }
   }
   return obj.raw();
 }
 
 
 RawClass* Parser::ResolveClassInPrefixScope(intptr_t ident_pos,
                                             const LibraryPrefix& prefix,
-                                            const String& name) {
+                                            const String& name,
+                                            Error* error) {
   const Object& obj =
-      Object::Handle(ResolveNameInPrefixScope(ident_pos, prefix, name));
+      Object::Handle(ResolveNameInPrefixScope(ident_pos, prefix, name, error));
   if (obj.IsClass()) {
     return Class::Cast(obj).raw();
   }
   return Class::null();
 }
 
 
 // Do a lookup for the identifier in the scope of the specified
 // library prefix. This means trying to resolve it locally in all of the
 // libraries present in the library prefix. If there are multiple libraries
 // with the name, issue an ambiguous reference error.
 AstNode* Parser::ResolveIdentInPrefixScope(intptr_t ident_pos,
                                            const LibraryPrefix& prefix,
                                            const String& ident) {
   TRACE_PARSER("ResolveIdentInPrefixScope");
   Object& obj =
-      Object::Handle(ResolveNameInPrefixScope(ident_pos, prefix, ident));
+      Object::Handle(ResolveNameInPrefixScope(ident_pos, prefix, ident, NULL));
   if (obj.IsNull()) {
     // Unresolved prefixed primary identifier.
     ErrorMsg(ident_pos, "identifier '%s.%s' cannot be resolved",
              String::Handle(prefix.name()).ToCString(),
              ident.ToCString());
   }
   if (obj.IsClass()) {
     const Class& cls = Class::Cast(obj);
     return new PrimaryNode(ident_pos, Class::ZoneHandle(cls.raw()));
   } else if (obj.IsField()) {
@@ skipping 578 matching lines @@
   ConsumeToken();
   if (!IsIdentifier()) {
     ErrorMsg("type name expected");
   }
   intptr_t type_pos = TokenPos();
   AbstractType& type = AbstractType::Handle(
       ParseType(ClassFinalizer::kCanonicalizeForCreation));
   // 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());
     // 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");
   }
 
   // The grammar allows for an optional ('.' identifier)? after the type, which
   // is a named constructor. Note that ParseType(kMustResolve) above will not
   // consume it as part of a misinterpreted qualified identifier, because only a
   // valid library prefix is accepted as qualifier.
@@ skipping 43 matching lines @@
     const String& constructor_name =
         BuildConstructorName(type_class_name, named_constructor);
     const String& external_constructor_name =
         (named_constructor ? constructor_name : type_class_name);
     Function& constructor = Function::ZoneHandle(
         type_class.LookupConstructor(constructor_name));
     if (constructor.IsNull()) {
       // Replace the type with a malformed type and compile a throw or report
       // a compile-time error if the constructor is const.
       type = ClassFinalizer::NewFinalizedMalformedType(
+          Error::Handle(),  // No previous error.
           current_class(),
           call_pos,
+          ClassFinalizer::kTryResolve,  // No compile-time error.
           "interface '%s' has no constructor named '%s'",
           type_class_name.ToCString(),
           external_constructor_name.ToCString());
       if (is_const) {
         const Error& error = Error::Handle(type.malformed_error());
         ErrorMsg(error);
       }
       return ThrowNoSuchMethodError(call_pos, external_constructor_name);
     }
     String& error_message = String::Handle();
@@ skipping 46 matching lines @@
   Function& constructor = Function::ZoneHandle(
       constructor_class.LookupConstructor(constructor_name));
   if (constructor.IsNull()) {
     constructor = constructor_class.LookupFactory(constructor_name);
     if (constructor.IsNull()) {
       const String& external_constructor_name =
           (named_constructor ? constructor_name : constructor_class_name);
       // Replace the type with a malformed type and compile a throw or report a
       // compile-time error if the constructor is const.
       type = ClassFinalizer::NewFinalizedMalformedType(
+          Error::Handle(),  // No previous error.
           current_class(),
           call_pos,
+          ClassFinalizer::kTryResolve,  // No compile-time error.
           "class '%s' has no constructor or factory named '%s'",
           String::Handle(constructor_class.Name()).ToCString(),
           external_constructor_name.ToCString());
       if (is_const) {
         const Error& error = Error::Handle(type.malformed_error());
         ErrorMsg(error);
       }
       return ThrowNoSuchMethodError(call_pos, external_constructor_name);
     } else if (constructor.IsRedirectingFactory()) {
       type = constructor.RedirectionType();
@@ skipping 728 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart