Treat dispatchers and implicit accessors the same for inlining decisions.

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.
 #if !defined(DART_PRECOMPILED_RUNTIME)
 #include "vm/flow_graph_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
@@ skipping 363 matching lines @@
     for (BlockIterator block_it = graph->postorder_iterator(); !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->ic_data().HasOnlyDispatcherTargets()) {
+              instance_call->ic_data()
+                  .HasOnlyDispatcherOrImplicitAccessorTargets()) {
             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->function();
               const Function* target = &Function::ZoneHandle(
                   instance_call->ic_data().GetTargetAt(0));
               inlined_info->Add(InlinedInfo(caller, target, depth + 1,
                                             instance_call, "Too deep"));
             }
           }
         } else if (current->IsStaticCall()) {
           StaticCallInstr* static_call = current->AsStaticCall();
           if (!inline_only_recognized_methods ||
-              static_call->function().IsRecognized()) {
+              static_call->function().IsRecognized() ||
+              static_call->function().IsDispatcherOrImplicitAccessor()) {
             static_calls_.Add(StaticCallInfo(static_call, graph));
           } else {
             // Method not inlined because inlining too deep and method
             // not recognized.
             if (FLAG_print_inlining_tree) {
               const Function* caller = &graph->function();
               const Function* target = &static_call->function();
               inlined_info->Add(InlinedInfo(caller, target, depth + 1,
                                             static_call, "Too deep"));
             }
@@ skipping 518 matching lines @@
                         "code size:  %" Pd ", "
                         "call sites: %" Pd ", "
                         "const args: %" Pd "\n",
                         size, call_site_count, constants_count));
           PRINT_INLINING_TREE("Heuristic fail", &call_data->caller, &function,
                               call_data->call);
           return false;
         }
 
         // Inline dispatcher methods regardless of the current depth.
-        const intptr_t depth = (function.IsInvokeFieldDispatcher() ||
-                                function.IsNoSuchMethodDispatcher())
-                                   ? 0
-                                   : inlining_depth_;
+        const intptr_t depth =
+            function.IsDispatcherOrImplicitAccessor() ? 0 : inlining_depth_;
         collected_call_sites_->FindCallSites(callee_graph, 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;
@@ skipping 964 matching lines @@
 
 bool FlowGraphInliner::AlwaysInline(const Function& function) {
   const char* kAlwaysInlineAnnotation = "AlwaysInline";
   if (FLAG_enable_inlining_annotations &&
       HasAnnotation(function, kAlwaysInlineAnnotation)) {
     TRACE_INLINING(
         THR_Print("AlwaysInline annotation for %s\n", function.ToCString()));
     return true;
   }
 
-  if (function.IsImplicitGetterFunction() ||
-      function.IsImplicitSetterFunction()) {
-    // Inlined accessors are smaller than a call.
+  if (function.IsDispatcherOrImplicitAccessor()) {
+    // Smaller or same size as the call.
     return true;
   }
 
   if (function.IsGetterFunction() || function.IsSetterFunction() ||
       IsInlineableOperator(function) ||
       (function.kind() == RawFunction::kConstructor)) {
     const intptr_t count = function.optimized_instruction_count();
     if ((count != 0) && (count < FLAG_inline_getters_setters_smaller_than)) {
       return true;
     }
@@ skipping 1658 matching lines @@
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)