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 5897 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 21 matching lines @@
   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.

[siva, 2012/09/24 18:28:51]

The comment in LookupFieldAllowPrivate has been modified but not this one?

[hausner, 2012/09/24 20:25:43]

Done.

   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.

[siva, 2012/09/24 18:28:51]

ditto comment regarding comment.

[hausner, 2012/09/24 20:25:43]

Done.

   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::AddImportAll(const Library& lib) const {
+  const Namespace& ns = Namespace::Handle(
+      Namespace::New(lib, Array::Handle(), Array::Handle()));
+  AddImport(ns);

[siva, 2012/09/24 18:28:51]

I would prefer if we did not have his convenience function and instead made the
callers create a NameSpace with null combinators and just call AddImport.

Would avoid duplicate handle creation (see code in Library::InitCoreLibrary)

[hausner, 2012/09/24 20:25:43]

Done. (Although I think the convenience function was nicer.)

+}
+
+
 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());
 }
@@ skipping 30 matching lines @@
   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());
     ASSERT(!core_lib.IsNull());
-    result.AddImport(core_lib);
+    result.AddImportAll(core_lib);
   }
   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();
   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);
+  core_lib.AddImportAll(core_impl_lib);
+  core_impl_lib.AddImportAll(core_lib);
   Library::InitMathLibrary(isolate);
   const Library& math_lib = Library::Handle(Library::MathLibrary());
-  core_lib.AddImport(math_lib);
-  core_impl_lib.AddImport(math_lib);
+  core_lib.AddImportAll(math_lib);
+  core_impl_lib.AddImportAll(math_lib);
   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);
+  lib.AddImportAll(core_impl_lib);
   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);
+  lib.AddImportAll(isolate_lib);
   const Library& wrappers_lib =
       Library::Handle(Library::NativeWrappersLibrary());
-  lib.AddImport(wrappers_lib);
+  lib.AddImportAll(wrappers_lib);
   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);
+  lib.AddImportAll(core_impl_lib);
   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();

[siva, 2012/09/24 18:28:51]

This seems to imply that a library can be imported with the same prefix but
different show/hide combinators. I presume
that means the last import statement is the one that takes precedence.

The implementation though is not quite like that as we go
over the imports from 0 .... length in lookups.

[hausner, 2012/09/24 20:25:43]

The spec does not say what happens if the combinators contradict each other. We
always have to go through all imports so that we detect ambiguous names. Gilad
said if you import the same name twice (explicitly) then you should get an
error. But these things change all the time, so I think we are fine for now as
the code is.

On 2012/09/24 18:28:51, siva wrote:

 
   // 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 4909 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart