[dart2wasm] Fix exponential compile time in dynamic closure calls

In the loop that has 2 recursive calls: with a name and without a name
we should stop early if we already know that this is unreachable (e.g.
all name combinations require a name or don't have a name).

This should make us now have O(#name-combinations) recursive calls,
emitting unreachables as soon as there's a set of names that aren't
feasible in any name combination.

Change-Id: I4c91a5fa91709398aa80ffd8dc278e30638acb0c
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/462400
Reviewed-by: Ömer Ağacan <omersa@google.com>
Commit-Queue: Martin Kustermann <kustermann@google.com>

Author: mkustermann

pkg/dart2wasm/lib/translator.dart

@@ -2516,17 +2516,53 @@ class _ClosureArgumentsToVtableEntryDispatcherGenerator
 
     // Check for each name whether it's there or not.
     final allCombinations = representation.nameCombinations.toList();
-    final sortedNames = allCombinations.expand((nc) => nc.names).toList()
-      ..sort();
+    final sortedNames =
+        allCombinations.expand((nc) => nc.names).toSet().toList()..sort();
     final nameIndexVar = b.addLocal(w.NumType.i32);
 
-    void codeGenNamedHandling(
-        List<String> currentNames, List<w.ValueType> typeStack, int nameIndex) {
-      final currentCombination = NameCombination(currentNames);
-      final isValidCombination = currentNames.isEmpty ||
-          allCombinations.any((nc) => nc.compareTo(currentCombination) == 0);
+    int matchingCombinations(List<String> currentNames, int nextNameIndex) {
+      int prefixMatches = 0;
+      bool exactMatch = false;
+      if (nextNameIndex == 0) {
+        assert(currentNames.isEmpty);
+        exactMatch = true;
+        prefixMatches = 1 + allCombinations.length;
+      } else {
+        for (final nc in allCombinations) {
+          if (currentNames.length <= nc.names.length) {
+            bool found = true;
+            for (int i = 0; i < currentNames.length; ++i) {
+              if (currentNames[i] != nc.names[i]) {
+                found = false;
+                break;
+              }
+            }
+            if (found) {
+              if (currentNames.length == nc.names.length) {
+                prefixMatches++;
+                exactMatch = true;
+              } else {
+                if (sortedNames[nextNameIndex - 1]
+                        .compareTo(nc.names[currentNames.length]) <
+                    0) {
+                  prefixMatches++;
+                }
+              }
+            }
+          }
+        }
+      }
+      return exactMatch ? prefixMatches : -prefixMatches;
+    }
+
+    final currentNames = <String>[];
 
-      if (isValidCombination) {
+    void generateNameHandling(int nextNameIndex) {
+      final match = matchingCombinations(currentNames, nextNameIndex);
+      final hasExactMatch = match > 0;
+      final hasNonExactMatches = match < 0 || match > 1;
+      final hasMoreMatches = match != 0;
+      if (hasExactMatch) {
         b.comment('Check whether all named are loaded');
         b.local_get(namedArgsLocal);
         b.array_len();
@@ -2543,31 +2579,33 @@ class _ClosureArgumentsToVtableEntryDispatcherGenerator
             .heapType as w.FunctionType);
         b.return_();
         b.end();
-      } else {
-        if (util.compilerAssertsEnabled) {
-          b.comment('Check there are more names passed by the caller,');
-          b.comment('because the currently processed name set');
-          b.comment('(which are: ${currentNames.join('-')}) does not');
-          b.comment(' correspond to a valid name combination.');
-          b.local_get(namedArgsLocal);
-          b.array_len();
-          b.local_get(nameIndexVar);
-          b.i32_eq();
-          b.if_();
-          b.comment('Unsupported name combination.');
-          b.comment('Maybe bug in closure representation building');
+        if (!hasNonExactMatches) {
+          b.comment('More names passed than expected.');
           b.unreachable();
-          b.end();
+          return;
         }
-      }
-
-      if (nameIndex == sortedNames.length) {
-        b.comment('More names passed then expected.');
+      } else if (hasMoreMatches && util.compilerAssertsEnabled) {
+        b.comment('Check there are more names passed by the caller,');
+        b.comment('because the currently processed name set');
+        b.comment('(which are: ${currentNames.join('-')}) does not');
+        b.comment(' correspond to a valid name combination.');
+        b.local_get(namedArgsLocal);
+        b.array_len();
+        b.local_get(nameIndexVar);
+        b.i32_eq();
+        b.if_();
+        b.comment('Unsupported name combination.');
+        b.comment('May be bug in closure representation building');
+        b.unreachable();
+        b.end();
+      } else {
+        b.comment('The names "${currentNames.join('-')}" are not part '
+            'of a used name combination.');
         b.unreachable();
         return;
       }
 
-      final newName = sortedNames[nameIndex];
+      final newName = sortedNames[nextNameIndex];
       final symbol = translator.symbols.symbolForNamedParameter(newName);
 
       b.comment('Load next name and see if it corresponds to "$newName"');
@@ -2592,16 +2630,19 @@ class _ClosureArgumentsToVtableEntryDispatcherGenerator
         b.i32_add();
         b.local_set(nameIndexVar);
 
-        codeGenNamedHandling([...currentNames, newName],
-            [...typeStack, translator.topType], nameIndex + 1);
+        currentNames.add(newName);
+        typeStack.add(translator.topType);
+        generateNameHandling(nextNameIndex + 1);
+        typeStack.removeLast();
+        currentNames.removeLast();
       }
       b.end();
 
       b.comment('Name "$newName" was *not* provided by caller.');
-      codeGenNamedHandling(currentNames, typeStack, nameIndex + 1);
+      generateNameHandling(nextNameIndex + 1);
     }
 
-    codeGenNamedHandling([], typeStack, 0);
+    generateNameHandling(0);
   }
 
   // This function is purely used for checking assumptions made by the code this

tests/web/wasm/closures/large_name_combination_test.dart

@@ -0,0 +1,124 @@
+// 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.
+
+import 'package:expect/expect.dart';
+
+void main() {
+  final l = <dynamic>['a', 1, foo];
+  final closure = l[int.parse('2')];
+
+  final sb = StringBuffer();
+
+  Expect.equals(foo(), closure());
+
+  Expect.equals(foo(a0: 0), closure(a0: 0));
+  Expect.equals(foo(a1: 1), closure(a1: 1));
+  Expect.equals(foo(a2: 2), closure(a2: 2));
+  Expect.equals(foo(a3: 3), closure(a3: 3));
+  Expect.equals(foo(a4: 4), closure(a4: 4));
+  Expect.equals(foo(a5: 5), closure(a5: 5));
+  Expect.equals(foo(a6: 6), closure(a6: 6));
+  Expect.equals(foo(a7: 7), closure(a7: 7));
+  Expect.equals(foo(a8: 8), closure(a8: 8));
+  Expect.equals(foo(a9: 9), closure(a9: 9));
+  Expect.equals(foo(a10: 10), closure(a10: 10));
+  Expect.equals(foo(a11: 11), closure(a11: 11));
+  Expect.equals(foo(a12: 12), closure(a12: 12));
+  Expect.equals(foo(a13: 13), closure(a13: 13));
+  Expect.equals(foo(a14: 14), closure(a14: 14));
+  Expect.equals(foo(a15: 15), closure(a15: 15));
+
+  Expect.equals(foo(a0: 0, a1: 1), closure(a0: 0, a1: 1));
+  Expect.equals(foo(a2: 2, a3: 3), closure(a2: 2, a3: 3));
+  Expect.equals(foo(a4: 4, a5: 5), closure(a4: 4, a5: 5));
+  Expect.equals(foo(a6: 6, a7: 7), closure(a6: 6, a7: 7));
+  Expect.equals(foo(a8: 8, a9: 9), closure(a8: 8, a9: 9));
+  Expect.equals(foo(a10: 10, a11: 11), closure(a10: 10, a11: 11));
+  Expect.equals(foo(a12: 12, a13: 13), closure(a12: 12, a13: 13));
+  Expect.equals(foo(a14: 14, a15: 15), closure(a14: 14, a15: 15));
+
+  Expect.equals(
+    foo(a0: 0, a1: 1, a2: 2, a3: 3),
+    closure(a0: 0, a1: 1, a2: 2, a3: 3),
+  );
+  Expect.equals(
+    foo(a4: 4, a5: 5, a6: 6, a7: 7),
+    closure(a4: 4, a5: 5, a6: 6, a7: 7),
+  );
+  Expect.equals(
+    foo(a8: 8, a9: 9, a10: 10, a11: 11),
+    closure(a8: 8, a9: 9, a10: 10, a11: 11),
+  );
+  Expect.equals(
+    foo(a12: 12, a13: 13, a14: 14, a15: 15),
+    closure(a12: 12, a13: 13, a14: 14, a15: 15),
+  );
+
+  Expect.equals(
+    foo(a0: 0, a1: 1, a2: 2, a3: 3, a4: 4, a5: 5, a6: 6, a7: 7),
+    closure(a0: 0, a1: 1, a2: 2, a3: 3, a4: 4, a5: 5, a6: 6, a7: 7),
+  );
+  Expect.equals(
+    foo(a8: 8, a9: 9, a10: 10, a11: 11, a12: 12, a13: 13, a14: 14, a15: 15),
+    closure(a8: 8, a9: 9, a10: 10, a11: 11, a12: 12, a13: 13, a14: 14, a15: 15),
+  );
+
+  Expect.equals(
+    foo(
+      a0: 0,
+      a1: 1,
+      a2: 2,
+      a3: 3,
+      a4: 4,
+      a5: 5,
+      a6: 6,
+      a7: 7,
+      a8: 8,
+      a9: 9,
+      a10: 10,
+      a11: 11,
+      a12: 12,
+      a13: 13,
+      a14: 14,
+      a15: 15,
+    ),
+    closure(
+      a0: 0,
+      a1: 1,
+      a2: 2,
+      a3: 3,
+      a4: 4,
+      a5: 5,
+      a6: 6,
+      a7: 7,
+      a8: 8,
+      a9: 9,
+      a10: 10,
+      a11: 11,
+      a12: 12,
+      a13: 13,
+      a14: 14,
+      a15: 15,
+    ),
+  );
+}
+
+String foo({
+  a0,
+  a1,
+  a2,
+  a3,
+  a4,
+  a5,
+  a6,
+  a7,
+  a8,
+  a9,
+  a10,
+  a11,
+  a12,
+  a13,
+  a14,
+  a15,
+}) => '$a0 $a1 $a2 $a3 $a4 $a5 $a6 $a7 $a8 $a9 $a10 $a11 $a12 $a13 $a14 $a15';