Version 2.17.0-54.0.dev

Merge commit '627326aec14f52f9fc9015ad22bd2810635e006d' into 'dev'

Author: Dart CI

DEPS

@@ -133,7 +133,7 @@ vars = {
   "mime_rev": "c931f4bed87221beaece356494b43731445ce7b8",
   "mockito_rev": "d39ac507483b9891165e422ec98d9fb480037c8b",
   "oauth2_rev": "7cd3284049fe5badbec9f2bea2afc41d14c01057",
-  "package_config_rev": "fb736aa12316dd2d882b202a438a6946a4b4bea0",
+  "package_config_rev": "8731bf10b5375542792a32a0f7c8a6f370583d96",
   "path_rev": "baedce9d2ca11ea2cdf54395a74eb038087777a4",
   "pedantic_rev": "66f2f6c27581c7936482e83be80b27be2719901c",
   "platform_rev": "1ffad63428bbd1b3ecaa15926bacfb724023648c",

pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart

@@ -79,6 +79,10 @@ void main(_, SendPort sendPort) {
           var request = new ExecuteDefinitionsPhaseRequest.deserialize(deserializer, zoneId);
           (await _executeDefinitionsPhase(request, sendRequest)).serialize(serializer);
           break;
+        case MessageType.executeTypesPhaseRequest:
+          var request = new ExecuteTypesPhaseRequest.deserialize(deserializer, zoneId);
+          (await _executeTypesPhase(request, sendRequest)).serialize(serializer);
+          break;
         case MessageType.response:
           var response = new SerializableResponse.deserialize(deserializer, zoneId);
           _responseCompleters.remove(response.requestId)!.complete(response);
@@ -135,6 +139,32 @@ Future<SerializableResponse> _instantiateMacro(
   }
 }
 
+Future<SerializableResponse> _executeTypesPhase(
+    ExecuteTypesPhaseRequest request,
+    Future<Response> Function(Request request) sendRequest) async {
+  try {
+    Macro? instance = _macroInstances[request.macro];
+    if (instance == null) {
+      throw new StateError('Unrecognized macro instance \${request.macro}\\n'
+          'Known instances: \$_macroInstances)');
+    }
+
+    var result = await executeTypesMacro(instance, request.declaration);
+    return new SerializableResponse(
+        responseType: MessageType.macroExecutionResult,
+        response: result,
+        requestId: request.id,
+        serializationZoneId: request.serializationZoneId);
+  } catch (e, s) {
+    return new SerializableResponse(
+      responseType: MessageType.error,
+      error: e.toString(),
+      stackTrace: s.toString(),
+      requestId: request.id,
+      serializationZoneId: request.serializationZoneId);
+  }
+}
+
 Future<SerializableResponse> _executeDeclarationsPhase(
     ExecuteDeclarationsPhaseRequest request,
     Future<Response> Function(Request request) sendRequest) async {

pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart

@@ -24,6 +24,13 @@ class TypeBuilderBase {
       : _augmentations = parentAugmentations ?? [];
 }
 
+class TypeBuilderImpl extends TypeBuilderBase implements TypeBuilder {
+  @override
+  void declareType(DeclarationCode typeDeclaration) {
+    _augmentations.add(typeDeclaration);
+  }
+}
+
 /// Base class for all [DeclarationBuilder]s.
 class DeclarationBuilderBase extends TypeBuilderBase
     implements ClassIntrospector, TypeResolver {
@@ -66,10 +73,8 @@ class DeclarationBuilderBase extends TypeBuilderBase
 class DeclarationBuilderImpl extends DeclarationBuilderBase
     implements DeclarationBuilder {
   DeclarationBuilderImpl(
-      ClassIntrospector classIntrospector, TypeResolver typeResolver,
-      {List<DeclarationCode>? parentAugmentations})
-      : super(classIntrospector, typeResolver,
-            parentAugmentations: parentAugmentations);
+      ClassIntrospector classIntrospector, TypeResolver typeResolver)
+      : super(classIntrospector, typeResolver);
 
   @override
   void declareInLibrary(DeclarationCode declaration) {
@@ -82,10 +87,8 @@ class ClassMemberDeclarationBuilderImpl extends DeclarationBuilderImpl
   final TypeAnnotation definingClass;
 
   ClassMemberDeclarationBuilderImpl(this.definingClass,
-      ClassIntrospector classIntrospector, TypeResolver typeResolver,
-      {List<DeclarationCode>? parentAugmentations})
-      : super(classIntrospector, typeResolver,
-            parentAugmentations: parentAugmentations);
+      ClassIntrospector classIntrospector, TypeResolver typeResolver)
+      : super(classIntrospector, typeResolver);
 
   @override
   void declareInClass(DeclarationCode declaration) {

pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart

@@ -6,6 +6,38 @@ import 'package:_fe_analyzer_shared/src/macros/executor.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor_shared/builder_impls.dart';
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
 
+/// Runs [macro] in the types phase and returns a  [MacroExecutionResult].
+Future<MacroExecutionResult> executeTypesMacro(
+    Macro macro, Declaration declaration) async {
+  TypeBuilderImpl builder = new TypeBuilderImpl();
+  if (declaration is FunctionDeclaration) {
+    if (macro is ConstructorTypesMacro &&
+        declaration is ConstructorDeclaration) {
+      await macro.buildTypesForConstructor(declaration, builder);
+      return builder.result;
+    } else if (macro is MethodTypesMacro && declaration is MethodDeclaration) {
+      await macro.buildTypesForMethod(declaration, builder);
+      return builder.result;
+    } else if (macro is FunctionTypesMacro) {
+      await macro.buildTypesForFunction(declaration, builder);
+      return builder.result;
+    }
+  } else if (declaration is VariableDeclaration) {
+    if (macro is FieldTypesMacro && declaration is FieldDeclaration) {
+      await macro.buildTypesForField(declaration, builder);
+      return builder.result;
+    } else if (macro is VariableTypesMacro) {
+      await macro.buildTypesForVariable(declaration, builder);
+      return builder.result;
+    }
+  } else if (macro is ClassTypesMacro && declaration is ClassDeclaration) {
+    await macro.buildTypesForClass(declaration, builder);
+    return builder.result;
+  }
+  throw new UnsupportedError('Unsupported macro type or invalid declaration:\n'
+      'macro: $macro\ndeclaration: $declaration');
+}
+
 /// Runs [macro] in the declaration phase and returns a  [MacroExecutionResult].
 Future<MacroExecutionResult> executeDeclarationsMacro(
     Macro macro,

pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart

@@ -237,6 +237,32 @@ class InstantiateMacroRequest extends Request {
   }
 }
 
+/// A request to execute a macro on a particular declaration in the types phase.
+class ExecuteTypesPhaseRequest extends Request {
+  final MacroInstanceIdentifier macro;
+  final DeclarationImpl declaration;
+
+  ExecuteTypesPhaseRequest(this.macro, this.declaration,
+      {required int serializationZoneId})
+      : super(serializationZoneId: serializationZoneId);
+
+  /// When deserializing we have already consumed the message type, so we don't
+  /// consume it again.
+  ExecuteTypesPhaseRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
+      : macro = new MacroInstanceIdentifierImpl.deserialize(deserializer),
+        declaration = RemoteInstance.deserialize(deserializer),
+        super.deserialize(deserializer, serializationZoneId);
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.executeTypesPhaseRequest.index);
+    macro.serialize(serializer);
+    declaration.serialize(serializer);
+
+    super.serialize(serializer);
+  }
+}
+
 /// A request to execute a macro on a particular declaration in the definition
 /// phase.
 class ExecuteDeclarationsPhaseRequest extends Request {
@@ -664,6 +690,7 @@ enum MessageType {
   error,
   executeDeclarationsPhaseRequest,
   executeDefinitionsPhaseRequest,
+  executeTypesPhaseRequest,
   instantiateMacroRequest,
   isExactlyTypeRequest,
   isSubtypeOfRequest,

pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart

@@ -420,10 +420,9 @@ class _SingleIsolatedMacroExecutor extends MacroExecutor {
 
   @override
   Future<MacroExecutionResult> executeTypesPhase(
-      MacroInstanceIdentifier macro, Declaration declaration) {
-    // TODO: implement executeTypesPhase
-    throw new UnimplementedError();
-  }
+          MacroInstanceIdentifier macro, DeclarationImpl declaration) =>
+      _sendRequest((zoneId) => new ExecuteTypesPhaseRequest(macro, declaration,
+          serializationZoneId: zoneId));
 
   @override
   Future<MacroInstanceIdentifier> instantiateMacro(

pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart

@@ -212,6 +212,35 @@ void main() {
     var testTypeDeclarationResolver =
         TestTypeDeclarationResolver({myClassStaticType: myClass});
 
+    group('in the types phase', () {
+      test('on methods', () async {
+        var result = await executor.executeTypesPhase(instanceId, myMethod);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyMethod {}'));
+      });
+
+      test('on constructors', () async {
+        var result =
+            await executor.executeTypesPhase(instanceId, myConstructor);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyConstructor {}'));
+      });
+
+      test('on fields', () async {
+        var result = await executor.executeTypesPhase(instanceId, myField);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyField {}'));
+      });
+
+      test('on classes', () async {
+        var result = await executor.executeTypesPhase(instanceId, myClass);
+        expect(
+            result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace(
+                'class MyClassBuilder implements Builder<MyClass> {}'));
+      });
+    });
+
     group('in the declaration phase', () {
       test('on methods', () async {
         var result = await executor.executeDeclarationsPhase(

pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart

@@ -14,16 +14,22 @@ import 'package:_fe_analyzer_shared/src/macros/api.dart';
 /// to validate the introspection APIs work as expected.
 class SimpleMacro
     implements
+        ClassTypesMacro,
         ClassDeclarationsMacro,
         ClassDefinitionMacro,
+        ConstructorTypesMacro,
         ConstructorDeclarationsMacro,
         ConstructorDefinitionMacro,
+        FieldTypesMacro,
         FieldDeclarationsMacro,
         FieldDefinitionMacro,
+        FunctionTypesMacro,
         FunctionDeclarationsMacro,
         FunctionDefinitionMacro,
+        MethodTypesMacro,
         MethodDeclarationsMacro,
         MethodDefinitionMacro,
+        VariableTypesMacro,
         VariableDeclarationsMacro,
         VariableDefinitionMacro {
   final int? x;
@@ -236,6 +242,77 @@ class SimpleMacro
       initializer: variable.initializer,
     );
   }
+
+  @override
+  FutureOr<void> buildTypesForClass(
+      ClassDeclaration clazz, TypeBuilder builder) {
+    List<Object> _buildTypeParam(
+        TypeParameterDeclaration typeParam, bool isFirst) {
+      return [
+        if (!isFirst) ', ',
+        typeParam.name,
+        if (typeParam.bounds != null) ...[
+          ' extends ',
+          typeParam.bounds!,
+        ]
+      ];
+    }
+
+    builder.declareType(DeclarationCode.fromParts([
+      'class ${clazz.name}Builder',
+      if (clazz.typeParameters.isNotEmpty) ...[
+        '<',
+        ..._buildTypeParam(clazz.typeParameters.first, true),
+        for (var typeParam in clazz.typeParameters.skip(1))
+          ..._buildTypeParam(typeParam, false),
+        '>',
+      ],
+      ' implements Builder<',
+      clazz.type,
+      if (clazz.typeParameters.isNotEmpty) ...[
+        '<',
+        clazz.typeParameters.first,
+        for (var typeParam in clazz.typeParameters) ', ${typeParam.name}',
+        '>',
+      ],
+      '> {}'
+    ]));
+  }
+
+  @override
+  FutureOr<void> buildTypesForConstructor(
+      ConstructorDeclaration constructor, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${constructor.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForField(
+      FieldDeclaration field, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${field.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForFunction(
+      FunctionDeclaration function, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${function.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForMethod(
+      MethodDeclaration method, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${method.name.capitalize()} {}'));
+  }
+
+  @override
+  FutureOr<void> buildTypesForVariable(
+      VariableDeclaration variable, TypeBuilder builder) {
+    builder.declareType(DeclarationCode.fromString(
+        'class GeneratedBy${variable.name.capitalize()} {}'));
+  }
 }
 
 FunctionBodyCode _buildFunctionAugmentation(FunctionDeclaration function) =>