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 455 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();

[srdjan, 2014/04/09 18:28:43]

Any reason for changing the order?

[Florian Schneider, 2014/04/10 08:49:25]

The reason is that dispatchers are instance calls, so if we want to inline other
calls inside dispatchers at the current depth, we need to inline those first.

       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