Eliminate imported_into pointers in Library

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 "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
@@ skipping 5919 matching lines @@
   }
   if (obj.IsFunction()) {
     return Function::Cast(obj).raw();
   }
 
   // No function found.
   return Function::null();
 }
 
 
-RawObject* Library::LookupObjectFiltered(const String& name,
-                                         const Library& filter_lib) const {
+RawObject* Library::LookupObject(const String& name) const {
   // First check if name is found in the local scope of the library.
   Object& obj = Object::Handle(LookupLocalObject(name));
   if (!obj.IsNull()) {
     return obj.raw();
   }
   // Now check if name is found in the top level scope of any imported libs.
   const Array& imports = Array::Handle(this->imports());
   Library& import_lib = Library::Handle();
   for (intptr_t j = 0; j < this->num_imports(); j++) {
     import_lib ^= imports.At(j);
-    // Skip over the library that we need to filter out.
-    if (!filter_lib.IsNull() && import_lib.raw() == filter_lib.raw()) {
-      continue;
-    }
     obj = import_lib.LookupLocalObject(name);
     if (!obj.IsNull()) {
       return obj.raw();
     }
   }
   return Object::null();
 }
 
 
-RawObject* Library::LookupObject(const String& name) const {
-  return LookupObjectFiltered(name, Library::Handle());
-}
-
-
-RawLibrary* Library::LookupObjectInImporter(const String& name) const {
-  Isolate* isolate = Isolate::Current();
-  const Array& imported_into_libs = Array::Handle(isolate,
-                                                  this->imported_into());
-  Library& lib = Library::Handle(isolate, Library::null());
-  Object& obj = Object::Handle(isolate, Object::null());
-  for (intptr_t i = 0; i < this->num_imported_into(); i++) {
-    lib ^= imported_into_libs.At(i);
-    obj = lib.LookupObjectFiltered(name, *this);
-    if (!obj.IsNull()) {
-      // If the object found is a class, field or function extract the
-      // library in which it is defined as it might be defined in one of
-      // the imported libraries.
-      Class& cls = Class::Handle(isolate, Class::null());
-      Function& func = Function::Handle(isolate, Function::null());
-      Field& field = Field::Handle(isolate, Field::null());
-      if (obj.IsClass()) {
-        cls ^= obj.raw();
-        lib ^= cls.library();
-      } else if (obj.IsFunction()) {
-        func ^= obj.raw();
-        cls ^= func.Owner();
-        lib ^= cls.library();
-      } else if (obj.IsField()) {
-        field ^= obj.raw();
-        cls ^= field.owner();
-        lib ^= cls.library();
-      }
-      return lib.raw();
-    }
-  }
-  return Library::null();
-}
-
-
-RawString* Library::DuplicateDefineErrorString(const String& entry_name,
-                                               const Library& conflict) const {
-  String& errstr = String::Handle();
-  Array& array = Array::Handle(Array::New(7));
-  errstr = String::New("'");
-  array.SetAt(0, errstr);
-  array.SetAt(1, entry_name);
-  errstr = String::New("' is defined in '");
-  array.SetAt(2, errstr);
-  errstr = url();
-  array.SetAt(3, errstr);
-  errstr = String::New("' and '");
-  array.SetAt(4, errstr);
-  errstr = conflict.url();
-  array.SetAt(5, errstr);
-  errstr = String::New("'");
-  array.SetAt(6, errstr);
-  errstr = String::ConcatAll(array);
-  return errstr.raw();
-}
-
-
-RawString* Library::FindDuplicateDefinition() const {
-  DictionaryIterator it(*this);
-  Object& obj = Object::Handle();
-  Class& cls = Class::Handle();
-  Function& func = Function::Handle();
-  Field& field = Field::Handle();
-  String& entry_name = String::Handle();
-  String& error_message = String::Handle();
-  Library& conflicting_lib = Library::Handle();
-  LibraryPrefix& lib_prefix = LibraryPrefix::Handle();
-  while (it.HasNext()) {
-    obj = it.GetNext();
-    ASSERT(!obj.IsNull());
-    if (obj.IsClass()) {
-      cls ^= obj.raw();
-      if (cls.IsCanonicalSignatureClass()) {
-        continue;
-      }
-      entry_name = cls.Name();
-    } else if (obj.IsFunction()) {
-      func ^= obj.raw();
-      entry_name = func.name();
-    } else if (obj.IsField()) {
-      field ^= obj.raw();
-      entry_name = field.name();
-    } else if (obj.IsLibraryPrefix()) {
-      // For library prefix objects we check to make sure there are no
-      // duplicate definitions within the libraries imported using this
-      // prefix.
-      lib_prefix ^= obj.raw();
-      error_message = lib_prefix.CheckForDuplicateDefinition();
-      if (!error_message.IsNull()) {
-        return error_message.raw();
-      }
-      // We don't check library prefixes defined in this library for
-      // conflicts because they are not visible in the importing scope and
-      // hence cannot cause any duplicate definitions.
-      continue;
-    } else {
-      UNREACHABLE();
-    }
-    conflicting_lib = LookupObjectInImporter(entry_name);
-    if (!conflicting_lib.IsNull()) {
-      return this->DuplicateDefineErrorString(entry_name, conflicting_lib);
-    }
-  }
-  return String::null();
-}
-
-
 RawClass* Library::LookupClass(const String& name) const {
   Object& obj = Object::Handle(LookupObject(name));
   if (!obj.IsNull() && obj.IsClass()) {
     return Class::CheckedHandle(obj.raw()).raw();
   }
   return Class::null();
 }
 
 
 RawClass* Library::LookupLocalClass(const String& name) const {
@@ skipping 103 matching lines @@
   Array& imports = Array::Handle(this->imports());
   intptr_t capacity = imports.Length();
   if (num_imports() == capacity) {
     capacity = capacity + kImportsCapacityIncrement;
     imports = Array::Grow(imports, capacity);
     StorePointer(&raw_ptr()->imports_, imports.raw());
   }
   intptr_t index = num_imports();
   imports.SetAt(index, library);
   set_num_imports(index + 1);
-  library.AddImportedInto(*this);
-}
-
-
-void Library::AddImportedInto(const Library& library) const {
-  Array& imported_into = Array::Handle(this->imported_into());
-  intptr_t capacity = imported_into.Length();
-  if (num_imported_into() == capacity) {
-    capacity = capacity + kImportedIntoCapacityIncrement;
-    imported_into = Array::Grow(imported_into, capacity);
-    StorePointer(&raw_ptr()->imported_into_, imported_into.raw());
-  }
-  intptr_t index = num_imported_into();
-  imported_into.SetAt(index, library);
-  set_num_imported_into(index + 1);
 }
 
 
 void Library::InitClassDictionary() const {
   // The last element of the dictionary specifies the number of in use slots.
   // TODO(iposva): Find reasonable initial size.
   const int kInitialElementCount = 16;
 
   const Array& dictionary =
       Array::Handle(Array::New(kInitialElementCount + 1, Heap::kOld));
   dictionary.SetAt(kInitialElementCount, Smi::Handle(Smi::New(0)));
   StorePointer(&raw_ptr()->dictionary_, dictionary.raw());
 }
 
 
 void Library::InitImportList() const {
   const Array& imports =
       Array::Handle(Array::New(kInitialImportsCapacity, Heap::kOld));
   StorePointer(&raw_ptr()->imports_, imports.raw());
   raw_ptr()->num_imports_ = 0;
 }
 
 
-void Library::InitImportedIntoList() const {
-  const Array& imported_into =
-      Array::Handle(Array::New(kInitialImportedIntoCapacity, Heap::kOld));
-  StorePointer(&raw_ptr()->imported_into_, imported_into.raw());
-  raw_ptr()->num_imported_into_ = 0;
-}
-
-
 RawLibrary* Library::New() {
   ASSERT(Object::library_class() != Class::null());
   RawObject* raw = Object::Allocate(Library::kClassId,
                                     Library::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibrary*>(raw);
 }
 
 
 RawLibrary* Library::NewLibraryHelper(const String& url,
                                       bool import_core_lib) {
   const Library& result = Library::Handle(Library::New());
   result.StorePointer(&result.raw_ptr()->name_, url.raw());
   result.StorePointer(&result.raw_ptr()->url_, url.raw());
   result.raw_ptr()->private_key_ = Scanner::AllocatePrivateKey(result);
   result.raw_ptr()->dictionary_ = Object::empty_array();
   result.raw_ptr()->anonymous_classes_ = Object::empty_array();
   result.raw_ptr()->num_anonymous_ = 0;
   result.raw_ptr()->imports_ = Object::empty_array();
   result.raw_ptr()->loaded_scripts_ = Array::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.set_debuggable(false);
   result.raw_ptr()->load_state_ = RawLibrary::kAllocated;
   result.raw_ptr()->index_ = -1;
   result.InitClassDictionary();
   result.InitImportList();
-  result.InitImportedIntoList();
   if (import_core_lib) {
     Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
     result.AddImport(core_lib);
   }
   return result.raw();
 }
 
 
 RawLibrary* Library::New(const String& url) {
@@ skipping 92 matching lines @@
     lib ^= libs.At(i);
     lib_url = lib.url();
     if (lib_url.Equals(url)) {
       return lib.raw();
     }
   }
   return Library::null();
 }
 
 
-RawString* Library::CheckForDuplicateDefinition() {
-  Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  ObjectStore* object_store = isolate->object_store();
-  ASSERT(object_store != NULL);
-  const GrowableObjectArray& libs =
-      GrowableObjectArray::Handle(object_store->libraries());
-  Library& lib = Library::Handle();
-  String& error_message = String::Handle();
-  for (int i = 0; i < libs.Length(); i++) {
-    lib ^= libs.At(i);
-    error_message = lib.FindDuplicateDefinition();
-    if (!error_message.IsNull()) {
-      return error_message.raw();
-    }
-  }
-  return String::null();
-}
-
-
 RawError* Library::Patch(const Script& script) const {
   ASSERT(script.kind() == RawScript::kPatchTag);
   return Compiler::Compile(*this, script);
 }
 
 
 bool Library::IsKeyUsed(intptr_t key) {
   intptr_t lib_key;
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
@@ skipping 174 matching lines @@
 const char* LibraryPrefix::ToCString() const {
   const char* kFormat = "LibraryPrefix:'%s'";
   const String& prefix = String::Handle(name());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, prefix.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, prefix.ToCString());
   return chars;
 }
 
 
-RawString* LibraryPrefix::CheckForDuplicateDefinition() const {
-  Library& lib = Library::Handle();
-  Library& conflicting_lib = Library::Handle();
-  Object& obj = Object::Handle();
-  Class& cls = Class::Handle();
-  Function& func = Function::Handle();
-  Field& field = Field::Handle();
-  String& entry_name = String::Handle();
-
-  for (intptr_t i = 0; i < num_libs(); i++) {
-    lib = GetLibrary(i);
-    ASSERT(!lib.IsNull());
-    DictionaryIterator it(lib);
-    while (it.HasNext()) {
-      obj = it.GetNext();
-      ASSERT(!obj.IsNull());
-      if (obj.IsClass()) {
-        cls ^= obj.raw();
-        if (cls.IsCanonicalSignatureClass()) {
-          continue;
-        }
-        entry_name = cls.Name();
-      } else if (obj.IsFunction()) {
-        func ^= obj.raw();
-        entry_name = func.name();
-      } else if (obj.IsField()) {
-        field ^= obj.raw();
-        entry_name = field.name();
-      } else {
-        // We don't check library prefixes defined in this library for
-        // conflicts because they are not visible in the importing scope and
-        // hence cannot cause any duplicate definitions.
-        continue;
-      }
-      for (intptr_t j = i + 1; j < num_libs(); j++) {
-        conflicting_lib = GetLibrary(j);
-        ASSERT(!conflicting_lib.IsNull());
-        // Check if name is found in the local scope of the library.
-        obj = conflicting_lib.LookupLocalObject(entry_name);
-        if (!obj.IsNull()) {
-          return lib.DuplicateDefineErrorString(entry_name, conflicting_lib);
-        }
-      }
-    }
-  }
-  return String::null();
-}
-
-
 void LibraryPrefix::set_name(const String& value) const {
   ASSERT(value.IsSymbol());
   StorePointer(&raw_ptr()->name_, value.raw());
 }
 
 
 void LibraryPrefix::set_libraries(const Array& value) const {
   StorePointer(&raw_ptr()->libraries_, value.raw());
 }
 
@@ skipping 4672 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "WeakProperty";
 }
 
 }  // namespace dart