update the macro examples for the latest apis

Author: jakemac53

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

@@ -7,65 +7,51 @@ import 'package:benchmark_harness/benchmark_harness.dart';
 import 'shared.dart';
 
 Future<void> runBenchmarks(MacroExecutor executor, Uri macroUri) async {
-  final typeDeclarations = {
+  final introspector = SimpleDefinitionPhaseIntrospector(declarations: {
     myClass.identifier: myClass,
     objectClass.identifier: objectClass
-  };
-  final typeIntrospector = SimpleTypeIntrospector(
-      constructors: {},
-      enumValues: {},
-      fields: {myClass: myClassFields},
-      methods: {myClass: myClassMethods});
-  final typeDeclarationResolver =
-      SimpleTypeDeclarationResolver(typeDeclarations);
-  final identifierResolver = SimpleIdentifierResolver({
+  }, identifiers: {
     Uri.parse('dart:core'): {
       'bool': boolIdentifier,
       'int': intIdentifier,
       'Object': objectIdentifier,
       'String': stringIdentifier,
     }
+  }, constructors: {}, enumValues: {}, fields: {
+    myClass: myClassFields
+  }, methods: {
+    myClass: myClassMethods
   });
   final identifierDeclarations = {
-    ...typeDeclarations,
-    for (final constructors in typeIntrospector.constructors.values)
+    ...introspector.declarations,
+    for (final constructors in introspector.constructors.values)
       for (final constructor in constructors)
         constructor.identifier: constructor,
-    for (final methods in typeIntrospector.methods.values)
+    for (final methods in introspector.methods.values)
       for (final method in methods) method.identifier: method,
-    for (final fields in typeIntrospector.fields.values)
+    for (final fields in introspector.fields.values)
       for (final field in fields) field.identifier: field,
   };
   final instantiateBenchmark =
       DataClassInstantiateBenchmark(executor, macroUri);
   await instantiateBenchmark.report();
   final instanceId = instantiateBenchmark.instanceIdentifier;
   final typesBenchmark = DataClassTypesPhaseBenchmark(
-      executor, macroUri, identifierResolver, instanceId);
+      executor, macroUri, instanceId, introspector);
   await typesBenchmark.report();
   BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
       [if (typesBenchmark.result != null) typesBenchmark.result!],
       identifierDeclarations);
   final declarationsBenchmark = DataClassDeclarationsPhaseBenchmark(
-      executor,
-      macroUri,
-      identifierResolver,
-      instanceId,
-      typeIntrospector,
-      typeDeclarationResolver);
+      executor, macroUri, instanceId, introspector);
   await declarationsBenchmark.report();
   BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
       [if (declarationsBenchmark.result != null) declarationsBenchmark.result!],
       identifierDeclarations);
   final definitionsBenchmark = DataClassDefinitionPhaseBenchmark(
-      executor,
-      macroUri,
-      identifierResolver,
-      instanceId,
-      typeIntrospector,
-      typeDeclarationResolver);
+      executor, macroUri, instanceId, introspector);
   await definitionsBenchmark.report();
   BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
@@ -90,88 +76,63 @@ class DataClassInstantiateBenchmark extends AsyncBenchmarkBase {
 class DataClassTypesPhaseBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
-  final IdentifierResolver identifierResolver;
   final MacroInstanceIdentifier instanceIdentifier;
+  final TypePhaseIntrospector introspector;
   MacroExecutionResult? result;
 
-  DataClassTypesPhaseBenchmark(this.executor, this.macroUri,
-      this.identifierResolver, this.instanceIdentifier)
+  DataClassTypesPhaseBenchmark(
+      this.executor, this.macroUri, this.instanceIdentifier, this.introspector)
       : super('DataClassTypesPhase');
 
   Future<void> run() async {
     if (instanceIdentifier.shouldExecute(
         DeclarationKind.classType, Phase.types)) {
       result = await executor.executeTypesPhase(
-          instanceIdentifier, myClass, identifierResolver);
+          instanceIdentifier, myClass, introspector);
     }
   }
 }
 
 class DataClassDeclarationsPhaseBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
-  final IdentifierResolver identifierResolver;
   final MacroInstanceIdentifier instanceIdentifier;
-  final TypeIntrospector typeIntrospector;
-  final TypeDeclarationResolver typeDeclarationResolver;
+  final DeclarationPhaseIntrospector introspector;
 
   MacroExecutionResult? result;
 
   DataClassDeclarationsPhaseBenchmark(
-      this.executor,
-      this.macroUri,
-      this.identifierResolver,
-      this.instanceIdentifier,
-      this.typeIntrospector,
-      this.typeDeclarationResolver)
+      this.executor, this.macroUri, this.instanceIdentifier, this.introspector)
       : super('DataClassDeclarationsPhase');
 
   Future<void> run() async {
     result = null;
     if (instanceIdentifier.shouldExecute(
         DeclarationKind.classType, Phase.declarations)) {
       result = await executor.executeDeclarationsPhase(
-          instanceIdentifier,
-          myClass,
-          identifierResolver,
-          typeDeclarationResolver,
-          SimpleTypeResolver(),
-          typeIntrospector);
+          instanceIdentifier, myClass, introspector);
     }
   }
 }
 
 class DataClassDefinitionPhaseBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
-  final IdentifierResolver identifierResolver;
   final MacroInstanceIdentifier instanceIdentifier;
-  final TypeIntrospector typeIntrospector;
-  final TypeDeclarationResolver typeDeclarationResolver;
+  final DefinitionPhaseIntrospector introspector;
 
   MacroExecutionResult? result;
 
   DataClassDefinitionPhaseBenchmark(
-      this.executor,
-      this.macroUri,
-      this.identifierResolver,
-      this.instanceIdentifier,
-      this.typeIntrospector,
-      this.typeDeclarationResolver)
+      this.executor, this.macroUri, this.instanceIdentifier, this.introspector)
       : super('DataClassDefinitionPhase');
 
   Future<void> run() async {
     result = null;
     if (instanceIdentifier.shouldExecute(
         DeclarationKind.classType, Phase.definitions)) {
       result = await executor.executeDefinitionsPhase(
-          instanceIdentifier,
-          myClass,
-          identifierResolver,
-          typeDeclarationResolver,
-          const SimpleTypeResolver(),
-          typeIntrospector,
-          const FakeTypeInferrer());
+          instanceIdentifier, myClass, introspector);
     }
   }
 }
@@ -182,6 +143,7 @@ final myClass = IntrospectableClassDeclarationImpl(
     id: RemoteInstance.uniqueId,
     identifier: myClassIdentifier,
     library: fooLibrary,
+    metadata: [],
     interfaces: [],
     hasAbstract: false,
     hasBase: false,
@@ -205,6 +167,7 @@ final myClassFields = [
       id: RemoteInstance.uniqueId,
       identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: 'myString'),
       library: fooLibrary,
+      metadata: [],
       isExternal: false,
       isFinal: true,
       isLate: false,
@@ -215,6 +178,7 @@ final myClassFields = [
       id: RemoteInstance.uniqueId,
       identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: 'myBool'),
       library: fooLibrary,
+      metadata: [],
       isExternal: false,
       isFinal: true,
       isLate: false,
@@ -228,6 +192,7 @@ final myClassMethods = [
     id: RemoteInstance.uniqueId,
     identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: '=='),
     library: fooLibrary,
+    metadata: [],
     isAbstract: false,
     isExternal: false,
     isGetter: false,
@@ -240,6 +205,7 @@ final myClassMethods = [
         id: RemoteInstance.uniqueId,
         identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: 'other'),
         library: fooLibrary,
+        metadata: [],
         isNamed: false,
         isRequired: true,
         type: NamedTypeAnnotationImpl(
@@ -257,6 +223,7 @@ final myClassMethods = [
     id: RemoteInstance.uniqueId,
     identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: 'hashCode'),
     library: fooLibrary,
+    metadata: [],
     isAbstract: false,
     isExternal: false,
     isOperator: false,
@@ -273,6 +240,7 @@ final myClassMethods = [
     id: RemoteInstance.uniqueId,
     identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: 'toString'),
     library: fooLibrary,
+    metadata: [],
     isAbstract: false,
     isExternal: false,
     isGetter: false,

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

@@ -7,7 +7,7 @@ import 'package:benchmark_harness/benchmark_harness.dart';
 import 'shared.dart';
 
 Future<void> runBenchmarks(MacroExecutor executor, Uri macroUri) async {
-  final identifierResolver = SimpleIdentifierResolver({
+  final introspector = SimpleTypePhaseIntrospector(identifiers: {
     Uri.parse('dart:core'): {
       'int': intIdentifier,
       'String': stringIdentifier,
@@ -23,7 +23,7 @@ Future<void> runBenchmarks(MacroExecutor executor, Uri macroUri) async {
   await instantiateBenchmark.report();
   final instanceId = instantiateBenchmark.instanceIdentifier;
   final typesBenchmark = FunctionalWidgetTypesPhaseBenchmark(
-      executor, macroUri, identifierResolver, instanceId);
+      executor, macroUri, instanceId, introspector);
   await typesBenchmark.report();
   BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
@@ -48,19 +48,19 @@ class FunctionalWidgetInstantiateBenchmark extends AsyncBenchmarkBase {
 class FunctionalWidgetTypesPhaseBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
-  final IdentifierResolver identifierResolver;
   final MacroInstanceIdentifier instanceIdentifier;
+  final TypePhaseIntrospector introspector;
   MacroExecutionResult? result;
 
-  FunctionalWidgetTypesPhaseBenchmark(this.executor, this.macroUri,
-      this.identifierResolver, this.instanceIdentifier)
+  FunctionalWidgetTypesPhaseBenchmark(
+      this.executor, this.macroUri, this.instanceIdentifier, this.introspector)
       : super('FunctionalWidgetTypesPhase');
 
   Future<void> run() async {
     if (instanceIdentifier.shouldExecute(
         DeclarationKind.function, Phase.types)) {
       result = await executor.executeTypesPhase(
-          instanceIdentifier, myFunction, identifierResolver);
+          instanceIdentifier, myFunction, introspector);
     }
   }
 }
@@ -83,6 +83,7 @@ final myFunction = FunctionDeclarationImpl(
     id: RemoteInstance.uniqueId,
     identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: '_myWidget'),
     library: fooLibrary,
+    metadata: [],
     isAbstract: false,
     isExternal: false,
     isGetter: false,
@@ -96,6 +97,7 @@ final myFunction = FunctionDeclarationImpl(
           isNamed: true,
           isRequired: true,
           library: fooLibrary,
+          metadata: [],
           type: stringType),
     ],
     positionalParameters: [
@@ -106,6 +108,7 @@ final myFunction = FunctionDeclarationImpl(
           isNamed: false,
           isRequired: true,
           library: fooLibrary,
+          metadata: [],
           type: buildContextType),
       ParameterDeclarationImpl(
           id: RemoteInstance.uniqueId,
@@ -114,6 +117,7 @@ final myFunction = FunctionDeclarationImpl(
           isNamed: false,
           isRequired: true,
           library: fooLibrary,
+          metadata: [],
           type: intType),
     ],
     returnType: widgetType,