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

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/dart.h"
 #include "vm/globals.h"
@@ skipping 1407 matching lines @@
   void set_source(const String& value) const;
   void set_kind(RawScript::Kind value) const;
   void set_tokens(const TokenStream& value) const;
   static RawScript* New();
 
   HEAP_OBJECT_IMPLEMENTATION(Script, Object);
   friend class Class;
 };
 
 
-class ClassDictionaryIterator : public ValueObject {
+class DictionaryIterator : public ValueObject {
  public:
-  explicit ClassDictionaryIterator(const Library& library);
-  bool HasNext() const {
-    return next_ix_ < size_;
-  }
-  // Returns a non-null raw object.
-  RawClass* GetNext();
+  explicit DictionaryIterator(const Library& library);
+
+  bool HasNext() const { return next_ix_ < size_; }
+
+  // Returns next non-null raw object.
+  RawObject* GetNext();
 
  private:
-  void MoveToNextClass();
+  void MoveToNextObject();
 
   const Array& array_;
   const int size_;  // Number of elements to iterate over.
   int next_ix_;  // Index of next element.
 
+  friend class ClassDictionaryIterator;
+  DISALLOW_COPY_AND_ASSIGN(DictionaryIterator);
+};
+
+
+class ClassDictionaryIterator : public DictionaryIterator {
+ public:
+  explicit ClassDictionaryIterator(const Library& library);
+
+  // Returns a non-null raw class.
+  RawClass* GetNextClass();
+
+ private:
+  void MoveToNextClass();
+
   DISALLOW_COPY_AND_ASSIGN(ClassDictionaryIterator);
 };
 
 
 class Library : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   void SetName(const String& name) const;
 
   RawString* url() const { return raw_ptr()->url_; }
@@ skipping 22 matching lines @@
   // Resolving native methods for script loaded in the library.
   Dart_NativeEntryResolver native_entry_resolver() const {
     return raw_ptr()->native_entry_resolver_;
   }
   void set_native_entry_resolver(Dart_NativeEntryResolver value) const {
     raw_ptr()->native_entry_resolver_ = value;
   }
 
   void Register() const;
   static RawLibrary* LookupLibrary(const String& url);
+  static RawString* CheckForDuplicateDefinition();
   static bool IsKeyUsed(intptr_t key);
 
   static void InitCoreLibrary(Isolate* isolate);
   static RawLibrary* CoreLibrary();
   static RawLibrary* CoreImplLibrary();
 
   // Eagerly compile all classes and functions in the library.
   static void CompileAll();
 
  private:
   static const int kInitialImportsCapacity = 4;
   static const int kImportsCapacityIncrement = 8;
+  static const int kInitialImportedIntoCapacity = 1;
+  static const int kImportedIntoCapacityIncrement = 2;
   static RawLibrary* New();
 
   intptr_t num_imports() const { return raw_ptr()->num_imports_; }
   void set_num_imports(intptr_t value) const {
     raw_ptr()->num_imports_ = value;
   }
+  intptr_t num_imported_into() const { return raw_ptr()->num_imported_into_; }
+  void set_num_imported_into(intptr_t value) const {
+    raw_ptr()->num_imported_into_ = value;
+  }
   RawArray* imports() const { return raw_ptr()->imports_; }
+  RawArray* imported_into() const { return raw_ptr()->imported_into_; }
   RawArray* dictionary() const { return raw_ptr()->dictionary_; }
   RawLibrary* next_registered() const { return raw_ptr()->next_registered_; }
   void InitClassDictionary() const;
   void InitImportList() const;
+  void InitImportedIntoList() const;
   void GrowDictionary(const Array& dict, intptr_t dict_size) const;
   static RawLibrary* NewLibraryHelper(const String& url,
                                       bool import_core_lib);
+  void AddImportedInto(const Library& library) const;
+  RawObject* LookupObjectFiltered(const String& name,
+                                  const Library& filter_lib) const;
+  RawLibrary* LookupObjectInImporter(const String& name) const;
+  RawString* DuplicateDefineErrorString(const String& entry_name,
+                                        const Library& conflicting_lib) const;
+  RawString* FindDuplicateDefinition(Library* conflicting_lib) const;
+
   HEAP_OBJECT_IMPLEMENTATION(Library, Object);
   friend class Class;
-  friend class ClassDictionaryIterator;
+  friend class DictionaryIterator;
   friend class Isolate;
 };
 
 
 class LibraryPrefix : public Object {
  public:
   RawString* name() const { return raw_ptr()->name_; }
   RawLibrary* library() const { return raw_ptr()->library_; }
 
   static intptr_t InstanceSize() {
@@ skipping 1377 matching lines @@
 }
 
 
 void Context::SetAt(intptr_t index, const Instance& value) const {
   StorePointer(InstanceAddr(index), value.raw());
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_