Updates to the JsonSerialization macro example. (#3550)

* Updates to the JsonSerialization macro example.

- Add support for a `toJson` method.
- Directly apply separate FromJson/ToJson macros in the declaration
  phase, instead of scanning the class for methods.

Author: jakemac53

working/macros/example/benchmark/simple.dart

@@ -118,15 +118,18 @@ Macro: $macro
   }
   var tmpDir = Directory.systemTemp.createTempSync('macro_benchmark');
   try {
+    var jsonSerializableUri =
+        Uri.parse('package:macro_proposal/json_serializable.dart');
     var macroUri = switch (macro) {
       'ChecksExtensions' =>
         Uri.parse('package:macro_proposal/checks_extensions.dart'),
       'DataClass' => Uri.parse('package:macro_proposal/data_class.dart'),
       'Injectable' => Uri.parse('package:macro_proposal/injectable.dart'),
       'FunctionalWidget' =>
         Uri.parse('package:macro_proposal/functional_widget.dart'),
-      'JsonSerializable' =>
-        Uri.parse('package:macro_proposal/json_serializable.dart'),
+      'JsonSerializable' => jsonSerializableUri,
+      'FromJson' => jsonSerializableUri,
+      'ToJson' => jsonSerializableUri,
       _ => throw UnsupportedError('Unrecognized macro $macro'),
     };
     var macroConstructors = switch (macro) {
@@ -147,6 +150,8 @@ Macro: $macro
         },
       'JsonSerializable' => {
           'JsonSerializable': [''],
+          'FromJson': [''],
+          'ToJson': [''],
         },
       _ => throw UnsupportedError('Unrecognized macro $macro'),
     };

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

@@ -22,7 +22,11 @@ Future<void> runBenchmarks(MacroExecutor executor, Uri macroUri) async {
       'String': stringIdentifier,
       'Map': mapIdentifier,
       'Object': objectIdentifier,
-    }
+    },
+    jsonSerializableUri: {
+      'FromJson': fromJsonMacroIdentifier,
+      'ToJson': toJsonMacroIdentifier,
+    },
   }, constructors: {}, enumValues: {}, fields: {
     myClass: myClassFields
   }, methods: {});
@@ -37,107 +41,129 @@ Future<void> runBenchmarks(MacroExecutor executor, Uri macroUri) async {
       for (final field in fields) field.identifier: field,
   };
   final instantiateBenchmark =
-      JsonSerializableInstantiateBenchmark(executor, macroUri);
+      InstantiateBenchmark(executor, macroUri, 'JsonSerializable');
   await instantiateBenchmark.report();
   final instanceId = instantiateBenchmark.instanceIdentifier;
-  final typesBenchmark = JsonSerializableTypesPhaseBenchmark(
-      executor, macroUri, instanceId, introspector);
-  await typesBenchmark.report();
-  BuildAugmentationLibraryBenchmark.reportAndPrint(
-      executor,
-      [if (typesBenchmark.result != null) typesBenchmark.result!],
-      identifierDeclarations);
   final declarationsBenchmark = JsonSerializableDeclarationsPhaseBenchmark(
       executor, macroUri, instanceId, introspector);
   await declarationsBenchmark.report();
   BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
       [if (declarationsBenchmark.result != null) declarationsBenchmark.result!],
       identifierDeclarations);
+
   introspector.constructors[myClass] = myClassConstructors;
-  final definitionsBenchmark = JsonSerializableDefinitionPhaseBenchmark(
-      executor, macroUri, instanceId, introspector);
-  await definitionsBenchmark.report();
+  introspector.methods[myClass] = myClassMethods;
+
+  final fromJsonInstantiateBenchmark =
+      InstantiateBenchmark(executor, macroUri, 'FromJson');
+  await fromJsonInstantiateBenchmark.report();
+  final fromJsonDefinitionsBenchmark = FromJsonDefinitionPhaseBenchmark(
+      executor,
+      macroUri,
+      fromJsonInstantiateBenchmark.instanceIdentifier,
+      introspector);
+  await fromJsonDefinitionsBenchmark.report();
   BuildAugmentationLibraryBenchmark.reportAndPrint(
       executor,
-      [if (definitionsBenchmark.result != null) definitionsBenchmark.result!],
+      [
+        if (fromJsonDefinitionsBenchmark.result != null)
+          fromJsonDefinitionsBenchmark.result!
+      ],
+      identifierDeclarations);
+
+  final toJsonInstantiateBenchmark =
+      InstantiateBenchmark(executor, macroUri, 'ToJson');
+  await toJsonInstantiateBenchmark.report();
+  final toJsonDefinitionsBenchmark = ToJsonDefinitionPhaseBenchmark(executor,
+      macroUri, toJsonInstantiateBenchmark.instanceIdentifier, introspector);
+  await toJsonDefinitionsBenchmark.report();
+  BuildAugmentationLibraryBenchmark.reportAndPrint(
+      executor,
+      [
+        if (toJsonDefinitionsBenchmark.result != null)
+          toJsonDefinitionsBenchmark.result!
+      ],
       identifierDeclarations);
 }
 
-class JsonSerializableInstantiateBenchmark extends AsyncBenchmarkBase {
+class InstantiateBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
   late MacroInstanceIdentifier instanceIdentifier;
+  final String macroName;
 
-  JsonSerializableInstantiateBenchmark(this.executor, this.macroUri)
-      : super('JsonSerializableInstantiate');
+  InstantiateBenchmark(this.executor, this.macroUri, this.macroName)
+      : super('${macroName}Instantiate');
 
   Future<void> run() async {
     instanceIdentifier = await executor.instantiateMacro(
-        macroUri, 'JsonSerializable', '', Arguments([], {}));
+        macroUri, macroName, '', Arguments([], {}));
   }
 }
 
-class JsonSerializableTypesPhaseBenchmark extends AsyncBenchmarkBase {
+class JsonSerializableDeclarationsPhaseBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
   final MacroInstanceIdentifier instanceIdentifier;
-  final TypePhaseIntrospector introspector;
+  final DeclarationPhaseIntrospector introspector;
+
   MacroExecutionResult? result;
 
-  JsonSerializableTypesPhaseBenchmark(
+  JsonSerializableDeclarationsPhaseBenchmark(
       this.executor, this.macroUri, this.instanceIdentifier, this.introspector)
-      : super('JsonSerializableTypesPhase');
+      : super('JsonSerializableDeclarationsPhase');
 
   Future<void> run() async {
+    result = null;
     if (instanceIdentifier.shouldExecute(
-        DeclarationKind.classType, Phase.types)) {
-      result = await executor.executeTypesPhase(
+        DeclarationKind.classType, Phase.declarations)) {
+      result = await executor.executeDeclarationsPhase(
           instanceIdentifier, myClass, introspector);
     }
   }
 }
 
-class JsonSerializableDeclarationsPhaseBenchmark extends AsyncBenchmarkBase {
+class FromJsonDefinitionPhaseBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
   final MacroInstanceIdentifier instanceIdentifier;
-  final DeclarationPhaseIntrospector introspector;
+  final DefinitionPhaseIntrospector introspector;
 
   MacroExecutionResult? result;
 
-  JsonSerializableDeclarationsPhaseBenchmark(
+  FromJsonDefinitionPhaseBenchmark(
       this.executor, this.macroUri, this.instanceIdentifier, this.introspector)
-      : super('JsonSerializableDeclarationsPhase');
+      : super('FromJsonDefinitionPhase');
 
   Future<void> run() async {
     result = null;
     if (instanceIdentifier.shouldExecute(
-        DeclarationKind.classType, Phase.declarations)) {
-      result = await executor.executeDeclarationsPhase(
-          instanceIdentifier, myClass, introspector);
+        DeclarationKind.constructor, Phase.definitions)) {
+      result = await executor.executeDefinitionsPhase(
+          instanceIdentifier, myClassConstructors.single, introspector);
     }
   }
 }
 
-class JsonSerializableDefinitionPhaseBenchmark extends AsyncBenchmarkBase {
+class ToJsonDefinitionPhaseBenchmark extends AsyncBenchmarkBase {
   final MacroExecutor executor;
   final Uri macroUri;
   final MacroInstanceIdentifier instanceIdentifier;
   final DefinitionPhaseIntrospector introspector;
 
   MacroExecutionResult? result;
 
-  JsonSerializableDefinitionPhaseBenchmark(
+  ToJsonDefinitionPhaseBenchmark(
       this.executor, this.macroUri, this.instanceIdentifier, this.introspector)
-      : super('JsonSerializableDefinitionPhase');
+      : super('ToJsonDefinitionPhase');
 
   Future<void> run() async {
     result = null;
     if (instanceIdentifier.shouldExecute(
-        DeclarationKind.classType, Phase.definitions)) {
+        DeclarationKind.method, Phase.definitions)) {
       result = await executor.executeDefinitionsPhase(
-          instanceIdentifier, myClass, introspector);
+          instanceIdentifier, myClassMethods.single, introspector);
     }
   }
 }
@@ -222,3 +248,34 @@ final myClassConstructors = [
       definingType: myClass.identifier,
       isFactory: true),
 ];
+
+final myClassMethods = [
+  MethodDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      identifier: IdentifierImpl(id: RemoteInstance.uniqueId, name: 'toJson'),
+      isGetter: false,
+      isOperator: false,
+      isSetter: false,
+      isStatic: false,
+      library: fooLibrary,
+      metadata: [],
+      hasBody: false,
+      hasExternal: false,
+      namedParameters: [],
+      positionalParameters: [],
+      returnType: NamedTypeAnnotationImpl(
+          id: RemoteInstance.uniqueId,
+          isNullable: false,
+          identifier: mapIdentifier,
+          typeArguments: [stringType, dynamicType]),
+      typeParameters: [],
+      definingType: myClass.identifier),
+];
+
+final jsonSerializableUri =
+    Uri.parse('package:macro_proposal/json_serializable.dart');
+
+final fromJsonMacroIdentifier =
+    IdentifierImpl(id: RemoteInstance.uniqueId, name: 'FromJson');
+final toJsonMacroIdentifier =
+    IdentifierImpl(id: RemoteInstance.uniqueId, name: 'ToJson');