Store resolved library prefix in unresolved class object in order not to repeat

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 703 matching lines @@
   friend class Object;
   friend class Instance;
   friend class Type;
 };
 
 
 // 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_; }
+  RawLibraryPrefix* library_prefix() const {
+    return raw_ptr()->library_prefix_;
+  }
   RawString* ident() const { return raw_ptr()->ident_; }
   intptr_t token_index() const { return raw_ptr()->token_index_; }
 
   RawClass* factory_signature_class() const {
     return raw_ptr()->factory_signature_class_;
   }
   void set_factory_signature_class(const Class& value) const;
 
   RawString* Name() const;
 
   static intptr_t InstanceSize() {
     return RoundedAllocationSize(sizeof(RawUnresolvedClass));
   }
   static RawUnresolvedClass* New(intptr_t token_index,
-                                 const String& qualifier,
+                                 const LibraryPrefix& library_prefix,
                                  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;
+  void set_library_prefix(const LibraryPrefix& library_prefix) const;
 
   static RawUnresolvedClass* New();
 
   HEAP_OBJECT_IMPLEMENTATION(UnresolvedClass, Object);
   friend class Class;
 };
 
 
 // AbstractType is an abstract superclass.
 // Subclasses of AbstractType are Type, TypeParameter, and
@@ skipping 170 matching lines @@
   static RawType* ListInterface();
 
   // The least specific valid raw type of the given class.
   // For example, type A<Dynamic> would be returned for class A<T>, and type
   // B<Dynamic, A<Dynamic>> would be returned for B<U, V extends A>.
   static RawType* NewRawType(const Class& type_class);
 
   // The finalized type of the given non-parameterized class.
   static RawType* NewNonParameterizedType(const Class& type_class);
 
-  static RawType* NewParameterizedType(
-      const Object& type_class, const AbstractTypeArguments& arguments);
-
   static RawType* New(const Object& clazz,
                       const AbstractTypeArguments& arguments);
 
  private:
   void set_type_state(int8_t state) const;
 
   static RawType* New();
 
   HEAP_OBJECT_IMPLEMENTATION(Type, AbstractType);
   friend class Class;
@@ skipping 2653 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_