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

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/code_generator.h"
@@ skipping 222 matching lines @@
   }
   function.SwitchToUnoptimizedCode();
   if (FLAG_trace_compiler) {
     OS::Print("--> restoring entry at %#"Px"\n",
               Code::Handle(function.unoptimized_code()).EntryPoint());
   }
 }
 
 
 // Return false if bailed out.
-static bool CompileParsedFunctionHelper(const ParsedFunction& parsed_function,
+static bool CompileParsedFunctionHelper(ParsedFunction* parsed_function,

[srdjan, 2013/06/03 15:24:14]

Why this change (from const reference to pointer)? I assume that at some point
you need to modify parse_function, but I could not locate where.

[Florian Schneider, 2013/06/03 15:33:48]

I need to call ParsedFunction::EnsureExpressionTemp from the flow graph builder

We only had a const-reference there. Changing it in FlowGraphBuilder has this
ripple-effect on all the rest.

                                         bool optimized) {

[srdjan, 2013/06/03 15:24:14]

You could add: 

const Function& function = parsed_function->function();, thus shortening some of
the code below.

[Florian Schneider, 2013/06/03 15:33:48]

Done.

-  if (optimized && !parsed_function.function().is_optimizable()) {
+  if (optimized && !parsed_function->function().is_optimizable()) {
     return false;
   }
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   bool is_compiled = false;
   Isolate* isolate = Isolate::Current();
   HANDLESCOPE(isolate);
   const intptr_t prev_deopt_id = isolate->deopt_id();
   isolate->set_deopt_id(0);
   LongJump* old_base = isolate->long_jump_base();
   LongJump bailout_jump;
   isolate->set_long_jump_base(&bailout_jump);
   if (setjmp(*bailout_jump.Set()) == 0) {
     FlowGraph* flow_graph = NULL;
     // TimerScope needs an isolate to be properly terminated in case of a
     // LongJump.
     {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::graphbuilder_timer,
                        isolate);
       Array& ic_data_array = Array::Handle();
       if (optimized) {
-        ASSERT(parsed_function.function().HasCode());
+        ASSERT(parsed_function->function().HasCode());
         // Extract type feedback before the graph is built, as the graph
         // builder uses it to attach it to nodes.
         // Do not use type feedback to optimize a function that was
         // deoptimized too often.
-        if (parsed_function.function().deoptimization_counter() <
+        if (parsed_function->function().deoptimization_counter() <
             FLAG_deoptimization_counter_threshold) {
           const Code& unoptimized_code =
-              Code::Handle(parsed_function.function().unoptimized_code());
+              Code::Handle(parsed_function->function().unoptimized_code());
           ic_data_array = unoptimized_code.ExtractTypeFeedbackArray();
         }
       }
 
       // Build the flow graph.
       FlowGraphBuilder builder(parsed_function,
                                ic_data_array,
                                NULL);  // NULL = not inlining.
       flow_graph = builder.BuildGraph();
     }
@@ skipping 103 matching lines @@
         if (DominatorBasedCSE::Optimize(flow_graph)) {
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
           // Do another round of CSE to take secondary effects into account:
           // e.g. when eliminating dependent loads (a.x[0] + a.x[0])
           // TODO(fschneider): Change to a one-pass optimization pass.
           DominatorBasedCSE::Optimize(flow_graph);
           DEBUG_ASSERT(flow_graph->VerifyUseLists());
         }
       }
       if (FLAG_loop_invariant_code_motion &&
-          (parsed_function.function().deoptimization_counter() <
+          (parsed_function->function().deoptimization_counter() <
            (FLAG_deoptimization_counter_threshold - 1))) {
         LICM licm(flow_graph);
         licm.Optimize();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
       }
       flow_graph->RemoveRedefinitions();
 
       if (FLAG_range_analysis) {
         // We have to perform range analysis after LICM because it
         // optimistically moves CheckSmi through phis into loop preheaders
@@ skipping 68 matching lines @@
     {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::graphcompiler_timer,
                        isolate);
       graph_compiler.CompileGraph();
     }
     {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::codefinalizer_timer,
                        isolate);
-      const Function& function = parsed_function.function();
+      const Function& function = parsed_function->function();
       const Code& code = Code::Handle(
           Code::FinalizeCode(function, &assembler, optimized));
       code.set_is_optimized(optimized);
       graph_compiler.FinalizePcDescriptors(code);
       graph_compiler.FinalizeDeoptInfo(code);
       graph_compiler.FinalizeStackmaps(code);
       graph_compiler.FinalizeVarDescriptors(code);
       graph_compiler.FinalizeExceptionHandlers(code);
       graph_compiler.FinalizeComments(code);
       graph_compiler.FinalizeStaticCallTargetsTable(code);
@@ skipping 194 matching lines @@
                 function.token_pos(),
                 (function.end_token_pos() - function.token_pos()));
     }
     {
       HANDLESCOPE(isolate);
       Parser::ParseFunction(parsed_function);
       parsed_function->AllocateVariables();
     }
 
     const bool success =
-        CompileParsedFunctionHelper(*parsed_function, optimized);
+        CompileParsedFunctionHelper(parsed_function, optimized);
     if (optimized && !success) {
       // Optimizer bailed out. Disable optimizations and to never try again.
       if (FLAG_trace_compiler) {
         OS::Print("--> disabling optimizations for '%s'\n",
                   function.ToFullyQualifiedCString());
       } else if (FLAG_trace_failed_optimization_attempts) {
         OS::Print("Cannot optimize: %s\n", function.ToFullyQualifiedCString());
       }
       function.set_is_optimizable(false);
       isolate->set_long_jump_base(base);
@@ skipping 41 matching lines @@
   return CompileFunctionHelper(function, false);  // Non-optimized.
 }
 
 
 RawError* Compiler::CompileOptimizedFunction(const Function& function) {
   return CompileFunctionHelper(function, true);  // Optimized.
 }
 
 
 RawError* Compiler::CompileParsedFunction(
-    const ParsedFunction& parsed_function) {
+    ParsedFunction* parsed_function) {
   Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     // Non-optimized code generator.
     CompileParsedFunctionHelper(parsed_function, false);
     if (FLAG_disassemble) {
-      DisassembleCode(parsed_function.function(), false);
+      DisassembleCode(parsed_function->function(), false);
     }
     isolate->set_long_jump_base(base);
     return Error::null();
   } else {
     Error& error = Error::Handle();
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return error.raw();
@@ skipping 59 matching lines @@
     func.SetNumOptionalParameters(0, true);
     // Manually generated AST, do not recompile.
     func.set_is_optimizable(false);
 
     // We compile the function here, even though InvokeStatic() below
     // would compile func automatically. We are checking fewer invariants
     // here.
     ParsedFunction* parsed_function = new ParsedFunction(func);
     parsed_function->SetNodeSequence(fragment);
     parsed_function->set_default_parameter_values(Array::ZoneHandle());
-    parsed_function->set_expression_temp_var(
-        ParsedFunction::CreateExpressionTempVar(0));
+    parsed_function->EnsureExpressionTemp();
     fragment->scope()->AddVariable(parsed_function->expression_temp_var());
     parsed_function->AllocateVariables();
 
     // Non-optimized code generator.
-    CompileParsedFunctionHelper(*parsed_function, false);
+    CompileParsedFunctionHelper(parsed_function, false);
 
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(func, Object::empty_array()));
     isolate->set_long_jump_base(base);
     return result.raw();
   } else {
     const Object& result =
       Object::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart