Do not create method extractors during JitOptimizer::TryExpandClassesInICData.

runtime/vm/jit_optimizer.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.
 #ifndef DART_PRECOMPILED_RUNTIME
 #include "vm/jit_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/compiler.h"
@@ skipping 123 matching lines @@
     if (!receiver_class.is_finalized()) {
       // Do not eagerly finalize classes. ResolveDynamicForReceiverClass can
       // cause class finalization, since callee's receiver class may not be
       // finalized yet.
       return false;
     }
     const Array& args_desc_array =
         Array::Handle(Z, ArgumentsDescriptor::New(call->ArgumentCount(),
                                                   call->argument_names()));
     ArgumentsDescriptor args_desc(args_desc_array);
-    const Function& function =
-        Function::Handle(Z, Resolver::ResolveDynamicForReceiverClass(
-                                receiver_class, call->function_name(),
-                                args_desc, false /* allow add */));
+    bool allow_add = false;
+    const Function& function = Function::Handle(
+        Z, Resolver::ResolveDynamicForReceiverClass(
+               receiver_class, call->function_name(), args_desc, allow_add));
     if (function.IsNull()) {
       return false;
     }
 
     // Create new ICData, do not modify the one attached to the instruction
     // since it is attached to the assembly instruction itself.
     // TODO(srdjan): Prevent modification of ICData object that is
     // referenced in assembly code.
     const ICData& ic_data = ICData::ZoneHandle(
         Z, ICData::NewFrom(*call->ic_data(), class_ids.length()));
@@ skipping 10 matching lines @@
   // Check if getter or setter in function's class and class is currently leaf.
   if (FLAG_guess_icdata_cid && ((call->token_kind() == Token::kGET) ||
                                 (call->token_kind() == Token::kSET))) {
     const Class& owner_class = Class::Handle(Z, function().Owner());
     if (!owner_class.is_abstract() && !CHA::HasSubclasses(owner_class) &&
         !CHA::IsImplemented(owner_class)) {
       const Array& args_desc_array =
           Array::Handle(Z, ArgumentsDescriptor::New(call->ArgumentCount(),
                                                     call->argument_names()));
       ArgumentsDescriptor args_desc(args_desc_array);
-      const Function& function =
-          Function::Handle(Z, Resolver::ResolveDynamicForReceiverClass(
-                                  owner_class, call->function_name(), args_desc,
-                                  false /* allow_add */));
+      bool allow_add = false;
+      const Function& function = Function::Handle(
+          Z, Resolver::ResolveDynamicForReceiverClass(
+                 owner_class, call->function_name(), args_desc, allow_add));
       if (!function.IsNull()) {
         const ICData& ic_data = ICData::ZoneHandle(
             Z, ICData::NewFrom(*call->ic_data(), class_ids.length()));
         ic_data.AddReceiverCheck(owner_class.id(), function);
         call->set_ic_data(&ic_data);
         return true;
       }
     }
   }
 
@@ skipping 1259 matching lines @@
   if (class_id < 0) return false;
   if (class_id >= I->class_table()->NumCids()) return false;
 
   RawClass* raw_class = I->class_table()->At(class_id);
   if (raw_class == NULL) return false;
   Class& cls = Class::Handle(Z, raw_class);
   if (cls.IsNull()) return false;
   if (!cls.is_finalized()) return false;
   if (Array::Handle(cls.functions()).IsNull()) return false;
 
-  Function& target_function = Function::Handle(
-      Z, Resolver::ResolveDynamicForReceiverClass(cls, name, args_desc));
+  bool allow_add = false;
+  Function& target_function =
+      Function::Handle(Z, Resolver::ResolveDynamicForReceiverClass(

[Vyacheslav Egorov (Google), 2017/04/07 05:53:00]

How about adding an assertion into ResolveDynamicForReceiverClass (and friends)
that allow_add implies IsMutatorOrAtSafepoint?

[rmacnak, 2017/04/07 16:42:57]

It fails. I created https://github.com/dart-lang/sdk/issues/29292 to address
this.

+                              cls, name, args_desc, allow_add));
   if (target_function.IsNull()) return false;
   *fn_return ^= target_function.raw();
   return true;
 }
 
 
 static int OrderById(const intptr_t* a, const intptr_t* b) {
   // Negative if 'a' should sort before 'b'.
   return *a - *b;
 }
@@ skipping 397 matching lines @@
   // Discard the environment from the original instruction because the store
   // can't deoptimize.
   instr->RemoveEnvironment();
   ReplaceCall(instr, store);
   return true;
 }
 
 
 }  // namespace dart
 #endif  // DART_PRECOMPILED_RUNTIME