VM: Implement closure calls as instance calls.

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, 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_inliner.h"
 
 #include "vm/block_scheduler.h"
 #include "vm/compiler.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
@@ skipping 283 matching lines @@
          !block_it.Done();
          block_it.Advance()) {
       for (ForwardInstructionIterator it(block_it.Current());
            !it.Done();
            it.Advance()) {
         Instruction* current = it.Current();
         if (current->IsPolymorphicInstanceCall()) {
           PolymorphicInstanceCallInstr* instance_call =
               current->AsPolymorphicInstanceCall();
           if (!inline_only_recognized_methods ||
-              instance_call->HasSingleRecognizedTarget()) {
+              instance_call->HasSingleRecognizedTarget() ||
+              instance_call->HasSingleDispatcherTarget()) {
             instance_calls_.Add(InstanceCallInfo(instance_call, graph));
           } else {
             // Method not inlined because inlining too deep and method
             // not recognized.
             if (FLAG_print_inlining_tree) {
               const Function* caller = &graph->parsed_function().function();
               const Function* target =
                   &Function::ZoneHandle(
                       instance_call->ic_data().GetTargetAt(0));
               inlined_info->Add(InlinedInfo(
@@ skipping 151 matching lines @@
                                          &inlined_info_);
     while (collected_call_sites_->HasCalls()) {
       TRACE_INLINING(OS::Print("  Depth %" Pd " ----------\n",
                                inlining_depth_));
       // Swap collected and inlining arrays and clear the new collecting array.
       call_sites_temp = collected_call_sites_;
       collected_call_sites_ = inlining_call_sites_;
       inlining_call_sites_ = call_sites_temp;
       collected_call_sites_->Clear();
       // Inline call sites at the current depth.
+      InlineInstanceCalls();
       InlineStaticCalls();
       InlineClosureCalls();
-      InlineInstanceCalls();
       // Increment the inlining depth. Checked before recursive inlining.
       ++inlining_depth_;
     }
     collected_call_sites_ = NULL;
     inlining_call_sites_ = NULL;
   }
 
   bool inlined() const { return inlined_; }
 
   double GrowthFactor() const {
@@ skipping 216 matching lines @@
                                  call_site_count,
                                  constants_count));
         if (FLAG_print_inlining_tree) {
           inlined_info_.Add(InlinedInfo(
               &call_data->caller, &function, inlining_depth_, call_data->call,
               "Heuristic fail"));
         }
         return false;
       }
 
-      collected_call_sites_->FindCallSites(callee_graph,
-                                           inlining_depth_,
-                                           &inlined_info_);
+      if (function.IsInvokeFieldDispatcher() ||
+          function.IsNoSuchMethodDispatcher()) {
+        // Append call sites to the currently processed list so that dispatcher
+        // methods get inlined regardless of the current depth.
+        inlining_call_sites_->FindCallSites(callee_graph,
+                                            0,
+                                            &inlined_info_);
+      } else {
+        collected_call_sites_->FindCallSites(callee_graph,
+                                             inlining_depth_,
+                                             &inlined_info_);
+      }
 
       // Add the function to the cache.
       if (!in_cache) {
         function_cache_.Add(parsed_function);
       }
 
       // Build succeeded so we restore the bailout jump.
       inlined_ = true;
       inlined_size_ += size;
       isolate->set_deopt_id(prev_deopt_id);
@@ skipping 920 matching lines @@
         OS::Print("After Inlining of %s\n", flow_graph_->
                   parsed_function().function().ToFullyQualifiedCString());
         FlowGraphPrinter printer(*flow_graph_);
         printer.PrintBlocks();
       }
     }
   }
 }
 
 }  // namespace dart