Move Kernel strings into the VM's heap.

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 <string>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
@@ skipping 40 matching lines @@
     } else if ((*outermost_node)->IsConstructor()) {
       parent = Constructor::Cast(*outermost_node)->parent();
     } else if ((*outermost_node)->IsField()) {
       parent = Field::Cast(*outermost_node)->parent();
     }
     if (parent != NULL && parent->IsClass()) *klass = Class::Cast(parent);
   }
 }
 
 
+ScopeBuilder::ScopeBuilder(ParsedFunction* parsed_function, TreeNode* node)
+    : result_(NULL),
+      parsed_function_(parsed_function),
+      node_(node),
+      translation_helper_(Thread::Current()),
+      zone_(translation_helper_.zone()),
+      type_translator_(&translation_helper_, &active_class_, /*finalize=*/true),
+      current_function_scope_(NULL),
+      scope_(NULL),
+      depth_(0),
+      name_index_(0),
+      needs_expr_temp_(false) {
+  Script& script = Script::Handle(Z, parsed_function->function().script());
+  H.SetStringData(TypedData::Handle(Z, script.kernel_strings()));
+}
+
+
 void ScopeBuilder::EnterScope(TreeNode* node, TokenPosition start_position) {
   scope_ = new (Z) LocalScope(scope_, depth_.function_, depth_.loop_);
   scope_->set_begin_token_pos(start_position);
   ASSERT(node->kernel_offset() >= 0);
   result_->scopes.Insert(node->kernel_offset(), scope_);
 }
 
 
 void ScopeBuilder::ExitScope(TokenPosition end_position) {
   scope_->set_end_token_pos(end_position);
@@ skipping 943 matching lines @@
 }
 
 
 Fragment operator<<(const Fragment& fragment, Instruction* next) {
   Fragment result = fragment;
   result <<= next;
   return result;
 }
 
 
+TranslationHelper::TranslationHelper(dart::Thread* thread)
+    : thread_(thread),
+      zone_(thread->zone()),
+      isolate_(thread->isolate()),
+      allocation_space_(thread->IsMutatorThread() ? Heap::kNew : Heap::kOld),
+      string_data_(TypedData::Handle(zone_)) {}
+
+
+void TranslationHelper::SetStringData(const TypedData& string_data) {
+  ASSERT(string_data_.IsNull());
+  string_data_ = string_data.raw();
+}
+
+
+uint8_t TranslationHelper::CharacterAt(String* string, intptr_t index) {
+  ASSERT(index < string->size());
+  return string_data_.GetUint8(string->offset() + index);
+}
+
+
+bool TranslationHelper::StringEquals(String* string, const char* other) {
+  NoSafepointScope no_safepoint;
+  intptr_t length = strlen(other);
+  return (length == string->size()) &&
+         memcmp(string_data_.DataAddr(string->offset()), other, length) == 0;
+}
+
+
+bool TranslationHelper::IsAdministrative(CanonicalName* name) {
+  // Administrative names start with '@'.
+  return (name->name()->size() > 0) && (CharacterAt(name->name(), 0) == '@');
+}
+
+
+bool TranslationHelper::IsPrivate(CanonicalName* name) {
+  // Private names start with '_'.
+  return (name->name()->size() > 0) && (CharacterAt(name->name(), 0) == '_');
+}
+
+
+bool TranslationHelper::IsRoot(CanonicalName* name) {
+  // The root is the only canonical name with no parent.
+  return name->parent() == NULL;
+}
+
+
+bool TranslationHelper::IsLibrary(CanonicalName* name) {
+  // Libraries are the only canonical names with the root as their parent.
+  return !IsRoot(name) && IsRoot(name->parent());
+}
+
+
+bool TranslationHelper::IsClass(CanonicalName* name) {
+  // Classes have the library as their parent and are not an administrative
+  // name starting with @.
+  return !IsAdministrative(name) && !IsRoot(name) && IsLibrary(name->parent());
+}
+
+
+bool TranslationHelper::IsMember(CanonicalName* name) {
+  return IsConstructor(name) || IsField(name) || IsProcedure(name);
+}
+
+
+bool TranslationHelper::IsField(CanonicalName* 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;
+  }
+  CanonicalName* kind = name->parent();
+  if (IsPrivate(name)) {
+    kind = kind->parent();
+  }
+  return StringEquals(kind->name(), "@fields");
+}
+
+
+bool TranslationHelper::IsConstructor(CanonicalName* 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;
+  }
+  CanonicalName* kind = name->parent();
+  if (IsPrivate(name)) {
+    kind = kind->parent();
+  }
+  return StringEquals(kind->name(), "@constructors");
+}
+
+
+bool TranslationHelper::IsProcedure(CanonicalName* name) {
+  return IsMethod(name) || IsGetter(name) || IsSetter(name) || IsFactory(name);
+}
+
+
+bool TranslationHelper::IsMethod(CanonicalName* 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;
+  }
+  CanonicalName* kind = name->parent();
+  if (IsPrivate(name)) {
+    kind = kind->parent();
+  }
+  return StringEquals(kind->name(), "@methods");
+}
+
+
+bool TranslationHelper::IsGetter(CanonicalName* 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;
+  }
+  CanonicalName* kind = name->parent();
+  if (IsPrivate(name)) {
+    kind = kind->parent();
+  }
+  return StringEquals(kind->name(), "@getters");
+}
+
+
+bool TranslationHelper::IsSetter(CanonicalName* 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;
+  }
+  CanonicalName* kind = name->parent();
+  if (IsPrivate(name)) {
+    kind = kind->parent();
+  }
+  return StringEquals(kind->name(), "@setters");
+}
+
+
+bool TranslationHelper::IsFactory(CanonicalName* 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;
+  }
+  CanonicalName* kind = name->parent();
+  if (IsPrivate(name)) {
+    kind = kind->parent();
+  }
+  return StringEquals(kind->name(), "@factories");
+}
+
+
+CanonicalName* TranslationHelper::EnclosingName(CanonicalName* name) {
+  ASSERT(IsField(name) || IsConstructor(name) || IsProcedure(name));
+  CanonicalName* enclosing = name->parent()->parent();
+  if (IsPrivate(name)) {
+    enclosing = enclosing->parent();
+  }
+  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(String* content,
                                             Heap::Space space) {
+  intptr_t length = content->size();
+  uint8_t* buffer = Z->Alloc<uint8_t>(length);
+  {
+    NoSafepointScope no_safepoint;
+    memmove(buffer, string_data_.DataAddr(content->offset()), length);
+  }
   return dart::String::ZoneHandle(
-      Z, dart::String::FromUTF8(content->buffer(), content->size(), space));
+      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(String* content) const {
+  intptr_t length = content->size();
+  uint8_t* buffer = Z->Alloc<uint8_t>(length);
+  {
+    NoSafepointScope no_safepoint;
+    memmove(buffer, string_data_.DataAddr(content->offset()), length);
+  }
   return dart::String::ZoneHandle(
-      Z, dart::Symbols::FromUTF8(thread_, content->buffer(), content->size()));
+      Z, dart::Symbols::FromUTF8(thread_, buffer, length));
 }
 
 dart::String& TranslationHelper::DartSymbol(const uint8_t* utf8_array,
                                             intptr_t len) const {
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromUTF8(thread_, utf8_array, len));
 }
 
 const dart::String& TranslationHelper::DartClassName(
     CanonicalName* kernel_class) {
-  ASSERT(kernel_class->IsClass());
+  ASSERT(IsClass(kernel_class));
   dart::String& name = DartString(kernel_class->name());
   return ManglePrivateName(kernel_class->parent(), &name);
 }
 
 
 const dart::String& TranslationHelper::DartConstructorName(
     CanonicalName* constructor) {
-  ASSERT(constructor->IsConstructor());
+  ASSERT(IsConstructor(constructor));
   return DartFactoryName(constructor);
 }
 
 
 const dart::String& TranslationHelper::DartProcedureName(
     CanonicalName* procedure) {
-  ASSERT(procedure->IsProcedure());
-  if (procedure->IsSetter()) {
+  ASSERT(IsProcedure(procedure));
+  if (IsSetter(procedure)) {
     return DartSetterName(procedure);
-  } else if (procedure->IsGetter()) {
+  } else if (IsGetter(procedure)) {
     return DartGetterName(procedure);
-  } else if (procedure->IsFactory()) {
+  } else if (IsFactory(procedure)) {
     return DartFactoryName(procedure);
   } else {
     return DartMethodName(procedure);
   }
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(CanonicalName* setter) {
   return DartSetterName(setter->parent(), setter->name());
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(Name* setter_name) {
   return DartSetterName(setter_name->library(), setter_name->string());
 }
 
 
 const dart::String& TranslationHelper::DartSetterName(CanonicalName* parent,
                                                       String* 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.
   ASSERT(setter->size() > 0);
   intptr_t skip = 0;
-  if (setter->buffer()[setter->size() - 1] == '=') {
+  if (CharacterAt(setter, setter->size() - 1) == '=') {
     skip = 1;
   }
+  intptr_t length = setter->size() - skip;
+  uint8_t* buffer = Z->Alloc<uint8_t>(length);
+  {
+    NoSafepointScope no_safepoint;
+    memmove(buffer, string_data_.DataAddr(setter->offset()), length);
+  }
   dart::String& name = dart::String::ZoneHandle(
-      Z, dart::String::FromUTF8(setter->buffer(), setter->size() - skip,
-                                allocation_space_));
+      Z, dart::String::FromUTF8(buffer, length, allocation_space_));
   ManglePrivateName(parent, &name, false);
   name = dart::Field::SetterSymbol(name);
   return name;
 }
 
 
 const dart::String& TranslationHelper::DartGetterName(CanonicalName* getter) {
   return DartGetterName(getter->parent(), getter->name());
 }
 
@@ skipping 38 matching lines @@
 
 
 const dart::String& TranslationHelper::DartMethodName(CanonicalName* parent,
                                                       String* method) {
   dart::String& name = DartString(method);
   return ManglePrivateName(parent, &name);
 }
 
 
 const dart::String& TranslationHelper::DartFactoryName(CanonicalName* factory) {
-  ASSERT(factory->IsConstructor() || factory->IsFactory());
+  ASSERT(IsConstructor(factory) || IsFactory(factory));
   GrowableHandlePtrArray<const dart::String> pieces(Z, 3);
-  pieces.Add(DartClassName(factory->EnclosingName()));
+  pieces.Add(DartClassName(EnclosingName(factory)));
   pieces.Add(Symbols::Dot());
   // [DartMethodName] will mangle the name.
   pieces.Add(DartMethodName(factory));
   return dart::String::ZoneHandle(
       Z, dart::Symbols::FromConcatAll(thread_, pieces));
 }
 
 
 dart::RawLibrary* TranslationHelper::LookupLibraryByKernelLibrary(
     CanonicalName* kernel_library) {
-  // We only use the name and don't rely on having any particular parent.  This
-  // ASSERT is just a sanity check.
-  ASSERT(kernel_library->IsLibrary() ||
-         kernel_library->parent()->IsAdministrative());
+  // 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(kernel_library->parent()));
   const dart::String& library_name = DartSymbol(kernel_library->name());
   ASSERT(!library_name.IsNull());
   dart::RawLibrary* library =
       dart::Library::LookupLibrary(thread_, library_name);
   ASSERT(library != Object::null());
   return library;
 }
 
 
 dart::RawClass* TranslationHelper::LookupClassByKernelClass(
     CanonicalName* kernel_class) {
-  ASSERT(kernel_class->IsClass());
+  ASSERT(IsClass(kernel_class));
   dart::RawClass* klass = NULL;
   const dart::String& class_name = DartClassName(kernel_class);
   CanonicalName* kernel_library = kernel_class->parent();
   dart::Library& library =
       dart::Library::Handle(Z, LookupLibraryByKernelLibrary(kernel_library));
   klass = library.LookupClassAllowPrivate(class_name);
 
   ASSERT(klass != Object::null());
   return klass;
 }
 
 
 dart::RawField* TranslationHelper::LookupFieldByKernelField(
     CanonicalName* kernel_field) {
-  ASSERT(kernel_field->IsField());
-  CanonicalName* enclosing = kernel_field->EnclosingName();
+  ASSERT(IsField(kernel_field));
+  CanonicalName* enclosing = EnclosingName(kernel_field);
 
   dart::Class& klass = dart::Class::Handle(Z);
-  if (enclosing->IsLibrary()) {
+  if (IsLibrary(enclosing)) {
     dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
     klass = library.toplevel_class();
   } else {
-    ASSERT(enclosing->IsClass());
+    ASSERT(IsClass(enclosing));
     klass = LookupClassByKernelClass(enclosing);
   }
   dart::RawField* field =
       klass.LookupFieldAllowPrivate(DartSymbol(kernel_field->name()));
   ASSERT(field != Object::null());
   return field;
 }
 
 
 dart::RawFunction* TranslationHelper::LookupStaticMethodByKernelProcedure(
     CanonicalName* 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).
-  CanonicalName* enclosing = procedure->EnclosingName();
-  if (enclosing->IsLibrary()) {
+  CanonicalName* enclosing = EnclosingName(procedure);
+  if (IsLibrary(enclosing)) {
     dart::Library& library =
         dart::Library::Handle(Z, LookupLibraryByKernelLibrary(enclosing));
     dart::RawFunction* function =
         library.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(function != Object::null());
     return function;
   } else {
-    ASSERT(enclosing->IsClass());
+    ASSERT(IsClass(enclosing));
     dart::Class& klass =
         dart::Class::Handle(Z, LookupClassByKernelClass(enclosing));
     dart::RawFunction* raw_function =
         klass.LookupFunctionAllowPrivate(procedure_name);
     ASSERT(raw_function != Object::null());
 
     // TODO(27590): We can probably get rid of this after no longer using
     // core libraries from the source.
     dart::Function& function = dart::Function::ZoneHandle(Z, raw_function);
     if (function.IsRedirectingFactory()) {
       ClassFinalizer::ResolveRedirectingFactory(klass, function);
       function = function.RedirectionTarget();
     }
     return function.raw();
   }
 }
 
 
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     CanonicalName* constructor) {
-  ASSERT(constructor->IsConstructor());
+  ASSERT(IsConstructor(constructor));
   dart::Class& klass = dart::Class::Handle(
-      Z, LookupClassByKernelClass(constructor->EnclosingName()));
+      Z, LookupClassByKernelClass(EnclosingName(constructor)));
   return LookupConstructorByKernelConstructor(klass, constructor);
 }
 
 
 dart::RawFunction* TranslationHelper::LookupConstructorByKernelConstructor(
     const dart::Class& owner,
     CanonicalName* constructor) {
-  ASSERT(constructor->IsConstructor());
+  ASSERT(IsConstructor(constructor));
   dart::RawFunction* function =
       owner.LookupConstructorAllowPrivate(DartConstructorName(constructor));
   ASSERT(function != Object::null());
   return function;
 }
 
 
 dart::Type& TranslationHelper::GetCanonicalType(const dart::Class& klass) {
   ASSERT(!klass.IsNull());
   // Note that if cls is _Closure, the returned type will be _Closure,
@@ skipping 406 matching lines @@
 
   // 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) {
   CanonicalName* target = node->target();
-  if (target->IsField()) {
+  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 {
       result_ = field.StaticValue();
     }
-  } else if (target->IsProcedure()) {
+  } else if (H.IsProcedure(target)) {
     const Function& function =
         Function::ZoneHandle(Z, H.LookupStaticMethodByKernelProcedure(target));
 
-    if (target->IsMethod()) {
+    if (H.IsMethod(target)) {
       Function& closure_function =
           Function::ZoneHandle(Z, function.ImplicitClosureFunction());
       closure_function.set_kernel_function(function.kernel_function());
       result_ = closure_function.ImplicitStaticClosure();
       result_ = H.Canonicalize(result_);
-    } else if (target->IsGetter()) {
+    } else if (H.IsGetter(target)) {
       UNIMPLEMENTED();
     } else {
       UNIMPLEMENTED();
     }
   }
 }
 
 
 void ConstantEvaluator::VisitVariableGet(VariableGet* node) {
   // When we see a [VariableGet] the corresponding [VariableDeclaration] must've
@@ skipping 90 matching lines @@
 
 void ConstantEvaluator::VisitNot(Not* node) {
   result_ ^= Bool::Get(!EvaluateBooleanExpression(node->expression())).raw();
 }
 
 
 void ConstantEvaluator::VisitPropertyGet(PropertyGet* node) {
   const intptr_t kLengthLen = sizeof("length") - 1;
 
   String* string = node->name()->string();
-  if ((string->size() == kLengthLen) &&
-      (memcmp(string->buffer(), "length", kLengthLen) == 0)) {
+  if ((string->size() == kLengthLen) && H.StringEquals(string, "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 104 matching lines @@
       breakable_block_(NULL),
       switch_block_(NULL),
       try_finally_block_(NULL),
       try_catch_block_(NULL),
       next_used_try_index_(0),
       catch_block_(NULL),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /* finalize= */ true),
       constant_evaluator_(this, zone_, &translation_helper_, &type_translator_),
-      streaming_flow_graph_builder_(NULL) {}
+      streaming_flow_graph_builder_(NULL) {
+  Script& script = Script::Handle(Z, parsed_function->function().script());
+  H.SetStringData(TypedData::Handle(Z, script.kernel_strings()));
+}
 
 
 FlowGraphBuilder::~FlowGraphBuilder() {
   if (streaming_flow_graph_builder_ != NULL) {
     delete streaming_flow_graph_builder_;
   }
 }
 
 
 Fragment FlowGraphBuilder::TranslateFinallyFinalizers(
@@ skipping 898 matching lines @@
   // Leave "result" on the stack since callers expect it to be there (even
   // though the function will result in an exception).
 
   return instructions;
 }
 
 
 dart::RawFunction* FlowGraphBuilder::LookupMethodByMember(
     CanonicalName* target,
     const dart::String& method_name) {
-  CanonicalName* kernel_class = target->EnclosingName();
+  CanonicalName* kernel_class = H.EnclosingName(target);
   dart::Class& klass =
       dart::Class::Handle(Z, H.LookupClassByKernelClass(kernel_class));
 
   dart::RawFunction* function = klass.LookupFunctionAllowPrivate(method_name);
   ASSERT(function != Object::null());
   return function;
 }
 
 
 LocalVariable* FlowGraphBuilder::MakeTemporary() {
@@ skipping 1803 matching lines @@
 }
 
 
 void FlowGraphBuilder::VisitStaticGet(StaticGet* node) {
   fragment_ = streaming_flow_graph_builder_->BuildAt(node->kernel_offset());
 }
 
 
 void FlowGraphBuilder::VisitStaticSet(StaticSet* node) {
   CanonicalName* target = node->target();
-  if (target->IsField()) {
+  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()));
     LocalVariable* variable = MakeTemporary();
     instructions += LoadLocal(variable);
     fragment_ = instructions + StoreStaticField(node->position(), field);
   } else {
-    ASSERT(target->IsProcedure());
+    ASSERT(H.IsProcedure(target));
 
     // Evaluate the expression on the right hand side.
     Fragment instructions = TranslateExpression(node->expression());
     LocalVariable* variable = MakeTemporary();
 
     // Prepare argument.
     instructions += LoadLocal(variable);
     instructions += PushArgument();
 
     // Invoke the setter function.
@@ skipping 27 matching lines @@
 
   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);
   CanonicalName* kernel_name = node->target();
-  if (kernel_name->IsProcedure()) {
-    if (kernel_name->IsGetter()) {
+  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;
     }
   } else {
-    ASSERT(kernel_name->IsField());
+    ASSERT(H.IsField(kernel_name));
     const dart::String& getter_name = H.DartGetterName(kernel_name);
     target = LookupMethodByMember(kernel_name, getter_name);
     ASSERT(target.IsGetterFunction() || target.IsImplicitGetterFunction());
   }
 
   Fragment instructions = TranslateExpression(node->receiver());
   instructions += PushArgument();
   fragment_ = instructions + StaticCall(node->position(), target, 1);
 }
 
@@ skipping 185 matching lines @@
 
 
 void FlowGraphBuilder::VisitConstructorInvocation(ConstructorInvocation* node) {
   if (node->is_const()) {
     fragment_ =
         Constant(constant_evaluator_.EvaluateConstructorInvocation(node));
     return;
   }
 
   dart::Class& klass = dart::Class::ZoneHandle(
-      Z, H.LookupClassByKernelClass(node->target()->EnclosingName()));
+      Z, H.LookupClassByKernelClass(H.EnclosingName(node->target())));
 
   Fragment instructions;
 
   // Check for malbounded-ness of type.
   if (I->type_checks()) {
     List<DartType>& kernel_type_arguments = node->arguments()->types();
     const TypeArguments& type_arguments = T.TranslateTypeArguments(
         kernel_type_arguments.raw_array(), kernel_type_arguments.length());
 
     AbstractType& type = AbstractType::Handle(
@@ skipping 1423 matching lines @@
 
   instructions += LoadLocal(closure);
   instructions += LoadLocal(parsed_function_->current_context_var());
   instructions +=
       StoreInstanceField(TokenPosition::kNoSource, Closure::context_offset());
 
   return instructions;
 }
 
 
-RawObject* EvaluateMetadata(TreeNode* const kernel_node) {
+RawObject* EvaluateMetadata(const dart::Field& metadata_field) {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Thread* thread = Thread::Current();
     Zone* zone_ = thread->zone();
 
+    TreeNode* kernel_node =
+        reinterpret_cast<TreeNode*>(metadata_field.kernel_field());
     List<Expression>* metadata_expressions = NULL;
     if (kernel_node->IsClass()) {
       metadata_expressions = &Class::Cast(kernel_node)->annotations();
     } else if (kernel_node->IsProcedure()) {
       metadata_expressions = &Procedure::Cast(kernel_node)->annotations();
     } else if (kernel_node->IsField()) {
       metadata_expressions = &Field::Cast(kernel_node)->annotations();
     } else if (kernel_node->IsConstructor()) {
       metadata_expressions = &Constructor::Cast(kernel_node)->annotations();
     } else {
       FATAL1("No support for metadata on this type of kernel node %p\n",
              kernel_node);
     }
 
-    TranslationHelper translation_helper(thread);
-    DartTypeTranslator type_translator(&translation_helper, NULL, true);
+    TranslationHelper helper(thread);
+    Script& script = Script::Handle(Z, metadata_field.Script());
+    helper.SetStringData(TypedData::Handle(Z, script.kernel_strings()));
+    DartTypeTranslator type_translator(&helper, NULL, true);
     ConstantEvaluator constant_evaluator(/* flow_graph_builder = */ NULL, Z,
-                                         &translation_helper, &type_translator);
+                                         &helper, &type_translator);
 
     const Array& metadata_values =
         Array::Handle(Z, Array::New(metadata_expressions->length()));
 
     for (intptr_t i = 0; i < metadata_expressions->length(); i++) {
       const Instance& value =
           constant_evaluator.EvaluateExpression((*metadata_expressions)[i]);
       metadata_values.SetAt(i, value);
     }
 
@@ skipping 73 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)