Move Kernel strings into the VM's heap.

runtime/vm/kernel_to_il.h

 // 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.
 
 #ifndef RUNTIME_VM_KERNEL_TO_IL_H_
 #define RUNTIME_VM_KERNEL_TO_IL_H_
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/growable_array.h"
@@ skipping 251 matching lines @@
   ~ActiveFunctionScope() { *active_class_ = saved_; }
 
  private:
   ActiveClass* active_class_;
   ActiveClass saved_;
 };
 
 
 class TranslationHelper {
  public:
-  explicit TranslationHelper(dart::Thread* thread)
-      : thread_(thread),
-        zone_(thread->zone()),
-        isolate_(thread->isolate()),
-        allocation_space_(thread->IsMutatorThread() ? Heap::kNew : Heap::kOld) {
-  }
+  explicit TranslationHelper(dart::Thread* thread);
   virtual ~TranslationHelper() {}
 
   Thread* thread() { return thread_; }
 
   Zone* zone() { return zone_; }
 
   Isolate* isolate() { return isolate_; }
 
   Heap::Space allocation_space() { return allocation_space_; }
 
+  // Access to strings.
+  const TypedData& string_data() { return string_data_; }
+  void SetStringData(const TypedData& string_data);
+  uint8_t CharacterAt(String* str, intptr_t index);
+  bool StringEquals(String* str, const char* other);
+
+  // Predicates on CanonicalNames.
+  bool IsAdministrative(CanonicalName* name);
+  bool IsPrivate(CanonicalName* name);
+  bool IsRoot(CanonicalName* name);
+  bool IsLibrary(CanonicalName* name);
+  bool IsClass(CanonicalName* name);
+  bool IsMember(CanonicalName* name);
+  bool IsField(CanonicalName* name);
+  bool IsConstructor(CanonicalName* name);
+  bool IsProcedure(CanonicalName* name);
+  bool IsMethod(CanonicalName* name);
+  bool IsGetter(CanonicalName* name);
+  bool IsSetter(CanonicalName* name);
+  bool IsFactory(CanonicalName* name);
+
+  // For a member (field, constructor, or procedure) return the canonical name
+  // of the enclosing class or library.
+  CanonicalName* EnclosingName(CanonicalName* name);
+
   RawInstance* Canonicalize(const Instance& instance);
 
   const dart::String& DartString(const char* content) {
     return DartString(content, allocation_space_);
   }
   const dart::String& DartString(const char* content, Heap::Space space);
 
   dart::String& DartString(String* content) {
     return DartString(content, allocation_space_);
   }
@@ skipping 57 matching lines @@
   // returned.  If the name is private, the canonical name [parent] will be used
   // to get the import URI of the library where the name is visible.
   dart::String& ManglePrivateName(CanonicalName* parent,
                                   dart::String* name_to_modify,
                                   bool symbolize = true);
 
   const dart::String& DartSetterName(CanonicalName* parent, String* setter);
   const dart::String& DartGetterName(CanonicalName* parent, String* getter);
   const dart::String& DartMethodName(CanonicalName* parent, String* method);
 
-  dart::Thread* thread_;
-  dart::Zone* zone_;
-  dart::Isolate* isolate_;
+  Thread* thread_;
+  Zone* zone_;
+  Isolate* isolate_;
   Heap::Space allocation_space_;
+
+  TypedData& string_data_;
 };
 
 // Regarding malformed types:
 // The spec says in section "19.1 Static Types" roughly:
 //
 //   A type T is malformed iff:
 //     * T does not denote a type in scope
 //     * T refers to a type parameter in a static member
 //     * T is a parametrized Type G<T1, ...> and G is malformed
 //     * T denotes declarations from multiple imports
@@ skipping 242 matching lines @@
   GrowableArray<LocalVariable*> stack_trace_variables;
   GrowableArray<LocalVariable*> catch_context_variables;
 
   // For-in iterators, one per for-in nesting level.
   GrowableArray<LocalVariable*> iterator_variables;
 };
 
 
 class ScopeBuilder : public RecursiveVisitor {
  public:
-  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) {}
+  ScopeBuilder(ParsedFunction* parsed_function, TreeNode* node);
 
   virtual ~ScopeBuilder() {}
 
   ScopeBuildingResult* BuildScopes();
 
   virtual void VisitName(Name* node) { /* NOP */
   }
 
   virtual void VisitThisExpression(ThisExpression* node);
   virtual void VisitTypeParameterType(TypeParameterType* node);
@@ skipping 458 matching lines @@
 
  private:
   FlowGraphBuilder* builder_;
   CatchBlock* outer_;
   LocalVariable* exception_var_;
   LocalVariable* stack_trace_var_;
   intptr_t catch_try_index_;
 };
 
 
-RawObject* EvaluateMetadata(TreeNode* const kernel_node);
+RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(TreeNode* const kernel_node);
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #else  // !defined(DART_PRECOMPILED_RUNTIME)
 
 #include "vm/object.h"
 #include "vm/kernel.h"
 
 namespace dart {
 namespace kernel {
 
-RawObject* EvaluateMetadata(TreeNode* const kernel_node);
+RawObject* EvaluateMetadata(const dart::Field& metadata_field);
 RawObject* BuildParameterDescriptor(TreeNode* const kernel_node);
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 #endif  // RUNTIME_VM_KERNEL_TO_IL_H_