Small cleanups in the Kernel FlowGraphBuilder

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/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/symbols.h"
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
 namespace dart {
 namespace kernel {
 
 #define Z (zone_)
 #define I (isolate_)
 #define T (type_translator_)
 #define H (translation_helper_)
 
 class SimpleExpressionConverter : public ExpressionVisitor {
  public:
-  SimpleExpressionConverter(Thread* thread, Zone* zone)
-      : translation_helper_(thread, zone, NULL),
-        zone_(zone),
+  explicit SimpleExpressionConverter(Thread* thread)
+      : translation_helper_(thread),
+        zone_(translation_helper_.zone()),
         is_simple_(false),
         simple_value_(NULL) {}
 
   virtual void VisitDefaultExpression(Expression* node) { is_simple_ = false; }
 
   virtual void VisitIntLiteral(IntLiteral* node) {
     is_simple_ = true;
     simple_value_ =
         &Integer::ZoneHandle(Z, Integer::New(node->value(), Heap::kOld));
     *simple_value_ = H.Canonicalize(*simple_value_);
@@ skipping 53 matching lines @@
 RawClass* BuildingTranslationHelper::LookupClassByKernelClass(Class* 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_)),
-      translation_helper_(this, thread_, zone_, isolate_),
+      translation_helper_(this, thread_),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /*finalize=*/false) {
   intptr_t source_file_count = program_->source_table().size();
   scripts_ = Array::New(source_file_count, Heap::kOld);
 }
 
 Object& KernelReader::ReadProgram() {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
@@ skipping 353 matching lines @@
   return script;
 }
 
 void KernelReader::GenerateFieldAccessors(const dart::Class& klass,
                                           const dart::Field& field,
                                           Field* kernel_field) {
   if (kernel_field->IsStatic() && kernel_field->initializer() != NULL) {
     // Static fields with initializers either have the static value set to the
     // initializer value if it is simple enough or else set to an uninitialized
     // sentinel.
-    SimpleExpressionConverter converter(H.thread(), Z);
+    SimpleExpressionConverter converter(H.thread());
     if (converter.IsSimple(kernel_field->initializer())) {
       // We do not need a getter.
       field.SetStaticValue(converter.SimpleValue(), true);
       return;
     }
     // We do need a getter that evaluates the initializer if necessary.
     field.SetStaticValue(Object::sentinel(), true);
   }
 
   const dart::String& getter_name = H.DartGetterName(kernel_field->name());
@@ skipping 235 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)