Introduce classes for string and name indexes

runtime/vm/kernel_binary_flowgraph.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_binary_flowgraph.h"
 
 #include "vm/object_store.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
@@ skipping 42 matching lines @@
 
     CacheConstantValue(offset, result_);
   }
   // We return a new `ZoneHandle` here on purpose: The intermediate language
   // instructions do not make a copy of the handle, so we do it.
   return dart::Instance::ZoneHandle(Z, result_.raw());
 }
 
 void StreamingConstantEvaluator::EvaluateStaticGet() {
   builder_->ReadPosition();
-  intptr_t target = builder_->ReadUInt() - 1;
+  NameIndex target = builder_->ReadCanonicalNameReference();
 
   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);
@@ skipping 13 matching lines @@
     } else if (H.IsGetter(target)) {
       UNIMPLEMENTED();
     } else {
       UNIMPLEMENTED();
     }
   }
 }
 
 
 void StreamingConstantEvaluator::EvaluateSymbolLiteral() {
-  int str_index = builder_->ReadUInt();
+  StringIndex str_index(builder_->ReadUInt());
   const dart::String& symbol_value = H.DartSymbol(str_index);
 
   const dart::Class& symbol_class =
       dart::Class::ZoneHandle(Z, I->object_store()->symbol_class());
   ASSERT(!symbol_class.IsNull());
   const dart::Function& symbol_constructor = Function::ZoneHandle(
       Z, symbol_class.LookupConstructor(Symbols::SymbolCtor()));
   ASSERT(!symbol_constructor.IsNull());
   result_ ^= EvaluateConstConstructorCall(
       symbol_class, TypeArguments::Handle(Z), symbol_constructor, symbol_value);
 }
 
 
 void StreamingConstantEvaluator::EvaluateDoubleLiteral() {
-  int str_index = builder_->ReadUInt();
+  StringIndex str_index(builder_->ReadUInt());
   result_ = dart::Double::New(H.DartString(str_index), Heap::kOld);
   result_ = H.Canonicalize(result_);
 }
 
 
 RawObject* StreamingConstantEvaluator::EvaluateConstConstructorCall(
     const dart::Class& type_class,
     const TypeArguments& type_arguments,
     const Function& constructor,
     const Object& argument) {
@@ skipping 205 matching lines @@
 uint32_t StreamingFlowGraphBuilder::ReadUInt() {
   return reader_->ReadUInt();
 }
 
 
 intptr_t StreamingFlowGraphBuilder::ReadListLength() {
   return reader_->ReadListLength();
 }
 
 
+NameIndex StreamingFlowGraphBuilder::ReadCanonicalNameReference() {
+  return reader_->ReadCanonicalNameReference();
+}
+
+
 TokenPosition StreamingFlowGraphBuilder::ReadPosition(bool record) {
   return reader_->ReadPosition(record);
 }
 
 
 Tag StreamingFlowGraphBuilder::ReadTag(uint8_t* payload) {
   return reader_->ReadTag(payload);
 }
 
 
@@ skipping 64 matching lines @@
   // The frontend will take care of emitting normal errors (like
   // [NoSuchMethodError]s) and only emit [InvalidExpression]s in very special
   // situations (e.g. an invalid annotation).
   return ThrowNoSuchMethodError();
 }
 
 
 Fragment StreamingFlowGraphBuilder::BuildStaticGet() {
   intptr_t saved_offset = ReaderOffset() - 1;  // Include the tag.
   TokenPosition position = ReadPosition();
-  intptr_t target = ReadUInt() - 1;
+  NameIndex target = ReadCanonicalNameReference();
 
   if (H.IsField(target)) {
     const dart::Field& field =
         dart::Field::ZoneHandle(Z, H.LookupFieldByKernelField(target));
     if (field.is_const()) {
       SetOffset(saved_offset);  // EvaluateExpression needs the tag.
       return Constant(constant_evaluator_.EvaluateExpression());
     } else {
       const dart::Class& owner = dart::Class::Handle(Z, field.Owner());
       const dart::String& getter_name = H.DartGetterName(target);
@@ skipping 42 matching lines @@
   instructions += PushArgument();
   instructions += LoadLocal(catch_block()->stack_trace_var());
   instructions += PushArgument();
   instructions += RethrowException(position, catch_block()->catch_try_index());
 
   return instructions;
 }
 
 
 Fragment StreamingFlowGraphBuilder::BuildBigIntLiteral() {
-  const dart::String& value = H.DartString(ReadUInt());
+  const dart::String& value = H.DartString(StringIndex(ReadUInt()));
   return Constant(Integer::ZoneHandle(Z, Integer::New(value, Heap::kOld)));
 }
 
 
 Fragment StreamingFlowGraphBuilder::BuildStringLiteral() {
-  intptr_t str_index = ReadUInt();
+  StringIndex str_index(ReadUInt());
   return Constant(H.DartSymbol(str_index));
 }
 
 
 Fragment StreamingFlowGraphBuilder::BuildIntLiteral(uint8_t payload) {
   int64_t value = static_cast<int32_t>(payload) - SpecializedIntLiteralBias;
   return IntConstant(value);
 }
 
 
@@ skipping 16 matching lines @@
 
 Fragment StreamingFlowGraphBuilder::BuildNullLiteral() {
   return Constant(Instance::ZoneHandle(Z, Instance::null()));
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)