Changes to handle unresolved qualified identifiers.

runtime/vm/object.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/object.h"
 
 #include "vm/assembler.h"
 #include "vm/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 32 matching lines @@
 #endif
 #define RAW_NULL kHeapObjectTag
 RawObject* Object::null_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::sentinel_ = reinterpret_cast<RawInstance*>(RAW_NULL);
 RawInstance* Object::transition_sentinel_ =
     reinterpret_cast<RawInstance*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::null_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::var_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::unresolved_class_class_ =
+    reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::parameterized_type_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_parameter_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_array_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instantiated_type_arguments_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 14 matching lines @@
 int Object::GetSingletonClassIndex(const RawClass* raw_class) {
   ASSERT(raw_class->IsHeapObject());
   if (raw_class == class_class()) {
     return kClassClass;
   } else if (raw_class == null_class()) {
     return kNullClass;
   } else if (raw_class == var_class()) {
     return kVarClass;
   } else if (raw_class == void_class()) {
     return kVoidClass;
+  } else if (raw_class == unresolved_class_class()) {
+    return kUnresolvedClassClass;
   } else if (raw_class == parameterized_type_class()) {
     return kParameterizedTypeClass;
   } else if (raw_class == type_parameter_class()) {
     return kTypeParameterClass;
   } else if (raw_class == instantiated_type_class()) {
     return kInstantiatedTypeClass;
   } else if (raw_class == type_arguments_class()) {
     return kTypeArgumentsClass;
   } else if (raw_class == type_array_class()) {
     return kTypeArrayClass;
@@ skipping 27 matching lines @@
   return kInvalidIndex;
 }
 
 
 RawClass* Object::GetSingletonClass(int index) {
   switch (index) {
     case kClassClass: return class_class();
     case kNullClass: return null_class();
     case kVarClass: return var_class();
     case kVoidClass: return void_class();
+    case kUnresolvedClassClass: return unresolved_class_class();
     case kParameterizedTypeClass: return parameterized_type_class();
     case kTypeParameterClass: return type_parameter_class();
     case kInstantiatedTypeClass: return instantiated_type_class();
     case kTypeArgumentsClass: return type_arguments_class();
     case kTypeArrayClass: return type_array_class();
     case kInstantiatedTypeArgumentsClass:
         return instantiated_type_arguments_class();
     case kFunctionClass: return function_class();
     case kFieldClass: return field_class();
     case kTokenStreamClass: return token_stream_class();
@@ skipping 12 matching lines @@
   return reinterpret_cast<RawClass*>(kHeapObjectTag);  // return RAW_NULL.
 }
 
 
 const char* Object::GetSingletonClassName(int index) {
   switch (index) {
     case kClassClass: return "Class";
     case kNullClass: return "Null";
     case kVarClass: return "var";
     case kVoidClass: return "void";
+    case kUnresolvedClassClass: return "UnresolvedClass";
     case kParameterizedTypeClass: return "ParameterizedType";
     case kTypeParameterClass: return "TypeParameter";
     case kInstantiatedTypeClass: return "InstantiatedType";
     case kTypeArgumentsClass: return "TypeArguments";
     case kTypeArrayClass: return "TypeArray";
     case kInstantiatedTypeArgumentsClass: return "InstantiatedTypeArguments";
     case kFunctionClass: return "Function";
     case kFieldClass: return "Field";
     case kTokenStreamClass: return "TokenStream";
     case kScriptClass: return "Script";
@@ skipping 65 matching lines @@
     sentinel ^= Object::Allocate(cls, Instance::InstanceSize(), Heap::kOld);
     sentinel_ = sentinel.raw();
 
     Instance& transition_sentinel = Instance::Handle();
     transition_sentinel ^=
         Object::Allocate(cls, Instance::InstanceSize(), Heap::kOld);
     transition_sentinel_ = transition_sentinel.raw();
   }
 
   // Allocate the remaining VM internal classes.
+  cls = Class::New<UnresolvedClass>();
+  unresolved_class_class_ = cls.raw();
+
   cls = Class::New<Instance>();
   var_class_ = cls.raw();
 
   cls = Class::New<Instance>();
   void_class_ = cls.raw();
 
   cls = Class::New<ParameterizedType>();
   parameterized_type_class_ = cls.raw();
 
   cls = Class::New<TypeParameter>();
@@ skipping 1206 matching lines @@
   const char* library_name = lib.IsNull() ? "" : lib.ToCString();
   const char* class_name = String::Handle(Name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, format, library_name, class_name) + 1;
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len));
   OS::SNPrint(chars, len, format, library_name, class_name);
   return chars;
 }
 
 
+RawUnresolvedClass* UnresolvedClass::New(intptr_t token_index,
+                                         const String& qualifier,
+                                         const String& ident) {
+  const UnresolvedClass& type = UnresolvedClass::Handle(UnresolvedClass::New());
+  type.set_token_index(token_index);
+  type.set_qualifier(qualifier);
+  type.set_ident(ident);
+  return type.raw();
+}
+
+
+RawUnresolvedClass* UnresolvedClass::New() {
+  const Class& unresolved_class_class =
+      Class::Handle(Object::unresolved_class_class());
+  RawObject* raw = Object::Allocate(unresolved_class_class,
+                                    UnresolvedClass::InstanceSize(),
+                                    Heap::kNew);
+  return reinterpret_cast<RawUnresolvedClass*>(raw);
+}
+
+
+void UnresolvedClass::set_token_index(intptr_t token_index) const {
+  raw_ptr()->token_index_ = token_index;
+}
+
+
+void UnresolvedClass::set_ident(const String& ident) const {
+  StorePointer(&raw_ptr()->ident_, ident.raw());
+}
+
+
+void UnresolvedClass::set_qualifier(const String& qualifier) const {
+  StorePointer(&raw_ptr()->qualifier_, qualifier.raw());
+}
+
+
+RawString* UnresolvedClass::Name() const {
+  if (qualifier() != String::null()) {
+    String& name = String::Handle();
+    name = qualifier();
+    String& str = String::Handle();
+    str = String::New(".");
+    name = String::Concat(name, str);
+    str = ident();
+    name = String::Concat(name, str);
+    return name.raw();
+  } else {
+    return ident();
+  }
+}
+
+
+const char* UnresolvedClass::ToCString() const {
+  return "UnresolvedClass";
+}
+
+
 bool Type::IsResolved() const {
   // Type is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 bool Type::HasResolvedTypeClass() const {
   // Type is an abstract class.
   UNREACHABLE();
   return false;
 }
 
 
 RawClass* Type::type_class() const {
   // Type is an abstract class.
   UNREACHABLE();
   return Class::null();
 }
 
 
-RawString* Type::unresolved_type_class() const {
+RawUnresolvedClass* Type::unresolved_class() const {
   // Type is an abstract class.
   UNREACHABLE();
-  return String::null();
+  return UnresolvedClass::null();
 }
 
 
 RawTypeArguments* Type::arguments() const  {
   // Type is an abstract class.
   UNREACHABLE();
   return TypeArguments::null();
 }
 
 
@@ skipping 31 matching lines @@
     class_name = cls.Name();
     num_type_params = cls.NumTypeParameters();  // Do not print the full vector.
     if (num_type_params > num_args) {
       ASSERT(!IsFinalized());
       // We fill up with "var".
       first_type_param_index = 0;
     } else {
       first_type_param_index = num_args - num_type_params;
     }
   } else {
-    class_name = unresolved_type_class();
+    const UnresolvedClass& type = UnresolvedClass::Handle(unresolved_class());
+    class_name = type.Name();
     num_type_params = num_args;
     first_type_param_index = 0;
   }
   String& type_name = String::Handle();
   if (num_type_params == 0) {
     type_name = class_name.raw();
   } else {
     const intptr_t num_strings = 2*num_type_params + 2;  // "C""<""T"", ""T"">".
     const Array& strings = Array::Handle(Array::New(num_strings));
     intptr_t s = 0;
@@ skipping 28 matching lines @@
   // Type is an abstract class.
   UNREACHABLE();
   return -1;
 }
 
 
 RawString* Type::ClassName() const {
   if (HasResolvedTypeClass()) {
     return Class::Handle(type_class()).Name();
   } else {
-    return unresolved_type_class();
+    return UnresolvedClass::Handle(unresolved_class()).Name();
   }
 }
 
 
 bool Type::IsBoolInterface() const {
   return HasResolvedTypeClass() &&
       (type_class() == Type::Handle(Type::BoolInterface()).type_class());
 }
 
 
@@ skipping 186 matching lines @@
 
 
 RawClass* ParameterizedType::type_class() const {
   ASSERT(HasResolvedTypeClass());
   Class& type_class = Class::Handle();
   type_class ^= raw_ptr()->type_class_;
   return type_class.raw();
 }
 
 
-RawString* ParameterizedType::unresolved_type_class() const {
+RawUnresolvedClass* ParameterizedType::unresolved_class() const {
   ASSERT(!HasResolvedTypeClass());
-  String& unresolved_type_class = String::Handle();
-  unresolved_type_class ^= raw_ptr()->type_class_;
-  return unresolved_type_class.raw();
+  UnresolvedClass& unresolved_class = UnresolvedClass::Handle();
+  unresolved_class ^= raw_ptr()->type_class_;
+  ASSERT(!unresolved_class.IsNull());
+  return unresolved_class.raw();
 }
 
 
 RawTypeArguments* ParameterizedType::arguments() const {
   return raw_ptr()->arguments_;
 }
 
 
 bool ParameterizedType::IsInstantiated() const {
   const TypeArguments& args = TypeArguments::Handle(arguments());
@@ skipping 13 matching lines @@
                                                     offset);
   }
   ParameterizedType& instantiated_type = ParameterizedType::Handle(
       ParameterizedType::New(Object::Handle(type_class()), type_arguments));
   instantiated_type.set_is_finalized();
   return instantiated_type.raw();
 }
 
 
 void ParameterizedType::set_type_class(const Object& value) const {
-  ASSERT(!value.IsNull() && (value.IsClass() || value.IsString()));
+  ASSERT(!value.IsNull() && (value.IsClass() || value.IsUnresolvedClass()));
   StorePointer(&raw_ptr()->type_class_, value.raw());
 }
 
 
 void ParameterizedType::set_arguments(const TypeArguments& value) const {
   StorePointer(&raw_ptr()->arguments_, value.raw());
 }
 
 
 RawParameterizedType* ParameterizedType::New() {
@@ skipping 4427 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart