Updates to data class macro benchmarks, add code optimizer benchmark (#3621)

- When benching augmentation library creation, include results from earlier stages 
- Only do formatting at the very end
- Add code optimization at the very end
- Make comparisons fair, only call `run` once inside the synchronous benchmarks.

Results for code optimization look fairly reasonable, ~25μs (total macro execution takes around 2ms prior to that, ignoring formatting).

Formatting is slower but maybe reasonable, around 450 μs.

Example run here https://gist.github.com/jakemac53/096b8380db41aa2eda46ae189a510c29.

cc @jacob314

Author: jakemac53

working/macros/example/benchmark/src/data_class.dart

@@ -7,21 +7,24 @@ import 'package:benchmark_harness/benchmark_harness.dart';
 import 'shared.dart';
 
 Future<void> runBenchmarks(MacroExecutor executor, Uri macroUri) async {
-  final introspector = SimpleDefinitionPhaseIntrospector(declarations: {
-    myClass.identifier: myClass,
-    objectClass.identifier: objectClass
-  }, identifiers: {
+  final libraryIdentifiers = {
     Uri.parse('dart:core'): {
       'bool': boolIdentifier,
       'int': intIdentifier,
       'Object': objectIdentifier,
       'String': stringIdentifier,
     }
-  }, constructors: {}, enumValues: {}, fields: {
-    myClass: myClassFields
-  }, methods: {
-    myClass: myClassMethods
-  });
+  };
+  final introspector = SimpleDefinitionPhaseIntrospector(
+      declarations: {
+        myClass.identifier: myClass,
+        objectClass.identifier: objectClass
+      },
+      identifiers: libraryIdentifiers,
+      constructors: {},
+      enumValues: {},
+      fields: {myClass: myClassFields},
+      methods: {myClass: myClassMethods});
   final identifierDeclarations = {
     ...introspector.declarations,
     for (final constructors in introspector.constructors.values)
@@ -48,15 +51,28 @@ Future<void> runBenchmarks(MacroExecutor executor, Uri macroUri) async {
   await declarationsBenchmark.report();
   BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
-      [if (declarationsBenchmark.result != null) declarationsBenchmark.result!],
+      [
+        if (typesBenchmark.result != null) typesBenchmark.result!,
+        if (declarationsBenchmark.result != null) declarationsBenchmark.result!,
+      ],
       identifierDeclarations);
   final definitionsBenchmark = DataClassDefinitionPhaseBenchmark(
       executor, macroUri, instanceId, introspector);
   await definitionsBenchmark.report();
-  BuildAugmentationLibraryBenchmark.reportAndPrint(
+  final rawLibrary = BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
-      [if (definitionsBenchmark.result != null) definitionsBenchmark.result!],
+      [
+        if (typesBenchmark.result != null) typesBenchmark.result!,
+        if (declarationsBenchmark.result != null) declarationsBenchmark.result!,
+        if (definitionsBenchmark.result != null) definitionsBenchmark.result!,
+      ],
       identifierDeclarations);
+
+  final formattedLibrary = FormatLibraryBenchmark.reportAndPrint(rawLibrary);
+
+  CodeOptimizerBenchmark(formattedLibrary, {'MyClass'},
+          BenchmarkCodeOptimizer(identifiers: libraryIdentifiers))
+      .reportAndPrint();
 }
 
 class DataClassInstantiateBenchmark extends AsyncBenchmarkBase {

working/macros/example/benchmark/src/shared.dart

@@ -1,12 +1,24 @@
 // There is no public API exposed yet, the in progress API lives here.
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
+import 'package:_fe_analyzer_shared/src/macros/code_optimizer.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor/introspection_impls.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor/remote_instance.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor.dart';
+import 'package:_fe_analyzer_shared/src/scanner/scanner.dart';
 import 'package:benchmark_harness/benchmark_harness.dart';
 import 'package:dart_style/dart_style.dart';
 
-class BuildAugmentationLibraryBenchmark extends BenchmarkBase {
+/// A benchmark which only calls `run` once inside `excersize`.
+class RunOnceBenchmarkBase extends BenchmarkBase {
+  RunOnceBenchmarkBase(super.name);
+
+  @override
+  void exercise() {
+    run();
+  }
+}
+
+class BuildAugmentationLibraryBenchmark extends RunOnceBenchmarkBase {
   final MacroExecutor executor;
   final List<MacroExecutionResult> results;
 
@@ -18,7 +30,7 @@ class BuildAugmentationLibraryBenchmark extends BenchmarkBase {
       this.executor, this.results, this.identifierDeclarations)
       : super('AugmentationLibrary');
 
-  static void reportAndPrint(
+  static String reportAndPrint(
     MacroExecutor executor,
     List<MacroExecutionResult> results,
     Map<Identifier, Declaration> identifierDeclarations,
@@ -31,8 +43,7 @@ class BuildAugmentationLibraryBenchmark extends BenchmarkBase {
     final benchmark = BuildAugmentationLibraryBenchmark(
         executor, results, identifierDeclarations);
     benchmark.report();
-    final formatBenchmark = FormatLibraryBenchmark(benchmark.library)..report();
-    print('${formatBenchmark.formattedResult}');
+    return benchmark.library;
   }
 
   void run() {
@@ -48,7 +59,7 @@ class BuildAugmentationLibraryBenchmark extends BenchmarkBase {
             kind: IdentifierKind.topLevelMember,
             name: identifier.name,
             staticScope: null,
-            uri: null);
+            uri: dartCore);
       } else {
         final declaration = identifierDeclarations[identifier];
         String? staticScope;
@@ -79,9 +90,11 @@ class BuildAugmentationLibraryBenchmark extends BenchmarkBase {
         (annotation) =>
             throw UnsupportedError('Omitted types are not supported!'));
   }
+
+  static final dartCore = Uri.parse('dart:core');
 }
 
-class FormatLibraryBenchmark extends BenchmarkBase {
+class FormatLibraryBenchmark extends RunOnceBenchmarkBase {
   final formatter = DartFormatter();
   final String library;
   late String _formattedResult;
@@ -90,7 +103,7 @@ class FormatLibraryBenchmark extends BenchmarkBase {
       .replaceAll('/*augment*/', 'augment')
       .replaceAll('on FakeTypeForFormatting {', '{');
 
-  FormatLibraryBenchmark(String library)
+  FormatLibraryBenchmark._(String library)
       : library = _prepareLibrary(library),
         super('FormatLibrary');
 
@@ -118,6 +131,51 @@ class FormatLibraryBenchmark extends BenchmarkBase {
   void run() {
     _formattedResult = formatter.format(library);
   }
+
+  static String reportAndPrint(String library) {
+    final formatBenchmark = FormatLibraryBenchmark._(library)..report();
+    print('${formatBenchmark.formattedResult}');
+    return formatBenchmark.formattedResult;
+  }
+}
+
+class CodeOptimizerBenchmark extends RunOnceBenchmarkBase {
+  final String library;
+  final Set<String> libraryDeclarationNames;
+  final BenchmarkCodeOptimizer optimizer;
+  late String optimizedLibrary;
+
+  CodeOptimizerBenchmark(
+      this.library, this.libraryDeclarationNames, this.optimizer)
+      : super('CodeOptimizer');
+
+  void run() {
+    optimizedLibrary = Edit.applyList(
+        optimizer.optimize(library,
+            libraryDeclarationNames: libraryDeclarationNames,
+            scannerConfiguration: ScannerConfiguration(
+                enableExtensionMethods: true,
+                enableNonNullable: true,
+                enableTripleShift: true,
+                forAugmentationLibrary: true)),
+        library);
+  }
+
+  void reportAndPrint() {
+    report();
+    print(optimizedLibrary);
+  }
+}
+
+class BenchmarkCodeOptimizer extends CodeOptimizer {
+  final Map<Uri, Map<String, Identifier>> identifiers;
+
+  BenchmarkCodeOptimizer({required this.identifiers});
+
+  @override
+  Set<String> getImportedNames(String uriStr) {
+    return (identifiers[Uri.parse(uriStr)] ?? {}).keys.toSet();
+  }
 }
 
 abstract mixin class Fake {