Changes to handle unresolved qualified identifiers.

runtime/vm/parser.cc

 // Copyright (c) 2011, 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 2087 matching lines @@
   }
   // Optionally parse a (possibly named) constructor name or factory.
   if ((CurrentToken() == Token::kIDENT) &&
       (CurrentLiteral()->Equals(members->class_name()) || member.has_factory)) {
     member.name = CurrentLiteral();
     member.name_pos = this->token_index_;
     // Factory result type is the same as the type name of the factory.
     // TODO(srdjan): Implement checks in class finalization when all types have
     // been resolved.
     if (member.has_factory && !member.name->Equals(members->class_name())) {
-      const TypeArguments& arguments = TypeArguments::Handle();
-      member.type = &Type::ZoneHandle(
-          Type::NewParameterizedType(*member.name, arguments));
+      const UnresolvedClass& type =
+          UnresolvedClass::Handle(UnresolvedClass::New(member.name_pos,
+                                                       String::Handle(),
+                                                       *(member.name)));
+      const TypeArguments& args = TypeArguments::Handle();
+      member.type = &Type::ZoneHandle(Type::NewParameterizedType(type, args));
     }
     ConsumeToken();
     // We must be dealing with a constructor or named constructor.
     member.kind = RawFunction::kConstructor;
     String& ctor_suffix = String::ZoneHandle(String::NewSymbol("."));
     if (CurrentToken() == Token::kPERIOD) {
       // Named constructor.
       ConsumeToken();
       const String* name = ExpectIdentifier("identifier expected");
       ctor_suffix = String::Concat(ctor_suffix, *name);
@@ skipping 1358 matching lines @@
     int nesting_level = 0;
     do {
       if (CurrentToken() == Token::kLT) {
         nesting_level++;
       } else if (CurrentToken() == Token::kGT) {
         nesting_level--;
       } else if (CurrentToken() == Token::kSAR) {
         nesting_level -= 2;
       } else if (CurrentToken() == Token::kSHR) {
         nesting_level -= 3;
+      } else if (CurrentToken() == Token::kIDENT) {
+        // Check to see if it is a qualified identifier.
+        if (LookaheadToken(1) == Token::kPERIOD) {
+          // Consume the identifier, the period will be consumed below.
+          ConsumeToken();
+        }
       } else if (CurrentToken() != Token::kCOMMA &&
-                 CurrentToken() != Token::kIDENT &&
                  CurrentToken() != Token::kEXTENDS) {
         // We are looking at something other than type parameters.
         return false;
       }
       ConsumeToken();
     } while (nesting_level > 0);
     if (nesting_level < 0) {
       return false;
     }
   }
@@ skipping 2062 matching lines @@
   return postfix_expr;
 }
 
 
 bool Parser::ResolveTypeFromClass(intptr_t type_pos,
                                   const Class& cls,
                                   Type* type) {
   ASSERT(type != NULL);
   // Resolve class.
   if (!type->HasResolvedTypeClass()) {
-    const String& unresolved_type_class =
-        String::Handle(type->unresolved_type_class());
+    const UnresolvedClass& unresolved_class =
+        UnresolvedClass::Handle(type->unresolved_class());
+    const String& unresolved_class_name =
+        String::Handle(unresolved_class.ident());
     // First check if the type is a type parameter of the given class.
     const TypeParameter& type_parameter = TypeParameter::Handle(
-        cls.LookupTypeParameter(unresolved_type_class));
+        cls.LookupTypeParameter(unresolved_class_name));
     if (!type_parameter.IsNull()) {
-      CheckTypeParameterReference(type_pos, unresolved_type_class);
+      CheckTypeParameterReference(type_pos, unresolved_class_name);
       // A type parameter cannot be parameterized, so report an error if type
       // arguments have previously been parsed.
       if (type->arguments() != TypeArguments::null()) {
         ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                  type_parameter.ToCString());
         return false;
       }
       *type = type_parameter.raw();
       return true;
     }
     const Class& resolved_type_class =
-        Class::Handle(LookupClass(unresolved_type_class));
+        Class::Handle(LookupClass(unresolved_class_name));
     if (resolved_type_class.IsNull()) {
       return false;
     }
     Object& type_class = Object::Handle(resolved_type_class.raw());
     ASSERT(type->IsParameterizedType());
-    // Replace unresolved type class with resolved type class.
+    // Replace unresolved class with resolved type class.
     ParameterizedType& parameterized_type = ParameterizedType::Handle();
     parameterized_type ^= type->raw();
     parameterized_type.set_type_class(type_class);
   }
   // Resolve type arguments, if any.
   const TypeArguments& arguments = TypeArguments::Handle(type->arguments());
   if (!arguments.IsNull()) {
     intptr_t num_arguments = arguments.Length();
     for (intptr_t i = 0; i < num_arguments; i++) {
       Type& type_argument = Type::Handle(arguments.TypeAt(i));
@@ skipping 401 matching lines @@
     ErrorMsg("type name expected");
   }
   QualIdent type_name;
   intptr_t type_pos = token_index_;
   ParseQualIdent(&type_name);
   if (type_name.local_scope_ident) {
     ErrorMsg(type_pos, "Using '%s' in this context is invalid",
              type_name.ident->ToCString());
   }
   Object& type_class = Object::Handle();
+  String& qualifier = String::Handle();
+  if (type_name.qualifier != NULL) {
+    qualifier ^= type_name.qualifier->raw();
+  }
   if (type_resolution == kDoNotResolve) {
-    // TODO(5072252): Figure out what should be done in this case.
-    if (type_name.qualifier != NULL) {
-      Unimplemented("cannot handle qualified type names yet");
-    }
-    type_class = type_name.ident->raw();
+    type_class = UnresolvedClass::New(type_pos, qualifier, *(type_name.ident));
   } else {
     TypeParameter& type_parameter = TypeParameter::Handle();
     // Check if qualifier is a type parameter of the class we are parsing.
     if (type_name.qualifier != NULL) {
       type_parameter =
           current_class().LookupTypeParameter(*type_name.qualifier);
       if (!type_parameter.IsNull()) {
         ErrorMsg(type_pos, "Use of '%s' in this context is invalid",
                  type_name.qualifier->ToCString());
       }
     } else {
       // Check if ident is a type parameter of the class we are parsing.
       type_parameter = current_class().LookupTypeParameter(*type_name.ident);
       if (!type_parameter.IsNull()) {
         CheckTypeParameterReference(type_name.ident_pos, *type_name.ident);
         if (CurrentToken() == Token::kLT) {
           // A type parameter cannot be parameterized.
           ErrorMsg(type_pos, "type parameter '%s' cannot be parameterized",
                    String::Handle(type_parameter.Name()).ToCString());
         }
         return type_parameter.raw();
       }
     }
     // Try to resolve the type class.
     type_class = LookupTypeClass(type_name, type_resolution);
+    if (!type_class.IsClass()) {
+      // We have an unresolved name, create an UnresolvedClass object
+      // for this case.
+      type_class = UnresolvedClass::New(type_pos,
+                                        qualifier,
+                                        *(type_name.ident));
+    }

[regis, 2011/10/13 17:23:03]

Why not move the creation of the unresolved class object to LookupTypeClass?
LookupTypeClass should not return a raw String anymore.

[siva, 2011/10/13 20:06:39]

Good idea, Done.

On 2011/10/13 17:23:03, regis wrote:

   }
   TypeArguments& type_arguments =
       TypeArguments::Handle(ParseTypeArguments(type_resolution));
   const Type& type = Type::Handle(
       Type::NewParameterizedType(type_class, type_arguments));
   if (type_resolution == kMustResolve) {
+    ASSERT(type_class.IsClass());  // Must be resolved.
     const String& errmsg = String::Handle(
         ClassFinalizer::FinalizeTypeWhileParsing(type));
     if (!errmsg.IsNull()) {
       ErrorMsg(errmsg.ToCString());
     }
   }
   return type.raw();
 }
 
 
@@ skipping 354 matching lines @@
 
     // TODO(srdjan): Evaluate if the mapping should occur during code
     // generation or here in the parser.
     const Type& factory_type = Type::Handle(type_class.factory_type());
     if (factory_type.IsNull()) {
       ErrorMsg("cannot allocate interface '%s' without factory class",
                type_class_name.ToCString());
     }
     if (!factory_type.HasResolvedTypeClass()) {
       // This error can occur only with bootstrap classes.
-      const String& missing_class_name =
-          String::Handle(factory_type.unresolved_type_class());
-      ErrorMsg("Unresolved factory class '%s'",
-               missing_class_name.ToCString());
+      const UnresolvedClass& unresolved =
+          UnresolvedClass::Handle(factory_type.unresolved_class());
+      const String& missing_class_name = String::Handle(unresolved.ident());
+      ErrorMsg("Unresolved factory class '%s'", missing_class_name.ToCString());
     }
 
     // Only change the class of the constructor to the factory class if the
     // factory class implements the interface 'type'.
     Class& factory_type_class = Class::Handle(factory_type.type_class());
     // TODO(regis): Verify in the guide/spec that a factory class must have
     // identical type parameters as the interface.
     // TODO(regis): Do we check that in the parser?
     // Assuming that it has been checked, it is sufficient to test if the
     // raw factory type implements the raw interface type.
@@ skipping 538 matching lines @@
 }
 
 
 void Parser::SkipNestedExpr() {
   const bool saved_mode = SetAllowFunctionLiterals(true);
   SkipExpr();
   SetAllowFunctionLiterals(saved_mode);
 }
 
 }  // namespace dart