diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
index fae7630..0749150 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
@@ -65,6 +65,12 @@
   String get name;
 }
 
+/// Base class for all Declarations which have a surrounding class.
+abstract class ClassMemberDeclaration implements Declaration {
+  /// The class that defines this method.
+  NamedTypeAnnotation get definingClass;
+}
+
 /// A declaration that defines a new type in the program.
 ///
 /// See subtypes [ClassDeclaration] and [TypeAliasDeclaration].
@@ -145,10 +151,8 @@
 }
 
 /// Method introspection information.
-abstract class MethodDeclaration implements FunctionDeclaration {
-  /// The class that defines this method.
-  NamedTypeAnnotation get definingClass;
-}
+abstract class MethodDeclaration
+    implements FunctionDeclaration, ClassMemberDeclaration {}
 
 /// Constructor introspection information.
 abstract class ConstructorDeclaration implements MethodDeclaration {
@@ -175,11 +179,9 @@
   ExpressionCode? get initializer;
 }
 
-/// Field introspection information ..
-abstract class FieldDeclaration implements VariableDeclaration {
-  /// The class that defines this method.
-  NamedTypeAnnotation get definingClass;
-}
+/// Field introspection information.
+abstract class FieldDeclaration
+    implements VariableDeclaration, ClassMemberDeclaration {}
 
 /// Parameter introspection information.
 abstract class ParameterDeclaration implements Declaration {
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart
index 577e7bf..c423331 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart
@@ -140,7 +140,7 @@
   Future<VariableDefinitionBuilder> buildField(String name) async {
     FieldDeclaration field = (await classIntrospector.fieldsOf(declaration))
         .firstWhere((field) => field.name == name);
-    return new FieldDefinitionBuilderImpl(
+    return new VariableDefinitionBuilderImpl(
         field, classIntrospector, typeResolver, typeDeclarationResolver,
         parentAugmentations: _augmentations);
   }
@@ -149,7 +149,7 @@
   Future<FunctionDefinitionBuilder> buildMethod(String name) async {
     MethodDeclaration method = (await classIntrospector.methodsOf(declaration))
         .firstWhere((method) => method.name == name);
-    return new MethodDefinitionBuilderImpl(
+    return new FunctionDefinitionBuilderImpl(
         method, classIntrospector, typeResolver, typeDeclarationResolver,
         parentAugmentations: _augmentations);
   }
@@ -171,31 +171,14 @@
 
   @override
   void augment(FunctionBodyCode body) {
-    _augmentations.add(_buildFunctionAugmentation(body, declaration));
-  }
-}
-
-/// Implementation of [MethodDefinitionBuilderImpl].
-class MethodDefinitionBuilderImpl extends FunctionDefinitionBuilderImpl {
-  @override
-  final MethodDeclaration declaration;
-
-  MethodDefinitionBuilderImpl(
-      this.declaration,
-      ClassIntrospector classIntrospector,
-      TypeResolver typeResolver,
-      TypeDeclarationResolver typeDeclarationResolver,
-      {List<DeclarationCode>? parentAugmentations})
-      : super(declaration, classIntrospector, typeResolver,
-            typeDeclarationResolver,
-            parentAugmentations: parentAugmentations);
-
-  @override
-  void augment(FunctionBodyCode body) {
-    _augmentations.add(_buildClassAugmentation(
-      declaration.definingClass,
-      [_buildFunctionAugmentation(body, declaration)],
-    ));
+    DeclarationCode augmentation =
+        _buildFunctionAugmentation(body, declaration);
+    if (declaration is ClassMemberDeclaration) {
+      augmentation = _buildClassAugmentation(
+          (declaration as ClassMemberDeclaration).definingClass,
+          [augmentation]);
+    }
+    _augmentations.add(augmentation);
   }
 }
 
@@ -241,33 +224,20 @@
       {DeclarationCode? getter,
       DeclarationCode? setter,
       ExpressionCode? initializer}) {
-    _augmentations.addAll(_buildVariableAugmentations(declaration,
-        getter: getter, setter: setter, initializer: initializer));
-  }
-}
+    List<DeclarationCode> augmentations = _buildVariableAugmentations(
+        declaration,
+        getter: getter,
+        setter: setter,
+        initializer: initializer);
+    if (declaration is ClassMemberDeclaration) {
+      augmentations = [
+        _buildClassAugmentation(
+            (declaration as ClassMemberDeclaration).definingClass,
+            augmentations)
+      ];
+    }
 
-class FieldDefinitionBuilderImpl extends DefinitionBuilderBase
-    implements VariableDefinitionBuilder {
-  final FieldDeclaration declaration;
-
-  FieldDefinitionBuilderImpl(
-      this.declaration,
-      ClassIntrospector classIntrospector,
-      TypeResolver typeResolver,
-      TypeDeclarationResolver typeDeclarationResolver,
-      {List<DeclarationCode>? parentAugmentations})
-      : super(classIntrospector, typeResolver, typeDeclarationResolver,
-            parentAugmentations: parentAugmentations);
-
-  @override
-  void augment(
-      {DeclarationCode? getter,
-      DeclarationCode? setter,
-      ExpressionCode? initializer}) {
-    _augmentations.add(_buildClassAugmentation(
-        declaration.definingClass,
-        _buildVariableAugmentations(declaration,
-            getter: getter, setter: setter, initializer: initializer)));
+    _augmentations.addAll(augmentations);
   }
 }
 
@@ -336,7 +306,7 @@
       declaration.returnType.code,
       ' ',
     ],
-    declaration.name,
+    declaration.name.trimEquals(),
     if (declaration.typeParameters.isNotEmpty) ...[
       '<',
       for (TypeParameterDeclaration typeParam
@@ -399,3 +369,7 @@
     body,
   ]);
 }
+
+extension _ on String {
+  String trimEquals() => endsWith('=') ? substring(0, length - 1) : this;
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart
index 4448b1e..c1367a2 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart
@@ -44,47 +44,54 @@
     Declaration declaration,
     ClassIntrospector classIntrospector,
     TypeResolver typeResolver) async {
-  if (declaration is FunctionDeclaration) {
-    if (macro is ConstructorDeclarationsMacro &&
-        declaration is ConstructorDeclaration) {
-      ClassMemberDeclarationBuilderImpl builder =
-          new ClassMemberDeclarationBuilderImpl(
-              declaration.definingClass, classIntrospector, typeResolver);
-      await macro.buildDeclarationsForConstructor(declaration, builder);
-      return builder.result;
-    } else if (macro is MethodDeclarationsMacro &&
-        declaration is MethodDeclaration) {
-      ClassMemberDeclarationBuilderImpl builder =
-          new ClassMemberDeclarationBuilderImpl(
-              declaration.definingClass, classIntrospector, typeResolver);
-      await macro.buildDeclarationsForMethod(declaration, builder);
-      return builder.result;
-    } else if (macro is FunctionDeclarationsMacro) {
-      DeclarationBuilderImpl builder =
-          new DeclarationBuilderImpl(classIntrospector, typeResolver);
-      await macro.buildDeclarationsForFunction(declaration, builder);
-      return builder.result;
-    }
-  } else if (declaration is VariableDeclaration) {
-    if (macro is FieldDeclarationsMacro && declaration is FieldDeclaration) {
-      ClassMemberDeclarationBuilderImpl builder =
-          new ClassMemberDeclarationBuilderImpl(
-              declaration.definingClass, classIntrospector, typeResolver);
-      await macro.buildDeclarationsForField(declaration, builder);
-      return builder.result;
-    } else if (macro is VariableDeclarationsMacro) {
-      DeclarationBuilderImpl builder =
-          new DeclarationBuilderImpl(classIntrospector, typeResolver);
-      await macro.buildDeclarationsForVariable(declaration, builder);
-      return builder.result;
-    }
-  } else if (macro is ClassDeclarationsMacro &&
-      declaration is ClassDeclaration) {
+  if (declaration is ClassDeclaration && macro is ClassDeclarationsMacro) {
     ClassMemberDeclarationBuilderImpl builder =
         new ClassMemberDeclarationBuilderImpl(
             declaration.type, classIntrospector, typeResolver);
     await macro.buildDeclarationsForClass(declaration, builder);
     return builder.result;
+  } else if (declaration is ClassMemberDeclaration) {
+    ClassMemberDeclarationBuilderImpl builder =
+        new ClassMemberDeclarationBuilderImpl(
+            declaration.definingClass, classIntrospector, typeResolver);
+    if (declaration is FunctionDeclaration) {
+      if (macro is ConstructorDeclarationsMacro &&
+          declaration is ConstructorDeclaration) {
+        await macro.buildDeclarationsForConstructor(declaration, builder);
+        return builder.result;
+      } else if (macro is MethodDeclarationsMacro &&
+          declaration is MethodDeclaration) {
+        await macro.buildDeclarationsForMethod(declaration, builder);
+        return builder.result;
+      } else if (macro is FunctionDeclarationsMacro) {
+        await macro.buildDeclarationsForFunction(
+            declaration as FunctionDeclaration, builder);
+        return builder.result;
+      }
+    } else if (declaration is VariableDeclaration) {
+      if (macro is FieldDeclarationsMacro && declaration is FieldDeclaration) {
+        await macro.buildDeclarationsForField(declaration, builder);
+        return builder.result;
+      } else if (macro is VariableDeclarationsMacro) {
+        DeclarationBuilderImpl builder =
+            new DeclarationBuilderImpl(classIntrospector, typeResolver);
+        await macro.buildDeclarationsForVariable(
+            declaration as VariableDeclaration, builder);
+        return builder.result;
+      }
+    }
+  } else {
+    DeclarationBuilderImpl builder =
+        new DeclarationBuilderImpl(classIntrospector, typeResolver);
+    if (declaration is FunctionDeclaration &&
+        macro is FunctionDeclarationsMacro) {
+      await macro.buildDeclarationsForFunction(declaration, builder);
+      return builder.result;
+    } else if (macro is VariableDeclarationsMacro &&
+        declaration is VariableDeclaration) {
+      await macro.buildDeclarationsForVariable(declaration, builder);
+      return builder.result;
+    }
   }
   throw new UnsupportedError('Unsupported macro type or invalid declaration:\n'
       'macro: $macro\ndeclaration: $declaration');
@@ -105,39 +112,27 @@
               typeResolver, typeDeclarationResolver);
       await macro.buildDefinitionForConstructor(declaration, builder);
       return builder.result;
-    } else if (macro is MethodDefinitionMacro &&
-        declaration is MethodDeclaration) {
-      MethodDefinitionBuilderImpl builder = new MethodDefinitionBuilderImpl(
-          declaration,
-          classIntrospector,
-          typeResolver,
-          typeDeclarationResolver);
-      await macro.buildDefinitionForMethod(declaration, builder);
-      return builder.result;
-    } else if (macro is FunctionDefinitionMacro) {
+    } else {
       FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
           declaration,
           classIntrospector,
           typeResolver,
           typeDeclarationResolver);
-      await macro.buildDefinitionForFunction(declaration, builder);
-      return builder.result;
+      if (macro is MethodDefinitionMacro && declaration is MethodDeclaration) {
+        await macro.buildDefinitionForMethod(declaration, builder);
+        return builder.result;
+      } else if (macro is FunctionDefinitionMacro) {
+        await macro.buildDefinitionForFunction(declaration, builder);
+        return builder.result;
+      }
     }
   } else if (declaration is VariableDeclaration) {
+    VariableDefinitionBuilderImpl builder = new VariableDefinitionBuilderImpl(
+        declaration, classIntrospector, typeResolver, typeDeclarationResolver);
     if (macro is FieldDefinitionMacro && declaration is FieldDeclaration) {
-      FieldDefinitionBuilderImpl builder = new FieldDefinitionBuilderImpl(
-          declaration,
-          classIntrospector,
-          typeResolver,
-          typeDeclarationResolver);
       await macro.buildDefinitionForField(declaration, builder);
       return builder.result;
     } else if (macro is VariableDefinitionMacro) {
-      VariableDefinitionBuilderImpl builder = new VariableDefinitionBuilderImpl(
-          declaration,
-          classIntrospector,
-          typeResolver,
-          typeDeclarationResolver);
       await macro.buildDefinitionForVariable(declaration, builder);
       return builder.result;
     }
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
index ce7d844..cdd1725 100644
--- a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/isolated_executor_test.dart
@@ -7,8 +7,6 @@
 
 import 'package:_fe_analyzer_shared/src/macros/bootstrap.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor.dart';
-import 'package:_fe_analyzer_shared/src/macros/executor_shared/introspection_impls.dart';
-import 'package:_fe_analyzer_shared/src/macros/executor_shared/remote_instance.dart';
 import 'package:_fe_analyzer_shared/src/macros/isolated_executor/isolated_executor.dart'
     as isolatedExecutor;
 
@@ -80,160 +78,65 @@
   });
 
   group('run macros', () {
-    var stringType = NamedTypeAnnotationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'String',
-        isNullable: false,
-        typeArguments: const []);
-
-    var myInterfaceType = NamedTypeAnnotationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'MyInterface',
-        isNullable: false,
-        typeArguments: const []);
-    var myMixinType = NamedTypeAnnotationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'MyMixin',
-        isNullable: false,
-        typeArguments: const []);
-    var mySuperclassType = NamedTypeAnnotationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'MySuperclass',
-        isNullable: false,
-        typeArguments: const []);
-    var myClassType = NamedTypeAnnotationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'MyClass',
-        isNullable: false,
-        typeArguments: const []);
-
-    var myClass = ClassDeclarationImpl(
-        id: RemoteInstance.uniqueId,
-        name: myClassType.name,
-        type: myClassType,
-        typeParameters: [],
-        interfaces: [myInterfaceType],
-        isAbstract: false,
-        isExternal: false,
-        mixins: [myMixinType],
-        superclass: mySuperclassType);
-    var myConstructor = ConstructorDeclarationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'myConstructor',
-        isAbstract: false,
-        isExternal: false,
-        isGetter: false,
-        isSetter: false,
-        namedParameters: [],
-        positionalParameters: [],
-        returnType: myClassType,
-        typeParameters: [],
-        definingClass: myClassType,
-        isFactory: false);
-    var myField = FieldDeclarationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'myField',
-        initializer: null,
-        isExternal: false,
-        isFinal: false,
-        isLate: false,
-        type: stringType,
-        definingClass: myClassType);
-    var myInterface = ClassDeclarationImpl(
-        id: RemoteInstance.uniqueId,
-        name: myInterfaceType.name,
-        type: myInterfaceType,
-        typeParameters: [],
-        interfaces: [],
-        isAbstract: false,
-        isExternal: false,
-        mixins: [],
-        superclass: null);
-    var myMethod = MethodDeclarationImpl(
-        id: RemoteInstance.uniqueId,
-        name: 'myMethod',
-        isAbstract: false,
-        isExternal: false,
-        isGetter: false,
-        isSetter: false,
-        namedParameters: [],
-        positionalParameters: [],
-        returnType: stringType,
-        typeParameters: [],
-        definingClass: myClassType);
-    var myMixin = ClassDeclarationImpl(
-        id: RemoteInstance.uniqueId,
-        name: myMixinType.name,
-        type: myMixinType,
-        typeParameters: [],
-        interfaces: [],
-        isAbstract: false,
-        isExternal: false,
-        mixins: [],
-        superclass: null);
-    var mySuperclass = ClassDeclarationImpl(
-        id: RemoteInstance.uniqueId,
-        name: mySuperclassType.name,
-        type: mySuperclassType,
-        typeParameters: [],
-        interfaces: [],
-        isAbstract: false,
-        isExternal: false,
-        mixins: [],
-        superclass: null);
-
-    var myClassStaticType = TestNamedStaticType(
-        'package:my_package/my_package.dart', myClassType.name, []);
-
-    var testTypeResolver = TestTypeResolver({
-      stringType: TestNamedStaticType('dart:core', stringType.name, []),
-      myClassType: myClassStaticType,
-    });
-    var testClassIntrospector = TestClassIntrospector(
-      constructors: {
-        myClass: [myConstructor],
-      },
-      fields: {
-        myClass: [myField],
-      },
-      interfaces: {
-        myClass: [myInterface],
-      },
-      methods: {
-        myClass: [myMethod],
-      },
-      mixins: {
-        myClass: [myMixin],
-      },
-      superclass: {
-        myClass: mySuperclass,
-      },
-    );
-    var testTypeDeclarationResolver =
-        TestTypeDeclarationResolver({myClassStaticType: myClass});
-
     group('in the types phase', () {
+      test('on functions', () async {
+        var result =
+            await executor.executeTypesPhase(instanceId, Fixtures.myFunction);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyFunction {}'));
+      });
+
       test('on methods', () async {
-        var result = await executor.executeTypesPhase(instanceId, myMethod);
+        var result =
+            await executor.executeTypesPhase(instanceId, Fixtures.myMethod);
         expect(result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace('class GeneratedByMyMethod {}'));
       });
 
+      test('on getters', () async {
+        var result = await executor.executeTypesPhase(
+          instanceId,
+          Fixtures.myVariableGetter,
+        );
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyVariableGetter {}'));
+      });
+
+      test('on setters', () async {
+        var result = await executor.executeTypesPhase(
+          instanceId,
+          Fixtures.myVariableSetter,
+        );
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedByMyVariableSetter {}'));
+      });
+
+      test('on variables', () async {
+        var result = await executor.executeTypesPhase(
+          instanceId,
+          Fixtures.myVariable,
+        );
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('class GeneratedBy_myVariable {}'));
+      });
+
       test('on constructors', () async {
-        var result =
-            await executor.executeTypesPhase(instanceId, myConstructor);
+        var result = await executor.executeTypesPhase(
+            instanceId, Fixtures.myConstructor);
         expect(result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace('class GeneratedByMyConstructor {}'));
       });
 
       test('on fields', () async {
-        var result = await executor.executeTypesPhase(instanceId, myField);
+        var result =
+            await executor.executeTypesPhase(instanceId, Fixtures.myField);
         expect(result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace('class GeneratedByMyField {}'));
       });
 
       test('on classes', () async {
-        var result = await executor.executeTypesPhase(instanceId, myClass);
+        var result =
+            await executor.executeTypesPhase(instanceId, Fixtures.myClass);
         expect(
             result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace(
@@ -242,9 +145,24 @@
     });
 
     group('in the declaration phase', () {
+      test('on functions', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId,
+            Fixtures.myFunction,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
+        expect(
+            result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace(
+                'String delegateMyFunction() => myFunction();'));
+      });
+
       test('on methods', () async {
         var result = await executor.executeDeclarationsPhase(
-            instanceId, myMethod, testTypeResolver, testClassIntrospector);
+            instanceId,
+            Fixtures.myMethod,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
         expect(
             result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace(
@@ -253,7 +171,10 @@
 
       test('on constructors', () async {
         var result = await executor.executeDeclarationsPhase(
-            instanceId, myConstructor, testTypeResolver, testClassIntrospector);
+            instanceId,
+            Fixtures.myConstructor,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
         expect(result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace('''
               augment class MyClass {
@@ -261,9 +182,45 @@
               }'''));
       });
 
+      test('on getters', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId,
+            Fixtures.myVariableGetter,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+                String get delegateMyVariable => myVariable;'''));
+      });
+
+      test('on setters', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId,
+            Fixtures.myVariableSetter,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+                void set delegateMyVariable(String value) => myVariable = value;'''));
+      });
+
+      test('on variables', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId,
+            Fixtures.myVariable,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+                String get delegate_myVariable => _myVariable;'''));
+      });
+
       test('on fields', () async {
         var result = await executor.executeDeclarationsPhase(
-            instanceId, myField, testTypeResolver, testClassIntrospector);
+            instanceId,
+            Fixtures.myField,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
         expect(result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace('''
               augment class MyClass {
@@ -273,7 +230,10 @@
 
       test('on classes', () async {
         var result = await executor.executeDeclarationsPhase(
-            instanceId, myClass, testTypeResolver, testClassIntrospector);
+            instanceId,
+            Fixtures.myClass,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector);
         expect(result.augmentations.single.debugString().toString(),
             equalsIgnoringWhitespace('''
               augment class MyClass {
@@ -283,13 +243,32 @@
     });
 
     group('in the definition phase', () {
+      test('on functions', () async {
+        var result = await executor.executeDefinitionsPhase(
+            instanceId,
+            Fixtures.myFunction,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+                augment String myFunction() {
+                  print('isAbstract: false');
+                  print('isExternal: false');
+                  print('isGetter: false');
+                  print('isSetter: false');
+                  print('returnType: String');
+                  return augment super();
+                }'''));
+      });
+
       test('on methods', () async {
         var definitionResult = await executor.executeDefinitionsPhase(
             instanceId,
-            myMethod,
-            testTypeResolver,
-            testClassIntrospector,
-            testTypeDeclarationResolver);
+            Fixtures.myMethod,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
         expect(definitionResult.augmentations, hasLength(2));
         var augmentationStrings = definitionResult.augmentations
             .map((a) => a.debugString().toString())
@@ -300,22 +279,89 @@
       test('on constructors', () async {
         var definitionResult = await executor.executeDefinitionsPhase(
             instanceId,
-            myConstructor,
-            testTypeResolver,
-            testClassIntrospector,
-            testTypeDeclarationResolver);
+            Fixtures.myConstructor,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
         expect(definitionResult.augmentations, hasLength(1));
         expect(definitionResult.augmentations.first.debugString().toString(),
             constructorDefinitionMatcher);
       });
 
+      test('on getters', () async {
+        var result = await executor.executeDefinitionsPhase(
+            instanceId,
+            Fixtures.myVariableGetter,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+                augment String myVariable() {
+                  print('isAbstract: false');
+                  print('isExternal: false');
+                  print('isGetter: true');
+                  print('isSetter: false');
+                  print('returnType: String');
+                  return augment super;
+                }'''));
+      });
+
+      test('on setters', () async {
+        var result = await executor.executeDefinitionsPhase(
+            instanceId,
+            Fixtures.myVariableSetter,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+                augment void myVariable(String value, ) {
+                  print('isAbstract: false');
+                  print('isExternal: false');
+                  print('isGetter: false');
+                  print('isSetter: true');
+                  print('returnType: void');
+                  print('positionalParam: String value');
+                  return augment super = value;
+                }'''));
+      });
+
+      test('on variables', () async {
+        var result = await executor.executeDefinitionsPhase(
+            instanceId,
+            Fixtures.myVariable,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
+        expect(
+            result.augmentations.map((a) => a.debugString().toString()),
+            unorderedEquals([
+              equalsIgnoringWhitespace('''
+                augment String get _myVariable {
+                  print('parentClass: ');
+                  print('isExternal: false');
+                  print('isFinal: true');
+                  print('isLate: false');
+                  return augment super;
+                }'''),
+              equalsIgnoringWhitespace('''
+                augment set _myVariable(String value) {
+                  augment super = value;
+                }'''),
+              equalsIgnoringWhitespace('''
+                augment final String _myVariable = '';
+                '''),
+            ]));
+      });
+
       test('on fields', () async {
         var definitionResult = await executor.executeDefinitionsPhase(
             instanceId,
-            myField,
-            testTypeResolver,
-            testClassIntrospector,
-            testTypeDeclarationResolver);
+            Fixtures.myField,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
         expect(definitionResult.augmentations, hasLength(1));
         expect(definitionResult.augmentations.first.debugString().toString(),
             fieldDefinitionMatcher);
@@ -324,10 +370,10 @@
       test('on classes', () async {
         var definitionResult = await executor.executeDefinitionsPhase(
             instanceId,
-            myClass,
-            testTypeResolver,
-            testClassIntrospector,
-            testTypeDeclarationResolver);
+            Fixtures.myClass,
+            Fixtures.testTypeResolver,
+            Fixtures.testClassIntrospector,
+            Fixtures.testTypeDeclarationResolver);
         var augmentationStrings = definitionResult.augmentations
             .map((a) => a.debugString().toString())
             .toList();
@@ -366,8 +412,8 @@
     print('isLate: false');
     return augment super;
   }
-  augment set (String value) {
-    augment super(value);
+  augment set myField(String value) {
+    augment super = value;
   }
 }''');
 
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart
index 222e1cd..40ad337 100644
--- a/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart
@@ -68,14 +68,31 @@
   @override
   FutureOr<void> buildDeclarationsForFunction(
       FunctionDeclaration function, DeclarationBuilder builder) {
-    if (function.positionalParameters.isNotEmpty ||
-        function.namedParameters.isNotEmpty) {
+    if (!function.isSetter &&
+        (function.positionalParameters.isNotEmpty ||
+            function.namedParameters.isNotEmpty)) {
       throw new UnsupportedError(
           'Can only run on functions with no parameters!');
     }
     builder.declareInLibrary(DeclarationCode.fromParts([
       function.returnType,
-      ' delegate${function.name.capitalize()}() => ${function.name}();',
+      if (function.isGetter) ' get' else if (function.isSetter) ' set ',
+      ' delegate${function.name.capitalize().trimEquals()}',
+      if (!function.isGetter) ...[
+        '(',
+        if (function.isSetter) ...[
+          function.positionalParameters.first.type,
+          ' value',
+        ],
+        ')',
+      ],
+      ' => ${function.name.trimEquals()}',
+      function.isGetter
+          ? ''
+          : function.isSetter
+              ? ' = value'
+              : '()',
+      ';',
     ]));
   }
 
@@ -237,8 +254,13 @@
           return augment super;
         }''',
       ]),
-      setter: DeclarationCode.fromParts(
-          ['set (', variable.type, ' value) { augment super(value); }']),
+      setter: DeclarationCode.fromParts([
+        'set ',
+        variable.name,
+        '(',
+        variable.type,
+        ' value) { augment super = value; }'
+      ]),
       initializer: variable.initializer,
     );
   }
@@ -296,8 +318,14 @@
   @override
   FutureOr<void> buildTypesForFunction(
       FunctionDeclaration function, TypeBuilder builder) {
+    var suffix = function.isGetter
+        ? 'Getter'
+        : function.isSetter
+            ? 'Setter'
+            : '';
     builder.declareType(DeclarationCode.fromString(
-        'class GeneratedBy${function.name.capitalize()} {}'));
+        'class GeneratedBy${function.name.capitalize().trimEquals()}'
+        '$suffix {}'));
   }
 
   @override
@@ -349,11 +377,17 @@
         if (param.bounds != null) param.bounds!,
         "');\n",
       ],
-      '''
-      return augment super();
+      'return augment super',
+      if (function.isSetter)
+        ' = ${function.positionalParameters.first.name}'
+      else if (!function.isGetter)
+        '()',
+      ''';
     }''',
     ]);
 
 extension _ on String {
-  String capitalize() => '${this[0].toUpperCase()}${this.substring(1)}';
+  String capitalize() => '${this[0].toUpperCase()}${substring(1)}';
+
+  String trimEquals() => endsWith('=') ? substring(0, length - 1) : this;
 }
diff --git a/pkg/_fe_analyzer_shared/test/macros/util.dart b/pkg/_fe_analyzer_shared/test/macros/util.dart
index ef73298..b4749fc 100644
--- a/pkg/_fe_analyzer_shared/test/macros/util.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/util.dart
@@ -6,6 +6,7 @@
 
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor_shared/introspection_impls.dart';
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/remote_instance.dart';
 
 import 'package:test/fake.dart';
 import 'package:test/test.dart';
@@ -214,3 +215,193 @@
     return true;
   }
 }
+
+class Fixtures {
+  static final stringType = NamedTypeAnnotationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'String',
+      isNullable: false,
+      typeArguments: const []);
+  static final voidType = NamedTypeAnnotationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'void',
+      isNullable: false,
+      typeArguments: const []);
+
+  // Top level, non-class declarations.
+  static final myFunction = FunctionDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'myFunction',
+      isAbstract: false,
+      isExternal: false,
+      isGetter: false,
+      isSetter: false,
+      namedParameters: [],
+      positionalParameters: [],
+      returnType: stringType,
+      typeParameters: []);
+  static final myVariable = VariableDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: '_myVariable',
+      initializer: ExpressionCode.fromString("''"),
+      isExternal: false,
+      isFinal: true,
+      isLate: false,
+      type: stringType);
+  static final myVariableGetter = FunctionDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'myVariable',
+      isAbstract: false,
+      isExternal: false,
+      isGetter: true,
+      isSetter: false,
+      namedParameters: [],
+      positionalParameters: [],
+      returnType: stringType,
+      typeParameters: []);
+  static final myVariableSetter = FunctionDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'myVariable=',
+      isAbstract: false,
+      isExternal: false,
+      isGetter: false,
+      isSetter: true,
+      namedParameters: [],
+      positionalParameters: [
+        ParameterDeclarationImpl(
+            id: RemoteInstance.uniqueId,
+            name: 'value',
+            defaultValue: null,
+            isNamed: false,
+            isRequired: true,
+            type: stringType)
+      ],
+      returnType: voidType,
+      typeParameters: []);
+
+  // Class and member declarations
+  static final myInterfaceType = NamedTypeAnnotationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'MyInterface',
+      isNullable: false,
+      typeArguments: const []);
+  static final myMixinType = NamedTypeAnnotationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'MyMixin',
+      isNullable: false,
+      typeArguments: const []);
+  static final mySuperclassType = NamedTypeAnnotationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'MySuperclass',
+      isNullable: false,
+      typeArguments: const []);
+  static final myClassType = NamedTypeAnnotationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'MyClass',
+      isNullable: false,
+      typeArguments: const []);
+  static final myClass = ClassDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: myClassType.name,
+      type: myClassType,
+      typeParameters: [],
+      interfaces: [myInterfaceType],
+      isAbstract: false,
+      isExternal: false,
+      mixins: [myMixinType],
+      superclass: mySuperclassType);
+  static final myConstructor = ConstructorDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'myConstructor',
+      isAbstract: false,
+      isExternal: false,
+      isGetter: false,
+      isSetter: false,
+      namedParameters: [],
+      positionalParameters: [],
+      returnType: myClassType,
+      typeParameters: [],
+      definingClass: myClassType,
+      isFactory: false);
+  static final myField = FieldDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'myField',
+      initializer: null,
+      isExternal: false,
+      isFinal: false,
+      isLate: false,
+      type: stringType,
+      definingClass: myClassType);
+  static final myInterface = ClassDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: myInterfaceType.name,
+      type: myInterfaceType,
+      typeParameters: [],
+      interfaces: [],
+      isAbstract: false,
+      isExternal: false,
+      mixins: [],
+      superclass: null);
+  static final myMethod = MethodDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: 'myMethod',
+      isAbstract: false,
+      isExternal: false,
+      isGetter: false,
+      isSetter: false,
+      namedParameters: [],
+      positionalParameters: [],
+      returnType: stringType,
+      typeParameters: [],
+      definingClass: myClassType);
+  static final myMixin = ClassDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: myMixinType.name,
+      type: myMixinType,
+      typeParameters: [],
+      interfaces: [],
+      isAbstract: false,
+      isExternal: false,
+      mixins: [],
+      superclass: null);
+  static final mySuperclass = ClassDeclarationImpl(
+      id: RemoteInstance.uniqueId,
+      name: mySuperclassType.name,
+      type: mySuperclassType,
+      typeParameters: [],
+      interfaces: [],
+      isAbstract: false,
+      isExternal: false,
+      mixins: [],
+      superclass: null);
+
+  static final myClassStaticType = TestNamedStaticType(
+      'package:my_package/my_package.dart', myClassType.name, []);
+
+  static final testTypeResolver = TestTypeResolver({
+    stringType: TestNamedStaticType('dart:core', stringType.name, []),
+    myClassType: myClassStaticType,
+  });
+  static final testClassIntrospector = TestClassIntrospector(
+    constructors: {
+      myClass: [myConstructor],
+    },
+    fields: {
+      myClass: [myField],
+    },
+    interfaces: {
+      myClass: [myInterface],
+    },
+    methods: {
+      myClass: [myMethod],
+    },
+    mixins: {
+      myClass: [myMixin],
+    },
+    superclass: {
+      myClass: mySuperclass,
+    },
+  );
+  static final testTypeDeclarationResolver =
+      TestTypeDeclarationResolver({myClassStaticType: myClass});
+}
diff --git a/tools/VERSION b/tools/VERSION
index 1cdff08..58a38b3 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 58
+PRERELEASE 59
 PRERELEASE_PATCH 0
\ No newline at end of file