Make saving and restoring of the context around closure calls explicit.

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 4967 matching lines @@
   const intptr_t condition_pos = token_index_;
   if (!FLAG_enable_asserts && !FLAG_enable_type_checks) {
     SkipExpr();
     ExpectToken(Token::kRPAREN);
     return NULL;
   }
   AstNode* condition = ParseExpr(kAllowConst);
   const intptr_t condition_end = token_index_;
   ExpectToken(Token::kRPAREN);
   if (condition->IsClosureNode()) {
+    EnsureExpressionTemp();
     // Function literal in assert implies a call.
     condition =
         new ClosureCallNode(condition_pos,
                             condition,
                             new ArgumentListNode(condition_pos));
   }
   condition = new UnaryOpNode(condition_pos, Token::kNOT, condition);
   AstNode* assert_throw = MakeAssertCall(condition_pos, condition_end);
   return new IfNode(condition_pos,
                     condition,
@@ skipping 1275 matching lines @@
           String::ZoneHandle(Field::GetterName(func_name));
       const int kNumArguments = 0;  // no arguments.
       const Array& kNoArgumentNames = Array::Handle();
       func = Resolver::ResolveStatic(cls,
                                      getter_name,
                                      kNumArguments,
                                      kNoArgumentNames,
                                      Resolver::kIsQualified);
       if (!func.IsNull()) {
         ASSERT(func.kind() != RawFunction::kConstImplicitGetter);
+        EnsureExpressionTemp();
         closure = new StaticGetterNode(call_pos,
                                        Class::ZoneHandle(cls.raw()),
                                        func_name);
         return new ClosureCallNode(call_pos, closure, arguments);
       }
     } else {
+      EnsureExpressionTemp();
       closure = GenerateStaticFieldLookup(field, call_pos);
       return new ClosureCallNode(call_pos, closure, arguments);
     }
     // Could not resolve static method: throw an exception if the arguments
     // do not match or compile time error otherwise.
     const Function& test_func = Function::Handle(
         Resolver::ResolveStaticByName(cls, func_name, Resolver::kIsQualified));
     if (test_func.IsNull()) {
       ErrorMsg(ident_pos, "unresolved static method '%s'",
           func_name.ToCString());
@@ skipping 19 matching lines @@
   }
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new InstanceCallNode(call_pos, receiver, func_name, arguments);
 }
 
 
 AstNode* Parser::ParseClosureCall(AstNode* closure) {
   TRACE_PARSER("ParseClosureCall");
   const intptr_t call_pos = token_index_;
   ASSERT(CurrentToken() == Token::kLPAREN);
+  EnsureExpressionTemp();
   ArgumentListNode* arguments = ParseActualParameters(NULL, kAllowConst);
   return new ClosureCallNode(call_pos, closure, arguments);
 }
 
 
 AstNode* Parser::ParseInstanceFieldAccess(AstNode* receiver,
                                           const String& field_name) {
   TRACE_PARSER("ParseInstanceFieldAccess");
   AstNode* access = NULL;
   const intptr_t call_pos = token_index_;
@@ skipping 2137 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart