Changes to handle unresolved qualified identifiers.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "vm/assert.h"
 #include "vm/globals.h"
 #include "vm/handles.h"
@@ skipping 101 matching lines @@
  public:
   // Index for Singleton internal VM classes,
   // this index is used in snapshots to refer to these classes directly.
   enum {
     kNullObject = 0,
     kSentinelObject,
     kClassClass,
     kNullClass,
     kVarClass,
     kVoidClass,
+    kUnresolvedClassClass,
     kParameterizedTypeClass,
     kTypeParameterClass,
     kInstantiatedTypeClass,
     kTypeArgumentsClass,
     kTypeArrayClass,
     kInstantiatedTypeArgumentsClass,
     kFunctionClass,
     kFieldClass,
     kTokenStreamClass,
     kScriptClass,
@@ skipping 70 matching lines @@
   // "uninitialized" fields.
   static RawInstance* sentinel() { return sentinel_; }
   // Value marking that we are transitioning from sentinel, e.g., computing
   // a field value. Used to detect circular initialization.
   static RawInstance* transition_sentinel() { return transition_sentinel_; }
 
   static RawClass* class_class() { return class_class_; }
   static RawClass* null_class() { return null_class_; }
   static RawClass* var_class() { return var_class_; }
   static RawClass* void_class() { return void_class_; }
+  static RawClass* unresolved_class_class() { return unresolved_class_class_; }
   static RawClass* parameterized_type_class() {
       return parameterized_type_class_;
   }
   static RawClass* type_parameter_class() { return type_parameter_class_; }
   static RawClass* instantiated_type_class() {
       return instantiated_type_class_;
   }
   static RawClass* type_arguments_class() { return type_arguments_class_; }
   static RawClass* type_array_class() { return type_array_class_; }
   static RawClass* instantiated_type_arguments_class() {
@@ skipping 83 matching lines @@
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
   static RawInstance* sentinel_;
   static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
   static RawClass* var_class_;  // Class of the 'var' type.
   static RawClass* void_class_;  // Class of the 'void' type.
+  static RawClass* unresolved_class_class_;  // Class of UnresolvedClass.
   static RawClass* parameterized_type_class_;  // Class of ParameterizedType.
   static RawClass* type_parameter_class_;  // Class of TypeParameter vm object.
   static RawClass* instantiated_type_class_;  // Class of InstantiatedType.
   static RawClass* type_arguments_class_;  // Class of TypeArguments vm object.
   static RawClass* type_array_class_;  // Class of the TypeArray vm object.
   static RawClass* instantiated_type_arguments_class_;  // Class of Inst..ments.
   static RawClass* function_class_;  // Class of the Function vm object.
   static RawClass* field_class_;  // Class of the Field vm object.
   static RawClass* token_stream_class_;  // Class of the TokenStream vm object.
   static RawClass* script_class_;  // Class of the Script vm object.
@@ skipping 283 matching lines @@
 
   // Assigns empty array to all raw class array fields.
   void InitEmptyFields();
 
   HEAP_OBJECT_IMPLEMENTATION(Class, Object);
   friend class Object;
   friend class Instance;
 };
 
 
+// Unresolved class is used for storing unresolved names which will be resolved
+// to a class after all classes have been loaded and finalized.
+class UnresolvedClass : public Object {
+ public:
+  RawString* qualifier() const { return raw_ptr()->qualifier_; }
+  RawString* ident() const { return raw_ptr()->ident_; }
+  intptr_t token_index() const { return raw_ptr()->token_index_; }
+
+  RawString* Name() const;
+
+  static intptr_t InstanceSize() {
+    return RoundedAllocationSize(sizeof(RawUnresolvedClass));
+  }
+  static RawUnresolvedClass* New(intptr_t token_index,
+                                 const String& qualifier,
+                                 const String& ident);
+
+ private:
+  void set_token_index(intptr_t token_index) const;
+  void set_ident(const String& ident) const;
+  void set_qualifier(const String& qualifier) const;
+
+  static RawUnresolvedClass* New();
+
+  HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
+  friend class Class;
+};
+
+
 // Type is an abstract superclass.
 // Subclasses of Type are ParameterizedType, TypeParameter, and
 // InstantiatedType.
 //
 // Caution: 'RawType*' denotes a 'raw' pointer to a VM object of class Type,
 // as opposed to 'Type' denoting a 'handle' to the same object. 'RawType' does
 // not relate to a 'raw type', as opposed to a 'cooked type' or 'rare type'.
 class Type : public Object {
  public:
   virtual bool IsFinalized() const;
   virtual bool IsResolved() const;
   virtual bool HasResolvedTypeClass() const;
   virtual RawClass* type_class() const;
-  virtual RawString* unresolved_type_class() const;
+  virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   virtual bool IsInstantiated() const;
 
   // Instantiate this type using the given type argument vector starting at the
   // given offset.
   // Return a new type, or return 'this' if it is already instantiated.
   virtual RawType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
@@ skipping 128 matching lines @@
   }
   void set_is_finalized() const;
   bool is_being_finalized() const {
     return raw_ptr()->type_state_ == RawParameterizedType::kBeingFinalized;
   }
   void set_is_being_finalized() const;
   virtual bool IsResolved() const;  // Class and all arguments classes resolved.
   virtual bool HasResolvedTypeClass() const;  // Own type class resolved.
   virtual RawClass* type_class() const;
   void set_type_class(const Object& value) const;
-  virtual RawString* unresolved_type_class() const;
+  virtual RawUnresolvedClass* unresolved_class() const;
   virtual RawTypeArguments* arguments() const;
   void set_arguments(const TypeArguments& value) const;
   virtual bool IsInstantiated() const;
   virtual RawType* InstantiateFrom(
       const TypeArguments& instantiator_type_arguments,
       intptr_t offset) const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawParameterizedType));
   }
@@ skipping 2018 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_