[vm,compiler] Avoid slow LookupFunctionAllowPrivate when reading kernel

When reading kernel function names are already mangled using private
key, so slower *AllowPrivate lookups are not needed.

Also cleaned up unused functions related to *AllowPrivate lookups.

TEST=runtime/tests/vm/dart/many_functions_test.dart
Fixes #61196

Change-Id: I8dd0b8b907ecea79314480dbc39e0edda8a243d0
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/443151
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

DEPS

@@ -701,6 +701,12 @@ hooks = [
     'pattern': '.',
     'action': ['python3', Var("dart_root") + '/tools/generate_sdk_version_file.py'],
   },
+  {
+    # Generate large tests.
+    'name': 'Generate large tests',
+    'pattern': '.',
+    'action': ['python3', Var("dart_root") + '/tools/generate_large_tests.py'],
+  },
   {
     'name': 'buildtools',
     'pattern': '.',

runtime/tests/vm/dart/.gitignore

@@ -0,0 +1,3 @@
+# Auto-generated tests
+many_functions_test.dart
+

runtime/tests/vm/dart/many_functions_generator.dart

@@ -0,0 +1,44 @@
+// Copyright (c) 2025, 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.
+
+// Generates 'runtime/tests/vm/dart/many_functions_test.dart'.
+// This auto-generated test verifies that compiler and VM are capable of
+// handling many functions.
+
+void main(List<String> args) {
+  final count = 10000;
+  final buffer = StringBuffer();
+  buffer.write('''
+// Copyright (c) 2025, 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.
+
+// THIS FILE IS GENERATED. DO NOT EDIT.
+
+''');
+  for (var i = 0; i < count; i++) {
+    buffer.write(generateFunction(i));
+  }
+
+  buffer.write('''
+void main() {
+   final array = [];
+''');
+  for (var i = 0; i < count; i++) {
+    buffer.write('array.add(f$i());\n');
+  }
+  buffer.write('''
+   print('ran \${array.length} functions');
+}
+''');
+
+  print(buffer.toString());
+}
+
+String generateFunction(int index) {
+  return '''
+@pragma('vm:never-inline')
+String f$index() { return 'function$index'; }
+''';
+}

runtime/tests/vm/vm.status

@@ -138,6 +138,7 @@ cc/VerifyImplicit_Crash: Crash # Negative tests of VerifiedMemory should crash i
 dart/appjit_cha_deopt_test: Pass, Slow # Quite slow in debug mode, uses --optimization-counter-threshold=100
 dart/b162922506_test: SkipSlow # Generates very large input file
 dart/hash_map_probes_limit_test: SkipSlow # Test includes large program compilation.
+dart/many_functions_test: SkipSlow # Too slow in debug mode.
 dart/minimal_kernel_test: SkipSlow # gen_kernel is too slow in debug mode
 dart/regress47472_test: Pass, Slow # Slow due to throwing 1 million exceptions.
 dart/spawn_shutdown_test: Pass, Slow # VM Shutdown test, It can take some time for all the isolates to shutdown in a Debug build.

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -1484,9 +1484,8 @@ Function& StreamingFlowGraphBuilder::FindMatchingFunction(
   ArgumentsDescriptor args_desc(
       Array::Handle(Z, ArgumentsDescriptor::NewBoxed(
                            type_args_len, argument_count, argument_names)));
-  return Function::Handle(
-      Z, Resolver::ResolveDynamicForReceiverClassAllowPrivate(klass, name,
-                                                              args_desc));
+  return Function::Handle(Z, Resolver::ResolveDynamicForReceiverClass(
+                                 klass, name, args_desc, /*allow_add=*/false));
 }
 
 bool StreamingFlowGraphBuilder::NeedsDebugStepCheck(const Function& function,

runtime/vm/compiler/frontend/kernel_translation_helper.cc

@@ -561,8 +561,7 @@ ClassPtr TranslationHelper::LookupClassByKernelClass(NameIndex kernel_class,
     }
     return Class::null();
   }
-  const Class& klass =
-      Class::Handle(Z, library.LookupClassAllowPrivate(class_name));
+  const Class& klass = Class::Handle(Z, library.LookupClass(class_name));
   if (klass.IsNull()) {
     if (required) {
       LookupFailed(kernel_class);
@@ -602,9 +601,8 @@ FieldPtr TranslationHelper::LookupFieldByKernelField(NameIndex kernel_field,
     }
     return Field::null();
   }
-  Field& field = Field::Handle(
-      Z, klass.LookupFieldAllowPrivate(
-             DartSymbolObfuscate(CanonicalNameString(kernel_field))));
+  Field& field =
+      Field::Handle(Z, klass.LookupField(DartFieldName(kernel_field)));
   if (field.IsNull() && required) {
     LookupFailed(kernel_field);
   }
@@ -625,9 +623,8 @@ FieldPtr TranslationHelper::LookupFieldByKernelGetterOrSetter(
     }
     return Field::null();
   }
-  const Field& field = Field::Handle(
-      Z, klass.LookupFieldAllowPrivate(
-             DartSymbolObfuscate(CanonicalNameString(kernel_field))));
+  const Field& field =
+      Field::Handle(Z, klass.LookupField(DartFieldName(kernel_field)));
   if (field.IsNull() && required) {
     LookupFailed(kernel_field);
   }
@@ -654,7 +651,7 @@ FunctionPtr TranslationHelper::LookupStaticMethodByKernelProcedure(
   const auto& error = klass.EnsureIsFinalized(thread_);
   ASSERT(error == Error::null());
   Function& function =
-      Function::Handle(Z, klass.LookupFunctionAllowPrivate(procedure_name));
+      Function::Handle(Z, klass.LookupFunction(procedure_name));
   if (function.IsNull() && required) {
     LookupFailed(procedure);
   }
@@ -687,7 +684,7 @@ FunctionPtr TranslationHelper::LookupConstructorByKernelConstructor(
   const auto& error = owner.EnsureIsFinalized(thread_);
   ASSERT(error == Error::null());
   Function& function = Function::Handle(
-      Z, owner.LookupConstructorAllowPrivate(DartConstructorName(constructor)));
+      Z, owner.LookupConstructor(DartConstructorName(constructor)));
   if (function.IsNull() && required) {
     LookupFailed(constructor);
   }
@@ -708,7 +705,7 @@ FunctionPtr TranslationHelper::LookupConstructorByKernelConstructor(
       String::ZoneHandle(Z, Symbols::FromConcatAll(thread_, pieces));
   const auto& error = owner.EnsureIsFinalized(thread_);
   ASSERT(error == Error::null());
-  FunctionPtr function = owner.LookupConstructorAllowPrivate(new_name);
+  FunctionPtr function = owner.LookupConstructor(new_name);
   if (function == Object::null() && required) {
     LookupFailed(constructor_name);
   }
@@ -723,7 +720,7 @@ FunctionPtr TranslationHelper::LookupMethodByMember(NameIndex target,
       Z, LookupClassByKernelClass(kernel_class, /*required=*/false));
   Function& function = Function::Handle(Z);
   if (!klass.IsNull() && klass.EnsureIsFinalized(thread_) == Error::null()) {
-    function = klass.LookupFunctionAllowPrivate(method_name);
+    function = klass.LookupFunction(method_name);
   }
   if (function.IsNull() && required) {
     LookupFailed(target);
@@ -746,36 +743,20 @@ ObjectPtr TranslationHelper::LookupMemberByMember(NameIndex kernel_name,
 
   Object& member = Object::Handle(Z);
   if (IsField(kernel_name)) {
-    member = klass.LookupFieldAllowPrivate(
-        DartSymbolObfuscate(CanonicalNameString(kernel_name)));
+    member = klass.LookupField(DartFieldName(kernel_name));
   } else {
     const String& procedure_name = DartProcedureName(kernel_name);
 
     const auto& error = klass.EnsureIsFinalized(thread_);
     ASSERT(error == Error::null());
-    member = klass.LookupFunctionAllowPrivate(procedure_name);
+    member = klass.LookupFunction(procedure_name);
   }
   if (member.IsNull() && required) {
     LookupFailed(kernel_name);
   }
   return member.ptr();
 }
 
-FunctionPtr TranslationHelper::LookupDynamicFunction(const Class& klass,
-                                                     const String& name) {
-  // Search the superclass chain for the selector.
-  Class& iterate_klass = Class::Handle(Z, klass.ptr());
-  while (!iterate_klass.IsNull()) {
-    FunctionPtr function =
-        iterate_klass.LookupDynamicFunctionAllowPrivate(name);
-    if (function != Object::null()) {
-      return function;
-    }
-    iterate_klass = iterate_klass.SuperClass();
-  }
-  return Function::null();
-}
-
 Type& TranslationHelper::GetDeclarationType(const Class& klass) {
   ASSERT(!klass.IsNull());
   // Forward expression evaluation class to a real class when

runtime/vm/compiler/frontend/kernel_translation_helper.h

@@ -176,7 +176,6 @@ class TranslationHelper {
                                    const String& method_name,
                                    bool required = true);
   ObjectPtr LookupMemberByMember(NameIndex kernel_name, bool required = true);
-  FunctionPtr LookupDynamicFunction(const Class& klass, const String& name);
 
   Type& GetDeclarationType(const Class& klass);
 

runtime/vm/object.cc

@@ -233,27 +233,6 @@ PRECOMPILER_WSR_FIELD_DEFINITION(Function, FunctionType, signature)
   }
 #endif
 
-// Remove private keys, but retain getter/setter/constructor/mixin manglings.
-StringPtr String::RemovePrivateKey(const String& name) {
-  ASSERT(name.IsOneByteString());
-  GrowableArray<uint8_t> without_key(name.Length());
-  intptr_t i = 0;
-  while (i < name.Length()) {
-    while (i < name.Length()) {
-      uint8_t c = name.CharAt(i++);
-      if (c == '@') break;
-      without_key.Add(c);
-    }
-    while (i < name.Length()) {
-      uint8_t c = name.CharAt(i);
-      if ((c < '0') || (c > '9')) break;
-      i++;
-    }
-  }
-
-  return String::FromLatin1(without_key.data(), without_key.length());
-}
-
 // Takes a vm internal name and makes it suitable for external user.
 //
 // Examples:
@@ -6670,10 +6649,6 @@ FunctionPtr Class::LookupDynamicFunctionUnsafe(const String& name) const {
   return LookupFunctionReadLocked(name, kInstance);
 }
 
-FunctionPtr Class::LookupDynamicFunctionAllowPrivate(const String& name) const {
-  return LookupFunctionAllowPrivate(name, kInstance);
-}
-
 FunctionPtr Class::LookupStaticFunction(const String& name) const {
   Thread* thread = Thread::Current();
   SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
@@ -6708,32 +6683,14 @@ FunctionPtr Class::LookupFunctionAllowPrivate(const String& name) const {
   return LookupFunctionAllowPrivate(name, kAny);
 }
 
-FunctionPtr Class::LookupFunctionReadLocked(const String& name) const {
-  return LookupFunctionReadLocked(name, kAny);
+FunctionPtr Class::LookupFunction(const String& name) const {
+  Thread* thread = Thread::Current();
+  SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
+  return LookupFunctionReadLocked(name);
 }
 
-// Returns true if 'prefix' and 'accessor_name' match 'name'.
-static bool MatchesAccessorName(const String& name,
-                                const char* prefix,
-                                intptr_t prefix_length,
-                                const String& accessor_name) {
-  intptr_t name_len = name.Length();
-  intptr_t accessor_name_len = accessor_name.Length();
-
-  if (name_len != (accessor_name_len + prefix_length)) {
-    return false;
-  }
-  for (intptr_t i = 0; i < prefix_length; i++) {
-    if (name.CharAt(i) != prefix[i]) {
-      return false;
-    }
-  }
-  for (intptr_t i = 0, j = prefix_length; i < accessor_name_len; i++, j++) {
-    if (name.CharAt(j) != accessor_name.CharAt(i)) {
-      return false;
-    }
-  }
-  return true;
+FunctionPtr Class::LookupFunctionReadLocked(const String& name) const {
+  return LookupFunctionReadLocked(name, kAny);
 }
 
 FunctionPtr Class::CheckFunctionType(const Function& func, MemberKind kind) {
@@ -6845,42 +6802,6 @@ FunctionPtr Class::LookupFunctionAllowPrivate(const String& name,
   return Function::null();
 }
 
-FunctionPtr Class::LookupGetterFunction(const String& name) const {
-  return LookupAccessorFunction(kGetterPrefix, kGetterPrefixLength, name);
-}
-
-FunctionPtr Class::LookupSetterFunction(const String& name) const {
-  return LookupAccessorFunction(kSetterPrefix, kSetterPrefixLength, name);
-}
-
-FunctionPtr Class::LookupAccessorFunction(const char* prefix,
-                                          intptr_t prefix_length,
-                                          const String& name) const {
-  ASSERT(!IsNull());
-  Thread* thread = Thread::Current();
-  if (EnsureIsFinalized(thread) != Error::null()) {
-    return Function::null();
-  }
-  REUSABLE_ARRAY_HANDLESCOPE(thread);
-  REUSABLE_FUNCTION_HANDLESCOPE(thread);
-  REUSABLE_STRING_HANDLESCOPE(thread);
-  Array& funcs = thread->ArrayHandle();
-  funcs = current_functions();
-  intptr_t len = funcs.Length();
-  Function& function = thread->FunctionHandle();
-  String& function_name = thread->StringHandle();
-  for (intptr_t i = 0; i < len; i++) {
-    function ^= funcs.At(i);
-    function_name = function.name();
-    if (MatchesAccessorName(function_name, prefix, prefix_length, name)) {
-      return function.ptr();
-    }
-  }
-
-  // No function found.
-  return Function::null();
-}
-
 FieldPtr Class::LookupInstanceField(const String& name) const {
   return LookupField(name, kInstance);
 }

runtime/vm/object.h

@@ -1717,19 +1717,17 @@ class Class : public Object {
   intptr_t FindImplicitClosureFunctionIndex(const Function& needle) const;
   FunctionPtr ImplicitClosureFunctionFromIndex(intptr_t idx) const;
 
+  FunctionPtr LookupFunction(const String& name) const;
   FunctionPtr LookupFunctionReadLocked(const String& name) const;
   FunctionPtr LookupDynamicFunctionUnsafe(const String& name) const;
 
-  FunctionPtr LookupDynamicFunctionAllowPrivate(const String& name) const;
   FunctionPtr LookupStaticFunction(const String& name) const;
   FunctionPtr LookupStaticFunctionAllowPrivate(const String& name) const;
   FunctionPtr LookupConstructor(const String& name) const;
   FunctionPtr LookupConstructorAllowPrivate(const String& name) const;
   FunctionPtr LookupFactory(const String& name) const;
   FunctionPtr LookupFactoryAllowPrivate(const String& name) const;
   FunctionPtr LookupFunctionAllowPrivate(const String& name) const;
-  FunctionPtr LookupGetterFunction(const String& name) const;
-  FunctionPtr LookupSetterFunction(const String& name) const;
   FieldPtr LookupInstanceField(const String& name) const;
   FieldPtr LookupStaticField(const String& name) const;
   FieldPtr LookupField(const String& name) const;
@@ -2248,10 +2246,6 @@ class Class : public Object {
                                          MemberKind kind) const;
   FieldPtr LookupField(const String& name, MemberKind kind) const;
 
-  FunctionPtr LookupAccessorFunction(const char* prefix,
-                                     intptr_t prefix_length,
-                                     const String& name) const;
-
   // Allocate an instance class which has a VM implementation.
   template <class FakeInstance, class TargetFakeInstance>
   static ClassPtr New(intptr_t id,
@@ -10599,8 +10593,6 @@ class String : public Instance {
   static StringPtr ToLowerCase(const String& str,
                                Heap::Space space = Heap::kNew);
 
-  static StringPtr RemovePrivateKey(const String& name);
-
   static const char* ScrubName(const String& name, bool is_extension = false);
   static StringPtr ScrubNameRetainPrivate(const String& name,
                                           bool is_extension = false);

runtime/vm/resolver.cc

@@ -157,15 +157,6 @@ FunctionPtr Resolver::ResolveDynamicForReceiverClass(
       std::mem_fn(&Class::LookupDynamicFunctionUnsafe));
 }
 
-FunctionPtr Resolver::ResolveDynamicForReceiverClassAllowPrivate(
-    const Class& receiver_class,
-    const String& function_name,
-    const ArgumentsDescriptor& args_desc) {
-  return ResolveDynamicForReceiverClassWithCustomLookup(
-      receiver_class, function_name, args_desc, /*allow_add=*/false,
-      std::mem_fn(&Class::LookupDynamicFunctionAllowPrivate));
-}
-
 FunctionPtr Resolver::ResolveFunction(Zone* zone,
                                       const Class& receiver_class,
                                       const String& function_name) {