feat(benchmark): add UniversalScenario enum and extend UniversalChainModule to support chain, register, named, override, async scenarios

benchmark_cherrypick/lib/benchmarks/universal_chain_benchmark.dart

@@ -0,0 +1,40 @@
+import 'package:benchmark_harness/benchmark_harness.dart';
+import 'package:benchmark_cherrypick/di_adapters/di_adapter.dart';
+import 'package:benchmark_cherrypick/scenarios/universal_chain_module.dart';
+import 'package:benchmark_cherrypick/scenarios/universal_service.dart';
+
+class UniversalChainBenchmark extends BenchmarkBase {
+  final DIAdapter di;
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode mode;
+
+  UniversalChainBenchmark(
+      this.di, {
+      this.chainCount = 1,
+      this.nestingDepth = 3,
+      this.mode = UniversalBindingMode.singletonStrategy,
+    }) : super(
+          'UniversalChain: $mode. C/D = $chainCount/$nestingDepth',
+        );
+
+  @override
+  void setup() {
+    di.setupModules([
+      UniversalChainModule(
+        chainCount: chainCount,
+        nestingDepth: nestingDepth,
+        bindingMode: mode,
+      ),
+    ]);
+  }
+
+  @override
+  void teardown() => di.teardown();
+
+  @override
+  void run() {
+    final serviceName = '${chainCount}_$nestingDepth';
+    di.resolve<UniversalService>(named: serviceName);
+  }
+}

benchmark_cherrypick/lib/scenarios/universal_chain_module.dart

@@ -0,0 +1,60 @@
+import 'package:cherrypick/cherrypick.dart';
+import 'universal_service.dart';
+
+enum UniversalBindingMode {
+  singletonStrategy,
+  factoryStrategy,
+  asyncStrategy,
+}
+
+class UniversalChainModule extends Module {
+  final int chainCount;
+  final int nestingDepth;
+  final UniversalBindingMode bindingMode;
+
+  UniversalChainModule({
+    required this.chainCount,
+    required this.nestingDepth,
+    this.bindingMode = UniversalBindingMode.singletonStrategy,
+  });
+
+  @override
+  void builder(Scope currentScope) {
+    for (var chainIndex = 0; chainIndex < chainCount; chainIndex++) {
+      for (var levelIndex = 0; levelIndex < nestingDepth; levelIndex++) {
+        final chain = chainIndex + 1;
+        final level = levelIndex + 1;
+        final prevDepName = '${chain}_${level - 1}';
+        final depName = '${chain}_$level';
+        switch (bindingMode) {
+          case UniversalBindingMode.singletonStrategy:
+            bind<UniversalService>()
+                .toProvide(() => UniversalServiceImpl(
+                  value: depName,
+                  dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                ))
+                .withName(depName)
+                .singleton();
+            break;
+          case UniversalBindingMode.factoryStrategy:
+            bind<UniversalService>()
+                .toProvide(() => UniversalServiceImpl(
+                  value: depName,
+                  dependency: currentScope.tryResolve<UniversalService>(named: prevDepName),
+                ))
+                .withName(depName);
+            break;
+          case UniversalBindingMode.asyncStrategy:
+            bind<UniversalService>()
+                .toProvideAsync(() async => UniversalServiceImpl(
+                  value: depName,
+                  dependency: await currentScope.resolveAsync<UniversalService>(named: prevDepName),
+                ))
+                .withName(depName)
+                .singleton();
+            break;
+        }
+      }
+    }
+  }
+}

benchmark_cherrypick/lib/scenarios/universal_service.dart

@@ -0,0 +1,10 @@
+
+abstract class UniversalService {
+  final String value;
+  final UniversalService? dependency;
+  UniversalService({required this.value, this.dependency});
+}
+
+class UniversalServiceImpl extends UniversalService {
+  UniversalServiceImpl({required super.value, super.dependency});
+}