Cleanup: use const reference for ParsedFunction where possible.

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/block_scheduler.h"
@@ skipping 78 matching lines @@
   virtual void ParseFunction(ParsedFunction* parsed_function) {
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
   }
 
   virtual FlowGraph* BuildFlowGraph(
       ParsedFunction* parsed_function,
       const ZoneGrowableArray<const ICData*>& ic_data_array,
       intptr_t osr_id) {
     // Build the flow graph.
-    FlowGraphBuilder builder(parsed_function,
+    FlowGraphBuilder builder(*parsed_function,
                              ic_data_array,
                              NULL,  // NULL = not inlining.
                              osr_id);
 
     return builder.BuildGraph();
   }
 
   virtual void FinalizeCompilation() { }
 };
 
@@ skipping 17 matching lines @@
     RegExpEngine::CompilationResult result =
         RegExpEngine::Compile(parsed_function->regexp_compile_data(),
                               parsed_function,
                               ic_data_array);
     backtrack_goto_ = result.backtrack_goto;
 
     // Allocate variables now that we know the number of locals.
     parsed_function->AllocateIrregexpVariables(result.num_stack_locals);
 
     // Build the flow graph.
-    FlowGraphBuilder builder(parsed_function,
+    FlowGraphBuilder builder(*parsed_function,
                              ic_data_array,
                              NULL,  // NULL = not inlining.
                              osr_id);
 
-    return new(isolate_) FlowGraph(parsed_function,
+    return new(isolate_) FlowGraph(*parsed_function,
                                    result.graph_entry,
                                    result.num_blocks);
   }
 
   virtual void FinalizeCompilation() {
     backtrack_goto_->ComputeOffsetTable(isolate_);
   }
 
  private:
   IndirectGotoInstr* backtrack_goto_;
@@ skipping 526 matching lines @@
         FlowGraphAllocator allocator(*flow_graph);
         allocator.AllocateRegisters();
         if (reorder_blocks) block_scheduler.ReorderBlocks();
 
         if (print_flow_graph) {
           FlowGraphPrinter::PrintGraph("After Optimizations", flow_graph);
         }
       }
 
       Assembler assembler(use_far_branches);
-      FlowGraphCompiler graph_compiler(
-          &assembler, flow_graph, optimized, inline_id_to_function);
+      FlowGraphCompiler graph_compiler(&assembler, flow_graph,
+                                       *parsed_function, optimized,
+                                       inline_id_to_function);
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::graphcompiler_timer,
                          isolate);
         graph_compiler.CompileGraph();
         pipeline->FinalizeCompilation();
       }
       {
         TimerScope timer(FLAG_compiler_stats,
                          &CompilerStats::codefinalizer_timer,
@@ skipping 504 matching lines @@
     const Object& result =
       PassiveObject::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart