Add an imported into list for libraries so that it is possible to lookup

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 3388 matching lines @@
   result.set_kind(kind);
   return result.raw();
 }
 
 
 const char* Script::ToCString() const {
   return "Script";
 }
 
 
+DictionaryIterator::DictionaryIterator(const Library& library)
+    : array_(Array::Handle(library.dictionary())),
+      // Last element in array is a Smi.
+      size_(Array::Handle(library.dictionary()).Length() - 1),
+      next_ix_(0) {
+  MoveToNextObject();
+}
+
+
+RawObject* DictionaryIterator::GetNext() {
+  ASSERT(HasNext());
+  int ix = next_ix_++;
+  MoveToNextObject();
+  ASSERT(array_.At(ix) != Object::null());
+  return array_.At(ix);
+}
+
+
+void DictionaryIterator::MoveToNextObject() {
+  Object& obj = Object::Handle(array_.At(next_ix_));
+  while (obj.IsNull() && HasNext()) {
+    next_ix_++;
+    obj = array_.At(next_ix_);
+  }
+}
+
+
 ClassDictionaryIterator::ClassDictionaryIterator(const Library& library)
-    : array_(Array::Handle(library.dictionary())),
-      // Last element in array is a Smi.
-      size_(Array::Handle(library.dictionary()).Length() - 1),
-      next_ix_(0) {
+    : DictionaryIterator(library) {
   MoveToNextClass();
 }
 
 
-RawClass* ClassDictionaryIterator::GetNext() {
+RawClass* ClassDictionaryIterator::GetNextClass() {
   ASSERT(HasNext());
   int ix = next_ix_++;
+  Object& obj = Object::Handle(array_.At(ix));
   MoveToNextClass();
-  ASSERT(array_.At(ix) != Object::null());
   Class& cls = Class::Handle();
-  cls ^= array_.At(ix);
+  cls ^= obj.raw();
   return cls.raw();
 }
 
 
 void ClassDictionaryIterator::MoveToNextClass() {
   Object& obj = Object::Handle(array_.At(next_ix_));
   while (!obj.IsClass() && HasNext()) {
     next_ix_++;
     obj = array_.At(next_ix_);
   }
@@ skipping 136 matching lines @@
       return entry.raw();
     }
     index = (index + 1) % dict_size;
     entry = dict.At(index);
   }
   return Class::null();
 }
 
 
 RawObject* Library::LookupObject(const String& name) const {
+  // First check if the name is found in the local scope.
   Object& obj = Object::Handle(LookupLocalObject(name));
   if (!obj.IsNull()) {
     return obj.raw();
   }
+  // Now check if the name is found in the local scope of any imported libs.
   Library& import = Library::Handle();
   Array& imports = Array::Handle(this->imports());
   for (intptr_t i = 0; i < num_imports(); i++) {
     import ^= imports.At(i);
     obj = import.LookupLocalObject(name);
     if (!obj.IsNull()) {
       return obj.raw();
     }
   }
   return Object::null();
 }
 
 
+RawObject* Library::LookupObjectInImporter(const String& name) const {
+  const Array& imported_into_libs = Array::Handle(this->imported_into());
+  Library& importer_lib = Library::Handle();
+  Object& obj = Object::Handle();
+  for (intptr_t i = 0; i < this->num_imported_into(); i++) {
+    importer_lib ^= imported_into_libs.At(i);
+    // Check if name is found in the top level scope of the importer.
+    ASSERT(importer_lib.raw() != raw());
+    // First check if name is found in the local scope of the library into

[Ivan Posva, 2011/10/20 08:46:04]

Please factor this out as it is essentially LookupObjectFiltered(name, *this)
where the second parameter is used to filter which imported library is skipped.
LookupObject then calls LookupObjectFiltered(name, Library::Handle()).

[siva, 2011/10/20 23:08:47]

Done.

+    // which this is imported into.
+    obj = importer_lib.LookupLocalObject(name);
+    if (!obj.IsNull()) {
+      return obj.raw();
+    }
+    // Now check if name is found in the top level scope of libs imported
+    // by the importer.
+    const Array& imports = Array::Handle(importer_lib.imports());
+    Library& import_lib = Library::Handle();
+    for (intptr_t j = 0; j < importer_lib.num_imports(); j++) {
+      import_lib ^= imports.At(j);
+      if (import_lib.raw() == raw()) {
+        continue;
+      }
+      obj = import_lib.LookupLocalObject(name);
+      if (!obj.IsNull()) {
+        return obj.raw();
+      }
+    }
+  }
+  return Object::null();
+}
+
+
+RawString* Library::DuplicateDefineErrorString(const Object& obj) const {
+  Class& cls = Class::Handle();
+  Function& func = Function::Handle();
+  Field& field = Field::Handle();
+  String& errstr = String::Handle();
+  if (obj.IsClass()) {
+    cls ^= obj.raw();
+    errstr = cls.Name();
+  } else if (obj.IsFunction()) {
+    func ^= obj.raw();
+    cls ^= func.owner();
+    errstr = func.name();
+  } else if (obj.IsField()) {
+    field ^= obj.raw();
+    cls ^= field.owner();
+    errstr = field.name();
+  } else {
+    UNREACHABLE();
+  }
+  const Library& lib = Library::Handle(cls.library());
+  Array& array = Array::Handle(Array::New(5));
+  array.SetAt(0, errstr);
+  errstr = String::New(" is defined in libraries ");
+  array.SetAt(1, errstr);
+  errstr = url();
+  array.SetAt(2, errstr);
+  errstr = String::New(" and ");
+  array.SetAt(3, errstr);
+  errstr = lib.url();
+  array.SetAt(4, errstr);
+  errstr = String::ConcatAll(array);
+  return errstr.raw();
+}
+
+
+RawObject* 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();
+  while (it.HasNext()) {
+    obj = it.GetNext();
+    if (obj.IsNull()) {

[Ivan Posva, 2011/10/20 08:46:04]

I don't think the iterator is ever handing out null objects.

[siva, 2011/10/20 23:08:47]

True, I changed this to an assertion.

On 2011/10/20 08:46:04, Ivan Posva wrote:

+      continue;
+    } else if (obj.IsClass()) {
+      cls ^= obj.raw();
+      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 {

[Ivan Posva, 2011/10/20 08:46:04]

Please add a comment explaining why you can skip library prefixes.

[siva, 2011/10/20 23:08:47]

Added comment stating that library prefixes in this library are not visible in
the importing scope.

On 2011/10/20 08:46:04, Ivan Posva wrote:

+      continue;
+    }
+    obj = LookupObjectInImporter(entry_name);
+    if (!obj.IsNull()) {
+      return obj.raw();
+    }
+  }
+  return Object::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 39 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() {
   const Class& library_class = Class::Handle(Object::library_class());
   RawObject* raw = Object::Allocate(library_class,
                                     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.raw_ptr()->name_ = url.raw();
   result.raw_ptr()->url_ = url.raw();
   result.raw_ptr()->private_key_ = Scanner::AllocatePrivateKey(result);
   result.raw_ptr()->dictionary_ = Array::Empty();
   result.raw_ptr()->anonymous_classes_ = Array::Empty();
   result.raw_ptr()->num_anonymous_ = 0;
   result.raw_ptr()->imports_ = Array::Empty();
   result.raw_ptr()->next_registered_ = Library::null();
   result.set_native_entry_resolver(NULL);
   result.raw_ptr()->corelib_imported_ = true;
   result.raw_ptr()->loaded_ = false;
   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);
     if (FLAG_expose_core_impl) {
       // Make implementation corelib visible to Dart code.
       result.AddImport(Library::Handle(Library::CoreImplLibrary()));
     }
   }
   return result.raw();
@@ skipping 31 matching lines @@
     lib_url = lib.url();
     if (lib_url.Equals(url)) {
       return lib.raw();
     }
     lib = lib.next_registered();
   }
   return Library::null();
 }
 
 
+RawString* Library::CheckForDuplicateDefinition() {
+  Library& lib = Library::Handle();
+  Isolate* isolate = Isolate::Current();
+  ASSERT(isolate != NULL);
+  ObjectStore* object_store = isolate->object_store();
+  ASSERT(object_store != NULL);
+  lib ^= object_store->registered_libraries();
+  Object& obj = Object::Handle();
+  while (!lib.IsNull()) {
+    obj = lib.FindDuplicateDefinition();
+    if (!obj.IsNull()) {
+      return lib.DuplicateDefineErrorString(obj);
+    }
+    lib ^= lib.next_registered();
+  }
+  return String::null();
+}
+
+
 bool Library::IsKeyUsed(intptr_t key) {
   intptr_t lib_key;
   Library& lib = Library::Handle();
   lib = Isolate::Current()->object_store()->registered_libraries();
   String& lib_url = String::Handle();
   while (!lib.IsNull()) {
     lib_url ^= lib.url();
     lib_key = lib_url.Hash();
     if (lib_key == key) {
       return true;
@@ skipping 73 matching lines @@
 }
 
 
 void Library::CompileAll() {
   Library& lib = Library::Handle(
       Isolate::Current()->object_store()->registered_libraries());
   Class& cls = Class::Handle();
   while (!lib.IsNull()) {
     ClassDictionaryIterator it(lib);
     while (it.HasNext()) {
-      cls ^= it.GetNext();
+      cls ^= it.GetNextClass();
       if (!cls.is_interface()) {
         Compiler::CompileAllFunctions(cls);
       }
     }
     Array& anon_classes = Array::Handle(lib.raw_ptr()->anonymous_classes_);
     for (int i = 0; i < lib.raw_ptr()->num_anonymous_; i++) {
       cls ^= anon_classes.At(i);
       ASSERT(!cls.is_interface());
       Compiler::CompileAllFunctions(cls);
     }
@@ skipping 2623 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