Eliminated with_checks variable

runtime/vm/intermediate_language.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/intermediate_language.h"
 
 #include "vm/bit_vector.h"
 #include "vm/bootstrap.h"
 #include "vm/compiler.h"
 #include "vm/constant_propagator.h"
@@ skipping 3327 matching lines @@
 
 intptr_t PolymorphicInstanceCallInstr::CallCount() const {
   return targets().AggregateCallCount();
 }
 
 
 // DBC does not support optimizing compiler and thus doesn't emit
 // PolymorphicInstanceCallInstr.
 #if !defined(TARGET_ARCH_DBC)
 void PolymorphicInstanceCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) {
-  if (!with_checks()) {
-    ASSERT(targets().HasSingleTarget());
-    const Function& target = targets().FirstTarget();
-    compiler->GenerateStaticCall(deopt_id(), instance_call()->token_pos(),
-                                 target, instance_call()->ArgumentCount(),
-                                 instance_call()->argument_names(), locs(),
-                                 ICData::Handle());
-    return;
-  }
-
   compiler->EmitPolymorphicInstanceCall(
       targets_, *instance_call(), instance_call()->ArgumentCount(),
       instance_call()->argument_names(), deopt_id(),
       instance_call()->token_pos(), locs(), complete(), total_call_count());
 }
 #endif
 
 
 RawType* PolymorphicInstanceCallInstr::ComputeRuntimeType(
     const CallTargets& targets) {
@@ skipping 40 matching lines @@
   const CallTargets* new_target =
       FlowGraphCompiler::ResolveCallTargetsForReceiverCid(
           receiver_cid,
           String::Handle(flow_graph->zone(), ic_data()->target_name()),
           Array::Handle(flow_graph->zone(), ic_data()->arguments_descriptor()));
   if (new_target == NULL) {
     // No specialization.
     return this;
   }
 
-  const bool with_checks = false;
-  const bool complete = false;
-  PolymorphicInstanceCallInstr* specialized = new PolymorphicInstanceCallInstr(
-      this, *new_target, with_checks, complete);
+  ASSERT(new_target->HasSingleTarget());

[Vyacheslav Egorov (Google), 2017/05/18 07:03:11]

similar pattern

+  const Function& target = new_target->FirstTarget();
+  ZoneGrowableArray<PushArgumentInstr*>* args = new (flow_graph->zone())
+      ZoneGrowableArray<PushArgumentInstr*>(ArgumentCount());
+  for (intptr_t i = 0; i < ArgumentCount(); i++) {
+    args->Add(PushArgumentAt(i));
+  }
+  StaticCallInstr* specialized = new (flow_graph->zone()) StaticCallInstr(
+      token_pos(), target, argument_names(), args, deopt_id(), CallCount());
   flow_graph->InsertBefore(this, specialized, env(), FlowGraph::kValue);
   return specialized;
 }
 
 
 Definition* PolymorphicInstanceCallInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!IsSureToCallSingleRecognizedTarget()) {
     return this;
   }
 
   const Function& target = targets().FirstTarget();
   if (target.recognized_kind() == MethodRecognizer::kObjectRuntimeType) {
     const AbstractType& type =
         AbstractType::Handle(ComputeRuntimeType(targets_));
     if (!type.IsNull()) {
       return flow_graph->GetConstant(type);
     }
   }
 
   return this;
 }
 
 
 bool PolymorphicInstanceCallInstr::IsSureToCallSingleRecognizedTarget() const {
-  if (FLAG_precompiled_mode && with_checks()) return false;
+  if (FLAG_precompiled_mode) return false;

[Vyacheslav Egorov (Google), 2017/05/18 07:03:11]

You can check for && !complete() here to make this condition less pessimistic.

   return targets_.HasSingleRecognizedTarget();
 }
 
 
 Definition* StaticCallInstr::Canonicalize(FlowGraph* flow_graph) {
   if (!FLAG_precompiled_mode) {
     return this;
   }
 
   if (function().recognized_kind() == MethodRecognizer::kObjectRuntimeType) {
@@ skipping 726 matching lines @@
                      "native function '%s' (%" Pd " arguments) cannot be found",
                      native_name().ToCString(), function().NumParameters());
   }
   set_is_auto_scope(auto_setup_scope);
   set_native_c_function(native_function);
 }
 
 #undef __
 
 }  // namespace dart