diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart
index 2bfd7e8..868e62f 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart
@@ -87,11 +87,6 @@
   void declareInClass(DeclarationCode declaration);
 }
 
-/// The api used by [Macro]s to reflect on the currently available
-/// members, superclass, and mixins for a given [ClassDeclaration]
-abstract class ClassDeclarationBuilder
-    implements ClassMemberDeclarationBuilder, ClassIntrospector {}
-
 /// The interface used by [Macro]s to resolve any [NamedStaticType] to its
 /// declaration.
 ///
@@ -117,23 +112,25 @@
   /// Retrieve a [VariableDefinitionBuilder] for a field by [name].
   ///
   /// Throws an [ArgumentError] if there is no field by that name.
-  VariableDefinitionBuilder buildField(String name);
+  Future<VariableDefinitionBuilder> buildField(String name);
 
   /// Retrieve a [FunctionDefinitionBuilder] for a method by [name].
   ///
   /// Throws an [ArgumentError] if there is no method by that name.
-  FunctionDefinitionBuilder buildMethod(String name);
+  Future<FunctionDefinitionBuilder> buildMethod(String name);
 
   /// Retrieve a [ConstructorDefinitionBuilder] for a constructor by [name].
   ///
   /// Throws an [ArgumentError] if there is no constructor by that name.
-  ConstructorDefinitionBuilder buildConstructor(String name);
+  Future<ConstructorDefinitionBuilder> buildConstructor(String name);
 }
 
 /// The apis used by [Macro]s to define the body of a constructor
 /// or wrap the body of an existing constructor with additional statements.
 abstract class ConstructorDefinitionBuilder implements DefinitionBuilder {
-  /// Augments an existing constructor body with [body].
+  /// Augments an existing constructor body with [body] and [initializers].
+  ///
+  /// The [initializers] should not contain trailing or preceding commas.
   ///
   /// TODO: Link the library augmentations proposal to describe the semantics.
   void augment({FunctionBodyCode? body, List<Code>? initializers});
@@ -151,6 +148,9 @@
 abstract class VariableDefinitionBuilder implements DefinitionBuilder {
   /// Augments the field.
   ///
+  /// For [getter] and [setter] the full function declaration should be
+  /// provided, minus the `augment` keyword (which will be implicitly added).
+  ///
   /// TODO: Link the library augmentations proposal to describe the semantics.
   void augment({
     DeclarationCode? getter,
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 10ccafa..fae7630 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
@@ -69,6 +69,9 @@
 ///
 /// See subtypes [ClassDeclaration] and [TypeAliasDeclaration].
 abstract class TypeDeclaration implements Declaration {
+  // TODO: Change this to a [StaticType]? https://github.com/dart-lang/language/issues/2072
+  TypeAnnotation get type;
+
   /// The type parameters defined for this type declaration.
   Iterable<TypeParameterDeclaration> get typeParameters;
 
@@ -144,7 +147,7 @@
 /// Method introspection information.
 abstract class MethodDeclaration implements FunctionDeclaration {
   /// The class that defines this method.
-  TypeAnnotation get definingClass;
+  NamedTypeAnnotation get definingClass;
 }
 
 /// Constructor introspection information.
@@ -155,23 +158,27 @@
 
 /// Variable introspection information.
 abstract class VariableDeclaration implements Declaration {
-  /// Whether this function has an `abstract` modifier.
-  bool get isAbstract;
-
-  /// Whether this function has an `external` modifier.
+  /// Whether this field has an `external` modifier.
   bool get isExternal;
 
+  /// Whether this field has a `final` modifier.
+  bool get isFinal;
+
+  /// Whether this field has a `late` modifier.
+  bool get isLate;
+
   /// The type of this field.
   TypeAnnotation get type;
 
-  /// A [Code] object representing the initializer for this field, if present.
-  Code? get initializer;
+  /// A [ExpressionCode] object representing the initializer for this field, if
+  /// present.
+  ExpressionCode? get initializer;
 }
 
 /// Field introspection information ..
 abstract class FieldDeclaration implements VariableDeclaration {
   /// The class that defines this method.
-  TypeAnnotation get definingClass;
+  NamedTypeAnnotation get definingClass;
 }
 
 /// Parameter introspection information.
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/macros.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/macros.dart
index 7685589a..5ab073a 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/macros.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/macros.dart
@@ -50,7 +50,7 @@
 /// The interface for [Macro]s that can be applied to any top level variable
 /// or instance field, and wants to augment the variable definition.
 abstract class VariableDefinitionMacro implements Macro {
-  FutureOr<void> buildDefinitionForFunction(
+  FutureOr<void> buildDefinitionForVariable(
       VariableDeclaration variable, VariableDefinitionBuilder builder);
 }
 
@@ -65,7 +65,7 @@
 /// contribute new non-type declarations to the program.
 abstract class ClassDeclarationsMacro implements Macro {
   FutureOr<void> buildDeclarationsForClass(
-      ClassDeclaration clazz, ClassDeclarationBuilder builder);
+      ClassDeclaration clazz, ClassMemberDeclarationBuilder builder);
 }
 
 /// The interface for [Macro]s that can be applied to any class, and wants to
@@ -85,13 +85,13 @@
 /// The interface for [Macro]s that can be applied to any field, and wants to
 /// contribute new type declarations to the program.
 abstract class FieldDeclarationsMacro implements Macro {
-  FutureOr<void> buildTypesForField(
+  FutureOr<void> buildDeclarationsForField(
       FieldDeclaration field, ClassMemberDeclarationBuilder builder);
 }
 
 /// The interface for [Macro]s that can be applied to any field, and wants to
 /// augment the field definition.
-abstract class FieldDefinitionsMacro implements Macro {
+abstract class FieldDefinitionMacro implements Macro {
   FutureOr<void> buildDefinitionForField(
       FieldDeclaration field, VariableDefinitionBuilder builder);
 }
@@ -105,7 +105,7 @@
 
 /// The interface for [Macro]s that can be applied to any method, and wants to
 /// contribute new non-type declarations to the program.
-abstract class MethodDeclarationDeclarationsMacro implements Macro {
+abstract class MethodDeclarationsMacro implements Macro {
   FutureOr<void> buildDeclarationsForMethod(
       MethodDeclaration method, ClassMemberDeclarationBuilder builder);
 }
@@ -121,19 +121,20 @@
 /// to contribute new type declarations to the program.
 abstract class ConstructorTypesMacro implements Macro {
   FutureOr<void> buildTypesForConstructor(
-      ConstructorDeclaration method, TypeBuilder builder);
+      ConstructorDeclaration constructor, TypeBuilder builder);
 }
 
 /// The interface for [Macro]s that can be applied to any constructors, and
 /// wants to contribute new non-type declarations to the program.
-abstract class ConstructorDeclarationDeclarationsMacro implements Macro {
+abstract class ConstructorDeclarationsMacro implements Macro {
   FutureOr<void> buildDeclarationsForConstructor(
-      ConstructorDeclaration method, ClassMemberDeclarationBuilder builder);
+      ConstructorDeclaration constructor,
+      ClassMemberDeclarationBuilder builder);
 }
 
 /// The interface for [Macro]s that can be applied to any constructor, and wants
 /// to augment the function definition.
 abstract class ConstructorDefinitionMacro implements Macro {
   FutureOr<void> buildDefinitionForConstructor(
-      ConstructorDeclaration method, ConstructorDefinitionBuilder builder);
+      ConstructorDeclaration constructor, ConstructorDefinitionBuilder builder);
 }
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
index 4d2f6a1..1c50b6a 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
@@ -37,6 +37,7 @@
 import 'dart:async';
 import 'dart:isolate';
 
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/execute_macro.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/executor_shared/response_impls.dart';
@@ -70,6 +71,10 @@
           var request = new InstantiateMacroRequest.deserialize(deserializer, zoneId);
           (await _instantiateMacro(request)).serialize(serializer);
           break;
+        case MessageType.executeDeclarationsPhaseRequest:
+          var request = new ExecuteDeclarationsPhaseRequest.deserialize(deserializer, zoneId);
+          (await _executeDeclarationsPhase(request, sendRequest)).serialize(serializer);
+          break;
         case MessageType.executeDefinitionsPhaseRequest:
           var request = new ExecuteDefinitionsPhaseRequest.deserialize(deserializer, zoneId);
           (await _executeDefinitionsPhase(request, sendRequest)).serialize(serializer);
@@ -130,6 +135,41 @@
   }
 }
 
+Future<SerializableResponse> _executeDeclarationsPhase(
+    ExecuteDeclarationsPhaseRequest 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 classIntrospector = ClientClassIntrospector(
+        sendRequest,
+        remoteInstance: request.classIntrospector,
+        serializationZoneId: request.serializationZoneId);
+    var typeResolver = ClientTypeResolver(
+        sendRequest,
+        remoteInstance: request.typeResolver,
+        serializationZoneId: request.serializationZoneId);
+
+    var result = await executeDeclarationsMacro(
+        instance, request.declaration, classIntrospector, typeResolver);
+    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> _executeDefinitionsPhase(
     ExecuteDefinitionsPhaseRequest request,
     Future<Response> Function(Request request) sendRequest) async {
@@ -152,54 +192,14 @@
         remoteInstance: request.classIntrospector,
         serializationZoneId: request.serializationZoneId);
 
-    Declaration declaration = request.declaration;
-    if (instance is FunctionDefinitionMacro &&
-        declaration is FunctionDeclarationImpl) {
-      FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
-          declaration,
-          typeResolver,
-          typeDeclarationResolver,
-          classIntrospector);
-      await instance.buildDefinitionForFunction(declaration, builder);
-      return new SerializableResponse(
-          responseType: MessageType.macroExecutionResult,
-          response: builder.result,
-          requestId: request.id,
-          serializationZoneId: request.serializationZoneId);
-    } else if (instance is MethodDefinitionMacro
-        && declaration is MethodDeclarationImpl) {
-      FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
-          declaration,
-          typeResolver,
-          typeDeclarationResolver,
-          classIntrospector);
-      await instance.buildDefinitionForMethod(declaration, builder);
-      var result = builder.result;
-      // Wrap augmentations up as a part of the class
-      if (result.augmentations.isNotEmpty) {
-        result = MacroExecutionResultImpl(
-          augmentations: [
-            DeclarationCode.fromParts([
-              'augment class ',
-              declaration.definingClass,
-              ' {\\n',
-              ...result.augmentations,
-              '\\n}',
-            ]),
-          ],
-          imports: result.imports,
-        );
-      }
-      return new SerializableResponse(
-          responseType: MessageType.macroExecutionResult,
-          response: result,
-          requestId: request.id,
-          serializationZoneId: request.serializationZoneId);
-    } else {
-      throw new UnsupportedError(
-          'Unsupported macro type, only Method and Function Definition '
-          'Macros are supported currently');
-    }
+    var result = await executeDefinitionMacro(
+        instance, request.declaration, classIntrospector, typeResolver,
+        typeDeclarationResolver);
+    return new SerializableResponse(
+        responseType: MessageType.macroExecutionResult,
+        response: result,
+        requestId: request.id,
+        serializationZoneId: request.serializationZoneId);
   } catch (e, s) {
     return new SerializableResponse(
       responseType: MessageType.error,
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
new file mode 100644
index 0000000..59a6376
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/builder_impls.dart
@@ -0,0 +1,398 @@
+// Copyright (c) 2021, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+
+import '../executor.dart';
+import '../api.dart';
+import 'response_impls.dart';
+
+class TypeBuilderBase {
+  /// The final result, will be built up over `augment` calls.
+  final List<DeclarationCode> _augmentations;
+
+  /// Creates and returns a [MacroExecutionResult] out of the [_augmentations]
+  /// created by this builder.
+  MacroExecutionResult get result => new MacroExecutionResultImpl(
+        augmentations: _augmentations,
+        // TODO: Implement `imports`, or possibly drop it?
+        imports: [],
+      );
+
+  TypeBuilderBase({List<DeclarationCode>? parentAugmentations})
+      : _augmentations = parentAugmentations ?? [];
+}
+
+/// Base class for all [DeclarationBuilder]s.
+class DeclarationBuilderBase extends TypeBuilderBase
+    implements ClassIntrospector, TypeResolver {
+  final ClassIntrospector classIntrospector;
+  final TypeResolver typeResolver;
+
+  DeclarationBuilderBase(this.classIntrospector, this.typeResolver,
+      {List<DeclarationCode>? parentAugmentations})
+      : super(parentAugmentations: parentAugmentations);
+
+  @override
+  Future<List<ConstructorDeclaration>> constructorsOf(ClassDeclaration clazz) =>
+      classIntrospector.constructorsOf(clazz);
+
+  @override
+  Future<List<FieldDeclaration>> fieldsOf(ClassDeclaration clazz) =>
+      classIntrospector.fieldsOf(clazz);
+
+  @override
+  Future<List<ClassDeclaration>> interfacesOf(ClassDeclaration clazz) =>
+      classIntrospector.interfacesOf(clazz);
+
+  @override
+  Future<List<MethodDeclaration>> methodsOf(ClassDeclaration clazz) =>
+      classIntrospector.methodsOf(clazz);
+
+  @override
+  Future<List<ClassDeclaration>> mixinsOf(ClassDeclaration clazz) =>
+      classIntrospector.mixinsOf(clazz);
+
+  @override
+  Future<ClassDeclaration?> superclassOf(ClassDeclaration clazz) =>
+      classIntrospector.superclassOf(clazz);
+
+  @override
+  Future<StaticType> resolve(TypeAnnotation typeAnnotation) =>
+      typeResolver.resolve(typeAnnotation);
+}
+
+class DeclarationBuilderImpl extends DeclarationBuilderBase
+    implements DeclarationBuilder {
+  DeclarationBuilderImpl(
+      ClassIntrospector classIntrospector, TypeResolver typeResolver,
+      {List<DeclarationCode>? parentAugmentations})
+      : super(classIntrospector, typeResolver,
+            parentAugmentations: parentAugmentations);
+
+  @override
+  void declareInLibrary(DeclarationCode declaration) {
+    _augmentations.add(declaration);
+  }
+}
+
+class ClassMemberDeclarationBuilderImpl extends DeclarationBuilderImpl
+    implements ClassMemberDeclarationBuilder {
+  final TypeAnnotation definingClass;
+
+  ClassMemberDeclarationBuilderImpl(this.definingClass,
+      ClassIntrospector classIntrospector, TypeResolver typeResolver,
+      {List<DeclarationCode>? parentAugmentations})
+      : super(classIntrospector, typeResolver,
+            parentAugmentations: parentAugmentations);
+
+  @override
+  void declareInClass(DeclarationCode declaration) {
+    _augmentations.add(_buildClassAugmentation(definingClass, [declaration]));
+  }
+}
+
+/// Base class for all [DefinitionBuilder]s.
+class DefinitionBuilderBase extends DeclarationBuilderBase
+    implements TypeDeclarationResolver {
+  final TypeDeclarationResolver typeDeclarationResolver;
+
+  DefinitionBuilderBase(ClassIntrospector classIntrospector,
+      TypeResolver typeResolver, this.typeDeclarationResolver,
+      {List<DeclarationCode>? parentAugmentations})
+      : super(classIntrospector, typeResolver,
+            parentAugmentations: parentAugmentations);
+
+  @override
+  Future<TypeDeclaration> declarationOf(NamedStaticType annotation) =>
+      typeDeclarationResolver.declarationOf(annotation);
+}
+
+class ClassDefinitionBuilderImpl extends DefinitionBuilderBase
+    implements ClassDefinitionBuilder {
+  /// The declaration this is a builder for.
+  final ClassDeclaration declaration;
+
+  ClassDefinitionBuilderImpl(
+      this.declaration,
+      ClassIntrospector classIntrospector,
+      TypeResolver typeResolver,
+      TypeDeclarationResolver typeDeclarationResolver,
+      {List<DeclarationCode>? parentAugmentations})
+      : super(classIntrospector, typeResolver, typeDeclarationResolver,
+            parentAugmentations: parentAugmentations);
+
+  @override
+  Future<ConstructorDefinitionBuilder> buildConstructor(String name) async {
+    ConstructorDeclaration constructor =
+        (await classIntrospector.constructorsOf(declaration))
+            .firstWhere((constructor) => constructor.name == name);
+    return new ConstructorDefinitionBuilderImpl(
+        constructor, classIntrospector, typeResolver, typeDeclarationResolver,
+        parentAugmentations: _augmentations);
+  }
+
+  @override
+  Future<VariableDefinitionBuilder> buildField(String name) async {
+    FieldDeclaration field = (await classIntrospector.fieldsOf(declaration))
+        .firstWhere((field) => field.name == name);
+    return new FieldDefinitionBuilderImpl(
+        field, classIntrospector, typeResolver, typeDeclarationResolver,
+        parentAugmentations: _augmentations);
+  }
+
+  @override
+  Future<FunctionDefinitionBuilder> buildMethod(String name) async {
+    MethodDeclaration method = (await classIntrospector.methodsOf(declaration))
+        .firstWhere((method) => method.name == name);
+    return new MethodDefinitionBuilderImpl(
+        method, classIntrospector, typeResolver, typeDeclarationResolver,
+        parentAugmentations: _augmentations);
+  }
+}
+
+/// Implementation of [FunctionDefinitionBuilder].
+class FunctionDefinitionBuilderImpl extends DefinitionBuilderBase
+    implements FunctionDefinitionBuilder {
+  final FunctionDeclaration declaration;
+
+  FunctionDefinitionBuilderImpl(
+      this.declaration,
+      ClassIntrospector classIntrospector,
+      TypeResolver typeResolver,
+      TypeDeclarationResolver typeDeclarationResolver,
+      {List<DeclarationCode>? parentAugmentations})
+      : super(classIntrospector, typeResolver, typeDeclarationResolver,
+            parentAugmentations: parentAugmentations);
+
+  @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)],
+    ));
+  }
+}
+
+class ConstructorDefinitionBuilderImpl extends DefinitionBuilderBase
+    implements ConstructorDefinitionBuilder {
+  final ConstructorDeclaration declaration;
+
+  ConstructorDefinitionBuilderImpl(
+      this.declaration,
+      ClassIntrospector classIntrospector,
+      TypeResolver typeResolver,
+      TypeDeclarationResolver typeDeclarationResolver,
+      {List<DeclarationCode>? parentAugmentations})
+      : super(classIntrospector, typeResolver, typeDeclarationResolver,
+            parentAugmentations: parentAugmentations);
+
+  @override
+  void augment({FunctionBodyCode? body, List<Code>? initializers}) {
+    body ??= new FunctionBodyCode.fromString('''{
+      augment super();
+    }''');
+    _augmentations.add(_buildClassAugmentation(declaration.definingClass, [
+      _buildFunctionAugmentation(body, declaration, initializers: initializers)
+    ]));
+  }
+}
+
+class VariableDefinitionBuilderImpl extends DefinitionBuilderBase
+    implements VariableDefinitionBuilder {
+  final VariableDeclaration declaration;
+
+  VariableDefinitionBuilderImpl(
+      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.addAll(_buildVariableAugmentations(declaration,
+        getter: getter, setter: setter, initializer: initializer));
+  }
+}
+
+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)));
+  }
+}
+
+/// Creates an augmentation of [clazz] with member [augmentations].
+DeclarationCode _buildClassAugmentation(
+        TypeAnnotation clazz, List<DeclarationCode> augmentations) =>
+    new DeclarationCode.fromParts([
+      'augment class ',
+      clazz,
+      ' {\n',
+      ...augmentations.joinAsCode('\n'),
+      '\n}',
+    ]);
+
+/// Builds all the possible augmentations for a variable.
+List<DeclarationCode> _buildVariableAugmentations(
+    VariableDeclaration declaration,
+    {DeclarationCode? getter,
+    DeclarationCode? setter,
+    ExpressionCode? initializer}) {
+  List<DeclarationCode> augmentations = [];
+  if (getter != null) {
+    augmentations.add(new DeclarationCode.fromParts([
+      'augment ',
+      getter,
+    ]));
+  }
+  if (setter != null) {
+    augmentations.add(new DeclarationCode.fromParts([
+      'augment ',
+      setter,
+    ]));
+  }
+  if (initializer != null) {
+    augmentations.add(new DeclarationCode.fromParts([
+      'augment ',
+      if (declaration.isFinal) 'final ',
+      declaration.type,
+      ' ',
+      declaration.name,
+      ' = ',
+      initializer,
+      ';',
+    ]));
+  }
+
+  return augmentations;
+}
+
+/// Builds the code to augment a function, method, or constructor with a new
+/// body.
+///
+/// The [initializers] parameter can only be used if [declaration] is a
+/// constructor.
+DeclarationCode _buildFunctionAugmentation(
+    FunctionBodyCode body, FunctionDeclaration declaration,
+    {List<Code>? initializers}) {
+  assert(initializers == null || declaration is ConstructorDeclaration);
+
+  return new DeclarationCode.fromParts([
+    'augment ',
+    if (declaration is ConstructorDeclaration) ...[
+      declaration.definingClass.name,
+      if (declaration.name.isNotEmpty) '.',
+    ] else ...[
+      declaration.returnType.code,
+      ' ',
+    ],
+    declaration.name,
+    if (declaration.typeParameters.isNotEmpty) ...[
+      '<',
+      for (TypeParameterDeclaration typeParam
+          in declaration.typeParameters) ...[
+        typeParam.name,
+        if (typeParam.bounds != null) ...['extends ', typeParam.bounds!.code],
+        if (typeParam != declaration.typeParameters.last) ', ',
+      ],
+      '>',
+    ],
+    '(',
+    for (ParameterDeclaration positionalRequired
+        in declaration.positionalParameters.where((p) => p.isRequired)) ...[
+      new ParameterCode.fromParts([
+        positionalRequired.type.code,
+        ' ',
+        positionalRequired.name,
+      ]),
+      ', '
+    ],
+    if (declaration.positionalParameters.any((p) => !p.isRequired)) ...[
+      '[',
+      for (ParameterDeclaration positionalOptional
+          in declaration.positionalParameters.where((p) => !p.isRequired)) ...[
+        new ParameterCode.fromParts([
+          positionalOptional.type.code,
+          ' ',
+          positionalOptional.name,
+        ]),
+        ', ',
+      ],
+      ']',
+    ],
+    if (declaration.namedParameters.isNotEmpty) ...[
+      '{',
+      for (ParameterDeclaration named in declaration.namedParameters) ...[
+        new ParameterCode.fromParts([
+          if (named.isRequired) 'required ',
+          named.type.code,
+          ' ',
+          named.name,
+          if (named.defaultValue != null) ...[
+            ' = ',
+            named.defaultValue!,
+          ],
+        ]),
+        ', ',
+      ],
+      '}',
+    ],
+    ') ',
+    if (initializers != null && initializers.isNotEmpty) ...[
+      ' : ',
+      initializers.first,
+      for (Code initializer in initializers.skip(1)) ...[
+        ',\n',
+        initializer,
+      ],
+    ],
+    body,
+  ]);
+}
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
new file mode 100644
index 0000000..f94470d
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/execute_macro.dart
@@ -0,0 +1,120 @@
+// Copyright (c) 2022, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+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 declaration phase and returns a  [MacroExecutionResult].
+Future<MacroExecutionResult> executeDeclarationsMacro(
+    Macro macro,
+    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) {
+    ClassMemberDeclarationBuilderImpl builder =
+        new ClassMemberDeclarationBuilderImpl(
+            declaration.type, classIntrospector, typeResolver);
+    await macro.buildDeclarationsForClass(declaration, builder);
+    return builder.result;
+  }
+  throw new UnsupportedError('Unsupported macro type or invalid declaration:\n'
+      'macro: $macro\ndeclaration: $declaration');
+}
+
+/// Runs [macro] in the definition phase and returns a  [MacroExecutionResult].
+Future<MacroExecutionResult> executeDefinitionMacro(
+    Macro macro,
+    Declaration declaration,
+    ClassIntrospector classIntrospector,
+    TypeResolver typeResolver,
+    TypeDeclarationResolver typeDeclarationResolver) async {
+  if (declaration is FunctionDeclaration) {
+    if (macro is ConstructorDefinitionMacro &&
+        declaration is ConstructorDeclaration) {
+      ConstructorDefinitionBuilderImpl builder =
+          new ConstructorDefinitionBuilderImpl(declaration, classIntrospector,
+              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) {
+      FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
+          declaration,
+          classIntrospector,
+          typeResolver,
+          typeDeclarationResolver);
+      await macro.buildDefinitionForFunction(declaration, builder);
+      return builder.result;
+    }
+  } else if (declaration is VariableDeclaration) {
+    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;
+    }
+  } else if (macro is ClassDefinitionMacro && declaration is ClassDeclaration) {
+    ClassDefinitionBuilderImpl builder = new ClassDefinitionBuilderImpl(
+        declaration, classIntrospector, typeResolver, typeDeclarationResolver);
+    await macro.buildDefinitionForClass(declaration, builder);
+    return builder.result;
+  }
+  throw new UnsupportedError('Unsupported macro type or invalid declaration:\n'
+      'macro: $macro\ndeclaration: $declaration');
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/introspection_impls.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/introspection_impls.dart
index a3f6fb4..9bdd740 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/introspection_impls.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/introspection_impls.dart
@@ -334,7 +334,7 @@
 class MethodDeclarationImpl extends FunctionDeclarationImpl
     implements MethodDeclaration {
   @override
-  final TypeAnnotationImpl definingClass;
+  final NamedTypeAnnotationImpl definingClass;
 
   @override
   RemoteInstanceKind get kind => RemoteInstanceKind.methodDeclaration;
@@ -401,7 +401,7 @@
     required TypeAnnotationImpl returnType,
     required List<TypeParameterDeclarationImpl> typeParameters,
     // Method fields
-    required TypeAnnotationImpl definingClass,
+    required NamedTypeAnnotationImpl definingClass,
     // Constructor fields
     required this.isFactory,
   }) : super(
@@ -433,15 +433,18 @@
 class VariableDeclarationImpl extends DeclarationImpl
     implements VariableDeclaration {
   @override
-  final Code? initializer;
-
-  @override
-  final bool isAbstract;
+  final ExpressionCode? initializer;
 
   @override
   final bool isExternal;
 
   @override
+  final bool isFinal;
+
+  @override
+  final bool isLate;
+
+  @override
   final TypeAnnotationImpl type;
 
   @override
@@ -451,8 +454,9 @@
     required int id,
     required String name,
     required this.initializer,
-    required this.isAbstract,
     required this.isExternal,
+    required this.isFinal,
+    required this.isLate,
     required this.type,
   }) : super(id: id, name: name);
 
@@ -466,8 +470,9 @@
 
     initializer.serializeNullable(serializer);
     serializer
-      ..addBool(isAbstract)
-      ..addBool(isExternal);
+      ..addBool(isExternal)
+      ..addBool(isFinal)
+      ..addBool(isLate);
     type.serialize(serializer);
   }
 }
@@ -475,16 +480,17 @@
 class FieldDeclarationImpl extends VariableDeclarationImpl
     implements FieldDeclaration {
   @override
-  final TypeAnnotationImpl definingClass;
+  final NamedTypeAnnotationImpl definingClass;
 
   FieldDeclarationImpl({
     // Declaration fields
     required int id,
     required String name,
     // Variable fields
-    required Code? initializer,
-    required bool isAbstract,
+    required ExpressionCode? initializer,
     required bool isExternal,
+    required bool isFinal,
+    required bool isLate,
     required TypeAnnotationImpl type,
     // Field fields
     required this.definingClass,
@@ -492,8 +498,9 @@
             id: id,
             name: name,
             initializer: initializer,
-            isAbstract: isAbstract,
             isExternal: isExternal,
+            isFinal: isFinal,
+            isLate: isLate,
             type: type);
 
   @override
@@ -513,11 +520,15 @@
 abstract class TypeDeclarationImpl extends DeclarationImpl
     implements TypeDeclaration {
   @override
+  final TypeAnnotationImpl type;
+
+  @override
   final List<TypeParameterDeclarationImpl> typeParameters;
 
   TypeDeclarationImpl({
     required int id,
     required String name,
+    required this.type,
     required this.typeParameters,
   }) : super(id: id, name: name);
 
@@ -535,6 +546,7 @@
       return;
     }
 
+    type.serialize(serializer);
     serializer..startList();
     for (TypeParameterDeclarationImpl param in typeParameters) {
       param.serialize(serializer);
@@ -568,6 +580,7 @@
     required int id,
     required String name,
     // TypeDeclaration fields
+    required TypeAnnotationImpl type,
     required List<TypeParameterDeclarationImpl> typeParameters,
     // ClassDeclaration fields
     required this.interfaces,
@@ -575,7 +588,7 @@
     required this.isExternal,
     required this.mixins,
     required this.superclass,
-  }) : super(id: id, name: name, typeParameters: typeParameters);
+  }) : super(id: id, name: name, type: type, typeParameters: typeParameters);
 
   @override
   void serialize(Serializer serializer) {
@@ -604,21 +617,22 @@
 
 class TypeAliasDeclarationImpl extends TypeDeclarationImpl
     implements TypeAliasDeclaration {
-  @override
-  RemoteInstanceKind get kind => RemoteInstanceKind.typeAliasDeclaration;
+  /// The type being aliased.
+  final TypeAnnotationImpl aliasedType;
 
   @override
-  final TypeAnnotationImpl type;
+  RemoteInstanceKind get kind => RemoteInstanceKind.typeAliasDeclaration;
 
   TypeAliasDeclarationImpl({
     // Declaration fields
     required int id,
     required String name,
     // TypeDeclaration fields
+    required TypeAnnotationImpl type,
     required List<TypeParameterDeclarationImpl> typeParameters,
     // TypeAlias fields
-    required this.type,
-  }) : super(id: id, name: name, typeParameters: typeParameters);
+    required this.aliasedType,
+  }) : super(id: id, name: name, type: type, typeParameters: typeParameters);
 
   @override
   void serialize(Serializer serializer) {
@@ -628,6 +642,6 @@
       return;
     }
 
-    type.serialize(serializer);
+    aliasedType.serialize(serializer);
   }
 }
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
index f16daf9..3eae69c 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/protocol.dart
@@ -239,6 +239,41 @@
 
 /// A request to execute a macro on a particular declaration in the definition
 /// phase.
+class ExecuteDeclarationsPhaseRequest extends Request {
+  final MacroInstanceIdentifier macro;
+  final DeclarationImpl declaration;
+
+  final RemoteInstanceImpl typeResolver;
+  final RemoteInstanceImpl classIntrospector;
+
+  ExecuteDeclarationsPhaseRequest(
+      this.macro, this.declaration, this.typeResolver, this.classIntrospector,
+      {required int serializationZoneId})
+      : super(serializationZoneId: serializationZoneId);
+
+  /// When deserializing we have already consumed the message type, so we don't
+  /// consume it again.
+  ExecuteDeclarationsPhaseRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
+      : macro = new MacroInstanceIdentifierImpl.deserialize(deserializer),
+        declaration = RemoteInstance.deserialize(deserializer),
+        typeResolver = RemoteInstance.deserialize(deserializer),
+        classIntrospector = RemoteInstance.deserialize(deserializer),
+        super.deserialize(deserializer, serializationZoneId);
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.executeDeclarationsPhaseRequest.index);
+    macro.serialize(serializer);
+    declaration.serialize(serializer);
+    typeResolver.serialize(serializer);
+    classIntrospector.serialize(serializer);
+
+    super.serialize(serializer);
+  }
+}
+
+/// A request to execute a macro on a particular declaration in the definition
+/// phase.
 class ExecuteDefinitionsPhaseRequest extends Request {
   final MacroInstanceIdentifier macro;
   final DeclarationImpl declaration;
@@ -627,6 +662,7 @@
   mixinsOfRequest,
   superclassOfRequest,
   error,
+  executeDeclarationsPhaseRequest,
   executeDefinitionsPhaseRequest,
   instantiateMacroRequest,
   isExactlyTypeRequest,
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/response_impls.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/response_impls.dart
index 77556ad..f829357 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/response_impls.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/response_impls.dart
@@ -2,13 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-import 'dart:async';
-
-import 'package:_fe_analyzer_shared/src/macros/executor_shared/remote_instance.dart';
-
 import '../executor.dart';
 import '../api.dart';
-import 'introspection_impls.dart';
 import 'serialization.dart';
 import 'serialization_extensions.dart';
 
@@ -55,10 +50,9 @@
   final List<DeclarationCode> imports;
 
   MacroExecutionResultImpl({
-    List<DeclarationCode>? augmentations,
-    List<DeclarationCode>? imports,
-  })  : augmentations = augmentations ?? [],
-        imports = imports ?? [];
+    required this.augmentations,
+    required this.imports,
+  });
 
   factory MacroExecutionResultImpl.deserialize(Deserializer deserializer) {
     deserializer.moveNext();
@@ -97,128 +91,3 @@
     serializer.endList();
   }
 }
-
-/// Implementation of [FunctionDefinitionBuilder].
-class FunctionDefinitionBuilderImpl implements FunctionDefinitionBuilder {
-  final TypeResolver typeResolver;
-  final TypeDeclarationResolver typeDeclarationResolver;
-  final ClassIntrospector classIntrospector;
-
-  /// The declaration this is a builder for.
-  final FunctionDeclarationImpl declaration;
-
-  /// The final result, will be built up over `augment` calls.
-  final MacroExecutionResultImpl result;
-
-  FunctionDefinitionBuilderImpl(this.declaration, this.typeResolver,
-      this.typeDeclarationResolver, this.classIntrospector)
-      : result = new MacroExecutionResultImpl();
-
-  FunctionDefinitionBuilderImpl.deserialize(Deserializer deserializer,
-      this.typeResolver, this.typeDeclarationResolver, this.classIntrospector)
-      : declaration = RemoteInstance.deserialize(deserializer),
-        result = new MacroExecutionResultImpl.deserialize(deserializer);
-
-  void serialize(Serializer serializer) {
-    // Note that the `typeResolver`, `typeDeclarationResolver`, and
-    // `classIntrospector` are not serialized. These have custom implementations
-    // on the client/server side.
-    declaration.serialize(serializer);
-    result.serialize(serializer);
-  }
-
-  @override
-  void augment(FunctionBodyCode body) {
-    result.augmentations.add(new DeclarationCode.fromParts([
-      'augment ',
-      declaration.returnType.code,
-      ' ',
-      declaration.name,
-      if (declaration.typeParameters.isNotEmpty) ...[
-        '<',
-        for (TypeParameterDeclaration typeParam
-            in declaration.typeParameters) ...[
-          typeParam.name,
-          if (typeParam.bounds != null) ...['extends ', typeParam.bounds!.code],
-          if (typeParam != declaration.typeParameters.last) ', ',
-        ],
-        '>',
-      ],
-      '(',
-      for (ParameterDeclaration positionalRequired
-          in declaration.positionalParameters.where((p) => p.isRequired)) ...[
-        new ParameterCode.fromParts([
-          positionalRequired.type.code,
-          ' ',
-          positionalRequired.name,
-        ]),
-        ', '
-      ],
-      if (declaration.positionalParameters.any((p) => !p.isRequired)) ...[
-        '[',
-        for (ParameterDeclaration positionalOptional in declaration
-            .positionalParameters
-            .where((p) => !p.isRequired)) ...[
-          new ParameterCode.fromParts([
-            positionalOptional.type.code,
-            ' ',
-            positionalOptional.name,
-          ]),
-          ', ',
-        ],
-        ']',
-      ],
-      if (declaration.namedParameters.isNotEmpty) ...[
-        '{',
-        for (ParameterDeclaration named in declaration.namedParameters) ...[
-          new ParameterCode.fromParts([
-            if (named.isRequired) 'required ',
-            named.type.code,
-            ' ',
-            named.name,
-            if (named.defaultValue != null) ...[
-              ' = ',
-              named.defaultValue!,
-            ],
-          ]),
-          ', ',
-        ],
-        '}',
-      ],
-      ') ',
-      body,
-    ]));
-  }
-
-  @override
-  Future<List<ConstructorDeclaration>> constructorsOf(ClassDeclaration clazz) =>
-      classIntrospector.constructorsOf(clazz);
-
-  @override
-  Future<List<FieldDeclaration>> fieldsOf(ClassDeclaration clazz) =>
-      classIntrospector.fieldsOf(clazz);
-
-  @override
-  Future<List<ClassDeclaration>> interfacesOf(ClassDeclaration clazz) =>
-      classIntrospector.interfacesOf(clazz);
-
-  @override
-  Future<List<MethodDeclaration>> methodsOf(ClassDeclaration clazz) =>
-      classIntrospector.methodsOf(clazz);
-
-  @override
-  Future<List<ClassDeclaration>> mixinsOf(ClassDeclaration clazz) =>
-      classIntrospector.mixinsOf(clazz);
-
-  @override
-  Future<TypeDeclaration> declarationOf(NamedStaticType annotation) =>
-      typeDeclarationResolver.declarationOf(annotation);
-
-  @override
-  Future<ClassDeclaration?> superclassOf(ClassDeclaration clazz) =>
-      classIntrospector.superclassOf(clazz);
-
-  @override
-  Future<StaticType> resolve(TypeAnnotation typeAnnotation) =>
-      typeResolver.resolve(typeAnnotation);
-}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization_extensions.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization_extensions.dart
index b7df0be..33464d7 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization_extensions.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/serialization_extensions.dart
@@ -152,8 +152,9 @@
         id: id,
         name: expectString(),
         initializer: (this..moveNext()).expectNullableCode(),
-        isAbstract: (this..moveNext()).expectBool(),
         isExternal: (this..moveNext()).expectBool(),
+        isFinal: (this..moveNext()).expectBool(),
+        isLate: (this..moveNext()).expectBool(),
         type: RemoteInstance.deserialize(this),
       );
 
@@ -161,8 +162,9 @@
         id: id,
         name: expectString(),
         initializer: (this..moveNext()).expectNullableCode(),
-        isAbstract: (this..moveNext()).expectBool(),
         isExternal: (this..moveNext()).expectBool(),
+        isFinal: (this..moveNext()).expectBool(),
+        isLate: (this..moveNext()).expectBool(),
         type: RemoteInstance.deserialize(this),
         definingClass: RemoteInstance.deserialize(this),
       );
@@ -170,6 +172,7 @@
   ClassDeclaration _expectClassDeclaration(int id) => new ClassDeclarationImpl(
         id: id,
         name: expectString(),
+        type: RemoteInstance.deserialize(this),
         typeParameters: (this..moveNext())._expectRemoteInstanceList(),
         interfaces: (this..moveNext())._expectRemoteInstanceList(),
         isAbstract: (this..moveNext()).expectBool(),
@@ -183,8 +186,9 @@
       new TypeAliasDeclarationImpl(
         id: id,
         name: expectString(),
-        typeParameters: (this..moveNext())._expectRemoteInstanceList(),
         type: RemoteInstance.deserialize(this),
+        typeParameters: (this..moveNext())._expectRemoteInstanceList(),
+        aliasedType: RemoteInstance.deserialize(this),
       );
 
   T expectCode<T extends Code>() {
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart
index 91b1125..e1e12fe 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart
@@ -6,6 +6,7 @@
 import 'dart:isolate';
 import 'dart:mirrors';
 
+import '../executor_shared/builder_impls.dart';
 import '../executor_shared/introspection_impls.dart';
 import '../executor_shared/response_impls.dart';
 import '../executor_shared/protocol.dart';
@@ -97,9 +98,9 @@
         declaration is FunctionDeclarationImpl) {
       FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
           declaration,
+          request.classIntrospector.instance as ClassIntrospector,
           request.typeResolver.instance as TypeResolver,
-          request.typeDeclarationResolver.instance as TypeDeclarationResolver,
-          request.classIntrospector.instance as ClassIntrospector);
+          request.typeDeclarationResolver.instance as TypeDeclarationResolver);
       await instance.buildDefinitionForFunction(declaration, builder);
       return new Response(
           response: builder.result,
@@ -109,9 +110,9 @@
         declaration is MethodDeclarationImpl) {
       FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
           declaration,
+          request.classIntrospector.instance as ClassIntrospector,
           request.typeResolver.instance as TypeResolver,
-          request.typeDeclarationResolver.instance as TypeDeclarationResolver,
-          request.classIntrospector.instance as ClassIntrospector);
+          request.typeDeclarationResolver.instance as TypeDeclarationResolver);
       await instance.buildDefinitionForMethod(declaration, builder);
       return new SerializableResponse(
           responseType: MessageType.macroExecutionResult,
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
index 57f0ec8..9194c7f 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolated_executor/isolated_executor.dart
@@ -377,13 +377,22 @@
 
   @override
   Future<MacroExecutionResult> executeDeclarationsPhase(
-      MacroInstanceIdentifier macro,
-      DeclarationImpl declaration,
-      TypeResolver typeResolver,
-      ClassIntrospector classIntrospector) {
-    // TODO: implement executeDeclarationsPhase
-    throw new UnimplementedError();
-  }
+          MacroInstanceIdentifier macro,
+          DeclarationImpl declaration,
+          TypeResolver typeResolver,
+          ClassIntrospector classIntrospector) =>
+      _sendRequest((zoneId) => new ExecuteDeclarationsPhaseRequest(
+          macro,
+          declaration,
+          new RemoteInstanceImpl(
+              instance: typeResolver,
+              id: RemoteInstance.uniqueId,
+              kind: RemoteInstanceKind.typeResolver),
+          new RemoteInstanceImpl(
+              instance: classIntrospector,
+              id: RemoteInstance.uniqueId,
+              kind: RemoteInstanceKind.classIntrospector),
+          serializationZoneId: zoneId));
 
   @override
   Future<MacroExecutionResult> executeDefinitionsPhase(
diff --git a/pkg/_fe_analyzer_shared/test/macros/executor_shared/serialization_test.dart b/pkg/_fe_analyzer_shared/test/macros/executor_shared/serialization_test.dart
index 6a3807b..b9efa16 100644
--- a/pkg/_fe_analyzer_shared/test/macros/executor_shared/serialization_test.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/executor_shared/serialization_test.dart
@@ -207,9 +207,10 @@
         var bar = VariableDeclarationImpl(
           id: RemoteInstance.uniqueId,
           name: 'bar',
-          isAbstract: false,
           isExternal: true,
-          initializer: Code.fromString('Bar()'),
+          isFinal: false,
+          isLate: true,
+          initializer: ExpressionCode.fromString('Bar()'),
           type: barType,
         );
         expectSerializationEquality(bar);
@@ -219,8 +220,9 @@
         var bar = FieldDeclarationImpl(
           id: RemoteInstance.uniqueId,
           name: 'bar',
-          isAbstract: false,
           isExternal: false,
+          isFinal: true,
+          isLate: false,
           initializer: null,
           type: barType,
           definingClass: fooType,
@@ -250,6 +252,7 @@
           isExternal: false,
           mixins: [serializableType],
           superclass: objectType,
+          type: fooType,
           typeParameters: [zapTypeParam],
         );
         expectSerializationEquality(fooClass);
@@ -262,9 +265,14 @@
           type: NamedTypeAnnotationImpl(
               id: RemoteInstance.uniqueId,
               isNullable: false,
+              name: 'FooOfBar',
+              typeArguments: []),
+          typeParameters: [zapTypeParam],
+          aliasedType: NamedTypeAnnotationImpl(
+              id: RemoteInstance.uniqueId,
+              isNullable: false,
               name: 'Foo',
               typeArguments: [barType]),
-          typeParameters: [zapTypeParam],
         );
         expectSerializationEquality(typeAlias);
       });
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 7c242a4..81aa97f 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
@@ -18,31 +18,23 @@
 
 void main() {
   late MacroExecutor executor;
-  late Directory tmpDir;
+  late File kernelOutputFile;
+  final macroName = 'SimpleMacro';
+  late MacroInstanceIdentifier instanceId;
+  late Uri macroUri;
   late File simpleMacroFile;
+  late Directory tmpDir;
 
-  setUpAll(() {
+  setUpAll(() async {
     // We support running from either the root of the SDK or the package root.
     simpleMacroFile = File(
         'pkg/_fe_analyzer_shared/test/macros/isolated_executor/simple_macro.dart');
     if (!simpleMacroFile.existsSync()) {
       simpleMacroFile = File('test/macros/isolated_executor/simple_macro.dart');
     }
-  });
-
-  setUp(() async {
     executor = await isolatedExecutor.start();
     tmpDir = Directory.systemTemp.createTempSync('isolated_executor_test');
-  });
-
-  tearDown(() {
-    if (tmpDir.existsSync()) tmpDir.deleteSync(recursive: true);
-    executor.close();
-  });
-
-  test('can load and run macros', () async {
-    var macroUri = simpleMacroFile.absolute.uri;
-    var macroName = 'SimpleMacro';
+    macroUri = simpleMacroFile.absolute.uri;
 
     var bootstrapContent = bootstrapMacroIsolate({
       macroUri.toString(): {
@@ -51,22 +43,22 @@
     });
     var bootstrapFile = File(tmpDir.uri.resolve('main.dart').toFilePath())
       ..writeAsStringSync(bootstrapContent);
-    var kernelOutputFile =
-        File(tmpDir.uri.resolve('main.dart.dill').toFilePath());
-    var result = await Process.run(Platform.resolvedExecutable, [
+    kernelOutputFile = File(tmpDir.uri.resolve('main.dart.dill').toFilePath());
+    var buildSnapshotResult = await Process.run(Platform.resolvedExecutable, [
       '--snapshot=${kernelOutputFile.uri.toFilePath()}',
       '--snapshot-kind=kernel',
       '--packages=${(await Isolate.packageConfig)!}',
       bootstrapFile.uri.toFilePath(),
     ]);
-    expect(result.exitCode, 0,
-        reason: 'stdout: ${result.stdout}\nstderr: ${result.stderr}');
+    expect(buildSnapshotResult.exitCode, 0,
+        reason: 'stdout: ${buildSnapshotResult.stdout}\n'
+            'stderr: ${buildSnapshotResult.stderr}');
 
     var clazzId = await executor.loadMacro(macroUri, macroName,
         precompiledKernelUri: kernelOutputFile.uri);
     expect(clazzId, isNotNull, reason: 'Can load a macro.');
 
-    var instanceId =
+    instanceId =
         await executor.instantiateMacro(clazzId, '', Arguments([], {}));
     expect(instanceId, isNotNull,
         reason: 'Can create an instance with no arguments.');
@@ -80,7 +72,14 @@
         clazzId, 'named', Arguments([], {'x': 1, 'y': 2}));
     expect(instanceId, isNotNull,
         reason: 'Can create an instance with named arguments.');
+  });
 
+  tearDownAll(() {
+    if (tmpDir.existsSync()) tmpDir.deleteSync(recursive: true);
+    executor.close();
+  });
+
+  group('run macros', () {
     var stringType = NamedTypeAnnotationImpl(
         id: RemoteInstance.uniqueId,
         name: 'String',
@@ -111,6 +110,7 @@
     var myClass = ClassDeclarationImpl(
         id: RemoteInstance.uniqueId,
         name: myClassType.name,
+        type: myClassType,
         typeParameters: [],
         interfaces: [myInterfaceType],
         isAbstract: false,
@@ -134,13 +134,15 @@
         id: RemoteInstance.uniqueId,
         name: 'myField',
         initializer: null,
-        isAbstract: false,
         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,
@@ -162,6 +164,7 @@
     var myMixin = ClassDeclarationImpl(
         id: RemoteInstance.uniqueId,
         name: myMixinType.name,
+        type: myMixinType,
         typeParameters: [],
         interfaces: [],
         isAbstract: false,
@@ -171,6 +174,7 @@
     var mySuperclass = ClassDeclarationImpl(
         id: RemoteInstance.uniqueId,
         name: mySuperclassType.name,
+        type: mySuperclassType,
         typeParameters: [],
         interfaces: [],
         isAbstract: false,
@@ -181,61 +185,189 @@
     var myClassStaticType = TestNamedStaticType(
         'package:my_package/my_package.dart', myClassType.name, []);
 
-    var definitionResult = await executor.executeDefinitionsPhase(
-        instanceId,
-        MethodDeclarationImpl(
-          id: RemoteInstance.uniqueId,
-          definingClass: myClassType,
-          isAbstract: false,
-          isExternal: false,
-          isGetter: false,
-          isSetter: false,
-          name: 'foo',
-          namedParameters: [],
-          positionalParameters: [],
-          returnType: stringType,
-          typeParameters: [],
-        ),
-        TestTypeResolver({
-          stringType: TestNamedStaticType('dart:core', stringType.name, []),
-          myClassType: myClassStaticType,
-        }),
-        TestClassIntrospector(
-          constructors: {
-            myClass: [myConstructor],
-          },
-          fields: {
-            myClass: [myField],
-          },
-          interfaces: {
-            myClass: [myInterface],
-          },
-          methods: {
-            myClass: [myMethod],
-          },
-          mixins: {
-            myClass: [myMixin],
-          },
-          superclass: {
-            myClass: mySuperclass,
-          },
-        ),
-        TestTypeDeclarationResolver({myClassStaticType: myClass}));
-    expect(definitionResult.augmentations, hasLength(1));
-    expect(definitionResult.augmentations.first.debugString().toString(),
-        equalsIgnoringWhitespace('''
-          augment class MyClass {
-            augment String foo() {
-              print('x: 1, y: 2');
-              print('parentClass: MyClass');
-              print('superClass: MySuperclass');
-              print('interface: MyInterface');
-              print('mixin: MyMixin');
-              print('field: myField');
-              print('method: myMethod');
-              print('constructor: myConstructor');
-              return augment super();
-            }
-          }'''));
+    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 declaration phase', () {
+      test('on methods', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId, myMethod, testTypeResolver, testClassIntrospector);
+        expect(
+            result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace(
+                'String delegateMemberMyMethod() => myMethod();'));
+      });
+
+      test('on constructors', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId, myConstructor, testTypeResolver, testClassIntrospector);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+              augment class MyClass {
+                factory MyClass.myConstructorDelegate() => MyClass.myConstructor();
+              }'''));
+      });
+
+      test('on fields', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId, myField, testTypeResolver, testClassIntrospector);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+              augment class MyClass {
+                String get delegateMyField => myField;
+              }'''));
+      });
+
+      test('on classes', () async {
+        var result = await executor.executeDeclarationsPhase(
+            instanceId, myClass, testTypeResolver, testClassIntrospector);
+        expect(result.augmentations.single.debugString().toString(),
+            equalsIgnoringWhitespace('''
+              augment class MyClass {
+                static const List<String> fieldNames = ['myField',];
+              }'''));
+      });
+    });
+
+    group('in the definition phase', () {
+      test('on methods', () async {
+        var definitionResult = await executor.executeDefinitionsPhase(
+            instanceId,
+            myMethod,
+            testTypeResolver,
+            testClassIntrospector,
+            testTypeDeclarationResolver);
+        expect(definitionResult.augmentations, hasLength(2));
+        var augmentationStrings = definitionResult.augmentations
+            .map((a) => a.debugString().toString())
+            .toList();
+        expect(augmentationStrings, unorderedEquals(methodDefinitionMatchers));
+      });
+
+      test('on constructors', () async {
+        var definitionResult = await executor.executeDefinitionsPhase(
+            instanceId,
+            myConstructor,
+            testTypeResolver,
+            testClassIntrospector,
+            testTypeDeclarationResolver);
+        expect(definitionResult.augmentations, hasLength(1));
+        expect(definitionResult.augmentations.first.debugString().toString(),
+            constructorDefinitionMatcher);
+      });
+
+      test('on fields', () async {
+        var definitionResult = await executor.executeDefinitionsPhase(
+            instanceId,
+            myField,
+            testTypeResolver,
+            testClassIntrospector,
+            testTypeDeclarationResolver);
+        expect(definitionResult.augmentations, hasLength(1));
+        expect(definitionResult.augmentations.first.debugString().toString(),
+            fieldDefinitionMatcher);
+      });
+
+      test('on classes', () async {
+        var definitionResult = await executor.executeDefinitionsPhase(
+            instanceId,
+            myClass,
+            testTypeResolver,
+            testClassIntrospector,
+            testTypeDeclarationResolver);
+        var augmentationStrings = definitionResult.augmentations
+            .map((a) => a.debugString().toString())
+            .toList();
+        expect(
+            augmentationStrings,
+            unorderedEquals([
+              ...methodDefinitionMatchers,
+              constructorDefinitionMatcher,
+              fieldDefinitionMatcher
+            ]));
+      });
+    });
   });
 }
+
+final constructorDefinitionMatcher = equalsIgnoringWhitespace('''
+augment class MyClass {
+  augment MyClass.myConstructor() {
+    print('definingClass: MyClass');
+    print('isFactory: false');
+    print('isAbstract: false');
+    print('isExternal: false');
+    print('isGetter: false');
+    print('isSetter: false');
+    print('returnType: MyClass');
+    return augment super();
+  }
+}''');
+
+final fieldDefinitionMatcher = equalsIgnoringWhitespace('''
+augment class MyClass {
+  augment String get myField {
+    print('parentClass: MyClass');
+    print('isExternal: false');
+    print('isFinal: false');
+    print('isLate: false');
+    return augment super;
+  }
+  augment set (String value) {
+    augment super(value);
+  }
+}''');
+
+final methodDefinitionMatchers = [
+  equalsIgnoringWhitespace('''
+    augment class MyClass {
+      augment String myMethod() {
+        print('definingClass: MyClass');
+        print('isAbstract: false');
+        print('isExternal: false');
+        print('isGetter: false');
+        print('isSetter: false');
+        print('returnType: String');
+        return augment super();
+      }
+    }
+    '''),
+  equalsIgnoringWhitespace('''
+    augment class MyClass {
+      augment String myMethod() {
+        print('x: 1, y: 2');
+        print('parentClass: MyClass');
+        print('superClass: MySuperclass');
+        print('interface: MyInterface');
+        print('mixin: MyMixin');
+        print('field: myField');
+        print('method: myMethod');
+        print('constructor: myConstructor');
+        return augment super();
+      }
+    }'''),
+];
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 84ddb7a..b5681aa 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
@@ -6,9 +6,26 @@
 
 import 'package:_fe_analyzer_shared/src/macros/api.dart';
 
-/// A very simple macro that annotates functions (or getters) with no arguments
-/// and adds a print statement to the top of them.
-class SimpleMacro implements MethodDefinitionMacro {
+/// A very simple macro that augments any declaration it is given, usually
+/// adding print statements and inlining values from the declaration object
+/// for comparision with expected values in tests.
+///
+/// When applied to [MethodDeclaration]s there is some extra work that happens
+/// to validate the introspection APIs work as expected.
+class SimpleMacro
+    implements
+        ClassDeclarationsMacro,
+        ClassDefinitionMacro,
+        ConstructorDeclarationsMacro,
+        ConstructorDefinitionMacro,
+        FieldDeclarationsMacro,
+        FieldDefinitionMacro,
+        FunctionDeclarationsMacro,
+        FunctionDefinitionMacro,
+        MethodDeclarationsMacro,
+        MethodDefinitionMacro,
+        VariableDeclarationsMacro,
+        VariableDefinitionMacro {
   final int? x;
   final int? y;
 
@@ -17,14 +34,132 @@
   SimpleMacro.named({this.x, this.y});
 
   @override
-  FutureOr<void> buildDefinitionForMethod(
-      MethodDeclaration method, FunctionDefinitionBuilder builder) async {
-    if (method.namedParameters
-        .followedBy(method.positionalParameters)
-        .isNotEmpty) {
-      throw ArgumentError(
-          'This macro can only be run on functions with no arguments!');
+  FutureOr<void> buildDeclarationsForClass(
+      ClassDeclaration clazz, ClassMemberDeclarationBuilder builder) async {
+    var fields = await builder.fieldsOf(clazz);
+    builder.declareInClass(DeclarationCode.fromParts([
+      'static const List<String> fieldNames = [',
+      for (var field in fields) "'${field.name}',",
+      '];',
+    ]));
+  }
+
+  @override
+  FutureOr<void> buildDeclarationsForConstructor(
+      ConstructorDeclaration constructor,
+      ClassMemberDeclarationBuilder builder) {
+    if (constructor.positionalParameters.isNotEmpty ||
+        constructor.namedParameters.isNotEmpty) {
+      throw new UnsupportedError(
+          'Can only run on constructors with no parameters!');
     }
+    builder.declareInClass(
+        DeclarationCode.fromString('factory ${constructor.definingClass.name}'
+            '.${constructor.name}Delegate() => '
+            '${constructor.definingClass.name}.${constructor.name}();'));
+  }
+
+  @override
+  FutureOr<void> buildDeclarationsForFunction(
+      FunctionDeclaration function, DeclarationBuilder builder) {
+    if (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}();',
+    ]));
+  }
+
+  @override
+  FutureOr<void> buildDeclarationsForMethod(
+      MethodDeclaration method, ClassMemberDeclarationBuilder builder) {
+    if (method.positionalParameters.isNotEmpty ||
+        method.namedParameters.isNotEmpty) {
+      throw new UnsupportedError('Can only run on method with no parameters!');
+    }
+    builder.declareInLibrary(DeclarationCode.fromParts([
+      method.returnType,
+      ' delegateMember${method.name.capitalize()}() => ${method.name}();',
+    ]));
+  }
+
+  @override
+  FutureOr<void> buildDeclarationsForVariable(
+      VariableDeclaration variable, DeclarationBuilder builder) {
+    builder.declareInLibrary(DeclarationCode.fromParts([
+      variable.type,
+      ' get delegate${variable.name.capitalize()} => ${variable.name};',
+    ]));
+  }
+
+  @override
+  FutureOr<void> buildDeclarationsForField(
+      FieldDeclaration field, ClassMemberDeclarationBuilder builder) {
+    builder.declareInClass(DeclarationCode.fromParts([
+      field.type,
+      ' get delegate${field.name.capitalize()} => ${field.name};',
+    ]));
+  }
+
+  @override
+  Future<void> buildDefinitionForClass(
+      ClassDeclaration clazz, ClassDefinitionBuilder builder) async {
+    // Apply ourself to all our members
+    var fields = (await builder.fieldsOf(clazz));
+    for (var field in fields) {
+      await buildDefinitionForField(
+          field, await builder.buildField(field.name));
+    }
+    var methods = (await builder.methodsOf(clazz));
+    for (var method in methods) {
+      await buildDefinitionForMethod(
+          method, await builder.buildMethod(method.name));
+    }
+    var constructors = (await builder.constructorsOf(clazz));
+    for (var constructor in constructors) {
+      await buildDefinitionForConstructor(
+          constructor, await builder.buildConstructor(constructor.name));
+    }
+  }
+
+  @override
+  Future<void> buildDefinitionForConstructor(ConstructorDeclaration constructor,
+      ConstructorDefinitionBuilder builder) async {
+    var clazz = await builder.declarationOf(
+            await builder.resolve(constructor.definingClass) as NamedStaticType)
+        as ClassDeclaration;
+    var fields = (await builder.fieldsOf(clazz));
+
+    builder.augment(
+      body: _buildFunctionAugmentation(constructor),
+      initializers: [
+        for (var field in fields)
+          // TODO: Compare against actual `int` type.
+          if (field.isFinal &&
+              (field.type as NamedTypeAnnotation).name == 'int')
+            Code.fromString('${field.name} = ${x!}'),
+      ],
+    );
+  }
+
+  @override
+  Future<void> buildDefinitionForField(
+          FieldDeclaration field, VariableDefinitionBuilder builder) async =>
+      buildDefinitionForVariable(field, builder);
+
+  @override
+  Future<void> buildDefinitionForFunction(
+      FunctionDeclaration function, FunctionDefinitionBuilder builder) async {
+    builder.augment(_buildFunctionAugmentation(function));
+  }
+
+  @override
+  Future<void> buildDefinitionForMethod(
+      MethodDeclaration method, FunctionDefinitionBuilder builder) async {
+    await buildDefinitionForFunction(method, builder);
 
     // Test the type resolver and static type interfaces
     var staticReturnType = await builder.resolve(method.returnType);
@@ -48,6 +183,9 @@
     // Test the type declaration resolver
     var parentClass =
         await builder.declarationOf(classType) as ClassDeclaration;
+    // Should be able to find ourself in the methods of the parent class.
+    (await builder.methodsOf(parentClass))
+        .singleWhere((m) => m.name == method.name);
 
     // Test the class introspector
     var superClass = (await builder.superclassOf(parentClass))!;
@@ -74,4 +212,71 @@
     }''',
     ]));
   }
+
+  @override
+  Future<void> buildDefinitionForVariable(
+      VariableDeclaration variable, VariableDefinitionBuilder builder) async {
+    var definingClass =
+        variable is FieldDeclaration ? variable.definingClass.name : '';
+    builder.augment(
+      getter: DeclarationCode.fromParts([
+        variable.type,
+        ' get ',
+        variable.name,
+        ''' {
+          print('parentClass: $definingClass');
+          print('isExternal: ${variable.isExternal}');
+          print('isFinal: ${variable.isFinal}');
+          print('isLate: ${variable.isLate}');
+          return augment super;
+        }''',
+      ]),
+      setter: DeclarationCode.fromParts(
+          ['set (', variable.type, ' value) { augment super(value); }']),
+      initializer: variable.initializer,
+    );
+  }
+}
+
+FunctionBodyCode _buildFunctionAugmentation(FunctionDeclaration function) =>
+    FunctionBodyCode.fromParts([
+      '{\n',
+      if (function is MethodDeclaration)
+        "print('definingClass: ${function.definingClass.name}');\n",
+      if (function is ConstructorDeclaration)
+        "print('isFactory: ${function.isFactory}');\n",
+      '''
+      print('isAbstract: ${function.isAbstract}');
+      print('isExternal: ${function.isExternal}');
+      print('isGetter: ${function.isGetter}');
+      print('isSetter: ${function.isSetter}');
+      print('returnType: ''',
+      function.returnType,
+      "');\n",
+      for (var param in function.positionalParameters) ...[
+        "print('positionalParam: ",
+        param.type,
+        ' ${param.name}',
+        if (param.defaultValue != null) ...[' = ', param.defaultValue!],
+        "');\n",
+      ],
+      for (var param in function.namedParameters) ...[
+        "print('namedParam: ",
+        param.type,
+        ' ${param.name}',
+        if (param.defaultValue != null) ...[' = ', param.defaultValue!],
+        "');\n",
+      ],
+      for (var param in function.typeParameters) ...[
+        "print('typeParam: ${param.name} ",
+        if (param.bounds != null) param.bounds!,
+        "');\n",
+      ],
+      '''
+      return augment super();
+    }''',
+    ]);
+
+extension _ on String {
+  String capitalize() => '${this[0].toUpperCase()}${this.substring(1)}';
 }