Add support for mixin declarations in the macro APIs

Adds MixinDeclaration/IntrospectableMixinDeclaration for introspection.

Adds MixinTypesMacro/MixinDeclarationsMacro/MixinDefinitionsMacro macro
interfaces.

Updates supporting serialization/execution code and tests.

Change-Id: I57245fe7d177b6d5ba57649455fbd844ba1f85c3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/294380
Reviewed-by: Bob Nystrom <[email protected]>
Commit-Queue: Jake Macdonald <[email protected]>

Author: jakemac53

pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart

@@ -198,6 +198,25 @@ abstract class EnumValueDeclaration implements Declaration {
 abstract class IntrospectableEnumDeclaration
     implements EnumDeclaration, IntrospectableEnum {}
 
+/// Mixin introspection information.
+///
+/// Information about fields and methods must be retrieved from the `builder`
+/// objects.
+abstract class MixinDeclaration implements ParameterizedTypeDeclaration {
+  /// Whether this mixin has a `base` modifier.
+  bool get hasBase;
+
+  /// All the `implements` type annotations.
+  Iterable<NamedTypeAnnotation> get interfaces;
+
+  /// All the `on` clause type annotations.
+  Iterable<NamedTypeAnnotation> get superclassConstraints;
+}
+
+/// An introspectable mixin declaration.
+abstract class IntrospectableMixinDeclaration
+    implements MixinDeclaration, IntrospectableType {}
+
 /// Type alias introspection information.
 abstract class TypeAliasDeclaration implements ParameterizedTypeDeclaration {
   /// The type annotation this is an alias for.

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

@@ -178,3 +178,24 @@ abstract class ConstructorDefinitionMacro implements Macro {
   FutureOr<void> buildDefinitionForConstructor(
       ConstructorDeclaration constructor, ConstructorDefinitionBuilder builder);
 }
+
+/// The interface for [Macro]s that can be applied to any mixin declaration, and
+/// want to contribute new type declarations to the program.
+abstract class MixinTypesMacro implements Macro {
+  FutureOr<void> buildTypesForMixin(
+      MixinDeclaration mixin, TypeBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any mixin declaration, and
+/// want to contribute new non-type declarations to the program.
+abstract class MixinDeclarationsMacro implements Macro {
+  FutureOr<void> buildDeclarationsForMixin(
+      IntrospectableMixinDeclaration mixin, MemberDeclarationBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any mixin declaration, and
+/// want to augment the definitions of the members of that mixin.
+abstract class MixinDefinitionMacro implements Macro {
+  FutureOr<void> buildDefinitionForMixin(
+      IntrospectableMixinDeclaration clazz, TypeDefinitionBuilder builder);
+}

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

@@ -312,11 +312,14 @@ abstract class MacroExecutionResult implements Serializable {
 
 /// Each of the possible types of declarations a macro can be applied to
 enum DeclarationKind {
-  clazz,
+  classType,
   constructor,
+  enumType,
+  enumValue,
   field,
   function,
   method,
+  mixinType,
   variable,
 }
 

pkg/_fe_analyzer_shared/lib/src/macros/executor/augmentation_library.dart

@@ -127,8 +127,10 @@ mixin AugmentationLibraryBuilder on MacroExecutor {
           ? 'class'
           : typeDeclaration is EnumDeclaration
               ? 'enum'
-              : throw new UnsupportedError(
-                  'Unsupported augmentation type $typeDeclaration');
+              : typeDeclaration is MixinDeclaration
+                  ? 'mixin'
+                  : throw new UnsupportedError(
+                      'Unsupported augmentation type $typeDeclaration');
       final List<String> keywords = [
         if (typeDeclaration is ClassDeclaration) ...[
           if (typeDeclaration.hasAbstract) 'abstract',
@@ -138,7 +140,9 @@ mixin AugmentationLibraryBuilder on MacroExecutor {
           if (typeDeclaration.hasInterface) 'interface',
           if (typeDeclaration.hasMixin) 'mixin',
           if (typeDeclaration.hasSealed) 'sealed',
-        ],
+        ] else if (typeDeclaration is MixinDeclaration &&
+            typeDeclaration.hasBase)
+          'base',
       ];
       // Has the effect of adding a space after the keywords
       if (keywords.isNotEmpty) keywords.add('');

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

@@ -37,6 +37,9 @@ Future<MacroExecutionResult> executeTypesMacro(Macro macro,
   } else if (macro is EnumTypesMacro && declaration is EnumDeclaration) {
     await macro.buildTypesForEnum(declaration, builder);
     return builder.result;
+  } else if (macro is MixinTypesMacro && declaration is MixinDeclaration) {
+    await macro.buildTypesForMixin(declaration, builder);
+    return builder.result;
   } else if (macro is EnumValueTypesMacro &&
       declaration is EnumValueDeclaration) {
     await macro.buildTypesForEnumValue(declaration, builder);
@@ -82,6 +85,21 @@ Future<MacroExecutionResult> executeDeclarationsMacro(
         typeResolver);
     await macro.buildDeclarationsForEnum(declaration, builder);
     return builder.result;
+  } else if (declaration is MixinDeclaration &&
+      macro is MixinDeclarationsMacro) {
+    if (declaration is! IntrospectableMixinDeclarationImpl) {
+      throw new ArgumentError(
+          'Mixin declarations annotated with a macro should be introspectable '
+          'in the declarations phase.');
+    }
+    MemberDeclarationBuilderImpl builder = new MemberDeclarationBuilderImpl(
+        declaration.identifier,
+        identifierResolver,
+        typeIntrospector,
+        typeDeclarationResolver,
+        typeResolver);
+    await macro.buildDeclarationsForMixin(declaration, builder);
+    return builder.result;
   } else if (declaration is MemberDeclaration) {
     MemberDeclarationBuilderImpl builder = new MemberDeclarationBuilderImpl(
         declaration.definingType as IdentifierImpl,
@@ -243,6 +261,21 @@ Future<MacroExecutionResult> executeDefinitionMacro(
         typeInferrer);
     await macro.buildDefinitionForEnumValue(declaration, builder);
     return builder.result;
+  } else if (macro is MixinDefinitionMacro && declaration is MixinDeclaration) {
+    if (declaration is! IntrospectableMixinDeclaration) {
+      throw new ArgumentError(
+          'Mixin declarations annotated with a macro should be introspectable '
+          'in the definitions phase.');
+    }
+    TypeDefinitionBuilderImpl builder = new TypeDefinitionBuilderImpl(
+        declaration,
+        identifierResolver,
+        typeIntrospector,
+        typeDeclarationResolver,
+        typeResolver,
+        typeInferrer);
+    await macro.buildDefinitionForMixin(declaration, builder);
+    return builder.result;
   }
   throw new UnsupportedError('Unsupported macro type or invalid declaration:\n'
       'macro: $macro\ndeclaration: $declaration');

pkg/_fe_analyzer_shared/lib/src/macros/executor/introspection_impls.dart

@@ -487,10 +487,10 @@ class MethodDeclarationImpl extends FunctionDeclarationImpl
   final bool isStatic;
 
   MethodDeclarationImpl({
-    // Declaration fields
+    // Declaration fields.
     required super.id,
     required super.identifier,
-    // Function fields
+    // Function fields.
     required super.isAbstract,
     required super.isExternal,
     required super.isGetter,
@@ -500,7 +500,7 @@ class MethodDeclarationImpl extends FunctionDeclarationImpl
     required super.positionalParameters,
     required super.returnType,
     required super.typeParameters,
-    // Method fields
+    // Method fields.
     required this.definingType,
     required this.isStatic,
   });
@@ -525,10 +525,10 @@ class ConstructorDeclarationImpl extends MethodDeclarationImpl
   RemoteInstanceKind get kind => RemoteInstanceKind.constructorDeclaration;
 
   ConstructorDeclarationImpl({
-    // Declaration fields
+    // Declaration fields.
     required super.id,
     required super.identifier,
-    // Function fields
+    // Function fields.
     required super.isAbstract,
     required super.isExternal,
     required super.isGetter,
@@ -538,9 +538,9 @@ class ConstructorDeclarationImpl extends MethodDeclarationImpl
     required super.positionalParameters,
     required super.returnType,
     required super.typeParameters,
-    // Method fields
+    // Method fields.
     required super.definingType,
-    // Constructor fields
+    // Constructor fields.
     required this.isFactory,
   }) : super(
           isStatic: true,
@@ -605,15 +605,15 @@ class FieldDeclarationImpl extends VariableDeclarationImpl
   final bool isStatic;
 
   FieldDeclarationImpl({
-    // Declaration fields
+    // Declaration fields.
     required super.id,
     required super.identifier,
-    // Variable fields
+    // Variable fields.
     required super.isExternal,
     required super.isFinal,
     required super.isLate,
     required super.type,
-    // Field fields
+    // Field fields.
     required this.definingType,
     required this.isStatic,
   });
@@ -699,12 +699,12 @@ class ClassDeclarationImpl extends ParameterizedTypeDeclarationImpl
       : RemoteInstanceKind.classDeclaration;
 
   ClassDeclarationImpl({
-    // Declaration fields
+    // Declaration fields.
     required super.id,
     required super.identifier,
-    // TypeDeclaration fields
+    // TypeDeclaration fields.
     required super.typeParameters,
-    // ClassDeclaration fields
+    // ClassDeclaration fields.
     required this.interfaces,
     required this.hasAbstract,
     required this.hasBase,
@@ -763,12 +763,12 @@ class EnumDeclarationImpl extends ParameterizedTypeDeclarationImpl
       : RemoteInstanceKind.enumDeclaration;
 
   EnumDeclarationImpl({
-    // Declaration fields
+    // Declaration fields.
     required super.id,
     required super.identifier,
-    // TypeDeclaration fields
+    // TypeDeclaration fields.
     required super.typeParameters,
-    // EnumDeclaration fields
+    // EnumDeclaration fields.
     required this.interfaces,
     required this.mixins,
   });
@@ -817,6 +817,60 @@ class EnumValueDeclarationImpl extends DeclarationImpl
   }
 }
 
+class IntrospectableMixinDeclarationImpl = MixinDeclarationImpl
+    with IntrospectableType
+    implements IntrospectableMixinDeclaration;
+
+class MixinDeclarationImpl extends ParameterizedTypeDeclarationImpl
+    implements MixinDeclaration {
+  @override
+  final bool hasBase;
+
+  @override
+  final List<NamedTypeAnnotationImpl> interfaces;
+
+  @override
+  final List<NamedTypeAnnotationImpl> superclassConstraints;
+
+  @override
+  RemoteInstanceKind get kind => this is IntrospectableMixinDeclaration
+      ? RemoteInstanceKind.introspectableMixinDeclaration
+      : RemoteInstanceKind.mixinDeclaration;
+
+  MixinDeclarationImpl({
+    // Declaration fields.
+    required super.id,
+    required super.identifier,
+    // TypeDeclaration fields.
+    required super.typeParameters,
+    // MixinDeclaration fields.
+    required this.hasBase,
+    required this.interfaces,
+    required this.superclassConstraints,
+  });
+
+  @override
+  void serialize(Serializer serializer) {
+    super.serialize(serializer);
+    // Client side we don't encode anything but the ID.
+    if (serializationMode.isClient) return;
+
+    serializer
+      ..addBool(hasBase)
+      ..startList();
+    for (NamedTypeAnnotationImpl interface in interfaces) {
+      interface.serialize(serializer);
+    }
+    serializer
+      ..endList()
+      ..startList();
+    for (NamedTypeAnnotationImpl constraint in superclassConstraints) {
+      constraint.serialize(serializer);
+    }
+    serializer..endList();
+  }
+}
+
 class TypeAliasDeclarationImpl extends ParameterizedTypeDeclarationImpl
     implements TypeAliasDeclaration {
   /// The type being aliased.
@@ -827,12 +881,12 @@ class TypeAliasDeclarationImpl extends ParameterizedTypeDeclarationImpl
   RemoteInstanceKind get kind => RemoteInstanceKind.typeAliasDeclaration;
 
   TypeAliasDeclarationImpl({
-    // Declaration fields
+    // Declaration fields.
     required super.id,
     required super.identifier,
-    // TypeDeclaration fields
+    // TypeDeclaration fields.
     required super.typeParameters,
-    // TypeAlias fields
+    // TypeAlias fields.
     required this.aliasedType,
   });
 

pkg/_fe_analyzer_shared/lib/src/macros/executor/remote_instance.dart

@@ -100,21 +100,23 @@ enum RemoteInstanceKind {
   functionTypeParameter,
   identifier,
   identifierResolver,
-  typeIntrospector,
   introspectableClassDeclaration,
   introspectableEnumDeclaration,
-  namedStaticType,
+  introspectableMixinDeclaration,
   methodDeclaration,
+  mixinDeclaration,
+  namedStaticType,
   namedTypeAnnotation,
   omittedTypeAnnotation,
   parameterDeclaration,
   recordFieldDeclaration,
   recordTypeAnnotation,
   staticType,
   typeAliasDeclaration,
+  typeDeclarationResolver,
   typeParameterDeclaration,
   typeResolver,
-  typeDeclarationResolver,
   typeInferrer,
+  typeIntrospector,
   variableDeclaration,
 }