Introduce classes for string and name indexes

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/kernel_binary.h"
@@ skipping 77 matching lines @@
   const intptr_t len = functions_.length();
   const Array& res = Array::Handle(zone_, Array::New(len, Heap::kOld));
   for (intptr_t i = 0; i < len; i++) {
     res.SetAt(i, *functions_[i]);
   }
   return res.raw();
 }
 
 
 RawLibrary* BuildingTranslationHelper::LookupLibraryByKernelLibrary(
-    intptr_t library) {
+    NameIndex library) {
   return reader_->LookupLibrary(library).raw();
 }
 
 
-RawClass* BuildingTranslationHelper::LookupClassByKernelClass(intptr_t klass) {
+RawClass* BuildingTranslationHelper::LookupClassByKernelClass(NameIndex klass) {
   return reader_->LookupClass(klass).raw();
 }
 
 
 KernelReader::KernelReader(Program* program)
     : program_(program),
       thread_(dart::Thread::Current()),
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
@@ skipping 61 matching lines @@
       if (!library.Loaded()) library.SetLoaded();
     }
 
     if (ClassFinalizer::ProcessPendingClasses(/*from_kernel=*/true)) {
       // There is a function _getMainClosure in dart:_builtin that returns the
       // main procedure.  Since the platform libraries are compiled before the
       // program script, this function might need to be patched here.
 
       // If there is no main method then we have compiled a partial Kernel file
       // and do not need to patch here.
-      intptr_t main = program_->main_method();
+      NameIndex main = program_->main_method();
       if (main == -1) {
         return dart::Library::Handle(Z);
       }
 
       // If the builtin library is not set in the object store, then we are
       // bootstrapping and do not need to patch here.
       dart::Library& builtin_library =
           dart::Library::Handle(Z, I->object_store()->builtin_library());
       if (builtin_library.IsNull()) {
         return dart::Library::Handle(Z);
       }
 
-      intptr_t main_library = H.EnclosingName(main);
+      NameIndex main_library = H.EnclosingName(main);
       dart::Library& library = LookupLibrary(main_library);
       // Sanity check that we can find the main entrypoint.
       Object& main_obj = Object::Handle(
           Z, library.LookupObjectAllowPrivate(H.DartSymbol("main")));
       ASSERT(!main_obj.IsNull());
 
       Function& to_patch = Function::Handle(
           Z, builtin_library.LookupFunctionAllowPrivate(
                  dart::String::Handle(dart::String::New("_getMainClosure"))));
 
       Procedure* procedure =
           reinterpret_cast<Procedure*>(to_patch.kernel_function());
       // If dart:_builtin was not compiled from Kernel at all or if it was
       // linked with a script, it does not need to be patched.
       if ((procedure != NULL) && (procedure->function()->body() == NULL)) {
         // We will handle the StaticGet specially and will not use the name.
         //
         // TODO(kmillikin): we are leaking the function body.  Find a way to
         // deallocate it.
         procedure->function()->set_body(
-            new ReturnStatement(new StaticGet(NULL)));
+            new ReturnStatement(new StaticGet(NameIndex())));
       }
       return library;
     }
   }
 
   // Either class finalization failed or we caught a compile error.
   // In both cases sticky error would be set.
   Error& error = Error::Handle(Z);
   error = thread_->sticky_error();
   thread_->clear_sticky_error();
@@ skipping 268 matching lines @@
   dart::String* native_name = NULL;
   if (is_external) {
     // Maybe it has a native implementation, which is not external as far as
     // the VM is concerned because it does have an implementation.  Check for
     // an ExternalName annotation and extract the string from it.
     for (int i = 0; i < kernel_procedure->annotations().length(); ++i) {
       Expression* annotation = kernel_procedure->annotations()[i];
       if (!annotation->IsConstructorInvocation()) continue;
       ConstructorInvocation* invocation =
           ConstructorInvocation::Cast(annotation);
-      intptr_t annotation_class = H.EnclosingName(invocation->target());
+      NameIndex annotation_class = H.EnclosingName(invocation->target());
       ASSERT(H.IsClass(annotation_class));
-      intptr_t class_name_index = H.CanonicalNameString(annotation_class);
+      StringIndex class_name_index = H.CanonicalNameString(annotation_class);
       // Just compare by name, do not generate the annotation class.
       if (!H.StringEquals(class_name_index, "ExternalName")) continue;
       ASSERT(H.IsLibrary(H.CanonicalNameParent(annotation_class)));
-      intptr_t library_name_index =
+      StringIndex library_name_index =
           H.CanonicalNameString(H.CanonicalNameParent(annotation_class));
       if (!H.StringEquals(library_name_index, "dart:_internal")) continue;
 
       is_external = false;
       ASSERT(invocation->arguments()->positional().length() == 1 &&
              invocation->arguments()->named().length() == 0);
       StringLiteral* literal =
           StringLiteral::Cast(invocation->arguments()->positional()[0]);
       native_name = &H.DartSymbol(literal->value());
       break;
@@ skipping 96 matching lines @@
     for (intptr_t i = 0; i <= last; ++i) {
       smi_value = Smi::New(source->At(i));
       array_object.SetAt(i, smi_value);
     }
     return array_object.raw();
   } else {
     return Array::New(0);
   }
 }
 
-Script& KernelReader::ScriptAt(intptr_t index, intptr_t import_uri) {
+Script& KernelReader::ScriptAt(intptr_t index, StringIndex import_uri) {
   Script& script = Script::ZoneHandle(Z);
   script ^= scripts_.At(index);
   if (script.IsNull()) {
     // Create script with correct uri(s).
     uint8_t* uri_buffer = program_->source_table().UriFor(index);
     intptr_t uri_size = program_->source_table().UriSizeFor(index);
     dart::String& uri_string = H.DartString(uri_buffer, uri_size, Heap::kOld);
     dart::String& import_uri_string =
         import_uri == -1 ? uri_string : H.DartString(import_uri, Heap::kOld);
     uint8_t* source_buffer = program_->source_table().SourceCodeFor(index);
@@ skipping 211 matching lines @@
     pos++;
   }
   if (is_setter) {
     function.SetParameterTypeAt(pos, AbstractType::dynamic_type());
     function.SetParameterNameAt(pos, Symbols::Value());
     pos++;
   }
 }
 
 
-dart::Library& KernelReader::LookupLibrary(intptr_t library) {
+dart::Library& KernelReader::LookupLibrary(NameIndex library) {
   dart::Library* handle = NULL;
   if (!libraries_.Lookup(library, &handle)) {
     const dart::String& url = H.DartSymbol(H.CanonicalNameString(library));
     handle =
         &dart::Library::Handle(Z, dart::Library::LookupLibrary(thread_, url));
     if (handle->IsNull()) {
       *handle = dart::Library::New(url);
       handle->Register(thread_);
     }
     ASSERT(!handle->IsNull());
     libraries_.Insert(library, handle);
   }
   return *handle;
 }
 
 
-dart::Class& KernelReader::LookupClass(intptr_t klass) {
+dart::Class& KernelReader::LookupClass(NameIndex klass) {
   dart::Class* handle = NULL;
   if (!classes_.Lookup(klass, &handle)) {
     dart::Library& library = LookupLibrary(H.CanonicalNameParent(klass));
     const dart::String& name = H.DartClassName(klass);
     handle = &dart::Class::Handle(Z, library.LookupClass(name));
     if (handle->IsNull()) {
       *handle = dart::Class::New(library, name, Script::Handle(Z),
                                  TokenPosition::kNoSource);
       library.AddClass(*handle);
     }
@@ skipping 49 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)