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 74bf73c..9a507f4 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart
@@ -30,7 +30,7 @@
   /// may be asked to run in this state during the development cycle. It is
   /// helpful for users if macros provide a best effort implementation in that
   /// case or handle the error in a useful way.
-  Future<StaticType> resolve(TypeAnnotation typeAnnotation);
+  Future<StaticType> resolve(covariant TypeAnnotation typeAnnotation);
 }
 
 /// The api used to introspect on a [ClassDeclaration].
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 09c2de9..c0f8a9f 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
@@ -49,10 +49,10 @@
 /// compared to other static types.
 abstract class StaticType {
   /// Returns true if this is a subtype of [other].
-  Future<bool> isSubtypeOf(StaticType other);
+  Future<bool> isSubtypeOf(covariant StaticType other);
 
   /// Returns true if this is an identical type to [other].
-  Future<bool> isExactly(StaticType other);
+  Future<bool> isExactly(covariant StaticType other);
 }
 
 /// A subtype of [StaticType] representing types that can be resolved by name
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
index 332144f..158363f 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/bootstrap.dart
@@ -27,6 +27,7 @@
 import 'dart:isolate';
 
 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';
 import 'package:_fe_analyzer_shared/src/macros/executor_shared/serialization.dart';
 import 'package:_fe_analyzer_shared/src/macros/executor_shared/protocol.dart';
@@ -39,27 +40,33 @@
 ///
 /// Supports the client side of the macro expansion protocol.
 void main(_, SendPort sendPort) {
+  /// Local function that sends requests and returns responses using [sendPort].
+  Future<Response> sendRequest(Request request) => _sendRequest(request, sendPort);
+
   withSerializationMode(SerializationMode.client, () {
     ReceivePort receivePort = new ReceivePort();
     sendPort.send(receivePort.sendPort);
+
     receivePort.listen((message) async {
       var deserializer = JsonDeserializer(message as Iterable<Object?>)
           ..moveNext();
+      int zoneId = deserializer.expectNum();
+      deserializer..moveNext();
       var type = MessageType.values[deserializer.expectNum()];
       var serializer = JsonSerializer();
       switch (type) {
         case MessageType.instantiateMacroRequest:
-          var request = InstantiateMacroRequest.deserialize(deserializer);
+          var request = new InstantiateMacroRequest.deserialize(deserializer, zoneId);
           (await _instantiateMacro(request)).serialize(serializer);
           break;
         case MessageType.executeDefinitionsPhaseRequest:
-          var request = ExecuteDefinitionsPhaseRequest.deserialize(
-              deserializer,
-              ClientTypeResolver(),
-              ClientClassIntrospector(),
-              ClientTypeDeclarationsResolver());
-          (await _executeDefinitionsPhase(request)).serialize(serializer);
+          var request = new ExecuteDefinitionsPhaseRequest.deserialize(deserializer, zoneId);
+          (await _executeDefinitionsPhase(request, sendRequest)).serialize(serializer);
           break;
+        case MessageType.response:
+          var response = new SerializableResponse.deserialize(deserializer, zoneId);
+          _responseCompleters.remove(response.requestId)!.complete(response);
+          return;
         default:
           throw new StateError('Unhandled event type \$type');
       }
@@ -102,31 +109,46 @@
         response: identifier,
         requestId: request.id,
         serializationZoneId: request.serializationZoneId);
-  } catch (e) {
+  } 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) async {
+    ExecuteDefinitionsPhaseRequest 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 typeResolver = ClientTypeResolver(
+        sendRequest,
+        remoteInstance: request.typeResolver,
+        serializationZoneId: request.serializationZoneId);
+    var typeDeclarationResolver = ClientTypeDeclarationResolver(
+        sendRequest,
+        remoteInstance: request.typeDeclarationResolver,
+        serializationZoneId: request.serializationZoneId);
+    var classIntrospector = ClientClassIntrospector(
+        sendRequest,
+        remoteInstance: request.classIntrospector,
+        serializationZoneId: request.serializationZoneId);
+
     Declaration declaration = request.declaration;
     if (instance is FunctionDefinitionMacro &&
         declaration is FunctionDeclarationImpl) {
       FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
           declaration,
-          request.typeResolver,
-          request.typeDeclarationResolver,
-          request.classIntrospector);
+          typeResolver,
+          typeDeclarationResolver,
+          classIntrospector);
       await instance.buildDefinitionForFunction(declaration, builder);
       return new SerializableResponse(
           responseType: MessageType.macroExecutionResult,
@@ -137,12 +159,28 @@
       throw new UnsupportedError(
           ('Only FunctionDefinitionMacros are supported currently'));
     }
-  } catch (e) {
+  } catch (e, s) {
     return new SerializableResponse(
       responseType: MessageType.error,
       error: e.toString(),
+      stackTrace: s.toString(),
       requestId: request.id,
       serializationZoneId: request.serializationZoneId);
   }
 }
+
+/// Holds on to response completers by request id.
+final _responseCompleters = <int, Completer<Response>>{};
+
+/// Serializes [request], sends it to [sendPort], and sets up a [Completer] in
+/// [_responseCompleters] to handle the response.
+Future<Response> _sendRequest(Request request, SendPort sendPort) {
+  Completer<Response> completer = Completer();
+  _responseCompleters[request.id] = completer;
+  JsonSerializer serializer = JsonSerializer();
+  serializer.addNum(request.serializationZoneId);
+  request.serialize(serializer);
+  sendPort.send(serializer.result);
+  return completer.future;
+}
 ''';
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 68d0f94..3f9e55c 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
@@ -6,6 +6,8 @@
 /// the isolate or process doing the work of macro loading and execution.
 library _fe_analyzer_shared.src.macros.executor_shared.protocol;
 
+import 'package:meta/meta.dart';
+
 import '../executor.dart';
 import '../api.dart';
 import '../executor_shared/response_impls.dart';
@@ -22,13 +24,16 @@
   Request({int? id, required this.serializationZoneId})
       : this.id = id ?? _next++;
 
-  Request.deserialize(Deserializer deserializer)
-      : serializationZoneId = (deserializer..moveNext()).expectNum(),
-        id = (deserializer..moveNext()).expectNum();
+  /// The [serializationZoneId] is a part of the header and needs to be parsed
+  /// before deserializing objects, and then passed in here.
+  Request.deserialize(Deserializer deserializer, this.serializationZoneId)
+      : id = (deserializer..moveNext()).expectNum();
 
-  void serialize(Serializer serializer) => serializer
-    ..addNum(serializationZoneId)
-    ..addNum(id);
+  /// The [serializationZoneId] needs to be separately serialized before the
+  /// rest of the object. This is not done by the instances themselves but by
+  /// the macro implementations.
+  @mustCallSuper
+  void serialize(Serializer serializer) => serializer.addNum(id);
 
   static int _next = 0;
 }
@@ -38,10 +43,15 @@
 class Response {
   final Object? response;
   final Object? error;
+  final String? stackTrace;
   final int requestId;
 
-  Response({this.response, this.error, required this.requestId})
-      : assert(response != null || error != null),
+  Response({
+    this.response,
+    this.error,
+    this.stackTrace,
+    required this.requestId,
+  })  : assert(response != null || error != null),
         assert(response == null || error == null);
 }
 
@@ -50,11 +60,13 @@
   final Serializable? response;
   final MessageType responseType;
   final String? error;
+  final String? stackTrace;
   final int requestId;
   final int serializationZoneId;
 
   SerializableResponse({
     this.error,
+    this.stackTrace,
     required this.requestId,
     this.response,
     required this.responseType,
@@ -70,10 +82,13 @@
     MessageType responseType = MessageType.values[deserializer.expectNum()];
     Serializable? response;
     String? error;
+    String? stackTrace;
     switch (responseType) {
       case MessageType.error:
         deserializer.moveNext();
         error = deserializer.expectString();
+        deserializer.moveNext();
+        stackTrace = deserializer.expectNullableString();
         break;
       case MessageType.macroClassIdentifier:
         response = new MacroClassIdentifierImpl.deserialize(deserializer);
@@ -84,6 +99,12 @@
       case MessageType.macroExecutionResult:
         response = new MacroExecutionResultImpl.deserialize(deserializer);
         break;
+      case MessageType.staticType:
+        response = RemoteInstance.deserialize(deserializer);
+        break;
+      case MessageType.boolean:
+        response = new BooleanValue.deserialize(deserializer);
+        break;
       default:
         throw new StateError('Unexpected response type $responseType');
     }
@@ -92,6 +113,7 @@
         responseType: responseType,
         response: response,
         error: error,
+        stackTrace: stackTrace,
         requestId: (deserializer..moveNext()).expectNum(),
         serializationZoneId: serializationZoneId);
   }
@@ -99,16 +121,30 @@
   void serialize(Serializer serializer) {
     serializer
       ..addNum(serializationZoneId)
+      ..addNum(MessageType.response.index)
       ..addNum(responseType.index);
     if (response != null) {
       response!.serialize(serializer);
     } else if (error != null) {
       serializer.addString(error!.toString());
+      serializer.addNullableString(stackTrace);
     }
     serializer.addNum(requestId);
   }
 }
 
+class BooleanValue implements Serializable {
+  final bool value;
+
+  BooleanValue(this.value);
+
+  BooleanValue.deserialize(Deserializer deserializer)
+      : value = (deserializer..moveNext()).expectBool();
+
+  @override
+  void serialize(Serializer serializer) => serializer..addBool(value);
+}
+
 /// A request to load a macro in this isolate.
 class LoadMacroRequest extends Request {
   final Uri library;
@@ -117,10 +153,11 @@
   LoadMacroRequest(this.library, this.name, {required int serializationZoneId})
       : super(serializationZoneId: serializationZoneId);
 
-  LoadMacroRequest.deserialize(Deserializer deserializer)
+  LoadMacroRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
       : library = Uri.parse((deserializer..moveNext()).expectString()),
         name = (deserializer..moveNext()).expectString(),
-        super.deserialize(deserializer);
+        super.deserialize(deserializer, serializationZoneId);
 
   @override
   void serialize(Serializer serializer) {
@@ -142,11 +179,12 @@
       {required int serializationZoneId})
       : super(serializationZoneId: serializationZoneId);
 
-  InstantiateMacroRequest.deserialize(Deserializer deserializer)
+  InstantiateMacroRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
       : macroClass = new MacroClassIdentifierImpl.deserialize(deserializer),
         constructorName = (deserializer..moveNext()).expectString(),
         arguments = new Arguments.deserialize(deserializer),
-        super.deserialize(deserializer);
+        super.deserialize(deserializer, serializationZoneId);
 
   @override
   void serialize(Serializer serializer) {
@@ -164,14 +202,9 @@
   final MacroInstanceIdentifier macro;
   final DeclarationImpl declaration;
 
-  /// Client/Server specific implementation, not serialized.
-  final TypeResolver typeResolver;
-
-  /// Client/Server specific implementation, not serialized.
-  final ClassIntrospector classIntrospector;
-
-  /// Client/Server specific implementation, not serialized.
-  final TypeDeclarationResolver typeDeclarationResolver;
+  final RemoteInstanceImpl typeResolver;
+  final RemoteInstanceImpl classIntrospector;
+  final RemoteInstanceImpl typeDeclarationResolver;
 
   ExecuteDefinitionsPhaseRequest(this.macro, this.declaration,
       this.typeResolver, this.classIntrospector, this.typeDeclarationResolver,
@@ -180,51 +213,175 @@
 
   /// When deserializing we have already consumed the message type, so we don't
   /// consume it again.
-  ExecuteDefinitionsPhaseRequest.deserialize(Deserializer deserializer,
-      this.typeResolver, this.classIntrospector, this.typeDeclarationResolver)
+  ExecuteDefinitionsPhaseRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
       : macro = new MacroInstanceIdentifierImpl.deserialize(deserializer),
         declaration = RemoteInstance.deserialize(deserializer),
-        super.deserialize(deserializer);
+        typeResolver = RemoteInstance.deserialize(deserializer),
+        classIntrospector = RemoteInstance.deserialize(deserializer),
+        typeDeclarationResolver = RemoteInstance.deserialize(deserializer),
+        super.deserialize(deserializer, serializationZoneId);
 
   void serialize(Serializer serializer) {
     serializer.addNum(MessageType.executeDefinitionsPhaseRequest.index);
     macro.serialize(serializer);
     declaration.serialize(serializer);
+    typeResolver.serialize(serializer);
+    classIntrospector.serialize(serializer);
+    typeDeclarationResolver.serialize(serializer);
+
     super.serialize(serializer);
   }
 }
 
 /// A request to reflect on a type annotation
-class ReflectTypeRequest extends Request {
+class ResolveTypeRequest extends Request {
   final TypeAnnotationImpl typeAnnotation;
+  final RemoteInstanceImpl typeResolver;
 
-  ReflectTypeRequest(this.typeAnnotation, {required int serializationZoneId})
+  ResolveTypeRequest(this.typeAnnotation, this.typeResolver,
+      {required int serializationZoneId})
       : super(serializationZoneId: serializationZoneId);
 
   /// When deserializing we have already consumed the message type, so we don't
   /// consume it again.
-  ReflectTypeRequest.deserialize(Deserializer deserializer)
+  ResolveTypeRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
       : typeAnnotation = RemoteInstance.deserialize(deserializer),
-        super.deserialize(deserializer);
+        typeResolver = RemoteInstance.deserialize(deserializer),
+        super.deserialize(deserializer, serializationZoneId);
 
   void serialize(Serializer serializer) {
-    serializer.addNum(MessageType.reflectTypeRequest.index);
+    serializer.addNum(MessageType.resolveTypeRequest.index);
     typeAnnotation.serialize(serializer);
+    typeResolver.serialize(serializer);
     super.serialize(serializer);
   }
 }
 
-/// TODO: Implement this
+/// A request to check if a type is exactly another type.
+class IsExactlyTypeRequest extends Request {
+  final RemoteInstanceImpl leftType;
+  final RemoteInstanceImpl rightType;
+
+  IsExactlyTypeRequest(this.leftType, this.rightType,
+      {required int serializationZoneId})
+      : super(serializationZoneId: serializationZoneId);
+
+  /// When deserializing we have already consumed the message type, so we don't
+  /// consume it again.
+  IsExactlyTypeRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
+      : leftType = RemoteInstance.deserialize(deserializer),
+        rightType = RemoteInstance.deserialize(deserializer),
+        super.deserialize(deserializer, serializationZoneId);
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.isExactlyTypeRequest.index);
+    leftType.serialize(serializer);
+    rightType.serialize(serializer);
+    super.serialize(serializer);
+  }
+}
+
+/// A request to check if a type is exactly another type.
+class IsSubtypeOfRequest extends Request {
+  final ClientStaticTypeImpl leftType;
+  final ClientStaticTypeImpl rightType;
+
+  IsSubtypeOfRequest(this.leftType, this.rightType,
+      {required int serializationZoneId})
+      : super(serializationZoneId: serializationZoneId);
+
+  /// When deserializing we have already consumed the message type, so we don't
+  /// consume it again.
+  IsSubtypeOfRequest.deserialize(
+      Deserializer deserializer, int serializationZoneId)
+      : leftType = RemoteInstance.deserialize(deserializer),
+        rightType = RemoteInstance.deserialize(deserializer),
+        super.deserialize(deserializer, serializationZoneId);
+
+  void serialize(Serializer serializer) {
+    serializer.addNum(MessageType.isSubtypeOfRequest.index);
+    leftType.remoteInstance.serialize(serializer);
+    rightType.remoteInstance.serialize(serializer);
+    super.serialize(serializer);
+  }
+}
+
+/// Client side implementation of a [TypeResolver], which creates a
+/// [ResolveTypeRequest] and passes it to a given [sendRequest] function which
+/// can return the [Response].
 class ClientTypeResolver implements TypeResolver {
+  /// The actual remote instance of this type resolver.
+  final RemoteInstanceImpl remoteInstance;
+
+  /// The ID of the zone in which to find the original type resolver.
+  final int serializationZoneId;
+
+  /// A function that can send a request and return a response using an
+  /// arbitrary communication channel.
+  final Future<Response> Function(Request request) _sendRequest;
+
+  ClientTypeResolver(this._sendRequest,
+      {required this.remoteInstance, required this.serializationZoneId});
+
   @override
-  Future<StaticType> resolve(TypeAnnotation typeAnnotation) {
-    // TODO: implement resolve
-    throw new UnimplementedError();
+  Future<StaticType> resolve(TypeAnnotationImpl typeAnnotation) async {
+    ResolveTypeRequest request = new ResolveTypeRequest(
+        typeAnnotation, remoteInstance,
+        serializationZoneId: serializationZoneId);
+    RemoteInstanceImpl remoteType =
+        _handleResponse(await _sendRequest(request));
+    return new ClientStaticTypeImpl(_sendRequest,
+        remoteInstance: remoteType, serializationZoneId: serializationZoneId);
+  }
+}
+
+class ClientStaticTypeImpl implements StaticType {
+  /// The actual remote instance of this static type.
+  final RemoteInstanceImpl remoteInstance;
+
+  final int serializationZoneId;
+
+  /// A function that can send a request and return a response using an
+  /// arbitrary communication channel.
+  final Future<Response> Function(Request request) sendRequest;
+
+  ClientStaticTypeImpl(this.sendRequest,
+      {required this.remoteInstance, required this.serializationZoneId});
+
+  @override
+  Future<bool> isExactly(ClientStaticTypeImpl other) async {
+    IsExactlyTypeRequest request = new IsExactlyTypeRequest(
+        this.remoteInstance, other.remoteInstance,
+        serializationZoneId: serializationZoneId);
+    return _handleResponse<BooleanValue>(await sendRequest(request)).value;
+  }
+
+  @override
+  Future<bool> isSubtypeOf(ClientStaticTypeImpl other) async {
+    IsSubtypeOfRequest request = new IsSubtypeOfRequest(this, other,
+        serializationZoneId: serializationZoneId);
+    return _handleResponse<BooleanValue>(await sendRequest(request)).value;
   }
 }
 
 /// TODO: Implement this
 class ClientClassIntrospector implements ClassIntrospector {
+  /// The actual remote instance of this type resolver.
+  final RemoteInstanceImpl remoteInstance;
+
+  /// The ID of the zone in which to find the original type resolver.
+  final int serializationZoneId;
+
+  /// A function that can send a request and return a response using an
+  /// arbitrary communication channel.
+  final Future<Response> Function(Request request) sendRequest;
+
+  ClientClassIntrospector(this.sendRequest,
+      {required this.remoteInstance, required this.serializationZoneId});
+
   @override
   Future<List<ConstructorDeclaration>> constructorsOf(ClassDeclaration clazz) {
     // TODO: implement constructorsOf
@@ -263,7 +420,20 @@
 }
 
 /// TODO: Implement this
-class ClientTypeDeclarationsResolver implements TypeDeclarationResolver {
+class ClientTypeDeclarationResolver implements TypeDeclarationResolver {
+  /// The actual remote instance of this type resolver.
+  final RemoteInstanceImpl remoteInstance;
+
+  /// The ID of the zone in which to find the original type resolver.
+  final int serializationZoneId;
+
+  /// A function that can send a request and return a response using an
+  /// arbitrary communication channel.
+  final Future<Response> Function(Request request) sendRequest;
+
+  ClientTypeDeclarationResolver(this.sendRequest,
+      {required this.remoteInstance, required this.serializationZoneId});
+
   @override
   Future<TypeDeclaration> declarationOf(NamedStaticType annotation) {
     // TODO: implement declarationOf
@@ -271,13 +441,39 @@
   }
 }
 
+/// An exception that occurred remotely, the exception object and stack trace
+/// are serialized as [String]s and both included in the [toString] output.
+class RemoteException implements Exception {
+  final String error;
+  final String? stackTrace;
+
+  RemoteException(this.error, [this.stackTrace]);
+
+  String toString() =>
+      'RemoteException: $error${stackTrace == null ? '' : '\n\n$stackTrace'}';
+}
+
+/// Either returns the actual response from [response], casted to [T], or throws
+/// a [RemoteException] with the given error and stack trace.
+T _handleResponse<T>(Response response) {
+  if (response.response != null) {
+    return response.response as T;
+  }
+  throw new RemoteException(response.error!.toString(), response.stackTrace);
+}
+
 enum MessageType {
+  boolean,
   error,
   executeDefinitionsPhaseRequest,
   instantiateMacroRequest,
+  isExactlyTypeRequest,
+  isSubtypeOfRequest,
   loadMacroRequest,
-  reflectTypeRequest,
+  resolveTypeRequest,
   macroClassIdentifier,
   macroInstanceIdentifier,
   macroExecutionResult,
+  response,
+  staticType,
 }
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/remote_instance.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/remote_instance.dart
index 5dcd1f8..59c26fd 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/remote_instance.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor_shared/remote_instance.dart
@@ -70,6 +70,20 @@
   }
 }
 
+/// A remote instance which is just a pointer to some server side instance of
+/// a generic object.
+///
+/// The wrapped object is not serialized.
+class RemoteInstanceImpl extends RemoteInstance {
+  /// Always null on the client side, has an actual instance on the server side.
+  final Object? instance;
+
+  @override
+  RemoteInstanceKind get kind => RemoteInstanceKind.instance;
+
+  RemoteInstanceImpl({required int id, this.instance}) : super(id);
+}
+
 // The kinds of instances.
 enum RemoteInstanceKind {
   classDeclaration,
@@ -83,4 +97,6 @@
   typeAliasDeclaration,
   typeParameterDeclaration,
   variableDeclaration,
+  // A generic instance that is just a pointer to some server side instance.
+  instance,
 }
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 1fafb40..c950279 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
@@ -11,23 +11,29 @@
       case SerializationMode.client:
         moveNext();
         RemoteInstanceKind kind = RemoteInstanceKind.values[expectNum()];
-        moveNext();
         switch (kind) {
           case RemoteInstanceKind.namedTypeAnnotation:
+            moveNext();
             return _expectNamedTypeAnnotation(id) as T;
           case RemoteInstanceKind.functionTypeAnnotation:
+            moveNext();
             return _expectFunctionTypeAnnotation(id) as T;
           case RemoteInstanceKind.functionDeclaration:
+            moveNext();
             return _expectFunctionDeclaration(id) as T;
           case RemoteInstanceKind.parameterDeclaration:
+            moveNext();
             return _expectParameterDeclaration(id) as T;
           case RemoteInstanceKind.typeParameterDeclaration:
+            moveNext();
             return _expectTypeParameterDeclaration(id) as T;
+          case RemoteInstanceKind.instance:
+            return new RemoteInstanceImpl(id: id) as T;
           default:
             throw new UnsupportedError('Unsupported remote object kind: $kind');
         }
       case SerializationMode.server:
-        return RemoteInstance.cached(id);
+        return RemoteInstance.cached(id) as T;
     }
   }
 
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart
index 24c7d80..f5a7287 100644
--- a/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart
@@ -9,6 +9,7 @@
 import 'isolate_mirrors_impl.dart';
 import '../executor_shared/introspection_impls.dart';
 import '../executor_shared/protocol.dart';
+import '../executor_shared/remote_instance.dart';
 import '../executor.dart';
 import '../api.dart';
 
@@ -106,8 +107,15 @@
           TypeResolver typeResolver,
           ClassIntrospector classIntrospector,
           TypeDeclarationResolver typeDeclarationResolver) =>
-      _sendRequest(new ExecuteDefinitionsPhaseRequest(macro, declaration,
-          typeResolver, classIntrospector, typeDeclarationResolver,
+      _sendRequest(new ExecuteDefinitionsPhaseRequest(
+          macro,
+          declaration,
+          new RemoteInstanceImpl(
+              instance: typeResolver, id: RemoteInstance.uniqueId),
+          new RemoteInstanceImpl(
+              instance: classIntrospector, id: RemoteInstance.uniqueId),
+          new RemoteInstanceImpl(
+              instance: typeDeclarationResolver, id: RemoteInstance.uniqueId),
           // Serialization zones are not necessary in this executor.
           serializationZoneId: -1));
 
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 fe7e32e..4673d17 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
@@ -89,9 +89,9 @@
         declaration is FunctionDeclarationImpl) {
       FunctionDefinitionBuilderImpl builder = new FunctionDefinitionBuilderImpl(
           declaration,
-          request.typeResolver,
-          request.typeDeclarationResolver,
-          request.classIntrospector);
+          request.typeResolver.instance as TypeResolver,
+          request.typeDeclarationResolver.instance as TypeDeclarationResolver,
+          request.classIntrospector.instance as ClassIntrospector);
       await instance.buildDefinitionForFunction(declaration, builder);
       return new Response(response: builder.result, requestId: request.id);
     } else {
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 4b564b6..b2b3b49 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
@@ -5,6 +5,8 @@
 import 'dart:async';
 import 'dart:isolate';
 
+import 'package:_fe_analyzer_shared/src/macros/executor_shared/remote_instance.dart';
+
 import '../api.dart';
 import '../executor_shared/introspection_impls.dart';
 import '../executor_shared/protocol.dart';
@@ -103,7 +105,7 @@
 
 class _SingleIsolatedMacroExecutor extends MacroExecutor {
   /// The stream on which we receive responses.
-  final Stream<Response> responseStream;
+  final Stream<Object> messageStream;
 
   /// The send port where we should send requests.
   final SendPort sendPort;
@@ -126,16 +128,85 @@
 
   _SingleIsolatedMacroExecutor(
       {required this.onClose,
-      required this.responseStream,
+      required this.messageStream,
       required this.sendPort}) {
-    responseStream.listen((event) {
-      Completer<Response>? completer =
-          responseCompleters.remove(event.requestId);
-      if (completer == null) {
-        throw new StateError(
-            'Got a response for an unrecognized request id ${event.requestId}');
-      }
-      completer.complete(event);
+    messageStream.listen((message) {
+      withSerializationMode(SerializationMode.server, () {
+        JsonDeserializer deserializer =
+            new JsonDeserializer(message as List<Object?>);
+        // Every object starts with a zone ID which dictates the zone in which
+        // we should deserialize the message.
+        deserializer.moveNext();
+        int zoneId = deserializer.expectNum();
+        Zone zone = serializationZones[zoneId]!;
+        zone.run(() async {
+          deserializer.moveNext();
+          MessageType messageType =
+              MessageType.values[deserializer.expectNum()];
+          switch (messageType) {
+            case MessageType.response:
+              SerializableResponse response =
+                  new SerializableResponse.deserialize(deserializer, zoneId);
+              Completer<Response>? completer =
+                  responseCompleters.remove(response.requestId);
+              if (completer == null) {
+                throw new StateError(
+                    'Got a response for an unrecognized request id '
+                    '${response.requestId}');
+              }
+              completer.complete(response);
+              break;
+            case MessageType.resolveTypeRequest:
+              ResolveTypeRequest request =
+                  new ResolveTypeRequest.deserialize(deserializer, zoneId);
+              SerializableResponse response = new SerializableResponse(
+                  response: new RemoteInstanceImpl(
+                      id: RemoteInstance.uniqueId,
+                      instance:
+                          await (request.typeResolver.instance as TypeResolver)
+                              .resolve(request.typeAnnotation)),
+                  requestId: request.id,
+                  responseType: MessageType.staticType,
+                  serializationZoneId: zoneId);
+              JsonSerializer serializer = new JsonSerializer();
+              response.serialize(serializer);
+              sendPort.send(serializer.result);
+              break;
+            case MessageType.isExactlyTypeRequest:
+              IsExactlyTypeRequest request =
+                  new IsExactlyTypeRequest.deserialize(deserializer, zoneId);
+              StaticType leftType = request.leftType.instance as StaticType;
+              StaticType rightType = request.leftType.instance as StaticType;
+              SerializableResponse response = new SerializableResponse(
+                  response:
+                      new BooleanValue(await leftType.isExactly(rightType)),
+                  requestId: request.id,
+                  responseType: MessageType.boolean,
+                  serializationZoneId: zoneId);
+              JsonSerializer serializer = new JsonSerializer();
+              response.serialize(serializer);
+              sendPort.send(serializer.result);
+              break;
+            case MessageType.isSubtypeOfRequest:
+              IsExactlyTypeRequest request =
+                  new IsExactlyTypeRequest.deserialize(deserializer, zoneId);
+              StaticType leftType = request.leftType.instance as StaticType;
+              StaticType rightType = request.leftType.instance as StaticType;
+              SerializableResponse response = new SerializableResponse(
+                  response:
+                      new BooleanValue(await leftType.isSubtypeOf(rightType)),
+                  requestId: request.id,
+                  responseType: MessageType.boolean,
+                  serializationZoneId: zoneId);
+              JsonSerializer serializer = new JsonSerializer();
+              response.serialize(serializer);
+              sendPort.send(serializer.result);
+              break;
+            default:
+              throw new StateError('Unexpected message type $messageType');
+          }
+        });
+      });
     });
   }
 
@@ -145,31 +216,22 @@
     Isolate isolate =
         await Isolate.spawnUri(precompiledKernelUri, [], receivePort.sendPort);
     Completer<SendPort> sendPortCompleter = new Completer();
-    StreamController<Response> responseStreamController =
+    StreamController<Object> messageStreamController =
         new StreamController(sync: true);
     receivePort.listen((message) {
       if (!sendPortCompleter.isCompleted) {
         sendPortCompleter.complete(message as SendPort);
       } else {
-        JsonDeserializer deserializer =
-            new JsonDeserializer(message as List<Object?>);
-        // Ever object starts with a zone ID which dictates the zone in which we
-        // should deserialize the message.
-        deserializer.moveNext();
-        int zoneId = deserializer.expectNum();
-        Zone zone = serializationZones[zoneId]!;
-        SerializableResponse response = zone.run(
-            () => new SerializableResponse.deserialize(deserializer, zoneId));
-        responseStreamController.add(response);
+        messageStreamController.add(message);
       }
-    }).onDone(responseStreamController.close);
+    }).onDone(messageStreamController.close);
 
     return new _SingleIsolatedMacroExecutor(
         onClose: () {
           receivePort.close();
           isolate.kill();
         },
-        responseStream: responseStreamController.stream,
+        messageStream: messageStreamController.stream,
         sendPort: await sendPortCompleter.future);
   }
 
@@ -199,8 +261,15 @@
           TypeResolver typeResolver,
           ClassIntrospector classIntrospector,
           TypeDeclarationResolver typeDeclarationResolver) =>
-      _sendRequest((zoneId) => new ExecuteDefinitionsPhaseRequest(macro,
-          declaration, typeResolver, classIntrospector, typeDeclarationResolver,
+      _sendRequest((zoneId) => new ExecuteDefinitionsPhaseRequest(
+          macro,
+          declaration,
+          new RemoteInstanceImpl(
+              instance: typeResolver, id: RemoteInstance.uniqueId),
+          new RemoteInstanceImpl(
+              instance: classIntrospector, id: RemoteInstance.uniqueId),
+          new RemoteInstanceImpl(
+              instance: typeDeclarationResolver, id: RemoteInstance.uniqueId),
           serializationZoneId: zoneId));
 
   @override
@@ -225,14 +294,16 @@
           {Uri? precompiledKernelUri}) =>
       throw new StateError('Unreachable');
 
-  /// Sends a [request] and handles the response, casting it to the expected
-  /// type or throwing the error provided.
+  /// Creates a [Request] with a given serialization zone ID, and handles the
+  /// response, casting it to the expected type or throwing the error provided.
   Future<T> _sendRequest<T>(Request Function(int) requestFactory) =>
       withSerializationMode(SerializationMode.server, () async {
         int zoneId = _nextSerializationZoneId++;
         serializationZones[zoneId] = Zone.current;
         Request request = requestFactory(zoneId);
         JsonSerializer serializer = new JsonSerializer();
+        // It is our responsibility to add the zone ID header.
+        serializer.addNum(zoneId);
         request.serialize(serializer);
         sendPort.send(serializer.result);
         Completer<Response> completer = new Completer<Response>();
@@ -241,7 +312,8 @@
           Response response = await completer.future;
           T? result = response.response as T?;
           if (result != null) return result;
-          throw response.error!;
+          throw new RemoteException(
+              response.error!.toString(), response.stackTrace);
         } finally {
           // Clean up the zone after the request is done.
           serializationZones.remove(zoneId);
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart b/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart
index aae2ad0..c1f7c1d 100644
--- a/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart
@@ -4,16 +4,16 @@
 
 import 'dart:io';
 
-import 'package:_fe_analyzer_shared/src/macros/api.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/isolate_mirrors_executor/isolate_mirrors_executor.dart'
     as mirrorExecutor;
 
-import 'package:test/fake.dart';
 import 'package:test/test.dart';
 
+import '../util.dart';
+
 void main() {
   late MacroExecutor executor;
   late File simpleMacroFile;
@@ -55,6 +55,11 @@
     expect(instanceId, isNotNull,
         reason: 'Can create an instance with named arguments.');
 
+    var returnType = NamedTypeAnnotationImpl(
+        id: RemoteInstance.uniqueId,
+        name: 'String',
+        isNullable: false,
+        typeArguments: const []);
     var definitionResult = await executor.executeDefinitionsPhase(
         instanceId,
         FunctionDeclarationImpl(
@@ -66,16 +71,13 @@
           name: 'foo',
           namedParameters: [],
           positionalParameters: [],
-          returnType: NamedTypeAnnotationImpl(
-              id: RemoteInstance.uniqueId,
-              name: 'String',
-              isNullable: false,
-              typeArguments: const []),
+          returnType: returnType,
           typeParameters: [],
         ),
-        _FakeTypeResolver(),
-        _FakeClassIntrospector(),
-        _FakeTypeDeclarationResolver());
+        TestTypeResolver(
+            {returnType: TestStaticType('dart:core', 'String', [])}),
+        FakeClassIntrospector(),
+        FakeTypeDeclarationResolver());
     expect(definitionResult.augmentations, hasLength(1));
     expect(definitionResult.augmentations.first.debugString().toString(),
         equalsIgnoringWhitespace('''
@@ -85,27 +87,3 @@
             }'''));
   });
 }
-
-class _FakeClassIntrospector with Fake implements ClassIntrospector {}
-
-class _FakeTypeResolver with Fake implements TypeResolver {}
-
-class _FakeTypeDeclarationResolver
-    with Fake
-    implements TypeDeclarationResolver {}
-
-extension _ on Code {
-  StringBuffer debugString([StringBuffer? buffer]) {
-    buffer ??= StringBuffer();
-    for (var part in parts) {
-      if (part is Code) {
-        part.debugString(buffer);
-      } else if (part is TypeAnnotation) {
-        part.code.debugString(buffer);
-      } else {
-        buffer.write(part.toString());
-      }
-    }
-    return buffer;
-  }
-}
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 c4cac8b..1bdb14f 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
@@ -5,7 +5,6 @@
 import 'dart:io';
 import 'dart:isolate';
 
-import 'package:_fe_analyzer_shared/src/macros/api.dart';
 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';
@@ -13,9 +12,10 @@
 import 'package:_fe_analyzer_shared/src/macros/isolated_executor/isolated_executor.dart'
     as isolatedExecutor;
 
-import 'package:test/fake.dart';
 import 'package:test/test.dart';
 
+import '../util.dart';
+
 void main() {
   late MacroExecutor executor;
   late Directory tmpDir;
@@ -40,7 +40,7 @@
     executor.close();
   });
 
-  test('can load macros and create instances', () async {
+  test('can load and run macros', () async {
     var macroUri = simpleMacroFile.absolute.uri;
     var macroName = 'SimpleMacro';
 
@@ -78,6 +78,11 @@
     expect(instanceId, isNotNull,
         reason: 'Can create an instance with named arguments.');
 
+    var returnType = NamedTypeAnnotationImpl(
+        id: RemoteInstance.uniqueId,
+        name: 'String',
+        isNullable: false,
+        typeArguments: const []);
     var definitionResult = await executor.executeDefinitionsPhase(
         instanceId,
         FunctionDeclarationImpl(
@@ -89,16 +94,13 @@
           name: 'foo',
           namedParameters: [],
           positionalParameters: [],
-          returnType: NamedTypeAnnotationImpl(
-              id: RemoteInstance.uniqueId,
-              name: 'String',
-              isNullable: false,
-              typeArguments: const []),
+          returnType: returnType,
           typeParameters: [],
         ),
-        _FakeTypeResolver(),
-        _FakeClassIntrospector(),
-        _FakeTypeDeclarationResolver());
+        TestTypeResolver(
+            {returnType: TestStaticType('dart:core', 'String', [])}),
+        FakeClassIntrospector(),
+        FakeTypeDeclarationResolver());
     expect(definitionResult.augmentations, hasLength(1));
     expect(definitionResult.augmentations.first.debugString().toString(),
         equalsIgnoringWhitespace('''
@@ -108,27 +110,3 @@
             }'''));
   });
 }
-
-class _FakeClassIntrospector with Fake implements ClassIntrospector {}
-
-class _FakeTypeResolver with Fake implements TypeResolver {}
-
-class _FakeTypeDeclarationResolver
-    with Fake
-    implements TypeDeclarationResolver {}
-
-extension _ on Code {
-  StringBuffer debugString([StringBuffer? buffer]) {
-    buffer ??= StringBuffer();
-    for (var part in parts) {
-      if (part is Code) {
-        part.debugString(buffer);
-      } else if (part is TypeAnnotation) {
-        part.code.debugString(buffer);
-      } else {
-        buffer.write(part.toString());
-      }
-    }
-    return buffer;
-  }
-}
diff --git a/pkg/_fe_analyzer_shared/test/macros/simple_macro.dart b/pkg/_fe_analyzer_shared/test/macros/simple_macro.dart
index b95da0b..ff31b12 100644
--- a/pkg/_fe_analyzer_shared/test/macros/simple_macro.dart
+++ b/pkg/_fe_analyzer_shared/test/macros/simple_macro.dart
@@ -18,13 +18,23 @@
 
   @override
   FutureOr<void> buildDefinitionForFunction(
-      FunctionDeclaration method, FunctionDefinitionBuilder builder) {
+      FunctionDeclaration method, FunctionDefinitionBuilder builder) async {
     if (method.namedParameters
         .followedBy(method.positionalParameters)
         .isNotEmpty) {
       throw ArgumentError(
           'This macro can only be run on functions with no arguments!');
     }
+
+    // Test the type resolver and static type interfaces
+    var staticReturnType = await builder.resolve(method.returnType);
+    if (!(await staticReturnType.isExactly(staticReturnType))) {
+      throw StateError('The return type should be exactly equal to itself!');
+    }
+    if (!(await staticReturnType.isSubtypeOf(staticReturnType))) {
+      throw StateError('The return type should be a subtype of itself!');
+    }
+
     builder.augment(FunctionBodyCode.fromString('''{
       print('x: $x, y: $y');
       return augment super();
diff --git a/pkg/_fe_analyzer_shared/test/macros/util.dart b/pkg/_fe_analyzer_shared/test/macros/util.dart
new file mode 100644
index 0000000..179f50b
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/macros/util.dart
@@ -0,0 +1,60 @@
+// 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/api.dart';
+
+import 'package:test/fake.dart';
+
+class FakeClassIntrospector with Fake implements ClassIntrospector {}
+
+class FakeTypeDeclarationResolver with Fake implements TypeDeclarationResolver {
+}
+
+class TestTypeResolver implements TypeResolver {
+  final Map<TypeAnnotation, StaticType> staticTypes;
+
+  TestTypeResolver(this.staticTypes);
+
+  @override
+  Future<StaticType> resolve(covariant TypeAnnotation typeAnnotation) async {
+    return staticTypes[typeAnnotation]!;
+  }
+}
+
+// Doesn't handle generics etc but thats ok for now
+class TestStaticType implements StaticType {
+  final String library;
+  final String name;
+  final List<TestStaticType> superTypes;
+
+  TestStaticType(this.library, this.name, this.superTypes);
+
+  @override
+  Future<bool> isExactly(TestStaticType other) async => _isExactly(other);
+
+  @override
+  Future<bool> isSubtypeOf(TestStaticType other) async =>
+      _isExactly(other) ||
+      superTypes.any((superType) => superType._isExactly(other));
+
+  bool _isExactly(TestStaticType other) =>
+      identical(other, this) ||
+      (library == other.library && name == other.name);
+}
+
+extension DebugCodeString on Code {
+  StringBuffer debugString([StringBuffer? buffer]) {
+    buffer ??= StringBuffer();
+    for (var part in parts) {
+      if (part is Code) {
+        part.debugString(buffer);
+      } else if (part is TypeAnnotation) {
+        part.code.debugString(buffer);
+      } else {
+        buffer.write(part.toString());
+      }
+    }
+    return buffer;
+  }
+}
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index e105550..ca03543 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -1110,6 +1110,7 @@
 reloading
 remapped
 remedy
+remotely
 removal
 remover
 renames