Support for show/hide combinators

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 69 matching lines @@
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::closure_data_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::field_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::literal_token_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::token_stream_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::script_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::library_prefix_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::namespace_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::code_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::instructions_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::pc_descriptors_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::stackmap_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::var_descriptors_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::exception_handlers_class_ =
     reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::deopt_info_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::context_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ skipping 247 matching lines @@
 
   cls = Class::New<Script>();
   script_class_ = cls.raw();
 
   cls = Class::New<Library>();
   library_class_ = cls.raw();
 
   cls = Class::New<LibraryPrefix>();
   library_prefix_class_ = cls.raw();
 
+  cls = Class::New<Namespace>();
+  namespace_class_ = cls.raw();
+
   cls = Class::New<Code>();
   code_class_ = cls.raw();
 
   cls = Class::New<Instructions>();
   instructions_class_ = cls.raw();
 
   cls = Class::New<PcDescriptors>();
   pc_descriptors_class_ = cls.raw();
 
   cls = Class::New<Stackmap>();
@@ skipping 72 matching lines @@
   SET_CLASS_NAME(type_arguments, TypeArguments);
   SET_CLASS_NAME(instantiated_type_arguments, InstantiatedTypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
   SET_CLASS_NAME(function, Function);
   SET_CLASS_NAME(closure_data, ClosureData);
   SET_CLASS_NAME(field, Field);
   SET_CLASS_NAME(literal_token, LiteralToken);
   SET_CLASS_NAME(token_stream, TokenStream);
   SET_CLASS_NAME(script, Script);
   SET_CLASS_NAME(library, LibraryClass);
   SET_CLASS_NAME(library_prefix, LibraryPrefix);

[siva, 2012/09/24 21:20:40]

oops forgot this:
We are missing
SET_CLASS_NAME(namespace, NameSpace);

and NameSpace added to symbols.h so that people referring
to this class name will get something.

[hausner, 2012/09/24 21:41:06]

Done.

   SET_CLASS_NAME(code, Code);
   SET_CLASS_NAME(instructions, Instructions);
   SET_CLASS_NAME(pc_descriptors, PcDescriptors);
   SET_CLASS_NAME(stackmap, Stackmap);
   SET_CLASS_NAME(var_descriptors, LocalVarDescriptors);
   SET_CLASS_NAME(exception_handlers, ExceptionHandlers);
   SET_CLASS_NAME(deopt_info, DeoptInfo);
   SET_CLASS_NAME(context, Context);
   SET_CLASS_NAME(context_scope, ContextScope);
   SET_CLASS_NAME(icdata, ICData);
@@ skipping 5804 matching lines @@
   Field& field = Field::Handle(LookupLocalField(name));
   if (!field.IsNull()) {
     return field.raw();
   }
 
   // Do not look up private names in imported libraries.
   if (ShouldBePrivate(name)) {
     return Field::null();
   }
 
-  // Now check if name is found in the top level scope of any imported
-  // libs.
+  // Now check if name is found in any imported libs.
   const Array& imports = Array::Handle(this->imports());
-  Library& import_lib = Library::Handle();
+  Namespace& import = Namespace::Handle();
+  Object& obj = Object::Handle();
   for (intptr_t j = 0; j < this->num_imports(); j++) {
-    import_lib ^= imports.At(j);
-
-
-    field = import_lib.LookupLocalField(name);
-    if (!field.IsNull()) {
+    import ^= imports.At(j);
+    obj = import.Lookup(name);
+    if (!obj.IsNull() && obj.IsField()) {
+      field ^= obj.raw();
       return field.raw();
     }
   }
   return Field::null();
 }
 
 
 RawField* Library::LookupLocalField(const String& name) const {
   Isolate* isolate = Isolate::Current();
   Field& field = Field::Handle(isolate, Field::null());
@@ skipping 20 matching lines @@
   Function& function = Function::Handle(LookupLocalFunction(name));
   if (!function.IsNull()) {
     return function.raw();
   }
 
   // Do not look up private names in imported libraries.
   if (ShouldBePrivate(name)) {
     return Function::null();
   }
 
-  // Now check if name is found in the top level scope of any imported
-  // libs.
+  // Now check if name is found in any imported libs.
   const Array& imports = Array::Handle(this->imports());
-  Library& import_lib = Library::Handle();
+  Namespace& import = Namespace::Handle();
+  Object& obj = Object::Handle();
   for (intptr_t j = 0; j < this->num_imports(); j++) {
-    import_lib ^= imports.At(j);
-
-
-    function = import_lib.LookupLocalFunction(name);
-    if (!function.IsNull()) {
+    import ^= imports.At(j);
+    obj = import.Lookup(name);
+    if (!obj.IsNull() && obj.IsFunction()) {
+      function ^= obj.raw();
       return function.raw();
     }
   }
   return Function::null();
 }
 
 
 RawFunction* Library::LookupLocalFunction(const String& name) const {
   Isolate* isolate = Isolate::Current();
   Object& obj = Object::Handle(isolate, Object::null());
@@ skipping 10 matching lines @@
   return Function::null();
 }
 
 
 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.
+  // Now check if name is found in any imported libs.
   const Array& imports = Array::Handle(this->imports());
-  Library& import_lib = Library::Handle();
+  Namespace& import = Namespace::Handle();
   for (intptr_t j = 0; j < this->num_imports(); j++) {
-    import_lib ^= imports.At(j);
-    obj = import_lib.LookupLocalObject(name);
+    import ^= imports.At(j);
+    obj = import.Lookup(name);
     if (!obj.IsNull()) {
       return obj.raw();
     }
   }
   return Object::null();
 }
 
 
 RawClass* Library::LookupClass(const String& name) const {
   Object& obj = Object::Handle(LookupObject(name));
@@ skipping 56 matching lines @@
   anon_array.SetAt(num_anonymous, cls);
   num_anonymous++;
   raw_ptr()->num_anonymous_ = num_anonymous;
 }
 
 
 RawLibrary* Library::LookupImport(const String& url) const {
   Isolate* isolate = Isolate::Current();
   const Array& imports = Array::Handle(isolate, this->imports());
   intptr_t num_imports = this->num_imports();
+  Namespace& import = Namespace::Handle(isolate, Namespace::null());
   Library& lib = Library::Handle(isolate, Library::null());
   String& import_url = String::Handle(isolate, String::null());
   for (int i = 0; i < num_imports; i++) {
-    lib ^= imports.At(i);
+    import ^= imports.At(i);
+    lib = import.library();
     import_url = lib.url();
     if (url.Equals(import_url)) {
       return lib.raw();
     }
   }
   return Library::null();
 }
 
 
-RawLibrary* Library::ImportAt(intptr_t index) const {
-  if ((index < 0) || index >= num_imports()) {
+RawLibrary* Library::ImportLibraryAt(intptr_t index) const {
+  Namespace& import = Namespace::Handle(ImportAt(index));
+  if (import.IsNull()) {
     return Library::null();
   }
-  const Array& import_list = Array::Handle(imports());
-  Library& lib = Library::Handle();
-  lib ^= import_list.At(index);
-  return lib.raw();
+  return import.library();
 }
 
 
-RawLibraryPrefix* Library::ImportPrefixAt(intptr_t index) const {
-  const Library& imported = Library::Handle(ImportAt(index));
-  if (imported.IsNull()) {
-    return LibraryPrefix::null();
+RawNamespace* Library::ImportAt(intptr_t index) const {
+  if ((index < 0) || index >= num_imports()) {
+    return Namespace::null();
   }
-  DictionaryIterator it(*this);
-  Object& obj = Object::Handle();
-  while (it.HasNext()) {
-    obj = it.GetNext();
-    if (obj.IsLibraryPrefix()) {
-      const LibraryPrefix& lib_prefix = LibraryPrefix::Cast(obj);
-      if (lib_prefix.ContainsLibrary(imported)) {
-        return lib_prefix.raw();
-      }
-    }
-  }
-  return LibraryPrefix::null();
+  const Array& import_list = Array::Handle(imports());
+  Namespace& import = Namespace::Handle();
+  import ^= import_list.At(index);
+  return import.raw();
 }
 
 
 bool Library::ImportsCorelib() const {
   Isolate* isolate = Isolate::Current();
   Library& imported = Library::Handle(isolate);
   intptr_t count = num_imports();
   for (int i = 0; i < count; i++) {
-    imported = ImportAt(i);
+    imported = ImportLibraryAt(i);
     if (imported.IsCoreLibrary()) {
       return true;
     }
   }
   LibraryPrefix& prefix = LibraryPrefix::Handle(isolate);
   LibraryPrefixIterator it(*this);
   while (it.HasNext()) {
     prefix = it.GetNext();
-    count = prefix.num_libs();
+    count = prefix.num_imports();
     for (int i = 0; i < count; i++) {
       imported = prefix.GetLibrary(i);
       if (imported.IsCoreLibrary()) {
         return true;
       }
     }
   }
   return false;
 }
 
 
-void Library::AddImport(const Library& library) const {
+void Library::AddImport(const Namespace& ns) const {
   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);
+  imports.SetAt(index, ns);
   set_num_imports(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 =
@@ skipping 32 matching lines @@
   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();
   if (import_core_lib) {
-    Library& core_lib = Library::Handle(Library::CoreLibrary());
+    const Library& core_lib = Library::Handle(Library::CoreLibrary());
     ASSERT(!core_lib.IsNull());
-    result.AddImport(core_lib);
+    const Namespace& ns = Namespace::Handle(
+        Namespace::New(core_lib, Array::Handle(), Array::Handle()));
+    result.AddImport(ns);
   }
   return result.raw();
 }
 
 
 RawLibrary* Library::New(const String& url) {
   return NewLibraryHelper(url, false);
 }
 
 
 void Library::InitCoreLibrary(Isolate* isolate) {
   const String& core_lib_url = String::Handle(Symbols::New("dart:core"));
   const Library& core_lib =
       Library::Handle(Library::NewLibraryHelper(core_lib_url, false));
   core_lib.Register();
+  const Namespace& core_ns = Namespace::Handle(
+      Namespace::New(core_lib, Array::Handle(), Array::Handle()));
   isolate->object_store()->set_core_library(core_lib);
   const String& core_impl_lib_url =
       String::Handle(Symbols::New("dart:coreimpl"));
   const Library& core_impl_lib =
       Library::Handle(Library::NewLibraryHelper(core_impl_lib_url, false));
   isolate->object_store()->set_core_impl_library(core_impl_lib);
   core_impl_lib.Register();
-  core_lib.AddImport(core_impl_lib);
-  core_impl_lib.AddImport(core_lib);
+  const Namespace& impl_ns = Namespace::Handle(
+      Namespace::New(core_impl_lib, Array::Handle(), Array::Handle()));
+  core_lib.AddImport(impl_ns);
+  core_impl_lib.AddImport(core_ns);
   Library::InitMathLibrary(isolate);
   const Library& math_lib = Library::Handle(Library::MathLibrary());
-  core_lib.AddImport(math_lib);
-  core_impl_lib.AddImport(math_lib);
+  const Namespace& math_ns = Namespace::Handle(
+      Namespace::New(math_lib, Array::Handle(), Array::Handle()));
+  core_lib.AddImport(math_ns);
+  core_impl_lib.AddImport(math_ns);
   isolate->object_store()->set_root_library(Library::Handle());
 
   // Hook up predefined classes without setting their library pointers. These
   // classes are coming from the VM isolate, and are shared between multiple
   // isolates so setting their library pointers would be wrong.
   const Class& cls = Class::Handle(Object::dynamic_class());
   core_lib.AddObject(cls, String::Handle(cls.Name()));
 }
 
 
 void Library::InitMathLibrary(Isolate* isolate) {
   const String& url = String::Handle(Symbols::New("dart:math"));
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
-  lib.AddImport(core_impl_lib);
+  const Namespace& impl_ns = Namespace::Handle(
+      Namespace::New(core_impl_lib, Array::Handle(), Array::Handle()));
+  lib.AddImport(impl_ns);
   isolate->object_store()->set_math_library(lib);
 }
 
 
 void Library::InitIsolateLibrary(Isolate* isolate) {
   const String& url = String::Handle(Symbols::New("dart:isolate"));
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   isolate->object_store()->set_isolate_library(lib);
 }
 
 
 void Library::InitMirrorsLibrary(Isolate* isolate) {
   const String& url = String::Handle(Symbols::New("dart:mirrors"));
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   const Library& isolate_lib = Library::Handle(Library::IsolateLibrary());
-  lib.AddImport(isolate_lib);
+  const Namespace& isolate_ns = Namespace::Handle(
+      Namespace::New(isolate_lib, Array::Handle(), Array::Handle()));
+  lib.AddImport(isolate_ns);
   const Library& wrappers_lib =
       Library::Handle(Library::NativeWrappersLibrary());
-  lib.AddImport(wrappers_lib);
+  const Namespace& wrappers_ns = Namespace::Handle(
+      Namespace::New(wrappers_lib, Array::Handle(), Array::Handle()));
+  lib.AddImport(wrappers_ns);
   isolate->object_store()->set_mirrors_library(lib);
 }
 
 
 void Library::InitScalarlistLibrary(Isolate* isolate) {
   const String& url = String::Handle(Symbols::New("dart:scalarlist"));
   const Library& lib = Library::Handle(Library::NewLibraryHelper(url, true));
   lib.Register();
   const Library& core_impl_lib = Library::Handle(Library::CoreImplLibrary());
-  lib.AddImport(core_impl_lib);
+  const Namespace& impl_ns = Namespace::Handle(
+      Namespace::New(core_impl_lib, Array::Handle(), Array::Handle()));
+  lib.AddImport(impl_ns);
   isolate->object_store()->set_scalarlist_library(lib);
 }
 
 
 void Library::InitNativeWrappersLibrary(Isolate* isolate) {
   static const int kNumNativeWrappersClasses = 4;
   ASSERT(kNumNativeWrappersClasses > 0 && kNumNativeWrappersClasses < 10);
   const String& native_flds_lib_url = String::Handle(
       Symbols::New("dart:nativewrappers"));
   const Library& native_flds_lib = Library::Handle(
@@ skipping 133 matching lines @@
   const char* kFormat = "Library:'%s'";
   const String& name = String::Handle(url());
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, name.ToCString()) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, name.ToCString());
   return chars;
 }
 
 
 RawLibrary* LibraryPrefix::GetLibrary(int index) const {
-  Library& lib = Library::Handle();
-  if ((index >= 0) || (index < num_libs())) {
-    Array& libs = Array::Handle(libraries());
-    lib ^= libs.At(index);
+  if ((index >= 0) || (index < num_imports())) {
+    const Array& imports = Array::Handle(this->imports());
+    const Namespace& import = Namespace::CheckedHandle(imports.At(index));
+    return import.library();
   }
-  return lib.raw();
+  return Library::null();
 }
 
 
 bool LibraryPrefix::ContainsLibrary(const Library& library) const {
-  intptr_t num_current_libs = num_libs();
-  if (num_current_libs > 0) {
+  intptr_t num_current_imports = num_imports();
+  if (num_current_imports > 0) {
     Library& lib = Library::Handle();
     const String& url = String::Handle(library.url());
     String& lib_url = String::Handle();
-    for (intptr_t i = 0; i < num_current_libs; i++) {
+    for (intptr_t i = 0; i < num_current_imports; i++) {
       lib = GetLibrary(i);
       ASSERT(!lib.IsNull());
       lib_url = lib.url();
       if (url.Equals(lib_url)) {
         return true;
       }
     }
   }
   return false;
 }
 
-void LibraryPrefix::AddLibrary(const Library& library) const {
-  intptr_t num_current_libs = num_libs();
 
-  // First check if the library is already in the list of libraries imported.
-  if (ContainsLibrary(library)) {
-    return;  // Library already imported with same prefix.
-  }
+void LibraryPrefix::AddImport(const Namespace& import) const {
+  intptr_t num_current_imports = num_imports();
 
   // The library needs to be added to the list.
-  Array& libs = Array::Handle(libraries());
-  const intptr_t length = (libs.IsNull()) ? 0 : libs.Length();
+  Array& imports = Array::Handle(this->imports());
+  const intptr_t length = (imports.IsNull()) ? 0 : imports.Length();
   // Grow the list if it is full.
-  if (num_current_libs >= length) {
+  if (num_current_imports >= length) {
     const intptr_t new_length = length + kIncrementSize;
-    libs = Array::Grow(libs, new_length, Heap::kOld);
-    set_libraries(libs);
+    imports = Array::Grow(imports, new_length, Heap::kOld);
+    set_imports(imports);
   }
-  libs.SetAt(num_current_libs, library);
-  set_num_libs(num_current_libs + 1);
+  imports.SetAt(num_current_imports, import);
+  set_num_imports(num_current_imports + 1);
 }
 
 
 RawClass* LibraryPrefix::LookupLocalClass(const String& class_name) const {
-  Array& libs = Array::Handle(libraries());
-  Class& resolved_class = Class::Handle();
-  Library& lib = Library::Handle();
-  for (intptr_t i = 0; i < num_libs(); i++) {
-    lib ^= libs.At(i);
-    ASSERT(!lib.IsNull());
-    resolved_class = lib.LookupLocalClass(class_name);
-    if (!resolved_class.IsNull()) {
-      return resolved_class.raw();
+  Array& imports = Array::Handle(this->imports());
+  Object& obj = Object::Handle();
+  Namespace& import = Namespace::Handle();
+  for (intptr_t i = 0; i < num_imports(); i++) {
+    import ^= imports.At(i);
+    obj = import.Lookup(class_name);
+    if (!obj.IsNull() && obj.IsClass()) {
+      // TODO(hausner):
+      return Class::Cast(obj).raw();
     }
   }
   return Class::null();
 }
 
 
 RawLibraryPrefix* LibraryPrefix::New() {
   ASSERT(Object::library_prefix_class() != Class::null());
   RawObject* raw = Object::Allocate(LibraryPrefix::kClassId,
                                     LibraryPrefix::InstanceSize(),
                                     Heap::kOld);
   return reinterpret_cast<RawLibraryPrefix*>(raw);
 }
 
 
-RawLibraryPrefix* LibraryPrefix::New(const String& name, const Library& lib) {
+RawLibraryPrefix* LibraryPrefix::New(const String& name,
+                                     const Namespace& import) {
   const LibraryPrefix& result = LibraryPrefix::Handle(LibraryPrefix::New());
   result.set_name(name);
-  result.set_num_libs(0);
-  result.AddLibrary(lib);
+  result.set_num_imports(0);
+  result.set_imports(Array::Handle(Array::New(kInitialSize)));
+  result.AddImport(import);
   return result.raw();
 }
 
 
+void LibraryPrefix::set_name(const String& value) const {
+  ASSERT(value.IsSymbol());
+  StorePointer(&raw_ptr()->name_, value.raw());
+}
+
+
+void LibraryPrefix::set_imports(const Array& value) const {
+  StorePointer(&raw_ptr()->imports_, value.raw());
+}
+
+
+void LibraryPrefix::set_num_imports(intptr_t value) const {
+  raw_ptr()->num_imports_ = value;
+}
+
+
 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;
 }
 
 
-void LibraryPrefix::set_name(const String& value) const {
-  ASSERT(value.IsSymbol());
-  StorePointer(&raw_ptr()->name_, value.raw());
+const char* Namespace::ToCString() const {
+  const char* kFormat = "Namespace for library '%s'";
+  const Library& lib = Library::Handle(library());
+  intptr_t len = OS::SNPrint(NULL, 0, kFormat, lib.ToCString()) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, kFormat, lib.ToCString());
+  return chars;
 }
 
 
-void LibraryPrefix::set_libraries(const Array& value) const {
-  StorePointer(&raw_ptr()->libraries_, value.raw());
+bool Namespace::HidesName(const String& name) const {
+  // Check whether the name is in the list of explicitly hidden names.
+  if (hide_names() != Array::null()) {
+    const Array& names = Array::Handle(hide_names());
+    String& hidden = String::Handle();
+    intptr_t num_names = names.Length();
+    for (intptr_t i = 0; i < num_names; i++) {
+      hidden ^= names.At(i);
+      if (name.Equals(hidden)) {
+        return true;
+      }
+    }
+  }
+  // The name is not explicitly hidden. Now check whether it is in the
+  // list of explicitly visible names, if there is one.
+  if (show_names() != Array::null()) {
+    const Array& names = Array::Handle(show_names());
+    String& shown = String::Handle();
+    intptr_t num_names = names.Length();
+    for (intptr_t i = 0; i < num_names; i++) {
+      shown ^= names.At(i);
+      if (name.Equals(shown)) {
+        return false;
+      }
+    }
+    // There is a list of visible names. The name we're looking for is not
+    // contained in the list, so it is hidden.
+    return true;
+  }
+  // The name is not filtered out.
+  return false;
 }
 
 
-void LibraryPrefix::set_num_libs(intptr_t value) const {
-  raw_ptr()->num_libs_ = value;
+RawObject* Namespace::Lookup(const String& name) const {
+  intptr_t i = 0;
+  const Library& lib = Library::Handle(library());
+  const Object& obj = Object::Handle(lib.LookupEntry(name, &i));
+  if (obj.IsNull() || HidesName(name)) {
+    return Object::null();
+  }
+  return obj.raw();
+}
+
+
+RawNamespace* Namespace::New() {
+  ASSERT(Object::namespace_class() != Class::null());
+  RawObject* raw = Object::Allocate(Namespace::kClassId,
+                                    Namespace::InstanceSize(),
+                                    Heap::kOld);
+  return reinterpret_cast<RawNamespace*>(raw);
+}
+
+
+RawNamespace* Namespace::New(const Library& library,
+                             const Array& show_names,
+                             const Array& hide_names) {
+  ASSERT(show_names.IsNull() || (show_names.Length() > 0));
+  ASSERT(hide_names.IsNull() || (hide_names.Length() > 0));
+  const Namespace& result = Namespace::Handle(Namespace::New());
+  result.StorePointer(&result.raw_ptr()->library_, library.raw());
+  result.StorePointer(&result.raw_ptr()->show_names_, show_names.raw());
+  result.StorePointer(&result.raw_ptr()->hide_names_, hide_names.raw());
+  return result.raw();
 }
 
 
 RawError* Library::CompileAll() {
   Error& error = Error::Handle();
   const GrowableObjectArray& libs = GrowableObjectArray::Handle(
       Isolate::Current()->object_store()->libraries());
   Library& lib = Library::Handle();
   Class& cls = Class::Handle();
   for (int i = 0; i < libs.Length(); i++) {
@@ skipping 5008 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart