Introduce classes for string and name indexes

runtime/vm/kernel_to_il.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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 1049 matching lines @@
   string_data_ = string_data.raw();
 }
 
 
 void TranslationHelper::SetCanonicalNames(const TypedData& canonical_names) {
   ASSERT(canonical_names_.IsNull());
   canonical_names_ = canonical_names.raw();
 }
 
 
-intptr_t TranslationHelper::StringOffset(intptr_t string_index) const {
-  return string_offsets_.GetUint32(string_index << 2);
+intptr_t TranslationHelper::StringOffset(StringIndex index) const {
+  return string_offsets_.GetUint32(index << 2);
 }
 
 
-intptr_t TranslationHelper::StringSize(intptr_t string_index) const {
-  return StringOffset(string_index + 1) - StringOffset(string_index);
+intptr_t TranslationHelper::StringSize(StringIndex index) const {
+  return StringOffset(StringIndex(index + 1)) - StringOffset(index);
 }
 
 
-uint8_t TranslationHelper::CharacterAt(intptr_t string_index, intptr_t index) {
+uint8_t TranslationHelper::CharacterAt(StringIndex string_index,
+                                       intptr_t index) {
   ASSERT(index < StringSize(string_index));
   return string_data_.GetUint8(StringOffset(string_index) + index);
 }
 
 
-bool TranslationHelper::StringEquals(intptr_t string_index, const char* other) {
+bool TranslationHelper::StringEquals(StringIndex string_index,
+                                     const char* other) {
   NoSafepointScope no_safepoint;
   intptr_t length = strlen(other);
   return (length == StringSize(string_index)) &&
          (memcmp(string_data_.DataAddr(StringOffset(string_index)), other,
                  length) == 0);
 }
 
 
-intptr_t TranslationHelper::CanonicalNameParent(intptr_t name) {
+NameIndex TranslationHelper::CanonicalNameParent(NameIndex name) {
   // Canonical names are pairs of 4-byte parent and string indexes, so the size
   // of an entry is 8 bytes.  The parent is biased: 0 represents the root name
   // and N+1 represents the name with index N.
-  return static_cast<intptr_t>(canonical_names_.GetUint32(8 * name)) - 1;
+  return NameIndex(static_cast<intptr_t>(canonical_names_.GetUint32(8 * name)) -
+                   1);
 }
 
 
-intptr_t TranslationHelper::CanonicalNameString(intptr_t name) {
-  return canonical_names_.GetUint32((8 * name) + 4);
+StringIndex TranslationHelper::CanonicalNameString(NameIndex name) {
+  return StringIndex(canonical_names_.GetUint32((8 * name) + 4));
 }
 
 
-bool TranslationHelper::IsAdministrative(intptr_t name) {
+bool TranslationHelper::IsAdministrative(NameIndex name) {
   // Administrative names start with '@'.
-  intptr_t name_string = CanonicalNameString(name);
+  StringIndex name_string = CanonicalNameString(name);
   return (StringSize(name_string) > 0) && (CharacterAt(name_string, 0) == '@');
 }
 
 
-bool TranslationHelper::IsPrivate(intptr_t name) {
+bool TranslationHelper::IsPrivate(NameIndex name) {
   // Private names start with '_'.
-  intptr_t name_string = CanonicalNameString(name);
+  StringIndex name_string = CanonicalNameString(name);
   return (StringSize(name_string) > 0) && (CharacterAt(name_string, 0) == '_');
 }
 
 
-bool TranslationHelper::IsRoot(intptr_t name) {
+bool TranslationHelper::IsRoot(NameIndex name) {
   return name == -1;
 }
 
 
-bool TranslationHelper::IsLibrary(intptr_t name) {
+bool TranslationHelper::IsLibrary(NameIndex name) {
   // Libraries are the only canonical names with the root as their parent.
   return !IsRoot(name) && IsRoot(CanonicalNameParent(name));
 }
 
 
-bool TranslationHelper::IsClass(intptr_t name) {
+bool TranslationHelper::IsClass(NameIndex name) {
   // Classes have the library as their parent and are not an administrative
   // name starting with @.
   return !IsAdministrative(name) && !IsRoot(name) &&
          IsLibrary(CanonicalNameParent(name));
 }
 
 
-bool TranslationHelper::IsMember(intptr_t name) {
+bool TranslationHelper::IsMember(NameIndex name) {
   return IsConstructor(name) || IsField(name) || IsProcedure(name);
 }
 
 
-bool TranslationHelper::IsField(intptr_t name) {
+bool TranslationHelper::IsField(NameIndex name) {
   // Fields with private names have the import URI of the library where they are
   // visible as the parent and the string "@fields" as the parent's parent.
   // Fields with non-private names have the string "@fields' as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  intptr_t kind = CanonicalNameParent(name);
+  NameIndex kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
     kind = CanonicalNameParent(kind);
   }
   return StringEquals(CanonicalNameString(kind), "@fields");
 }
 
 
-bool TranslationHelper::IsConstructor(intptr_t name) {
+bool TranslationHelper::IsConstructor(NameIndex name) {
   // Constructors with private names have the import URI of the library where
   // they are visible as the parent and the string "@constructors" as the
   // parent's parent.  Constructors with non-private names have the string
   // "@constructors" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  intptr_t kind = CanonicalNameParent(name);
+  NameIndex kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
     kind = CanonicalNameParent(kind);
   }
   return StringEquals(CanonicalNameString(kind), "@constructors");
 }
 
 
-bool TranslationHelper::IsProcedure(intptr_t name) {
+bool TranslationHelper::IsProcedure(NameIndex name) {
   return IsMethod(name) || IsGetter(name) || IsSetter(name) || IsFactory(name);
 }
 
 
-bool TranslationHelper::IsMethod(intptr_t name) {
+bool TranslationHelper::IsMethod(NameIndex name) {
   // Methods with private names have the import URI of the library where they
   // are visible as the parent and the string "@methods" as the parent's parent.
   // Methods with non-private names have the string "@methods" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  intptr_t kind = CanonicalNameParent(name);
+  NameIndex kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
     kind = CanonicalNameParent(kind);
   }
   return StringEquals(CanonicalNameString(kind), "@methods");
 }
 
 
-bool TranslationHelper::IsGetter(intptr_t name) {
+bool TranslationHelper::IsGetter(NameIndex name) {
   // Getters with private names have the import URI of the library where they
   // are visible as the parent and the string "@getters" as the parent's parent.
   // Getters with non-private names have the string "@getters" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  intptr_t kind = CanonicalNameParent(name);
+  NameIndex kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
     kind = CanonicalNameParent(kind);
   }
   return StringEquals(CanonicalNameString(kind), "@getters");
 }
 
 
-bool TranslationHelper::IsSetter(intptr_t name) {
+bool TranslationHelper::IsSetter(NameIndex name) {
   // Setters with private names have the import URI of the library where they
   // are visible as the parent and the string "@setters" as the parent's parent.
   // Setters with non-private names have the string "@setters" as the parent.
   if (IsRoot(name)) {
     return false;
   }
-  intptr_t kind = CanonicalNameParent(name);
+  NameIndex kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
     kind = CanonicalNameParent(kind);
   }
   return StringEquals(CanonicalNameString(kind), "@setters");
 }
 
 
-bool TranslationHelper::IsFactory(intptr_t name) {
+bool TranslationHelper::IsFactory(NameIndex name) {
   // Factories with private names have the import URI of the library where they
   // are visible as the parent and the string "@factories" as the parent's
   // parent.  Factories with non-private names have the string "@factories" as
   // the parent.
   if (IsRoot(name)) {
     return false;
   }
-  intptr_t kind = CanonicalNameParent(name);
+  NameIndex kind = CanonicalNameParent(name);
   if (IsPrivate(name)) {
     kind = CanonicalNameParent(kind);
   }
   return StringEquals(CanonicalNameString(kind), "@factories");
 }
 
 
-intptr_t TranslationHelper::EnclosingName(intptr_t name) {
+NameIndex TranslationHelper::EnclosingName(NameIndex name) {
   ASSERT(IsField(name) || IsConstructor(name) || IsProcedure(name));
-  intptr_t enclosing = CanonicalNameParent(CanonicalNameParent(name));
+  NameIndex enclosing = CanonicalNameParent(CanonicalNameParent(name));
   if (IsPrivate(name)) {
     enclosing = CanonicalNameParent(enclosing);
   }
   ASSERT(IsLibrary(enclosing) || IsClass(enclosing));
   return enclosing;
 }
 
 
 RawInstance* TranslationHelper::Canonicalize(const Instance& instance) {
   if (instance.IsNull()) return instance.raw();
 
   const char* error_str = NULL;
   RawInstance* result = instance.CheckAndCanonicalize(thread(), &error_str);
   if (result == Object::null()) {
     ReportError("Invalid const object %s", error_str);
   }
   return result;
 }
 
 
 const dart::String& TranslationHelper::DartString(const char* content,
                                                   Heap::Space space) {
   return dart::String::ZoneHandle(Z, dart::String::New(content, space));
 }
 
 
-dart::String& TranslationHelper::DartString(intptr_t string_index,
+dart::String& TranslationHelper::DartString(StringIndex string_index,
                                             Heap::Space space) {
   intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
   }
   return dart::String::ZoneHandle(
       Z, dart::String::FromUTF8(buffer, length, space));
 }
 
 
 dart::String& TranslationHelper::DartString(const uint8_t* utf8_array,
                                             intptr_t len,
                                             Heap::Space space) {
   return dart::String::ZoneHandle(
       Z, dart::String::FromUTF8(utf8_array, len, space));
 }
 
 
 const dart::String& TranslationHelper::DartSymbol(const char* content) const {
   return dart::String::ZoneHandle(Z, Symbols::New(thread_, content));
 }
 
 
-dart::String& TranslationHelper::DartSymbol(intptr_t string_index) const {
+dart::String& TranslationHelper::DartSymbol(StringIndex string_index) const {
   intptr_t length = StringSize(string_index);
   uint8_t* buffer = Z->Alloc<uint8_t>(length);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(string_index)), length);
   }
   return dart::String::ZoneHandle(Z,
                                   Symbols::FromUTF8(thread_, buffer, length));
 }
 
 dart::String& TranslationHelper::DartSymbol(const uint8_t* utf8_array,
                                             intptr_t len) const {
   return dart::String::ZoneHandle(Z,
                                   Symbols::FromUTF8(thread_, utf8_array, len));
 }
 
-const dart::String& TranslationHelper::DartClassName(intptr_t kernel_class) {
+const dart::String& TranslationHelper::DartClassName(NameIndex kernel_class) {
   ASSERT(IsClass(kernel_class));
   dart::String& name = DartString(CanonicalNameString(kernel_class));
   return ManglePrivateName(CanonicalNameParent(kernel_class), &name);
 }
 
 
 const dart::String& TranslationHelper::DartConstructorName(
-    intptr_t constructor) {
+    NameIndex constructor) {
   ASSERT(IsConstructor(constructor));
   return DartFactoryName(constructor);
 }
 
 
-const dart::String& TranslationHelper::DartProcedureName(intptr_t procedure) {
+const dart::String& TranslationHelper::DartProcedureName(NameIndex procedure) {
   ASSERT(IsProcedure(procedure));
   if (IsSetter(procedure)) {
     return DartSetterName(procedure);
   } else if (IsGetter(procedure)) {
     return DartGetterName(procedure);
   } else if (IsFactory(procedure)) {
     return DartFactoryName(procedure);
   } else {
     return DartMethodName(procedure);
   }
 }
 
 
-const dart::String& TranslationHelper::DartSetterName(intptr_t setter) {
+const dart::String& TranslationHelper::DartSetterName(NameIndex setter) {
   return DartSetterName(CanonicalNameParent(setter),
                         CanonicalNameString(setter));
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(Name* setter_name) {
   return DartSetterName(setter_name->library(), setter_name->string_index());
 }
 
 
-const dart::String& TranslationHelper::DartSetterName(intptr_t parent,
-                                                      intptr_t setter) {
+const dart::String& TranslationHelper::DartSetterName(NameIndex parent,
+                                                      StringIndex setter) {
   // The names flowing into [setter] are coming from the Kernel file:
   //   * user-defined setters: `fieldname=`
   //   * property-set expressions:  `fieldname`
   //
   // The VM uses `get:fieldname` and `set:fieldname`.
   //
   // => In order to be consistent, we remove the `=` always and adopt the VM
   //    conventions.
   intptr_t size = StringSize(setter);
   ASSERT(size > 0);
   if (CharacterAt(setter, size - 1) == '=') {
     --size;
   }
   uint8_t* buffer = Z->Alloc<uint8_t>(size);
   {
     NoSafepointScope no_safepoint;
     memmove(buffer, string_data_.DataAddr(StringOffset(setter)), size);
   }
   dart::String& name = dart::String::ZoneHandle(
       Z, dart::String::FromUTF8(buffer, size, allocation_space_));
   ManglePrivateName(parent, &name, false);
   name = dart::Field::SetterSymbol(name);
   return name;
 }
 
 
-const dart::String& TranslationHelper::DartGetterName(intptr_t getter) {
+const dart::String& TranslationHelper::DartGetterName(NameIndex getter) {
   return DartGetterName(CanonicalNameParent(getter),
                         CanonicalNameString(getter));
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(Name* getter_name) {
   return DartGetterName(getter_name->library(), getter_name->string_index());
 }
 
 
-const dart::String& TranslationHelper::DartGetterName(intptr_t parent,
-                                                      intptr_t getter) {
+const dart::String& TranslationHelper::DartGetterName(NameIndex parent,
+                                                      StringIndex getter) {
   dart::String& name = DartString(getter);
   ManglePrivateName(parent, &name, false);
   name = dart::Field::GetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartFieldName(Name* kernel_name) {
   dart::String& name = DartString(kernel_name->string_index());
   return ManglePrivateName(kernel_name->library(), &name);
 }
 
 
 const dart::String& TranslationHelper::DartInitializerName(Name* kernel_name) {
   // The [DartFieldName] will take care of mangling the name.
   dart::String& name =
       dart::String::Handle(Z, DartFieldName(kernel_name).raw());
   name = Symbols::FromConcat(thread_, Symbols::InitPrefix(), name);
   return name;
 }
 
 
-const dart::String& TranslationHelper::DartMethodName(intptr_t method) {
+const dart::String& TranslationHelper::DartMethodName(NameIndex method) {
   return DartMethodName(CanonicalNameParent(method),
                         CanonicalNameString(method));
 }
 
 
 const dart::String& TranslationHelper::DartMethodName(Name* method_name) {
   return DartMethodName(method_name->library(), method_name->string_index());
 }
 
 
-const dart::String& TranslationHelper::DartMethodName(intptr_t parent,
-                                                      intptr_t method) {
+const dart::String& TranslationHelper::DartMethodName(NameIndex parent,
+                                                      StringIndex method) {
   dart::String& name = DartString(method);
   return ManglePrivateName(parent, &name);
 }
 
 
-const dart::String& TranslationHelper::DartFactoryName(intptr_t factory) {
+const dart::String& TranslationHelper::DartFactoryName(NameIndex factory) {
   ASSERT(IsConstructor(factory) || IsFactory(factory));
   GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
   pieces.Add(DartClassName(EnclosingName(factory)));
   pieces.Add(Symbols::Dot());
   // [DartMethodName] will mangle the name.
   pieces.Add(DartMethodName(factory));
   return dart::String::ZoneHandle(Z, Symbols::FromConcatAll(thread_, pieces));
 }
 
 
 RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
-    intptr_t kernel_library) {
+    NameIndex kernel_library) {
   // We only use the string and don't rely on having any particular parent.
   // This ASSERT is just a sanity check.
   ASSERT(IsLibrary(kernel_library) ||
          IsAdministrative(CanonicalNameParent(kernel_library)));
   const dart::String& library_name =
       DartSymbol(CanonicalNameString(kernel_library));
   ASSERT(!library_name.IsNull());
   RawLibrary* library = dart::Library::LookupLibrary(thread_, library_name);
   ASSERT(library != Object::null());
   return library;
 }
 
 
-RawClass* TranslationHelper::LookupClassByKernelClass(intptr_t kernel_class) {
+RawClass* TranslationHelper::LookupClassByKernelClass(NameIndex kernel_class) {
   ASSERT(IsClass(kernel_class));
   const dart::String& class_name = DartClassName(kernel_class);
-  intptr_t kernel_library = CanonicalNameParent(kernel_class);
+  NameIndex kernel_library = CanonicalNameParent(kernel_class);
   dart::Library& library =
       dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
   RawClass* klass = library.LookupClassAllowPrivate(class_name);
 
   ASSERT(klass != Object::null());
   return klass;
 }
 
 
-RawField* TranslationHelper::LookupFieldByKernelField(intptr_t kernel_field) {
+RawField* TranslationHelper::LookupFieldByKernelField(NameIndex kernel_field) {
   ASSERT(IsField(kernel_field));
-  intptr_t enclosing = EnclosingName(kernel_field);
+  NameIndex enclosing = EnclosingName(kernel_field);
 
   dart::Class& klass = dart::Class::Handle(Z);
   if (IsLibrary(enclosing)) {
     dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
     klass = library.toplevel_class();
   } else {
     ASSERT(IsClass(enclosing));
     klass = LookupClassByKernelClass(enclosing);
   }
   RawField* field = klass.LookupFieldAllowPrivate(
       DartSymbol(CanonicalNameString(kernel_field)));
   ASSERT(field != Object::null());
   return field;
 }
 
 
 RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
-    intptr_t procedure) {
+    NameIndex procedure) {
   const dart::String& procedure_name = DartProcedureName(procedure);
 
   // The parent is either a library or a class (in which case the procedure is a
   // static method).
-  intptr_t enclosing = EnclosingName(procedure);
+  NameIndex enclosing = EnclosingName(procedure);
   if (IsLibrary(enclosing)) {
     dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
     RawFunction* function = library.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(function != Object::null());
     return function;
   } else {
     ASSERT(IsClass(enclosing));
     dart::Class& klass =
         dart::Class::Handle(Z, LookupClassByKernelClass(enclosing));
     Function& function = Function::ZoneHandle(
         Z, klass.LookupFunctionAllowPrivate(procedure_name));
     ASSERT(!function.IsNull());
 
     // TODO(27590): We can probably get rid of this after no longer using
     // core libraries from the source.
     if (function.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(klass, function);
       function = function.RedirectionTarget();
     }
     return function.raw();
   }
 }
 
 
 RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
-    intptr_t constructor) {
+    NameIndex constructor) {
   ASSERT(IsConstructor(constructor));
   dart::Class& klass = dart::Class::Handle(
       Z, LookupClassByKernelClass(EnclosingName(constructor)));
   return LookupConstructorByKernelConstructor(klass, constructor);
 }
 
 
 RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     const dart::Class& owner,
-    intptr_t constructor) {
+    NameIndex constructor) {
   ASSERT(IsConstructor(constructor));
   RawFunction* function =
       owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
   ASSERT(function != Object::null());
   return function;
 }
 
 
 dart::Type& TranslationHelper::GetCanonicalType(const dart::Class& klass) {
   ASSERT(!klass.IsNull());
@@ skipping 33 matching lines @@
 
   va_list args;
   va_start(args, format);
   Report::LongJumpV(prev_error, null_script, TokenPosition::kNoSource, format,
                     args);
   va_end(args);
   UNREACHABLE();
 }
 
 
-dart::String& TranslationHelper::ManglePrivateName(intptr_t parent,
+dart::String& TranslationHelper::ManglePrivateName(NameIndex parent,
                                                    dart::String* name_to_modify,
                                                    bool symbolize) {
   if (name_to_modify->Length() >= 1 && name_to_modify->CharAt(0) == '_') {
     const dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(parent));
     *name_to_modify = library.PrivateName(*name_to_modify);
   } else if (symbolize) {
     *name_to_modify = Symbols::New(thread_, *name_to_modify);
   }
   return *name_to_modify;
@@ skipping 352 matching lines @@
   ASSERT(!function.IsNull());
 
   // Run the method and canonicalize the result.
   const Object& result = RunFunction(function, kernel_arguments, &receiver);
   result_ ^= result.raw();
   result_ = H.Canonicalize(result_);
 }
 
 
 void ConstantEvaluator::VisitStaticGet(StaticGet* node) {
-  intptr_t target = node->target();
+  NameIndex target = node->target();
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::Handle(Z, H.LookupFieldByKernelField(target));
     if (field.StaticValue() == Object::sentinel().raw() ||
         field.StaticValue() == Object::transition_sentinel().raw()) {
       field.EvaluateInitializer();
       result_ = field.StaticValue();
       result_ = H.Canonicalize(result_);
       field.SetStaticValue(result_, true);
     } else {
@@ skipping 110 matching lines @@
   }
 }
 
 
 void ConstantEvaluator::VisitNot(Not* node) {
   result_ ^= Bool::Get(!EvaluateBooleanExpression(node->expression())).raw();
 }
 
 
 void ConstantEvaluator::VisitPropertyGet(PropertyGet* node) {
-  intptr_t string_index = node->name()->string_index();
+  StringIndex string_index = node->name()->string_index();
   if (H.StringEquals(string_index, "length")) {
     node->receiver()->AcceptExpressionVisitor(this);
     if (result_.IsString()) {
       const dart::String& str =
           dart::String::Handle(Z, dart::String::RawCast(result_.raw()));
       result_ = Integer::New(str.Length());
     } else {
       H.ReportError(
           "Constant expressions can only call "
           "'length' on string constants.");
@@ skipping 1027 matching lines @@
 
   instructions += StaticCall(TokenPosition::kNoSource, throw_function, 6);
   // Leave "result" on the stack since callers expect it to be there (even
   // though the function will result in an exception).
 
   return instructions;
 }
 
 
 RawFunction* FlowGraphBuilder::LookupMethodByMember(
-    intptr_t target,
+    NameIndex target,
     const dart::String& method_name) {
-  intptr_t kernel_class = H.EnclosingName(target);
+  NameIndex kernel_class = H.EnclosingName(target);
   dart::Class& klass =
       dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
 
   RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
   ASSERT(function != Object::null());
   return function;
 }
 
 
 LocalVariable* FlowGraphBuilder::MakeTemporary() {
@@ skipping 1250 matching lines @@
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry(intptr_t try_index) {
   return new (Z) JoinEntryInstr(AllocateBlockId(), try_index);
 }
 
 
 JoinEntryInstr* FlowGraphBuilder::BuildJoinEntry() {
   return new (Z) JoinEntryInstr(AllocateBlockId(), CurrentTryIndex());
 }
 
 
-Fragment FlowGraphBuilder::TranslateFieldInitializer(intptr_t canonical_name,
+Fragment FlowGraphBuilder::TranslateFieldInitializer(NameIndex canonical_name,
                                                      Expression* init) {
   dart::Field& field =
       dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(canonical_name));
   if (init->IsNullLiteral()) {
     field.RecordStore(Object::null_object());
     return Fragment();
   }
   Fragment instructions;
   instructions += LoadLocal(scopes_->this_variable);
   instructions += TranslateExpression(init);
@@ skipping 555 matching lines @@
     } else {
       UNIMPLEMENTED();
     }
   } else {
     UNIMPLEMENTED();
   }
 }
 
 
 void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
-  intptr_t target = node->target();
+  NameIndex target = node->target();
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     const AbstractType& dst_type = AbstractType::ZoneHandle(Z, field.type());
     Fragment instructions = TranslateExpression(node->expression());
     if (NeedsDebugStepCheck(stack_, node->position())) {
       instructions = DebugStepCheck(node->position()) + instructions;
     }
     instructions += CheckAssignableInCheckedMode(
         dst_type, dart::String::ZoneHandle(Z, field.name()));
@@ skipping 41 matching lines @@
   instructions += PushArgument();
 
   const dart::String& setter_name = H.DartSetterName(node->name());
   instructions += InstanceCall(node->position(), setter_name, Token::kSET, 2);
   fragment_ = instructions + Drop();
 }
 
 
 void FlowGraphBuilder::VisitDirectPropertyGet(DirectPropertyGet* node) {
   Function& target = Function::ZoneHandle(Z);
-  intptr_t kernel_name = node->target();
+  NameIndex kernel_name = node->target();
   if (H.IsProcedure(kernel_name)) {
     if (H.IsGetter(kernel_name)) {
       target = LookupMethodByMember(kernel_name, H.DartGetterName(kernel_name));
     } else {
       target = LookupMethodByMember(kernel_name, H.DartMethodName(kernel_name));
       target = target.ImplicitClosureFunction();
       ASSERT(!target.IsNull());
       fragment_ = BuildImplicitClosureCreation(target);
       return;
     }
@@ skipping 1800 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)