Remove TuckTemp, PickTemp, use temporary locals instead.

runtime/vm/parser.cc

 // Copyright (c) 2012, 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/parser.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/compiler_stats.h"
@@ skipping 7386 matching lines @@
     if (!type_arguments.IsNull() &&
         !type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(list);
     AbstractTypeArguments& canonical_type_arguments =
         AbstractTypeArguments::ZoneHandle(type_arguments.Canonicalize());
-    return new ConstructorCallNode(literal_pos,
-                                   canonical_type_arguments,
-                                   list_literal_factory,
-                                   factory_param);
+    return CreateConstructorCallNode(literal_pos,
+                                     canonical_type_arguments,
+                                     list_literal_factory,
+                                     factory_param);
   }
 }
 
 
+ConstructorCallNode* Parser::CreateConstructorCallNode(
+    intptr_t token_index,
+    const AbstractTypeArguments& type_arguments,
+    const Function& constructor,
+    ArgumentListNode* arguments) {
+  if (!type_arguments.IsNull() && !type_arguments.IsInstantiated()) {
+    EnsureExpressionTemp();
+  }
+  LocalVariable* allocated =
+      CreateTempConstVariable(token_index, token_index, "alloc");
+  return new ConstructorCallNode(token_index,
+                                 type_arguments,
+                                 constructor,
+                                 arguments,
+                                 *allocated);
+}
+
+
 static void AddKeyValuePair(ArrayNode* pairs,
                             bool is_const,
                             AstNode* key,
                             AstNode* value) {
   if (is_const) {
     ASSERT(key->IsLiteralNode());
     ASSERT(key->AsLiteralNode()->literal().IsString());
     const Instance& new_key = key->AsLiteralNode()->literal();
     for (int i = 0; i < pairs->length(); i += 2) {
       const Instance& key_i =
@@ skipping 176 matching lines @@
         map_literal_factory_class.LookupFactory(map_literal_factory_name));
     ASSERT(!map_literal_factory.IsNull());
     if (!map_type_arguments.IsNull() &&
         !map_type_arguments.IsInstantiated() &&
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     ArgumentListNode* factory_param = new ArgumentListNode(literal_pos);
     factory_param->Add(kv_pairs);
-    return new ConstructorCallNode(literal_pos,
-                                   map_type_arguments,
-                                   map_literal_factory,
-                                   factory_param);
+    return CreateConstructorCallNode(literal_pos,
+                                     map_type_arguments,
+                                     map_literal_factory,
+                                     factory_param);
   }
 }
 
 
 AstNode* Parser::ParseCompoundLiteral() {
   TRACE_PARSER("ParseCompoundLiteral");
   bool is_const = false;
   if (CurrentToken() == Token::kCONST) {
     is_const = true;
     ConsumeToken();
@@ skipping 242 matching lines @@
         (current_block_->scope->function_level() > 0)) {
       // Make sure that the instantiator is captured.
       CaptureReceiver();
     }
     if (type.IsMalformed()) {
       // Compile the throw of a dynamic type error due to a bound error.
       return ThrowTypeError(type_pos, type);
     }
     // If the type argument vector is not instantiated, we verify in checked
     // mode at runtime that it is within its declared bounds.
-    new_object = new ConstructorCallNode(
+    new_object = CreateConstructorCallNode(
         new_pos, type_arguments, constructor, arguments);
   }
   return new_object;
 }
 
 
 String& Parser::Interpolate(ArrayNode* values) {
   const String& class_name =
       String::Handle(String::NewSymbol(kStringClassName));
   const Class& cls = Class::Handle(LookupImplClass(class_name));
@@ skipping 557 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart