Fix two bugs in the Dart VM's super-noSuchMethod invocation.

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 "lib/invocation_mirror.h"
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
@@ skipping 91 matching lines @@
   Instance& stack_trace = Instance::ZoneHandle(excp.stacktrace());
   if (stack_trace.IsNew()) {
     stack_trace ^= Object::Clone(stack_trace, Heap::kOld);
   }
   return new ThrowNode(token_pos,
                        new LiteralNode(token_pos, exception),
                        new LiteralNode(token_pos, stack_trace));
 }
 
 
-LocalVariable* ParsedFunction::CreateExpressionTempVar(intptr_t token_pos) {
-  return new LocalVariable(token_pos,
-                           Symbols::ExprTemp(),
-                           Type::ZoneHandle(Type::DynamicType()));
+LocalVariable* ParsedFunction::EnsureExpressionTemp() {
+  if (!has_expression_temp_var()) {
+    LocalVariable* temp =
+        new LocalVariable(function_.token_pos(),
+                          Symbols::ExprTemp(),
+                          Type::ZoneHandle(Type::DynamicType()));
+    ASSERT(temp != NULL);
+    set_expression_temp_var(temp);
+  }
+  ASSERT(has_expression_temp_var());
+  return expression_temp_var();
 }
 
 
 void ParsedFunction::SetNodeSequence(SequenceNode* node_sequence) {
   ASSERT(node_sequence_ == NULL);
   ASSERT(node_sequence != NULL);
   node_sequence_ = node_sequence;
 }
 
 
@@ skipping 1268 matching lines @@
 static const String& PrivateCoreLibName(const String& str) {
   const Library& core_lib = Library::Handle(Library::CoreLibrary());
   const String& private_name = String::ZoneHandle(core_lib.PrivateName(str));
   return private_name;
 }
 
 
 StaticCallNode* Parser::BuildInvocationMirrorAllocation(
     intptr_t call_pos,
     const String& function_name,
-    const ArgumentListNode& function_args) {
+    const ArgumentListNode& function_args,
+    const LocalVariable* temp_for_last_arg) {
   const intptr_t args_pos = function_args.token_pos();
   // Build arguments to the call to the static
   // InvocationMirror._allocateInvocationMirror method.
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   // The first argument is the original function name.
   arguments->Add(new LiteralNode(args_pos, function_name));
   // The second argument is the arguments descriptor of the original function.
   const Array& args_descriptor =
       Array::ZoneHandle(ArgumentsDescriptor::New(function_args.length(),
                                                  function_args.names()));
   arguments->Add(new LiteralNode(args_pos, args_descriptor));
   // The third argument is an array containing the original function arguments,
   // including the receiver.
   ArrayNode* args_array =
       new ArrayNode(args_pos, Type::ZoneHandle(Type::ArrayType()));
   for (intptr_t i = 0; i < function_args.length(); i++) {
-    args_array->AddElement(function_args.NodeAt(i));
+    AstNode* arg = function_args.NodeAt(i);
+    if ((temp_for_last_arg != NULL) && (i == function_args.length() - 1)) {
+      args_array->AddElement(
+          new CommaNode(arg->token_pos(),
+                        new StoreLocalNode(arg->token_pos(),
+                                           temp_for_last_arg,
+                                           arg),
+                        new LoadLocalNode(arg->token_pos(),
+                                          temp_for_last_arg)));
+    } else {
+      args_array->AddElement(function_args.NodeAt(i));
+    }
   }
   arguments->Add(args_array);
   // Lookup the static InvocationMirror._allocateInvocationMirror method.
   const Class& mirror_class =
       Class::Handle(LookupCoreClass(Symbols::InvocationMirror()));
   ASSERT(!mirror_class.IsNull());
   const Function& allocation_function = Function::ZoneHandle(
       mirror_class.LookupStaticFunction(
           PrivateCoreLibName(Symbols::AllocateInvocationMirror())));
   ASSERT(!allocation_function.IsNull());
   return new StaticCallNode(call_pos, allocation_function, arguments);
 }
 
 
 ArgumentListNode* Parser::BuildNoSuchMethodArguments(
     intptr_t call_pos,
     const String& function_name,
-    const ArgumentListNode& function_args) {
+    const ArgumentListNode& function_args,
+    const LocalVariable* temp_for_last_arg) {
   ASSERT(function_args.length() >= 1);  // The receiver is the first argument.
   const intptr_t args_pos = function_args.token_pos();
   ArgumentListNode* arguments = new ArgumentListNode(args_pos);
   arguments->Add(function_args.NodeAt(0));
   // The second argument is the invocation mirror.
   arguments->Add(BuildInvocationMirrorAllocation(
-      call_pos, function_name, function_args));
+      call_pos, function_name, function_args, temp_for_last_arg));
   return arguments;
 }
 
 
 AstNode* Parser::ParseSuperCall(const String& function_name) {
   TRACE_PARSER("ParseSuperCall");
   ASSERT(CurrentToken() == Token::kLPAREN);
   const intptr_t supercall_pos = TokenPos();
 
   // 'this' parameter is the first argument to super call.
@@ skipping 5417 matching lines @@
       ConsumeToken();
       AstNode* expr = ParseExpr(kAllowConst, kConsumeCascades);
       list->Add(expr);
     }
     expressions = list;
   }
   return expressions;
 }
 
 
-const LocalVariable* Parser::GetIncrementTempLocal() {
-  if (!parsed_function()->has_expression_temp_var()) {
-    LocalVariable* temp = ParsedFunction::CreateExpressionTempVar(
-        current_function().token_pos());
-    ASSERT(temp != NULL);
-    parsed_function()->set_expression_temp_var(temp);
-  }
-  ASSERT(parsed_function()->has_expression_temp_var());
-  return parsed_function()->expression_temp_var();
-}
-
-
 void Parser::EnsureExpressionTemp() {
   // Temporary used later by the flow_graph_builder.
-  GetIncrementTempLocal();
+  parsed_function()->EnsureExpressionTemp();
 }
 
 
 void Parser::EnsureSavedCurrentContext() {
   // Used later by the flow_graph_builder to save current context.
   if (!parsed_function()->has_saved_current_context_var()) {
     LocalVariable* temp =
         new LocalVariable(current_function().token_pos(),
                           Symbols::SavedCurrentContextVar(),
                           Type::ZoneHandle(Type::DynamicType()));
@@ skipping 3051 matching lines @@
 void Parser::SkipQualIdent() {
   ASSERT(IsIdentifier());
   ConsumeToken();
   if (CurrentToken() == Token::kPERIOD) {
     ConsumeToken();  // Consume the kPERIOD token.
     ExpectIdentifier("identifier expected after '.'");
   }
 }
 
 }  // namespace dart