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

runtime/vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 1731 matching lines @@
         Array::Handle(Array::Grow(canonical_list, new_length, Heap::kOld));
     set_constants(new_canonical_list);
     new_canonical_list.SetAt(index, constant);
   } else {
     canonical_list.SetAt(index, constant);
   }
 }
 
 
 RawUnresolvedClass* UnresolvedClass::New(intptr_t token_index,
-                                         const String& qualifier,
+                                         const LibraryPrefix& library_prefix,
                                          const String& ident) {
   const UnresolvedClass& type = UnresolvedClass::Handle(UnresolvedClass::New());
   type.set_token_index(token_index);
-  type.set_qualifier(qualifier);
+  type.set_library_prefix(library_prefix);
   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());
+void UnresolvedClass::set_library_prefix(
+    const LibraryPrefix& library_prefix) const {
+  StorePointer(&raw_ptr()->library_prefix_, library_prefix.raw());
 }
 
 
 void UnresolvedClass::set_factory_signature_class(const Class& value) const {
   StorePointer(&raw_ptr()->factory_signature_class_, value.raw());
 }
 
 
 RawString* UnresolvedClass::Name() const {
-  if (qualifier() != String::null()) {
+  if (library_prefix() != LibraryPrefix::null()) {
+    const LibraryPrefix& lib_prefix = LibraryPrefix::Handle(library_prefix());
     String& name = String::Handle();
-    name = qualifier();
     String& str = String::Handle();
+    name = lib_prefix.name();  // Qualifier.
     str = String::New(".");
     name = String::Concat(name, str);
     str = ident();
     name = String::Concat(name, str);
     return name.raw();
   } else {
     return ident();
   }
 }
 
@@ skipping 325 matching lines @@
 
 
 RawType* Type::ListInterface() {
   return Isolate::Current()->object_store()->list_interface();
 }
 
 
 RawType* Type::NewRawType(const Class& type_class) {
   const AbstractTypeArguments& type_arguments =
       AbstractTypeArguments::Handle(type_class.type_parameter_extends());
-  return NewParameterizedType(Object::Handle(type_class.raw()), type_arguments);
+  return New(Object::Handle(type_class.raw()), type_arguments);
 }
 
 
 RawType* Type::NewNonParameterizedType(
     const Class& type_class) {
   ASSERT(!type_class.HasTypeArguments());
   const TypeArguments& no_type_arguments = TypeArguments::Handle();
   Type& type = Type::Handle();
   type ^= Type::New(
       Object::Handle(type_class.raw()), no_type_arguments);
   type.set_is_finalized();
   type ^= type.Canonicalize();
   return type.raw();
 }
 
 
-RawType* Type::NewParameterizedType(const Object& clazz,
-                                    const AbstractTypeArguments& arguments) {
-  return Type::New(clazz, arguments);
-}
-
-
 void Type::set_is_finalized() const {
   ASSERT(!IsFinalized());
   set_type_state(RawType::kFinalized);
 }
 
 
 void Type::set_is_being_finalized() const {
   ASSERT(!IsFinalized() && !IsBeingFinalized());
   set_type_state(RawType::kBeingFinalized);
 }
@@ skipping 3470 matching lines @@
     // Can occur when running disassembler.
     return "Instance";
   } else {
     const char* kFormat = "Instance of '%s'";
     Class& cls = Class::Handle(clazz());
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::Handle();
     const intptr_t num_type_arguments = cls.NumTypeArguments();
     if (num_type_arguments > 0) {
       type_arguments = GetTypeArguments();
     }
-    const Type& type = Type::Handle(
-        Type::NewParameterizedType(cls, type_arguments));
+    const Type& type = Type::Handle(Type::New(cls, type_arguments));
     const String& type_name = String::Handle(type.Name());
     // Calculate the size of the string.
     intptr_t len = OS::SNPrint(NULL, 0, kFormat, type_name.ToCString()) + 1;
     char* chars = reinterpret_cast<char*>(
         Isolate::Current()->current_zone()->Allocate(len));
     OS::SNPrint(chars, len, kFormat, type_name.ToCString());
     return chars;
   }
 }
 
@@ skipping 2215 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