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

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/code_descriptors.h"
 #include "vm/dart_entry.h"
@@ skipping 23 matching lines @@
 DECLARE_FLAG(bool, enable_type_checks);
 
 
 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;
 }
 
 
-FlowGraphBuilder::FlowGraphBuilder(const ParsedFunction& parsed_function,
+FlowGraphBuilder::FlowGraphBuilder(ParsedFunction* parsed_function,
                                    const Array& ic_data_array,
                                    InlineExitCollector* exit_collector)
   : parsed_function_(parsed_function),
     ic_data_array_(ic_data_array),
-    num_copied_params_(parsed_function.num_copied_params()),
+    num_copied_params_(parsed_function->num_copied_params()),
     // All parameters are copied if any parameter is.
     num_non_copied_params_((num_copied_params_ == 0)
-        ? parsed_function.function().num_fixed_parameters()
+        ? parsed_function->function().num_fixed_parameters()
         : 0),
-    num_stack_locals_(parsed_function.num_stack_locals()),
+    num_stack_locals_(parsed_function->num_stack_locals()),
     exit_collector_(exit_collector),
     last_used_block_id_(0),  // 0 is used for the graph entry.
     context_level_(0),
     last_used_try_index_(CatchClauseNode::kInvalidTryIndex),
     try_index_(CatchClauseNode::kInvalidTryIndex),
     graph_entry_(NULL),
     args_pushed_(0) { }
 
 
 void FlowGraphBuilder::AddCatchEntry(CatchBlockEntryInstr* entry) {
@@ skipping 450 matching lines @@
 
 
 Definition* EffectGraphVisitor::BuildStoreTemp(const LocalVariable& local,
                                                Value* value) {
   ASSERT(!local.is_captured());
   return new StoreLocalInstr(local, value);
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreExprTemp(Value* value) {
-  return BuildStoreTemp(*owner()->parsed_function().expression_temp_var(),
+  return BuildStoreTemp(*owner()->parsed_function()->expression_temp_var(),
                         value);
 }
 
 
 Definition* EffectGraphVisitor::BuildLoadExprTemp() {
-  return BuildLoadLocal(*owner()->parsed_function().expression_temp_var());
+  return BuildLoadLocal(*owner()->parsed_function()->expression_temp_var());
 }
 
 
 Definition* EffectGraphVisitor::BuildStoreLocal(
     const LocalVariable& local, Value* value, bool result_is_needed) {
   if (local.is_captured()) {
     InlineBailout("EffectGraphVisitor::BuildStoreLocal (context)");
     if (result_is_needed) {
       value = Bind(BuildStoreExprTemp(value));
     }
@@ skipping 220 matching lines @@
   ValueGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::Bailout(const char* reason) {
   owner()->Bailout(reason);
 }
 
 
 void EffectGraphVisitor::InlineBailout(const char* reason) {
-  owner()->parsed_function().function().set_is_inlinable(false);
+  owner()->parsed_function()->function().set_is_inlinable(false);
   if (owner()->IsInlining()) owner()->Bailout(reason);
 }
 
 
 // <Statement> ::= Return { value:                <Expression>
 //                          inlined_finally_list: <InlinedFinally>* }
 void EffectGraphVisitor::VisitReturnNode(ReturnNode* node) {
   ValueGraphVisitor for_value(owner(), temp_index());
   node->value()->Visit(&for_value);
   Append(for_value);
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
     EffectGraphVisitor for_effect(owner(), temp_index());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
 
   Value* return_value = for_value.value();
   if (FLAG_enable_type_checks) {
-    const Function& function = owner()->parsed_function().function();
+    const Function& function = owner()->parsed_function()->function();
     const bool is_implicit_dynamic_getter =
         (!function.is_static() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kConstImplicitGetter)));
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     // The body of a constructor cannot modify the type of the
     // constructed instance, which is passed in as an implicit parameter.
     // However, factories may create an instance of the wrong type.
     if (!is_implicit_dynamic_getter && !function.IsConstructor()) {
       const AbstractType& dst_type =
           AbstractType::ZoneHandle(
-              owner()->parsed_function().function().result_type());
+              owner()->parsed_function()->function().result_type());
       return_value = BuildAssignableValue(node->value()->token_pos(),
                                           return_value,
                                           dst_type,
                                           Symbols::FunctionResult());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
-  if (owner()->parsed_function().saved_entry_context_var() != NULL) {
+  if (owner()->parsed_function()->saved_entry_context_var() != NULL) {
     // CTX on entry was saved, but not linked as context parent.
-    BuildLoadContext(*owner()->parsed_function().saved_entry_context_var());
+    BuildLoadContext(*owner()->parsed_function()->saved_entry_context_var());
   } else {
     while (current_context_level-- > 0) {
       UnchainContext();
     }
   }
 
   AddReturnExit(node->token_pos(), return_value);
 }
 
 
@@ skipping 49 matching lines @@
 
   // If nothing is known about the value, as is the case for passed-in
   // parameters, and since dst_type is not one of the tested cases above, then
   // the type test cannot be eliminated.
   if (value == NULL) {
     return false;
   }
 
   const bool eliminated = value->Type()->IsAssignableTo(dst_type);
   if (FLAG_trace_type_check_elimination) {
-    FlowGraphPrinter::PrintTypeCheck(owner()->parsed_function(),
+    FlowGraphPrinter::PrintTypeCheck(*owner()->parsed_function(),
                                      token_pos,
                                      value,
                                      dst_type,
                                      dst_name,
                                      eliminated);
   }
   return eliminated;
 }
 
 
@@ skipping 127 matching lines @@
   }
   EffectGraphVisitor::VisitBinaryOpNode(node);
 }
 
 
 void EffectGraphVisitor::BuildTypecheckPushArguments(
     intptr_t token_pos,
     PushArgumentInstr** push_instantiator_result,
     PushArgumentInstr** push_instantiator_type_arguments_result) {
   const Class& instantiator_class = Class::Handle(
-      owner()->parsed_function().function().Owner());
+      owner()->parsed_function()->function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   Value* instantiator_type_arguments = NULL;
   Value* instantiator = BuildInstantiator();
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     *push_instantiator_result = PushArgument(BuildNullValue());
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
     instantiator = Bind(BuildStoreExprTemp(instantiator));
     *push_instantiator_result = PushArgument(instantiator);
     Value* loaded = Bind(BuildLoadExprTemp());
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, loaded);
   }
   *push_instantiator_type_arguments_result =
       PushArgument(instantiator_type_arguments);
 }
 
 
 
 void EffectGraphVisitor::BuildTypecheckArguments(
     intptr_t token_pos,
     Value** instantiator_result,
     Value** instantiator_type_arguments_result) {
   Value* instantiator = NULL;
   Value* instantiator_type_arguments = NULL;
   const Class& instantiator_class = Class::Handle(
-      owner()->parsed_function().function().Owner());
+      owner()->parsed_function()->function().Owner());
   // Since called only when type tested against is not instantiated.
   ASSERT(instantiator_class.NumTypeParameters() > 0);
   instantiator = BuildInstantiator();
   if (instantiator == NULL) {
     // No instantiator when inside factory.
     instantiator = BuildNullValue();
     instantiator_type_arguments =
         BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   } else {
     // Preserve instantiator.
@@ skipping 753 matching lines @@
 
 intptr_t EffectGraphVisitor::GetCurrentTempLocalIndex() const {
   return kFirstLocalSlotFromFp
       - owner()->num_stack_locals()
       - owner()->num_copied_params()
       - owner()->args_pushed()
       - temp_index() + 1;
 }
 
 
-class TempLocalScope : public ValueObject {
- public:
-  TempLocalScope(EffectGraphVisitor* visitor, Value* value)
-      : visitor_(visitor) {
-    ASSERT(value->definition()->temp_index() == visitor->temp_index() - 1);
-    intptr_t index = visitor->GetCurrentTempLocalIndex();
-    char name[64];
-    OS::SNPrint(name, 64, ":tmp_local%"Pd, index);
-    var_ = new LocalVariable(0, String::ZoneHandle(Symbols::New(name)),
-                             Type::ZoneHandle(Type::DynamicType()));
-    var_->set_index(index);
-    visitor->Do(new PushTempInstr(value));
-    visitor->AllocateTempIndex();
-  }
+LocalVariable* EffectGraphVisitor::EnterTempLocalScope(Value* value) {
+  Do(new PushTempInstr(value));
+  AllocateTempIndex();
 
-  LocalVariable* var() const { return var_; }
+  ASSERT(value->definition()->temp_index() == temp_index() - 1);
+  intptr_t index = GetCurrentTempLocalIndex();
+  char name[64];
+  OS::SNPrint(name, 64, ":tmp_local%"Pd, index);
+  LocalVariable*  var =
+      new LocalVariable(0, String::ZoneHandle(Symbols::New(name)),
+                        Type::ZoneHandle(Type::DynamicType()));
+  var->set_index(index);
+  return var;
+}
 
-  ~TempLocalScope() {
-    Value* result = visitor_->Bind(new LoadLocalInstr(*var_));
-    visitor_->DeallocateTempIndex(1);
-    visitor_->ReturnDefinition(new DropTempsInstr(1, result));
-  }
 
- private:
-  EffectGraphVisitor* visitor_;
-  LocalVariable* var_;
-};
+Definition* EffectGraphVisitor::ExitTempLocalScope(LocalVariable* var) {
+    Value* tmp = Bind(new LoadLocalInstr(*var));
+    DeallocateTempIndex(1);
+    ASSERT(GetCurrentTempLocalIndex() == var->index());
+    return new DropTempsInstr(1, tmp);
+}
 
 
 void EffectGraphVisitor::BuildLetTempExpressions(LetNode* node) {
   intptr_t num_temps = node->num_temps();
   for (intptr_t i = 0; i < num_temps; ++i) {
     ValueGraphVisitor for_value(owner(), temp_index());
     node->InitializerAt(i)->Visit(&for_value);
     Append(for_value);
     Value* temp_val = for_value.value();
     node->TempAt(i)->set_index(GetCurrentTempLocalIndex());
@@ skipping 41 matching lines @@
   const AbstractTypeArguments& type_args =
       AbstractTypeArguments::ZoneHandle(node->type().arguments());
   Value* element_type = BuildInstantiatedTypeArguments(node->token_pos(),
                                                        type_args);
   CreateArrayInstr* create = new CreateArrayInstr(node->token_pos(),
                                                   node->length(),
                                                   node->type(),
                                                   element_type);
   Value* array_val = Bind(create);
 
-  { TempLocalScope tmp(this, array_val);
+  { LocalVariable* tmp_var = EnterTempLocalScope(array_val);
     const intptr_t class_id = create->Type()->ToCid();
     const intptr_t deopt_id = Isolate::kNoDeoptId;
     for (int i = 0; i < node->length(); ++i) {
-      Value* array = Bind(new LoadLocalInstr(*tmp.var()));
+      Value* array = Bind(new LoadLocalInstr(*tmp_var));
       Value* index = Bind(new ConstantInstr(Smi::ZoneHandle(Smi::New(i))));
       ValueGraphVisitor for_value(owner(), temp_index());
       node->ElementAt(i)->Visit(&for_value);
       Append(for_value);
       // No store barrier needed for constants.
       const StoreBarrierType emit_store_barrier =
           for_value.value()->BindsToConstant()
               ? kNoStoreBarrier
               : kEmitStoreBarrier;
       intptr_t index_scale = FlowGraphCompiler::ElementSizeFor(class_id);
       StoreIndexedInstr* store = new StoreIndexedInstr(
           array, index, for_value.value(),
           emit_store_barrier, index_scale, class_id, deopt_id);
       Do(store);
     }
+    ReturnDefinition(ExitTempLocalScope(tmp_var));
   }
 }
 
 
 void EffectGraphVisitor::VisitClosureNode(ClosureNode* node) {
   const Function& function = node->function();
 
   if (function.IsImplicitStaticClosureFunction()) {
     Instance& closure = Instance::ZoneHandle();
     closure ^= function.implicit_static_closure();
@@ skipping 34 matching lines @@
 
   // The function type of a closure may have type arguments. In that case, pass
   // the type arguments of the instantiator. Otherwise, pass null object.
   const Class& cls = Class::Handle(function.signature_class());
   ASSERT(!cls.IsNull());
   const bool requires_type_arguments = cls.HasTypeArguments();
   Value* type_arguments = NULL;
   if (requires_type_arguments) {
     ASSERT(!function.IsImplicitStaticClosureFunction());
     const Class& instantiator_class = Class::Handle(
-        owner()->parsed_function().function().Owner());
+        owner()->parsed_function()->function().Owner());
     type_arguments = BuildInstantiatorTypeArguments(node->token_pos(),
                                                     instantiator_class,
                                                     NULL);
   } else {
     type_arguments = BuildNullValue();
   }
   PushArgumentInstr* push_type_arguments = PushArgument(type_arguments);
   arguments->Add(push_type_arguments);
   ReturnDefinition(
       new CreateClosureInstr(node->function(), arguments, node->token_pos()));
@@ skipping 100 matching lines @@
   node->closure()->Visit(&for_closure);
   Append(for_closure);
   PushArgumentInstr* push_closure = PushArgument(for_closure.value());
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(node->arguments()->length());
   arguments->Add(push_closure);
   BuildPushArguments(*node->arguments(), arguments);
 
   // Save context around the call.
-  ASSERT(owner()->parsed_function().saved_current_context_var() != NULL);
-  BuildStoreContext(*owner()->parsed_function().saved_current_context_var());
+  ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
+  BuildStoreContext(*owner()->parsed_function()->saved_current_context_var());
   return new ClosureCallInstr(node, arguments);
 }
 
 
 void EffectGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Do(BuildClosureCall(node));
   // Restore context from saved location.
-  ASSERT(owner()->parsed_function().saved_current_context_var() != NULL);
-  BuildLoadContext(*owner()->parsed_function().saved_current_context_var());
+  ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
+  BuildLoadContext(*owner()->parsed_function()->saved_current_context_var());
 }
 
 
 void ValueGraphVisitor::VisitClosureCallNode(ClosureCallNode* node) {
   Value* result = Bind(BuildClosureCall(node));
   // Restore context from temp.
-  ASSERT(owner()->parsed_function().saved_current_context_var() != NULL);
-  BuildLoadContext(*owner()->parsed_function().saved_current_context_var());
+  ASSERT(owner()->parsed_function()->saved_current_context_var() != NULL);
+  BuildLoadContext(*owner()->parsed_function()->saved_current_context_var());
   ReturnValue(result);
 }
 
 
 void EffectGraphVisitor::VisitCloneContextNode(CloneContextNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCloneContextNode (context)");
   Value* context = Bind(new CurrentContextInstr());
   Value* clone = Bind(new CloneContextInstr(node->token_pos(), context));
   AddInstruction(new StoreContextInstr(clone));
 }
@@ skipping 144 matching lines @@
   //   StaticCall(constructor, t_n+1, t_n+2, ...)
   // No need to preserve allocated value (simpler than in ValueGraphVisitor).
   Value* allocated_value = BuildObjectAllocation(node);
   PushArgumentInstr* push_allocated_value = PushArgument(allocated_value);
   BuildConstructorCall(node, push_allocated_value);
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiator() {
   const Class& instantiator_class = Class::Handle(
-      owner()->parsed_function().function().Owner());
+      owner()->parsed_function()->function().Owner());
   if (instantiator_class.NumTypeParameters() == 0) {
     return NULL;
   }
   Function& outer_function =
-      Function::Handle(owner()->parsed_function().function().raw());
+      Function::Handle(owner()->parsed_function()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     return NULL;
   }
 
-  ASSERT(owner()->parsed_function().instantiator() != NULL);
+  ASSERT(owner()->parsed_function()->instantiator() != NULL);
   ValueGraphVisitor for_instantiator(owner(), temp_index());
-  owner()->parsed_function().instantiator()->Visit(&for_instantiator);
+  owner()->parsed_function()->instantiator()->Visit(&for_instantiator);
   Append(for_instantiator);
   return for_instantiator.value();
 }
 
 
 // 'expression_temp_var' may not be used inside this method if 'instantiator'
 // is not NULL.
 Value* EffectGraphVisitor::BuildInstantiatorTypeArguments(
     intptr_t token_pos,
     const Class& instantiator_class,
     Value* instantiator) {
   if (instantiator_class.NumTypeParameters() == 0) {
     // The type arguments are compile time constants.
     AbstractTypeArguments& type_arguments = AbstractTypeArguments::ZoneHandle();
     // Type is temporary. Only its type arguments are preserved.
     Type& type = Type::Handle(
         Type::New(instantiator_class, type_arguments, token_pos, Heap::kNew));
     type ^= ClassFinalizer::FinalizeType(
         instantiator_class, type, ClassFinalizer::kFinalize);
     ASSERT(!type.IsMalformed());
     type_arguments = type.arguments();
     type_arguments = type_arguments.Canonicalize();
     return Bind(new ConstantInstr(type_arguments));
   }
   Function& outer_function =
-      Function::Handle(owner()->parsed_function().function().raw());
+      Function::Handle(owner()->parsed_function()->function().raw());
   while (outer_function.IsLocalFunction()) {
     outer_function = outer_function.parent_function();
   }
   if (outer_function.IsFactory()) {
     // No instantiator for factories.
     ASSERT(instantiator == NULL);
-    ASSERT(owner()->parsed_function().instantiator() != NULL);
+    ASSERT(owner()->parsed_function()->instantiator() != NULL);
     ValueGraphVisitor for_instantiator(owner(), temp_index());
-    owner()->parsed_function().instantiator()->Visit(&for_instantiator);
+    owner()->parsed_function()->instantiator()->Visit(&for_instantiator);
     Append(for_instantiator);
     return for_instantiator.value();
   }
   if (instantiator == NULL) {
     instantiator = BuildInstantiator();
   }
   // The instantiator is the receiver of the caller, which is not a factory.
   // The receiver cannot be null; extract its AbstractTypeArguments object.
   // Note that in the factory case, the instantiator is the first parameter
   // of the factory, i.e. already an AbstractTypeArguments object.
   intptr_t type_arguments_field_offset =
       instantiator_class.type_arguments_field_offset();
   ASSERT(type_arguments_field_offset != Class::kNoTypeArguments);
 
   return Bind(new LoadFieldInstr(
       instantiator,
       type_arguments_field_offset,
       Type::ZoneHandle()));  // Not an instance, no type.
 }
 
 
 Value* EffectGraphVisitor::BuildInstantiatedTypeArguments(
     intptr_t token_pos,
     const AbstractTypeArguments& type_arguments) {
   if (type_arguments.IsNull() || type_arguments.IsInstantiated()) {
     return Bind(new ConstantInstr(type_arguments));
   }
   // The type arguments are uninstantiated.
   const Class& instantiator_class = Class::ZoneHandle(
-      owner()->parsed_function().function().Owner());
+      owner()->parsed_function()->function().Owner());
   Value* instantiator_value =
       BuildInstantiatorTypeArguments(token_pos, instantiator_class, NULL);
   const bool use_instantiator_type_args =
       type_arguments.IsUninstantiatedIdentity() ||
       type_arguments.CanShareInstantiatorTypeArguments(
           instantiator_class);
   return use_instantiator_type_args
       ? instantiator_value
       : Bind(new InstantiateTypeArgumentsInstr(token_pos,
                                                type_arguments,
@@ skipping 14 matching lines @@
 
     // No instantiator required.
     Value* instantiator_val = Bind(new ConstantInstr(
         Smi::ZoneHandle(Smi::New(StubCode::kNoInstantiator))));
     call_arguments->Add(PushArgument(instantiator_val));
     return;
   }
 
   // The type arguments are uninstantiated. We use expression_temp_var to save
   // the instantiator type arguments because they have two uses.
-  ASSERT(owner()->parsed_function().expression_temp_var() != NULL);
+  ASSERT(owner()->parsed_function()->expression_temp_var() != NULL);
   const Class& instantiator_class = Class::Handle(
-      owner()->parsed_function().function().Owner());
+      owner()->parsed_function()->function().Owner());
   Value* type_arguments_val = BuildInstantiatorTypeArguments(
       node->token_pos(), instantiator_class, NULL);
 
   const bool use_instantiator_type_args =
       node->type_arguments().IsUninstantiatedIdentity() ||
       node->type_arguments().CanShareInstantiatorTypeArguments(
           instantiator_class);
 
   if (!use_instantiator_type_args) {
     const intptr_t len = node->type_arguments().Length();
@@ skipping 40 matching lines @@
 
   // t_n contains the allocated and initialized object.
   //   t_n      <- AllocateObject(class)
   //   t_n      <- StoreLocal(temp, t_n);
   //   t_n+1    <- ctor-arg
   //   t_n+2... <- constructor arguments start here
   //   StaticCall(constructor, t_n, t_n+1, ...)
   //   tn       <- LoadLocal(temp)
 
   Value* allocate = BuildObjectAllocation(node);
-  { TempLocalScope tmp(this, allocate);
-    Value* allocated_tmp = Bind(new LoadLocalInstr(*tmp.var()));
+  { LocalVariable* tmp_var = EnterTempLocalScope(allocate);
+    Value* allocated_tmp = Bind(new LoadLocalInstr(*tmp_var));
     PushArgumentInstr* push_allocated_value = PushArgument(allocated_tmp);
     BuildConstructorCall(node, push_allocated_value);
+    ReturnDefinition(ExitTempLocalScope(tmp_var));
   }
 }
 
 
 void EffectGraphVisitor::VisitInstanceGetterNode(InstanceGetterNode* node) {
   ValueGraphVisitor for_receiver(owner(), temp_index());
   node->receiver()->Visit(&for_receiver);
   Append(for_receiver);
   PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
@@ skipping 76 matching lines @@
       new ZoneGrowableArray<PushArgumentInstr*>();
   Function& getter_function = Function::ZoneHandle();
   if (node->is_super_getter()) {
     // Statically resolved instance getter, i.e. "super getter".
     ASSERT(node->receiver() != NULL);
     getter_function = Resolver::ResolveDynamicAnyArgs(node->cls(), getter_name);
     if (getter_function.IsNull()) {
       // Resolve and call noSuchMethod.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->receiver());
-      StaticCallInstr* call = BuildStaticNoSuchMethodCall(node->cls(),
-                                                          node->receiver(),
-                                                          getter_name,
-                                                          arguments);
+      StaticCallInstr* call =
+          BuildStaticNoSuchMethodCall(node->cls(),
+                                      node->receiver(),
+                                      getter_name,
+                                      arguments,
+                                      false);  // Don't save last argument.
       ReturnDefinition(call);
       return;
     } else {
       ValueGraphVisitor receiver_value(owner(), temp_index());
       node->receiver()->Visit(&receiver_value);
       Append(receiver_value);
       arguments->Add(PushArgument(receiver_value.value()));
     }
   } else {
     getter_function = node->cls().LookupStaticFunction(getter_name);
@@ skipping 50 matching lines @@
           ? Resolver::ResolveDynamicAnyArgs(node->cls(), setter_name)
           : node->cls().LookupStaticFunction(setter_name));
   StaticCallInstr* call;
   if (setter_function.IsNull()) {
     if (is_super_setter) {
       ASSERT(node->receiver() != NULL);
       // Resolve and call noSuchMethod.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->receiver());
       arguments->Add(node->value());
-      call = BuildStaticNoSuchMethodCall(node->cls(),
-                                         node->receiver(),
-                                         setter_name,
-                                         arguments);
+      call = BuildStaticNoSuchMethodCall(
+          node->cls(),
+          node->receiver(),
+          setter_name,
+          arguments,
+          result_is_needed);  // Save last arg if result is needed.
     } else {
       // Throw a NoSuchMethodError.
       call = BuildThrowNoSuchMethodError(
           node->token_pos(),
           node->cls(),
           setter_name,
           InvocationMirror::EncodeType(
             node->cls().IsTopLevel() ?
                 InvocationMirror::kTopLevel :
                 InvocationMirror::kStatic,
@@ skipping 211 matching lines @@
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
       StaticCallInstr* call =
           BuildStaticNoSuchMethodCall(node->super_class(),
                                       node->array(),
                                       Symbols::IndexToken(),
-                                      arguments);
+                                      arguments,
+                                      false);  // Don't save last arg.
       ReturnDefinition(call);
       return;
     }
   }
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
   ValueGraphVisitor for_array(owner(), temp_index());
   node->array()->Visit(&for_array);
   Append(for_array);
   arguments->Add(PushArgument(for_array.value()));
@@ skipping 33 matching lines @@
     // Resolve the store indexed operator in the super class.
     super_function = &Function::ZoneHandle(
         Resolver::ResolveDynamicAnyArgs(node->super_class(),
                                         Symbols::AssignIndexToken()));
     if (super_function->IsNull()) {
       // Could not resolve super operator. Generate call noSuchMethod() of the
       // super class instead.
       ArgumentListNode* arguments = new ArgumentListNode(node->token_pos());
       arguments->Add(node->array());
       arguments->Add(node->index_expr());
-
-      // Even though noSuchMethod most likely does not return,
-      // we save the stored value if the result is needed.
-      if (result_is_needed) {
-        ValueGraphVisitor for_value(owner(), temp_index());
-        node->value()->Visit(&for_value);
-        Append(for_value);
-        Do(BuildStoreExprTemp(for_value.value()));
-
-        const LocalVariable* temp =
-            owner()->parsed_function().expression_temp_var();
-        AstNode* value = new LoadLocalNode(node->token_pos(), temp);
-        arguments->Add(value);
-      } else {
-        arguments->Add(node->value());
-      }
-      StaticCallInstr* call =
-          BuildStaticNoSuchMethodCall(node->super_class(),
-                                      node->array(),
-                                      Symbols::AssignIndexToken(),
-                                      arguments);
+      arguments->Add(node->value());
+      StaticCallInstr* call = BuildStaticNoSuchMethodCall(
+          node->super_class(),
+          node->array(),
+          Symbols::AssignIndexToken(),
+          arguments,
+          result_is_needed);  // Save last arg if result is needed.
       if (result_is_needed) {
         Do(call);
+        // BuildStaticNoSuchMethodCall stores the value in expression_temp.
         return BuildLoadExprTemp();
       } else {
         return call;
       }
     }
   }
 
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(3);
   ValueGraphVisitor for_array(owner(), temp_index());
@@ skipping 58 matching lines @@
   ReturnDefinition(BuildStoreIndexedValues(node, kResultNotNeeded));
 }
 
 
 void ValueGraphVisitor::VisitStoreIndexedNode(StoreIndexedNode* node) {
   ReturnDefinition(BuildStoreIndexedValues(node, kResultNeeded));
 }
 
 
 bool EffectGraphVisitor::MustSaveRestoreContext(SequenceNode* node) const {
-  return (node == owner()->parsed_function().node_sequence()) &&
-         (owner()->parsed_function().saved_entry_context_var() != NULL);
+  return (node == owner()->parsed_function()->node_sequence()) &&
+         (owner()->parsed_function()->saved_entry_context_var() != NULL);
 }
 
 
 void EffectGraphVisitor::UnchainContext() {
   InlineBailout("EffectGraphVisitor::UnchainContext (context)");
   Value* context = Bind(new CurrentContextInstr());
   Value* parent = Bind(
       new LoadFieldInstr(context,
                          Context::parent_offset(),
                          Type::ZoneHandle()));  // Not an instance, no type.
@@ skipping 19 matching lines @@
                                       num_context_variables));
 
     // If this node_sequence is the body of the function being compiled, and if
     // this function allocates context variables, but none of its enclosing
     // functions do, the context on entry is not linked as parent of the
     // allocated context but saved on entry and restored on exit as to prevent
     // memory leaks.
     // In this case, the parser pre-allocates a variable to save the context.
     if (MustSaveRestoreContext(node)) {
       Value* current_context = Bind(new CurrentContextInstr());
-      Do(BuildStoreTemp(*owner()->parsed_function().saved_entry_context_var(),
+      Do(BuildStoreTemp(*owner()->parsed_function()->saved_entry_context_var(),
                         current_context));
       Value* null_context = Bind(new ConstantInstr(Object::ZoneHandle()));
       AddInstruction(new StoreContextInstr(null_context));
     }
 
     AddInstruction(new ChainContextInstr(allocated_context));
     owner()->set_context_level(scope->context_level());
 
     // If this node_sequence is the body of the function being compiled, copy
     // the captured parameters from the frame into the context.
-    if (node == owner()->parsed_function().node_sequence()) {
+    if (node == owner()->parsed_function()->node_sequence()) {
       ASSERT(scope->context_level() == 1);
-      const Function& function = owner()->parsed_function().function();
+      const Function& function = owner()->parsed_function()->function();
       int num_params = function.NumParameters();
       int param_frame_index = (num_params == function.num_fixed_parameters()) ?
           (kParamEndSlotFromFp + num_params) : kFirstLocalSlotFromFp;
       // Handle the saved arguments descriptor as an additional parameter.
-      if (owner()->parsed_function().GetSavedArgumentsDescriptorVar() != NULL) {
+      if (owner()->parsed_function()->GetSavedArgumentsDescriptorVar() !=
+          NULL) {
         ASSERT(param_frame_index == kFirstLocalSlotFromFp);
         num_params++;
       }
       for (int pos = 0; pos < num_params; param_frame_index--, pos++) {
         const LocalVariable& parameter = *scope->VariableAt(pos);
         ASSERT(parameter.owner() == scope);
         if (parameter.is_captured()) {
           // Create a temporary local describing the original position.
           const String& temp_name = String::ZoneHandle(String::Concat(
               parameter.name(), String::Handle(Symbols::New("-orig"))));
@@ skipping 11 matching lines @@
           // the function.
           Value* null_constant =
               Bind(new ConstantInstr(Object::ZoneHandle()));
           Do(BuildStoreLocal(*temp_local, null_constant, kResultNotNeeded));
         }
       }
     }
   }
 
   if (FLAG_enable_type_checks &&
-      (node == owner()->parsed_function().node_sequence())) {
-    const Function& function = owner()->parsed_function().function();
+      (node == owner()->parsed_function()->node_sequence())) {
+    const Function& function = owner()->parsed_function()->function();
     const int num_params = function.NumParameters();
     int pos = 0;
     if (function.IsConstructor()) {
       // Skip type checking of receiver and phase for constructor functions.
       pos = 2;
     } else if (function.IsFactory() || function.IsDynamicFunction()) {
       // Skip type checking of type arguments for factory functions.
       // Skip type checking of receiver for instance functions.
       pos = 1;
     }
@@ skipping 27 matching lines @@
     Append(for_effect);
     if (!is_open()) {
       // E.g., because of a JumpNode.
       break;
     }
   }
 
   if (is_open()) {
     if (MustSaveRestoreContext(node)) {
       ASSERT(num_context_variables > 0);
-      BuildLoadContext(*owner()->parsed_function().saved_entry_context_var());
+      BuildLoadContext(*owner()->parsed_function()->saved_entry_context_var());
     } else if (num_context_variables > 0) {
       UnchainContext();
     }
   }
 
   // No continue on sequence allowed.
   ASSERT((node->label() == NULL) ||
          (node->label()->join_for_continue() == NULL));
   // If this node sequence is labeled, a break out of the sequence will have
   // taken care of unchaining the context.
   if ((node->label() != NULL) &&
       (node->label()->join_for_break() != NULL)) {
     if (is_open()) Goto(node->label()->join_for_break());
     exit_ = node->label()->join_for_break();
   }
 
   // The outermost function sequence cannot contain a label.
   ASSERT((node->label() == NULL) ||
-         (node != owner()->parsed_function().node_sequence()));
+         (node != owner()->parsed_function()->node_sequence()));
   owner()->set_context_level(previous_context_level);
 }
 
 
 void EffectGraphVisitor::VisitCatchClauseNode(CatchClauseNode* node) {
   InlineBailout("EffectGraphVisitor::VisitCatchClauseNode (exception)");
   // NOTE: The implicit variables ':saved_context', ':exception_var'
   // and ':stacktrace_var' can never be captured variables.
   // Restores CTX from local variable ':saved_context'.
   AddInstruction(
@@ skipping 91 matching lines @@
   }
 }
 
 
 // Looks up dynamic method noSuchMethod in target_class
 // (including its super class chain) and builds a static call to it.
 StaticCallInstr* EffectGraphVisitor::BuildStaticNoSuchMethodCall(
     const Class& target_class,
     AstNode* receiver,
     const String& method_name,
-    ArgumentListNode* method_arguments) {
-  // Build the graph to allocate an InvocationMirror object by calling
-  // the static allocation method.
-  const Library& corelib = Library::Handle(Library::CoreLibrary());
-  const Class& mirror_class = Class::Handle(
-      corelib.LookupClassAllowPrivate(Symbols::InvocationMirror()));
-  ASSERT(!mirror_class.IsNull());
-  const Function& allocation_function = Function::ZoneHandle(
-      Resolver::ResolveStaticByName(
-          mirror_class,
-          PrivateCoreLibName(Symbols::AllocateInvocationMirror()),
-          Resolver::kIsQualified));
-  ASSERT(!allocation_function.IsNull());
-
-  // Evaluate the receiver before the arguments. This will be used
-  // as an argument to the noSuchMethod call.
-  ValueGraphVisitor for_receiver(owner(), temp_index());
-  receiver->Visit(&for_receiver);
-  Append(for_receiver);
-  PushArgumentInstr* push_receiver = PushArgument(for_receiver.value());
-
-  // Allocate the arguments and pass them into the construction
-  // of the InvocationMirror.
-  const intptr_t args_pos = method_arguments->token_pos();
-  ArgumentListNode* arguments = new ArgumentListNode(args_pos);
-  // The first argument is the original method name.
-  arguments->Add(new LiteralNode(args_pos, method_name));
-  // The second argument is the arguments descriptor of the original method.
-  const Array& args_descriptor =
-      Array::ZoneHandle(ArgumentsDescriptor::New(method_arguments->length(),
-                                                 method_arguments->names()));
-  arguments->Add(new LiteralNode(args_pos, args_descriptor));
-  // The third argument is an array containing the original method arguments,
-  // including the receiver.
-  ArrayNode* args_array = new ArrayNode(
-      args_pos,
-      Type::ZoneHandle(Type::ArrayType()));
-  for (intptr_t i = 0; i < method_arguments->length(); i++) {
-    args_array->AddElement(method_arguments->NodeAt(i));
+    ArgumentListNode* method_arguments,
+    bool save_last_arg) {
+  intptr_t args_pos = method_arguments->token_pos();
+  LocalVariable* temp = NULL;
+  if (save_last_arg) {
+    temp = owner()->parsed_function()->EnsureExpressionTemp();
   }
-  arguments->Add(args_array);
-  ZoneGrowableArray<PushArgumentInstr*>* allocation_args =
-      new ZoneGrowableArray<PushArgumentInstr*>(arguments->length());
-  BuildPushArguments(*arguments, allocation_args);
-  StaticCallInstr* allocation = new StaticCallInstr(args_pos,
-                                                    allocation_function,
-                                                    Array::ZoneHandle(),
-                                                    allocation_args);
-  Value* invocation_mirror = Bind(allocation);
-  PushArgumentInstr* push_invocation_mirror = PushArgument(invocation_mirror);
-  // Lookup noSuchMethod and call it with the receiver and the InvocationMirror.
+  ArgumentListNode* args =
+      Parser::BuildNoSuchMethodArguments(args_pos,
+                                         method_name,
+                                         *method_arguments,
+                                         temp);
   const Function& no_such_method_func = Function::ZoneHandle(
       Resolver::ResolveDynamicAnyArgs(target_class, Symbols::NoSuchMethod()));
   // We are guaranteed to find noSuchMethod of class Object.
   ASSERT(!no_such_method_func.IsNull());
-  ZoneGrowableArray<PushArgumentInstr*>* args =
+  ZoneGrowableArray<PushArgumentInstr*>* push_arguments =
       new ZoneGrowableArray<PushArgumentInstr*>(2);
-  args->Add(push_receiver);
-  args->Add(push_invocation_mirror);
+  BuildPushArguments(*args, push_arguments);
   return new StaticCallInstr(args_pos,
                              no_such_method_func,
                              Array::ZoneHandle(),
-                             args);
+                             push_arguments);
 }
-
-
 StaticCallInstr* EffectGraphVisitor::BuildThrowNoSuchMethodError(
     intptr_t token_pos,
     const Class& function_class,
     const String& function_name,
     int invocation_type) {
   ZoneGrowableArray<PushArgumentInstr*>* arguments =
       new ZoneGrowableArray<PushArgumentInstr*>();
   // Object receiver.
   // TODO(regis): For now, we pass a class literal of the unresolved
   // method's owner, but this is not specified and will probably change.
@@ skipping 108 matching lines @@
 
   Goto(finally_entry);
   AppendFragment(finally_entry, for_finally_block);
   exit_ = for_finally_block.exit_;
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraph() {
   if (FLAG_print_ast) {
     // Print the function ast before IL generation.
-    AstPrinter::PrintFunctionNodes(parsed_function());
+    AstPrinter::PrintFunctionNodes(*parsed_function());
   }
   // Compilation can be nested, preserve the computation-id.
-  const Function& function = parsed_function().function();
+  const Function& function = parsed_function()->function();
   TargetEntryInstr* normal_entry =
       new TargetEntryInstr(AllocateBlockId(),
                            CatchClauseNode::kInvalidTryIndex);
-  graph_entry_ = new GraphEntryInstr(parsed_function(), normal_entry);
+  graph_entry_ = new GraphEntryInstr(*parsed_function(), normal_entry);
   EffectGraphVisitor for_effect(this, 0);
   // This check may be deleted if the generated code is leaf.
   CheckStackOverflowInstr* check =
       new CheckStackOverflowInstr(function.token_pos());
   // If we are inlining don't actually attach the stack check. We must still
   // create the stack check in order to allocate a deopt id.
   if (!IsInlining()) for_effect.AddInstruction(check);
-  parsed_function().node_sequence()->Visit(&for_effect);
+  parsed_function()->node_sequence()->Visit(&for_effect);
   AppendFragment(normal_entry, for_effect);
   // Check that the graph is properly terminated.
   ASSERT(!for_effect.is_open());
   FlowGraph* graph = new FlowGraph(*this, graph_entry_, last_used_block_id_);
   return graph;
 }
 
 
 void FlowGraphBuilder::Bailout(const char* reason) {
   const char* kFormat = "FlowGraphBuilder Bailout: %s %s";
-  const char* function_name = parsed_function_.function().ToCString();
+  const char* function_name = parsed_function_->function().ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name, reason) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name, reason);
   const Error& error = Error::Handle(
       LanguageError::New(String::Handle(String::New(chars))));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart