Add Zone-based handle allocation interface and reduce use of Isolate-based interfaces.

runtime/vm/ast_transformer.cc

 // Copyright (c) 2014, 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/ast_transformer.h"
 
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/thread.h"
 
 namespace dart {
 
-// Quick access to the current isolate and zone.
-#define I (thread()->isolate())
+// Quick access to the current zone.
 #define Z (thread()->zone())
 
 // Nodes that are unreachable from already parsed expressions.
 #define FOR_EACH_UNREACHABLE_NODE(V)                                           \
   V(AwaitMarker)                                                               \
   V(Case)                                                                      \
   V(CatchClause)                                                               \
   V(CloneContext)                                                              \
   V(ClosureCall)                                                               \
   V(DoWhile)                                                                   \
@@ skipping 34 matching lines @@
 
 AstNode* AwaitTransformer::Transform(AstNode* expr) {
   expr->Visit(this);
   return result_;
 }
 
 
 LocalVariable* AwaitTransformer::EnsureCurrentTempVar() {
   const char* await_temp_prefix = ":await_temp_var_";
   const String& cnt_str = String::ZoneHandle(
-      I, String::NewFormatted("%s%d", await_temp_prefix, temp_cnt_));
-  const String& symbol = String::ZoneHandle(I, Symbols::New(cnt_str));
+      Z, String::NewFormatted("%s%d", await_temp_prefix, temp_cnt_));
+  const String& symbol = String::ZoneHandle(Z, Symbols::New(cnt_str));
   ASSERT(!symbol.IsNull());
   // Look up the variable through the preamble scope.
   LocalVariable* await_tmp = preamble_->scope()->LookupVariable(symbol, false);
   if (await_tmp == NULL) {
     // If we need a new temp variable, we add it to the function's top scope.
     await_tmp = new (Z) LocalVariable(
         Scanner::kNoSourcePos, symbol, Type::ZoneHandle(Type::DynamicType()));
     function_top_->AddVariable(await_tmp);
     // After adding it to the top scope, we can look it up from the preamble.
     // The following call includes an ASSERT check.
@@ skipping 53 matching lines @@
       preamble_->scope(), Symbols::AsyncOperationErrorParam());
 
   AstNode* transformed_expr = Transform(node->expr());
   preamble_->Add(new(Z) StoreLocalNode(
       Scanner::kNoSourcePos, result_param, transformed_expr));
 
   LoadLocalNode* load_result_param = new(Z) LoadLocalNode(
       Scanner::kNoSourcePos, result_param);
 
   const Class& future_cls =
-      Class::ZoneHandle(I, I->object_store()->future_class());
+      Class::ZoneHandle(Z, thread()->isolate()->object_store()->future_class());

[Ivan Posva, 2015/01/23 04:53:04]

Was wondering whether it makes sense to keep I defined as "thread()->isolate()",
but it seems to be the only use of isolate().

[koda, 2015/01/23 14:29:31]

Acknowledged.

   ASSERT(!future_cls.IsNull());
   const AbstractType& future_type =
-      AbstractType::ZoneHandle(I, future_cls.RareType());
+      AbstractType::ZoneHandle(Z, future_cls.RareType());
   ASSERT(!future_type.IsNull());
 
   LocalScope* is_not_future_scope = ChainNewScope(preamble_->scope());
   SequenceNode* is_not_future_branch =
       new (Z) SequenceNode(Scanner::kNoSourcePos, is_not_future_scope);
 
   // if (:result_param is !Future) {
   //   :result_param = Future.value(:result_param);
   // }
   const Function& value_ctor = Function::ZoneHandle(
-      I, future_cls.LookupFunction(Symbols::FutureValue()));
+      Z, future_cls.LookupFunction(Symbols::FutureValue()));
   ASSERT(!value_ctor.IsNull());
   ArgumentListNode* ctor_args = new (Z) ArgumentListNode(Scanner::kNoSourcePos);
   ctor_args->Add(new (Z) LoadLocalNode(Scanner::kNoSourcePos, result_param));
   ConstructorCallNode* ctor_call =
       new (Z) ConstructorCallNode(Scanner::kNoSourcePos,
-                                  TypeArguments::ZoneHandle(I),
+                                  TypeArguments::ZoneHandle(Z),
                                   value_ctor,
                                   ctor_args);
   is_not_future_branch->Add(new (Z) StoreLocalNode(
       Scanner::kNoSourcePos, result_param, ctor_call));
   AstNode* is_not_future_test = new (Z) ComparisonNode(
       Scanner::kNoSourcePos,
       Token::kISNOT,
       load_result_param,
       new (Z) TypeNode(Scanner::kNoSourcePos, future_type));
   preamble_->Add(new(Z) IfNode(Scanner::kNoSourcePos,
                                is_not_future_test,
                                is_not_future_branch,
                                NULL));
 
   AwaitMarkerNode* await_marker = new (Z) AwaitMarkerNode();
   await_marker->set_scope(preamble_->scope());
   preamble_->Add(await_marker);
   ArgumentListNode* args = new(Z) ArgumentListNode(Scanner::kNoSourcePos);
 
   args->Add(new(Z) LoadLocalNode(Scanner::kNoSourcePos, async_op));
   preamble_->Add(new (Z) StoreLocalNode(
       Scanner::kNoSourcePos,
       result_param,
       new(Z) InstanceCallNode(Scanner::kNoSourcePos,
                               load_result_param,
                               Symbols::FutureThen(),
                               args)));
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const Function& async_catch_helper = Function::ZoneHandle(
-      I, core_lib.LookupFunctionAllowPrivate(Symbols::AsyncCatchHelper()));
+      Z, core_lib.LookupFunctionAllowPrivate(Symbols::AsyncCatchHelper()));
   ASSERT(!async_catch_helper.IsNull());
   ArgumentListNode* catch_helper_args = new (Z) ArgumentListNode(
       Scanner::kNoSourcePos);
   InstanceGetterNode* catch_error_getter = new (Z) InstanceGetterNode(
       Scanner::kNoSourcePos,
       load_result_param,
       Symbols::FutureCatchError());
   catch_helper_args->Add(catch_error_getter);
   catch_helper_args->Add(new (Z) LoadLocalNode(
       Scanner::kNoSourcePos, async_op));
   preamble_->Add(new (Z) StaticCallNode(
       Scanner::kNoSourcePos,
       async_catch_helper,
       catch_helper_args));
   ReturnNode* continuation_return = new(Z) ReturnNode(Scanner::kNoSourcePos);
   continuation_return->set_return_type(ReturnNode::kContinuationTarget);
   preamble_->Add(continuation_return);
 
   // If this expression is part of a try block, also append the code for
   // restoring the saved try context that lives on the stack.
   const String& async_saved_try_ctx_name =
-      String::Handle(I, parsed_function_->async_saved_try_ctx_name());
+      String::Handle(Z, parsed_function_->async_saved_try_ctx_name());
   if (!async_saved_try_ctx_name.IsNull()) {
     LocalVariable* async_saved_try_ctx =
         GetVariableInScope(preamble_->scope(), async_saved_try_ctx_name);
     preamble_->Add(new (Z) StoreLocalNode(
         Scanner::kNoSourcePos,
         parsed_function_->saved_try_ctx(),
         new (Z) LoadLocalNode(Scanner::kNoSourcePos, async_saved_try_ctx)));
   }
 
   LoadLocalNode* load_error_param = new (Z) LoadLocalNode(
@@ skipping 369 matching lines @@
 void AwaitTransformer::VisitThrowNode(ThrowNode* node) {
   // TODO(mlippautz): Check if relevant.
   AstNode* new_exception = Transform(node->exception());
   AstNode* new_stacktrace = Transform(node->stacktrace());
   result_ = new(Z) ThrowNode(node->token_pos(),
                              new_exception,
                              new_stacktrace);
 }
 
 }  // namespace dart