diff --git a/BUILD.gn b/BUILD.gn
index 338f5ec..ad09ed8 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -50,16 +50,6 @@
     "utils/kernel-service:kernel-service",
   ]
 
-  # We do not support AOT on ia32 and should therefore cannot provide native
-  # snapshot tooling.
-  if (dart_target_arch != "ia32") {
-    if (is_product) {
-      deps += [ "runtime/bin:analyze_snapshot_product" ]
-    } else {
-      deps += [ "runtime/bin:analyze_snapshot" ]
-    }
-  }
-
   # TODO(bkonyi): this dep causes a segfault on Android XARM_X64 builds.
   # See issue #41776.
   if (dart_target_arch != "arm") {
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api.dart
new file mode 100644
index 0000000..5d5c262
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api.dart
@@ -0,0 +1,10 @@
+// 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';
+
+part 'api/builders.dart';
+part 'api/code.dart';
+part 'api/introspection.dart';
+part 'api/macros.dart';
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart
new file mode 100644
index 0000000..74bf73c
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/builders.dart
@@ -0,0 +1,159 @@
+// 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.
+
+part of '../api.dart';
+
+/// The base interface used to add declarations to the program as well
+/// as augment existing ones.
+abstract class Builder {}
+
+/// The api used by [Macro]s to contribute new type declarations to the
+/// current library, and get [TypeAnnotation]s from runtime [Type] objects.
+abstract class TypeBuilder implements Builder {
+  /// Adds a new type declaration to the surrounding library.
+  void declareType(DeclarationCode typeDeclaration);
+}
+
+/// The interface to resolve a [TypeAnnotation] to a [StaticType].
+///
+/// The [StaticType]s can be compared against other [StaticType]s to see how
+/// they relate to each other.
+///
+/// This api is only available to the declaration and definition phases of
+/// macro expansion.
+abstract class TypeResolver {
+  /// Resolves [typeAnnotation] to a [StaticType].
+  ///
+  /// Throws an error if the type annotation cannot be resolved. This should
+  /// only happen in the case of incomplete or invalid programs, but macros
+  /// 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);
+}
+
+/// The api used to introspect on a [ClassDeclaration].
+///
+/// Available in the declaration and definition phases, but limited in the
+/// declaration phase to immediately annotated [ClassDeclaration]s. This is
+/// done by limiting the access to the [TypeDeclarationResolver] to the
+/// definition phase.
+abstract class ClassIntrospector {
+  /// The fields available for [clazz].
+  ///
+  /// This may be incomplete if in the declaration phase and additional macros
+  /// are going to run on this class.
+  Future<List<FieldDeclaration>> fieldsOf(ClassDeclaration clazz);
+
+  /// The methods available so far for the current class.
+  ///
+  /// This may be incomplete if additional declaration macros are running on
+  /// this class.
+  Future<List<MethodDeclaration>> methodsOf(ClassDeclaration clazz);
+
+  /// The constructors available so far for the current class.
+  ///
+  /// This may be incomplete if additional declaration macros are running on
+  /// this class.
+  Future<List<ConstructorDeclaration>> constructorsOf(ClassDeclaration clazz);
+
+  /// The class that is directly extended via an `extends` clause.
+  Future<ClassDeclaration?> superclassOf(ClassDeclaration clazz);
+
+  /// All of the classes that are mixed in with `with` clauses.
+  Future<List<ClassDeclaration>> mixinsOf(ClassDeclaration clazz);
+
+  /// All of the classes that are implemented with an `implements` clause.
+  Future<List<ClassDeclaration>> interfacesOf(ClassDeclaration clazz);
+}
+
+/// The api used by [Macro]s to contribute new (non-type)
+/// declarations to the current library.
+///
+/// Can also be used to do subtype checks on types.
+abstract class DeclarationBuilder
+    implements Builder, TypeResolver, ClassIntrospector {
+  /// Adds a new regular declaration to the surrounding library.
+  ///
+  /// Note that type declarations are not supported.
+  void declareInLibrary(DeclarationCode declaration);
+}
+
+/// The api used by [Macro]s to contribute new members to a class.
+abstract class ClassMemberDeclarationBuilder implements DeclarationBuilder {
+  /// Adds a new declaration to the surrounding class.
+  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.
+///
+/// Only available in the definition phase of macro expansion.
+abstract class TypeDeclarationResolver {
+  /// Resolves a [NamedStaticType] to its [TypeDeclaration].
+  Future<TypeDeclaration> declarationOf(NamedStaticType annotation);
+}
+
+/// The base class for builders in the definition phase. These can convert
+/// any [TypeAnnotation] into its corresponding [TypeDeclaration], and also
+/// reflect more deeply on those.
+abstract class DefinitionBuilder
+    implements
+        Builder,
+        TypeResolver,
+        ClassIntrospector,
+        TypeDeclarationResolver {}
+
+/// The apis used by [Macro]s that run on classes, to fill in the definitions
+/// of any external declarations within that class.
+abstract class ClassDefinitionBuilder implements DefinitionBuilder {
+  /// Retrieve a [VariableDefinitionBuilder] for a field by [name].
+  ///
+  /// Throws an [ArgumentError] if there is no field by that name.
+  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);
+
+  /// Retrieve a [ConstructorDefinitionBuilder] for a constructor by [name].
+  ///
+  /// Throws an [ArgumentError] if there is no constructor by that name.
+  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].
+  ///
+  /// TODO: Link the library augmentations proposal to describe the semantics.
+  void augment({FunctionBodyCode? body, List<Code>? initializers});
+}
+
+/// The apis used by [Macro]s to augment functions or methods.
+abstract class FunctionDefinitionBuilder implements DefinitionBuilder {
+  /// Augments the function.
+  ///
+  /// TODO: Link the library augmentations proposal to describe the semantics.
+  void augment(FunctionBodyCode body);
+}
+
+/// The api used by [Macro]s to augment a top level variable or instance field.
+abstract class VariableDefinitionBuilder implements DefinitionBuilder {
+  /// Augments the field.
+  ///
+  /// TODO: Link the library augmentations proposal to describe the semantics.
+  void augment({
+    DeclarationCode? getter,
+    DeclarationCode? setter,
+    ExpressionCode? initializer,
+  });
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/code.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/code.dart
new file mode 100644
index 0000000..89f169f
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/code.dart
@@ -0,0 +1,104 @@
+// 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.
+
+part of '../api.dart';
+
+/// The base class representing an arbitrary chunk of Dart code, which may or
+/// may not be syntactically or semantically valid yet.
+class Code {
+  /// All the chunks of [Code] or raw [String]s that comprise this [Code]
+  /// object.
+  final List<Object> parts;
+
+  Code.fromString(String code) : parts = [code];
+
+  Code.fromParts(this.parts);
+}
+
+/// A piece of code representing a syntactically valid declaration.
+class DeclarationCode extends Code {
+  DeclarationCode.fromString(String code) : super.fromString(code);
+
+  DeclarationCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+/// A piece of code representing a syntactically valid element.
+///
+/// Should not include any trailing commas,
+class ElementCode extends Code {
+  ElementCode.fromString(String code) : super.fromString(code);
+
+  ElementCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+/// A piece of code representing a syntactically valid expression.
+class ExpressionCode extends Code {
+  ExpressionCode.fromString(String code) : super.fromString(code);
+
+  ExpressionCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+/// A piece of code representing a syntactically valid function body.
+///
+/// This includes any and all code after the parameter list of a function,
+/// including modifiers like `async`.
+///
+/// Both arrow and block function bodies are allowed.
+class FunctionBodyCode extends Code {
+  FunctionBodyCode.fromString(String code) : super.fromString(code);
+
+  FunctionBodyCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+/// A piece of code representing a syntactically valid identifier.
+class IdentifierCode extends Code {
+  IdentifierCode.fromString(String code) : super.fromString(code);
+
+  IdentifierCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+/// A piece of code identifying a named argument.
+///
+/// This should not include any trailing commas.
+class NamedArgumentCode extends Code {
+  NamedArgumentCode.fromString(String code) : super.fromString(code);
+
+  NamedArgumentCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+/// A piece of code identifying a syntactically valid function parameter.
+///
+/// This should not include any trailing commas, but may include modifiers
+/// such as `required`, and default values.
+///
+/// There is no distinction here made between named and positional parameters,
+/// nor between optional or required parameters. It is the job of the user to
+/// construct and combine these together in a way that creates valid parameter
+/// lists.
+class ParameterCode extends Code {
+  ParameterCode.fromString(String code) : super.fromString(code);
+
+  ParameterCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+/// A piece of code representing a syntactically valid statement.
+///
+/// Should always end with a semicolon.
+class StatementCode extends Code {
+  StatementCode.fromString(String code) : super.fromString(code);
+
+  StatementCode.fromParts(List<Object> parts) : super.fromParts(parts);
+}
+
+extension Join<T extends Code> on List<T> {
+  /// Joins all the items in [this] with [separator], and returns
+  /// a new list.
+  List<Code> joinAsCode(String separator) => [
+        for (int i = 0; i < length - 1; i++) ...[
+          this[i],
+          new Code.fromString(separator),
+        ],
+        last,
+      ];
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
new file mode 100644
index 0000000..e892296
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/introspection.dart
@@ -0,0 +1,192 @@
+// 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.
+
+part of '../api.dart';
+
+/// The base class for an unresolved reference to a type.
+///
+/// See the subtypes [FunctionTypeAnnotation] and [NamedTypeAnnotation].
+abstract class TypeAnnotation {
+  /// Whether or not the type annotation is explicitly nullable (contains a
+  /// trailing `?`)
+  bool get isNullable;
+
+  /// A [Code] object representation of this type annotation.
+  Code get code;
+}
+
+/// The base class for function type declarations.
+abstract class FunctionTypeAnnotation implements TypeAnnotation {
+  /// The return type of this function.
+  TypeAnnotation get returnType;
+
+  /// The positional parameters for this function.
+  Iterable<ParameterDeclaration> get positionalParameters;
+
+  /// The named parameters for this function.
+  Iterable<ParameterDeclaration> get namedParameters;
+
+  /// The type parameters for this function.
+  Iterable<TypeParameterDeclaration> get typeParameters;
+}
+
+/// An unresolved reference to a type.
+///
+/// These can be resolved to a [TypeDeclaration] using the `builder` classes
+/// depending on the phase a macro is running in.
+abstract class NamedTypeAnnotation implements TypeAnnotation {
+  /// The name of the type as it exists in the type annotation.
+  String get name;
+
+  /// The type arguments, if applicable.
+  Iterable<TypeAnnotation> get typeArguments;
+}
+
+/// The interface representing a resolved type.
+///
+/// Resolved types understand exactly what type they represent, and can be
+/// compared to other static types.
+abstract class StaticType {
+  /// Returns true if this is a subtype of [other].
+  Future<bool> isSubtypeOf(StaticType other);
+
+  /// Returns true if this is an identical type to [other].
+  Future<bool> isExactly(StaticType other);
+}
+
+/// A subtype of [StaticType] representing types that can be resolved by name
+/// to a concrete declaration.
+abstract class NamedStaticType implements StaticType {
+  String get name;
+}
+
+/// The base class for all declarations.
+abstract class Declaration {
+  /// The name of this declaration.
+  String get name;
+}
+
+/// A declaration that defines a new type in the program.
+abstract class TypeDeclaration implements Declaration {
+  /// The type parameters defined for this type declaration.
+  Iterable<TypeParameterDeclaration> get typeParameters;
+
+  /// Create a static type representing this type with [typeArguments].
+  ///
+  /// If [isNullable] is `true`, then this type will behave as if it has a
+  /// trailing `?`.
+  ///
+  /// Throws an exception if the type could not be instantiated, typically due
+  /// to one of the type arguments not matching the bounds of the corresponding
+  /// type parameter.
+  Future<StaticType> instantiate(
+      {required List<StaticType> typeArguments, required bool isNullable});
+}
+
+/// Class (and enum) introspection information.
+///
+/// Information about fields, methods, and constructors must be retrieved from
+/// the `builder` objects.
+abstract class ClassDeclaration implements TypeDeclaration {
+  /// Whether this class has an `abstract` modifier.
+  bool get isAbstract;
+
+  /// Whether this class has an `external` modifier.
+  bool get isExternal;
+
+  /// The `extends` type annotation, if present.
+  TypeAnnotation? get superclass;
+
+  /// All the `implements` type annotations.
+  Iterable<TypeAnnotation> get interfaces;
+
+  /// All the `with` type annotations.
+  Iterable<TypeAnnotation> get mixins;
+
+  /// All the type arguments, if applicable.
+  Iterable<TypeParameterDeclaration> get typeParameters;
+}
+
+/// Function introspection information.
+abstract class FunctionDeclaration implements Declaration {
+  /// Whether this function has an `abstract` modifier.
+  bool get isAbstract;
+
+  /// Whether this function has an `external` modifier.
+  bool get isExternal;
+
+  /// Whether this function is actually a getter.
+  bool get isGetter;
+
+  /// Whether this function is actually a setter.
+  bool get isSetter;
+
+  /// The return type of this function.
+  TypeAnnotation get returnType;
+
+  /// The positional parameters for this function.
+  Iterable<ParameterDeclaration> get positionalParameters;
+
+  /// The named parameters for this function.
+  Iterable<ParameterDeclaration> get namedParameters;
+
+  /// The type parameters for this function.
+  Iterable<TypeParameterDeclaration> get typeParameters;
+}
+
+/// Method introspection information.
+abstract class MethodDeclaration implements FunctionDeclaration {
+  /// The class that defines this method.
+  TypeAnnotation get definingClass;
+}
+
+/// Constructor introspection information.
+abstract class ConstructorDeclaration implements MethodDeclaration {
+  /// Whether or not this is a factory constructor.
+  bool get isFactory;
+}
+
+/// 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.
+  bool get isExternal;
+
+  /// The type of this field.
+  TypeAnnotation get type;
+
+  /// A [Code] object representing the initializer for this field, if present.
+  Code? get initializer;
+}
+
+/// Field introspection information ..
+abstract class FieldDeclaration implements VariableDeclaration {
+  /// The class that defines this method.
+  TypeAnnotation get definingClass;
+}
+
+/// Parameter introspection information.
+abstract class ParameterDeclaration implements Declaration {
+  /// The type of this parameter.
+  TypeAnnotation get type;
+
+  /// Whether or not this is a named parameter.
+  bool get isNamed;
+
+  /// Whether or not this parameter is either a non-optional positional
+  /// parameter or an optional parameter with the `required` keyword.
+  bool get isRequired;
+
+  /// A [Code] object representing the default value for this parameter, if
+  /// present. Can be used to copy default values to other parameters.
+  Code? get defaultValue;
+}
+
+/// Type parameter introspection information.
+abstract class TypeParameterDeclaration implements Declaration {
+  /// The bounds for this type parameter, if it has any.
+  TypeAnnotation? get bounds;
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/api/macros.dart b/pkg/_fe_analyzer_shared/lib/src/macros/api/macros.dart
new file mode 100644
index 0000000..7685589a
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/api/macros.dart
@@ -0,0 +1,139 @@
+// 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.
+
+part of '../api.dart';
+
+/// The marker interface for all types of macros.
+abstract class Macro {}
+
+/// The interface for [Macro]s that can be applied to any top level function,
+/// instance method, or static method, and wants to contribute new type
+/// declarations to the program.
+abstract class FunctionTypesMacro implements Macro {
+  FutureOr<void> buildTypesForFunction(
+      FunctionDeclaration function, TypeBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any top level function,
+/// instance method, or static method, and wants to contribute new non-type
+/// declarations to the program.
+abstract class FunctionDeclarationsMacro implements Macro {
+  FutureOr<void> buildDeclarationsForFunction(
+      FunctionDeclaration function, DeclarationBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any top level function,
+/// instance method, or static method, and wants to augment the function
+/// definition.
+abstract class FunctionDefinitionMacro implements Macro {
+  FutureOr<void> buildDefinitionForFunction(
+      FunctionDeclaration function, FunctionDefinitionBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any top level variable or
+/// instance field, and wants to contribute new type declarations to the
+/// program.
+abstract class VariableTypesMacro implements Macro {
+  FutureOr<void> buildTypesForVariable(
+      VariableDeclaration variable, TypeBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any top level variable or
+/// instance field and wants to contribute new non-type declarations to the
+/// program.
+abstract class VariableDeclarationsMacro implements Macro {
+  FutureOr<void> buildDeclarationsForVariable(
+      VariableDeclaration variable, DeclarationBuilder builder);
+}
+
+/// 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(
+      VariableDeclaration variable, VariableDefinitionBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any class, and wants to
+/// contribute new type declarations to the program.
+abstract class ClassTypesMacro implements Macro {
+  FutureOr<void> buildTypesForClass(
+      ClassDeclaration clazz, TypeBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any class, and wants to
+/// contribute new non-type declarations to the program.
+abstract class ClassDeclarationsMacro implements Macro {
+  FutureOr<void> buildDeclarationsForClass(
+      ClassDeclaration clazz, ClassDeclarationBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any class, and wants to
+/// augment the definitions of members on the class.
+abstract class ClassDefinitionMacro implements Macro {
+  FutureOr<void> buildDefinitionForClass(
+      ClassDeclaration clazz, ClassDefinitionBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any field, and wants to
+/// contribute new type declarations to the program.
+abstract class FieldTypesMacro implements Macro {
+  FutureOr<void> buildTypesForField(
+      FieldDeclaration field, TypeBuilder builder);
+}
+
+/// 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(
+      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 {
+  FutureOr<void> buildDefinitionForField(
+      FieldDeclaration field, VariableDefinitionBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any method, and wants to
+/// contribute new type declarations to the program.
+abstract class MethodTypesMacro implements Macro {
+  FutureOr<void> buildTypesForMethod(
+      MethodDeclaration method, TypeBuilder builder);
+}
+
+/// 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 {
+  FutureOr<void> buildDeclarationsForMethod(
+      MethodDeclaration method, ClassMemberDeclarationBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any method, and wants to
+/// augment the function definition.
+abstract class MethodDefinitionMacro implements Macro {
+  FutureOr<void> buildDefinitionForMethod(
+      MethodDeclaration method, FunctionDefinitionBuilder builder);
+}
+
+/// The interface for [Macro]s that can be applied to any constructor, and wants
+/// to contribute new type declarations to the program.
+abstract class ConstructorTypesMacro implements Macro {
+  FutureOr<void> buildTypesForConstructor(
+      ConstructorDeclaration method, 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 {
+  FutureOr<void> buildDeclarationsForConstructor(
+      ConstructorDeclaration method, 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);
+}
diff --git a/pkg/_fe_analyzer_shared/lib/src/macros/executor.dart b/pkg/_fe_analyzer_shared/lib/src/macros/executor.dart
new file mode 100644
index 0000000..0d4e878
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/executor.dart
@@ -0,0 +1,115 @@
+// 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 'api.dart';
+
+/// The interface used by Dart language implementations, in order to load
+/// and execute macros, as well as produce library augmentations from those
+/// macro applications.
+///
+/// This class more clearly defines the role of a Dart language implementation
+/// during macro discovery and expansion, and unifies how augmentation libraries
+/// are produced.
+abstract class MacroExecutor {
+  /// Invoked when an implementation discovers a new macro definition in a
+  /// [library] with [name], and prepares this executor to run the macro.
+  ///
+  /// May be invoked more than once for the same macro, which will cause the
+  /// macro to be re-loaded. Previous [MacroClassIdentifier]s and
+  /// [MacroInstanceIdentifier]s given for this macro will be invalid after
+  /// that point and should be discarded.
+  ///
+  /// Throws an exception if the macro fails to load.
+  Future<MacroClassIdentifier> loadMacro(Uri library, String name);
+
+  /// Creates an instance of [macroClass] in the executor, and returns an
+  /// identifier for that instance.
+  ///
+  /// Throws an exception if an instance is not created.
+  Future<MacroInstanceIdentifier> instantiateMacro(
+      MacroClassIdentifier macroClass, String constructor, Arguments arguments);
+
+  /// Runs the type phase for [macro] on a given [declaration].
+  ///
+  /// Throws an exception if there is an error executing the macro.
+  Future<MacroExecutionResult> executeTypesPhase(
+      MacroInstanceIdentifier macro, Declaration declaration);
+
+  /// Runs the declarations phase for [macro] on a given [declaration].
+  ///
+  /// Throws an exception if there is an error executing the macro.
+  Future<MacroExecutionResult> executeDeclarationsPhase(
+      MacroInstanceIdentifier macro,
+      Declaration declaration,
+      TypeResolver typeResolver,
+      ClassIntrospector classIntrospector);
+
+  /// Runs the definitions phase for [macro] on a given [declaration].
+  ///
+  /// Throws an exception if there is an error executing the macro.
+  Future<MacroExecutionResult> executeDefinitionsPhase(
+      MacroInstanceIdentifier macro,
+      Declaration declaration,
+      TypeResolver typeResolver,
+      ClassIntrospector classIntrospector,
+      TypeDeclarationResolver typeDeclarationResolver);
+
+  /// Combines multiple [MacroExecutionResult]s into a single library
+  /// augmentation file, and returns a [String] representing that file.
+  Future<String> buildAugmentationLibrary(
+      Iterable<MacroExecutionResult> macroResults);
+
+  /// Tell the executor to shut down and clean up any resources it may have
+  /// allocated.
+  void close();
+}
+
+/// The arguments passed to a macro constructor.
+///
+/// All argument instances must be of type [Code] or a built-in value type that
+/// is serializable (num, bool, String, null, etc).
+class Arguments {
+  final List<Object?> positional;
+
+  final Map<String, Object?> named;
+
+  Arguments(this.positional, this.named);
+}
+
+/// An opaque identifier for a macro class, retrieved by
+/// [MacroExecutor.loadMacro].
+///
+/// Used to execute or reload this macro in the future.
+abstract class MacroClassIdentifier {}
+
+/// An opaque identifier for an instance of a macro class, retrieved by
+/// [MacroExecutor.instantiateMacro].
+///
+/// Used to execute or reload this macro in the future.
+abstract class MacroInstanceIdentifier {}
+
+/// A summary of the results of running a macro in a given phase.
+///
+/// All modifications are expressed in terms of library augmentation
+/// declarations.
+abstract class MacroExecutionResult {
+  /// Any library imports that should be added to support the code used in
+  /// the augmentations.
+  Iterable<DeclarationCode> get imports;
+
+  /// Any augmentations that should be applied as a result of executing a macro.
+  Iterable<DeclarationCode> get augmentations;
+}
+
+/// Each of the different macro execution phases.
+enum Phase {
+  /// Only new types are added in this phase.
+  types,
+
+  /// New non-type declarations are added in this phase.
+  declarations,
+
+  /// This phase allows augmenting existing declarations.
+  definitions,
+}
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
new file mode 100644
index 0000000..d6476af
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_executor.dart
@@ -0,0 +1,137 @@
+// 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 'dart:isolate';
+import 'dart:mirrors';
+
+import 'isolate_mirrors_impl.dart';
+import 'protocol.dart';
+import '../executor.dart';
+import '../api.dart';
+
+/// A [MacroExecutor] implementation which relies on [IsolateMirror.loadUri]
+/// in order to load macros libraries.
+///
+/// All actual work happens in a separate [Isolate], and this class serves as
+/// a bridge between that isolate and the language frontends.
+class IsolateMirrorMacroExecutor implements MacroExecutor {
+  /// The actual isolate doing macro loading and execution.
+  final Isolate _macroIsolate;
+
+  /// The channel used to send requests to the [_macroIsolate].
+  final SendPort _sendPort;
+
+  /// The stream of responses from the [_macroIsolate].
+  final Stream<GenericResponse> _responseStream;
+
+  /// A map of response completers by request id.
+  final _responseCompleters = <int, Completer<GenericResponse>>{};
+
+  /// A function that should be invoked when shutting down this executor
+  /// to perform any necessary cleanup.
+  final void Function() _onClose;
+
+  IsolateMirrorMacroExecutor._(
+      this._macroIsolate, this._sendPort, this._responseStream, this._onClose) {
+    _responseStream.listen((event) {
+      Completer<GenericResponse>? completer =
+          _responseCompleters.remove(event.requestId);
+      if (completer == null) {
+        throw new StateError(
+            'Got a response for an unrecognized request id ${event.requestId}');
+      }
+      completer.complete(event);
+    });
+  }
+
+  /// Initialize an [IsolateMirrorMacroExecutor] and return it once ready.
+  ///
+  /// Spawns the macro isolate and sets up a communication channel.
+  static Future<MacroExecutor> start() async {
+    ReceivePort receivePort = new ReceivePort();
+    Completer<SendPort> sendPortCompleter = new Completer<SendPort>();
+    StreamController<GenericResponse> responseStreamController =
+        new StreamController<GenericResponse>(sync: true);
+    receivePort.listen((message) {
+      if (!sendPortCompleter.isCompleted) {
+        sendPortCompleter.complete(message as SendPort);
+      } else {
+        responseStreamController.add(message as GenericResponse);
+      }
+    }).onDone(responseStreamController.close);
+    Isolate macroIsolate = await Isolate.spawn(spawn, receivePort.sendPort);
+
+    return new IsolateMirrorMacroExecutor._(
+        macroIsolate,
+        await sendPortCompleter.future,
+        responseStreamController.stream,
+        receivePort.close);
+  }
+
+  @override
+  Future<String> buildAugmentationLibrary(
+      Iterable<MacroExecutionResult> macroResults) {
+    // TODO: implement buildAugmentationLibrary
+    throw new UnimplementedError();
+  }
+
+  @override
+  void close() {
+    _onClose();
+    _macroIsolate.kill();
+  }
+
+  @override
+  Future<MacroExecutionResult> executeDeclarationsPhase(
+      MacroInstanceIdentifier macro,
+      Declaration declaration,
+      TypeResolver typeResolver,
+      ClassIntrospector classIntrospector) {
+    // TODO: implement executeDeclarationsPhase
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<MacroExecutionResult> executeDefinitionsPhase(
+          MacroInstanceIdentifier macro,
+          Declaration declaration,
+          TypeResolver typeResolver,
+          ClassIntrospector classIntrospector,
+          TypeDeclarationResolver typeDeclarationResolver) =>
+      _sendRequest(new ExecuteDefinitionsPhaseRequest(macro, declaration,
+          typeResolver, classIntrospector, typeDeclarationResolver));
+
+  @override
+  Future<MacroExecutionResult> executeTypesPhase(
+      MacroInstanceIdentifier macro, Declaration declaration) {
+    // TODO: implement executeTypesPhase
+    throw new UnimplementedError();
+  }
+
+  @override
+  Future<MacroInstanceIdentifier> instantiateMacro(
+          MacroClassIdentifier macroClass,
+          String constructor,
+          Arguments arguments) =>
+      _sendRequest(
+          new InstantiateMacroRequest(macroClass, constructor, arguments));
+
+  @override
+  Future<MacroClassIdentifier> loadMacro(Uri library, String name) =>
+      _sendRequest(new LoadMacroRequest(library, name));
+
+  /// Sends a request and returns the response, casting it to the expected
+  /// type.
+  Future<T> _sendRequest<T>(Request request) async {
+    _sendPort.send(request);
+    Completer<GenericResponse<T>> completer =
+        new Completer<GenericResponse<T>>();
+    _responseCompleters[request.id] = completer;
+    GenericResponse<T> response = await completer.future;
+    T? result = response.response;
+    if (result != null) return result;
+    throw response.error!;
+  }
+}
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
new file mode 100644
index 0000000..3cf24a5
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/isolate_mirrors_impl.dart
@@ -0,0 +1,255 @@
+// 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 'dart:isolate';
+import 'dart:mirrors';
+
+import 'protocol.dart';
+import '../executor.dart';
+import '../api.dart';
+
+/// Spawns a new isolate for loading and executing macros.
+void spawn(SendPort sendPort) {
+  ReceivePort receivePort = new ReceivePort();
+  sendPort.send(receivePort.sendPort);
+  receivePort.listen((message) async {
+    if (message is LoadMacroRequest) {
+      GenericResponse<MacroClassIdentifier> response =
+          await _loadMacro(message);
+      sendPort.send(response);
+    } else if (message is InstantiateMacroRequest) {
+      GenericResponse<MacroInstanceIdentifier> response =
+          await _instantiateMacro(message);
+      sendPort.send(response);
+    } else if (message is ExecuteDefinitionsPhaseRequest) {
+      GenericResponse<MacroExecutionResult> response =
+          await _executeDefinitionsPhase(message);
+      sendPort.send(response);
+    } else {
+      throw new StateError('Unrecognized event type $message');
+    }
+  });
+}
+
+/// Maps macro identifiers to class mirrors.
+final _macroClasses = <_MacroClassIdentifier, ClassMirror>{};
+
+/// Handles [LoadMacroRequest]s.
+Future<GenericResponse<MacroClassIdentifier>> _loadMacro(
+    LoadMacroRequest request) async {
+  try {
+    _MacroClassIdentifier identifier =
+        new _MacroClassIdentifier(request.library, request.name);
+    if (_macroClasses.containsKey(identifier)) {
+      throw new UnsupportedError(
+          'Reloading macros is not supported by this implementation');
+    }
+    LibraryMirror libMirror =
+        await currentMirrorSystem().isolate.loadUri(request.library);
+    ClassMirror macroClass =
+        libMirror.declarations[new Symbol(request.name)] as ClassMirror;
+    _macroClasses[identifier] = macroClass;
+    return new GenericResponse(response: identifier, requestId: request.id);
+  } catch (e) {
+    return new GenericResponse(error: e, requestId: request.id);
+  }
+}
+
+/// Maps macro instance identifiers to instances.
+final _macroInstances = <_MacroInstanceIdentifier, Macro>{};
+
+/// Handles [InstantiateMacroRequest]s.
+Future<GenericResponse<MacroInstanceIdentifier>> _instantiateMacro(
+    InstantiateMacroRequest request) async {
+  try {
+    ClassMirror? clazz = _macroClasses[request.macroClass];
+    if (clazz == null) {
+      throw new ArgumentError('Unrecognized macro class ${request.macroClass}');
+    }
+    Macro instance = clazz.newInstance(
+        new Symbol(request.constructorName), request.arguments.positional, {
+      for (MapEntry<String, Object?> entry in request.arguments.named.entries)
+        new Symbol(entry.key): entry.value,
+    }).reflectee as Macro;
+    _MacroInstanceIdentifier identifier = new _MacroInstanceIdentifier();
+    _macroInstances[identifier] = instance;
+    return new GenericResponse<MacroInstanceIdentifier>(
+        response: identifier, requestId: request.id);
+  } catch (e) {
+    return new GenericResponse(error: e, requestId: request.id);
+  }
+}
+
+Future<GenericResponse<MacroExecutionResult>> _executeDefinitionsPhase(
+    ExecuteDefinitionsPhaseRequest request) async {
+  try {
+    Macro? instance = _macroInstances[request.macro];
+    if (instance == null) {
+      throw new StateError('Unrecognized macro instance ${request.macro}\n'
+          'Known instances: $_macroInstances)');
+    }
+    Declaration declaration = request.declaration;
+    if (instance is FunctionDefinitionMacro &&
+        declaration is FunctionDeclaration) {
+      _FunctionDefinitionBuilder builder = new _FunctionDefinitionBuilder(
+          declaration,
+          request.typeResolver,
+          request.typeDeclarationResolver,
+          request.classIntrospector);
+      await instance.buildDefinitionForFunction(declaration, builder);
+      return new GenericResponse(
+          response: builder.result, requestId: request.id);
+    } else {
+      throw new UnsupportedError(
+          ('Only FunctionDefinitionMacros are supported currently'));
+    }
+  } catch (e) {
+    return new GenericResponse(error: e, requestId: request.id);
+  }
+}
+
+/// Our implementation of [MacroClassIdentifier].
+class _MacroClassIdentifier implements MacroClassIdentifier {
+  final String id;
+
+  _MacroClassIdentifier(Uri library, String name) : id = '$library#$name';
+
+  operator ==(other) => other is _MacroClassIdentifier && id == other.id;
+
+  int get hashCode => id.hashCode;
+}
+
+/// Our implementation of [MacroInstanceIdentifier].
+class _MacroInstanceIdentifier implements MacroInstanceIdentifier {
+  static int _next = 0;
+
+  final int id;
+
+  _MacroInstanceIdentifier() : id = _next++;
+
+  operator ==(other) => other is _MacroInstanceIdentifier && id == other.id;
+
+  int get hashCode => id;
+}
+
+/// Our implementation of [MacroExecutionResult].
+class _MacroExecutionResult implements MacroExecutionResult {
+  @override
+  final List<DeclarationCode> augmentations = <DeclarationCode>[];
+
+  @override
+  final List<DeclarationCode> imports = <DeclarationCode>[];
+}
+
+/// Custom implementation of [FunctionDefinitionBuilder].
+class _FunctionDefinitionBuilder implements FunctionDefinitionBuilder {
+  final TypeResolver typeResolver;
+  final TypeDeclarationResolver typeDeclarationResolver;
+  final ClassIntrospector classIntrospector;
+
+  /// The declaration this is a builder for.
+  final FunctionDeclaration declaration;
+
+  /// The final result, will be built up over `augment` calls.
+  final _MacroExecutionResult result = new _MacroExecutionResult();
+
+  _FunctionDefinitionBuilder(this.declaration, this.typeResolver,
+      this.typeDeclarationResolver, this.classIntrospector);
+
+  @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/isolate_mirrors_executor/protocol.dart b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/protocol.dart
new file mode 100644
index 0000000..96a2724
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/lib/src/macros/isolate_mirrors_executor/protocol.dart
@@ -0,0 +1,61 @@
+// 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.
+
+/// Defines the objects used for communication between the macro executor and
+/// the isolate doing the work of macro loading and execution.
+library protocol;
+
+import '../executor.dart';
+import '../api.dart';
+
+/// Base class all requests extend, provides a unique id for each request.
+class Request {
+  final int id;
+
+  Request() : id = _next++;
+
+  static int _next = 0;
+}
+
+/// A generic response object that is either an instance of [T] or an error.
+class GenericResponse<T> {
+  final T? response;
+  final Object? error;
+  final int requestId;
+
+  GenericResponse({this.response, this.error, required this.requestId})
+      : assert(response != null || error != null),
+        assert(response == null || error == null);
+}
+
+/// A request to load a macro in this isolate.
+class LoadMacroRequest extends Request {
+  final Uri library;
+  final String name;
+
+  LoadMacroRequest(this.library, this.name);
+}
+
+/// A request to instantiate a macro instance.
+class InstantiateMacroRequest extends Request {
+  final MacroClassIdentifier macroClass;
+  final String constructorName;
+  final Arguments arguments;
+
+  InstantiateMacroRequest(
+      this.macroClass, this.constructorName, this.arguments);
+}
+
+/// A request to execute a macro on a particular declaration in the definition
+/// phase.
+class ExecuteDefinitionsPhaseRequest extends Request {
+  final MacroInstanceIdentifier macro;
+  final Declaration declaration;
+  final TypeResolver typeResolver;
+  final ClassIntrospector classIntrospector;
+  final TypeDeclarationResolver typeDeclarationResolver;
+
+  ExecuteDefinitionsPhaseRequest(this.macro, this.declaration,
+      this.typeResolver, this.classIntrospector, this.typeDeclarationResolver);
+}
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
new file mode 100644
index 0000000..48ca97b
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/isolate_mirror_executor_test.dart
@@ -0,0 +1,147 @@
+// 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: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/isolate_mirrors_executor/isolate_mirrors_executor.dart';
+
+import 'package:test/fake.dart';
+import 'package:test/test.dart';
+
+void main() {
+  late MacroExecutor executor;
+
+  setUp(() async {
+    executor = await IsolateMirrorMacroExecutor.start();
+  });
+
+  tearDown(() {
+    executor.close();
+  });
+
+  test('can load macros and create instances', () async {
+    var clazzId = await executor.loadMacro(
+        // Tests run from the root of the repo.
+        File('pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/simple_macro.dart')
+            .absolute
+            .uri,
+        'SimpleMacro');
+    expect(clazzId, isNotNull, reason: 'Can load a macro.');
+
+    var instanceId =
+        await executor.instantiateMacro(clazzId, '', Arguments([], {}));
+    expect(instanceId, isNotNull,
+        reason: 'Can create an instance with no arguments.');
+
+    instanceId =
+        await executor.instantiateMacro(clazzId, '', Arguments([1, 2], {}));
+    expect(instanceId, isNotNull,
+        reason: 'Can create an instance with positional arguments.');
+
+    instanceId = await executor.instantiateMacro(
+        clazzId, 'named', Arguments([], {'x': 1, 'y': 2}));
+    expect(instanceId, isNotNull,
+        reason: 'Can create an instance with named arguments.');
+
+    var definitionResult = await executor.executeDefinitionsPhase(
+        instanceId,
+        _FunctionDeclaration(
+          isAbstract: false,
+          isExternal: false,
+          isGetter: false,
+          isSetter: false,
+          name: 'foo',
+          namedParameters: [],
+          positionalParameters: [],
+          returnType:
+              _TypeAnnotation(Code.fromString('String'), isNullable: false),
+          typeParameters: [],
+        ),
+        _FakeTypeResolver(),
+        _FakeClassIntrospector(),
+        _FakeTypeDeclarationResolver());
+    expect(definitionResult.augmentations, hasLength(1));
+    expect(definitionResult.augmentations.first.debugString().toString(),
+        equalsIgnoringWhitespace('''
+            augment String foo() {
+              print('x: 1, y: 2');
+              return augment super();
+            }'''));
+  });
+}
+
+class _FakeClassIntrospector with Fake implements ClassIntrospector {}
+
+class _FakeTypeResolver with Fake implements TypeResolver {}
+
+class _FakeTypeDeclarationResolver
+    with Fake
+    implements TypeDeclarationResolver {}
+
+class _FunctionDeclaration implements FunctionDeclaration {
+  @override
+  final bool isAbstract;
+
+  @override
+  final bool isExternal;
+
+  @override
+  final bool isGetter;
+
+  @override
+  final bool isSetter;
+
+  @override
+  final String name;
+
+  @override
+  final Iterable<ParameterDeclaration> namedParameters;
+
+  @override
+  final Iterable<ParameterDeclaration> positionalParameters;
+
+  @override
+  final TypeAnnotation returnType;
+
+  @override
+  final Iterable<TypeParameterDeclaration> typeParameters;
+
+  _FunctionDeclaration({
+    required this.isAbstract,
+    required this.isExternal,
+    required this.isGetter,
+    required this.isSetter,
+    required this.name,
+    required this.namedParameters,
+    required this.positionalParameters,
+    required this.returnType,
+    required this.typeParameters,
+  });
+}
+
+class _TypeAnnotation implements TypeAnnotation {
+  @override
+  final Code code;
+
+  @override
+  final bool isNullable;
+
+  _TypeAnnotation(this.code, {required this.isNullable});
+}
+
+extension _ on Code {
+  StringBuffer debugString([StringBuffer? buffer]) {
+    buffer ??= StringBuffer();
+    for (var part in parts) {
+      if (part is Code) {
+        part.debugString(buffer);
+      } else {
+        buffer.write(part.toString());
+      }
+    }
+    return buffer;
+  }
+}
diff --git a/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/simple_macro.dart b/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/simple_macro.dart
new file mode 100644
index 0000000..b95da0b
--- /dev/null
+++ b/pkg/_fe_analyzer_shared/test/macros/isolate_mirror_executor/simple_macro.dart
@@ -0,0 +1,33 @@
+// 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 '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 FunctionDefinitionMacro {
+  final int? x;
+  final int? y;
+
+  SimpleMacro([this.x, this.y]);
+
+  SimpleMacro.named({this.x, this.y});
+
+  @override
+  FutureOr<void> buildDefinitionForFunction(
+      FunctionDeclaration method, FunctionDefinitionBuilder builder) {
+    if (method.namedParameters
+        .followedBy(method.positionalParameters)
+        .isNotEmpty) {
+      throw ArgumentError(
+          'This macro can only be run on functions with no arguments!');
+    }
+    builder.augment(FunctionBodyCode.fromString('''{
+      print('x: $x, y: $y');
+      return augment super();
+    }'''));
+  }
+}
diff --git a/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart b/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart
index aa75988..3b4f5f2 100644
--- a/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart
+++ b/pkg/analysis_server/lib/src/services/completion/dart/extension_member_contributor.dart
@@ -7,10 +7,10 @@
 import 'package:analysis_server/src/provisional/completion/dart/completion_dart.dart';
 import 'package:analysis_server/src/services/completion/dart/completion_manager.dart';
 import 'package:analysis_server/src/services/completion/dart/suggestion_builder.dart';
-import 'package:analysis_server/src/utilities/extensions/element.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
+import 'package:analyzer/src/dart/resolver/applicable_extensions.dart';
 
 /// A contributor that produces suggestions based on the members of an
 /// extension.
@@ -115,21 +115,21 @@
 
   void _addExtensionMembers(List<ExtensionElement> extensions,
       CompletionSuggestionKind? kind, DartType type) {
-    var containingLibrary = request.libraryElement;
-    var typeSystem = containingLibrary.typeSystem;
-    for (var extension in extensions) {
-      var extendedType =
-          extension.resolvedExtendedType(containingLibrary, type);
-      if (extendedType != null && typeSystem.isSubtypeOf(type, extendedType)) {
-        var inheritanceDistance = 0.0;
-        if (type is InterfaceType && extendedType is InterfaceType) {
-          inheritanceDistance = memberBuilder.request.featureComputer
-              .inheritanceDistanceFeature(type.element, extendedType.element);
-        }
-        // TODO(brianwilkerson) We might want to apply the substitution to the
-        //  members of the extension for display purposes.
-        _addInstanceMembers(extension, kind, inheritanceDistance);
+    var applicableExtensions = extensions.applicableTo(
+      targetLibrary: request.libraryElement,
+      targetType: type,
+    );
+    for (var instantiatedExtension in applicableExtensions) {
+      var extendedType = instantiatedExtension.extendedType;
+      var inheritanceDistance = 0.0;
+      if (type is InterfaceType && extendedType is InterfaceType) {
+        inheritanceDistance = memberBuilder.request.featureComputer
+            .inheritanceDistanceFeature(type.element, extendedType.element);
       }
+      // TODO(brianwilkerson) We might want to apply the substitution to the
+      //  members of the extension for display purposes.
+      _addInstanceMembers(
+          instantiatedExtension.extension, kind, inheritanceDistance);
     }
   }
 
diff --git a/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart b/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart
index 12c65d0..98cc241 100644
--- a/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart
+++ b/pkg/analysis_server/lib/src/services/correction/dart/import_library.dart
@@ -153,11 +153,12 @@
         continue;
       }
       foundImport = true;
-      var instantiatedExtensions = ApplicableExtensions(
-        targetLibrary: libraryElement,
-        targetType: targetType,
-        memberName: memberName,
-      ).instantiate(importedLibrary.exportedExtensions);
+      var instantiatedExtensions = importedLibrary.exportedExtensions
+          .hasMemberWithBaseName(memberName)
+          .applicableTo(
+            targetLibrary: libraryElement,
+            targetType: targetType,
+          );
       for (var instantiatedExtension in instantiatedExtensions) {
         // If the import has a combinator that needs to be updated, then offer
         // to update it.
@@ -454,11 +455,12 @@
 
   @override
   Future<void> compute(ChangeBuilder builder) async {
-    var instantiatedExtensions = ApplicableExtensions(
-      targetLibrary: libraryElement,
-      targetType: targetType,
-      memberName: memberName,
-    ).instantiate(library.exportedExtensions);
+    var instantiatedExtensions = library.exportedExtensions
+        .hasMemberWithBaseName(memberName)
+        .applicableTo(
+          targetLibrary: libraryElement,
+          targetType: targetType,
+        );
     if (instantiatedExtensions.isNotEmpty) {
       await builder.addDartFileEdit(file, (builder) {
         _uriText = builder.importLibrary(library.source.uri);
diff --git a/pkg/analysis_server/lib/src/utilities/extensions/element.dart b/pkg/analysis_server/lib/src/utilities/extensions/element.dart
index 33e7498..1bc51b1 100644
--- a/pkg/analysis_server/lib/src/utilities/extensions/element.dart
+++ b/pkg/analysis_server/lib/src/utilities/extensions/element.dart
@@ -3,10 +3,6 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/element/element.dart';
-import 'package:analyzer/dart/element/type.dart';
-import 'package:analyzer/src/dart/element/generic_inferrer.dart';
-import 'package:analyzer/src/dart/element/type_algebra.dart';
-import 'package:analyzer/src/dart/element/type_system.dart';
 
 extension ClassElementExtensions on ClassElement {
   /// Return `true` if this element represents the class `Iterable` from
@@ -59,35 +55,6 @@
   }
 }
 
-extension ExtensionElementExtensions on ExtensionElement {
-  /// Use the [type] of the object being extended in the [library] to compute
-  /// the actual type extended by this [extension]. Return the computed type,
-  /// or `null` if the type can't be computed.
-  /// TODO(scheglov) share with analyzer
-  DartType? resolvedExtendedType(LibraryElement library, DartType type) {
-    final typeParameters = this.typeParameters;
-    var inferrer =
-        GenericInferrer(library.typeSystem as TypeSystemImpl, typeParameters);
-    inferrer.constrainArgument(
-      type,
-      extendedType,
-      'extendedType',
-    );
-    var typeArguments = inferrer.infer(typeParameters,
-        failAtError: true, genericMetadataIsEnabled: true);
-    if (typeArguments == null) {
-      return null;
-    }
-    var substitution = Substitution.fromPairs(
-      typeParameters,
-      typeArguments,
-    );
-    return substitution.substituteType(
-      extendedType,
-    );
-  }
-}
-
 extension LibraryElementExtensions on LibraryElement {
   /// Return all extensions exported from this library.
   Iterable<ExtensionElement> get exportedExtensions {
diff --git a/pkg/analyzer/lib/src/dart/resolver/applicable_extensions.dart b/pkg/analyzer/lib/src/dart/resolver/applicable_extensions.dart
index 95d2c81..478c884 100644
--- a/pkg/analyzer/lib/src/dart/resolver/applicable_extensions.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/applicable_extensions.dart
@@ -10,139 +10,18 @@
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/type_algebra.dart';
-import 'package:analyzer/src/dart/element/type_system.dart';
 import 'package:analyzer/src/dart/resolver/resolution_result.dart';
 
-/// Extensions that can be applied, within the [targetLibrary], to the
-/// [targetType], and that define a member with the base [memberName].
-class ApplicableExtensions {
-  final LibraryElementImpl targetLibrary;
-  final DartType targetType;
-  final String memberName;
-
-  ApplicableExtensions({
-    required LibraryElement targetLibrary,
-    required this.targetType,
-    required this.memberName,
-  }) : targetLibrary = targetLibrary as LibraryElementImpl;
-
-  bool get _genericMetadataIsEnabled {
-    return targetLibrary.featureSet.isEnabled(
-      Feature.generic_metadata,
-    );
-  }
-
-  TypeSystemImpl get _typeSystem {
-    return targetLibrary.typeSystem;
-  }
-
-  /// Return [extensions] that match the configuration.
-  List<InstantiatedExtension> instantiate(
-    Iterable<ExtensionElement> extensions,
-  ) {
-    if (identical(targetType, NeverTypeImpl.instance)) {
-      return const <InstantiatedExtension>[];
-    }
-
-    var instantiatedExtensions = <InstantiatedExtension>[];
-
-    var candidates = _withMember(extensions);
-    for (var candidate in candidates) {
-      var extension = candidate.extension;
-
-      var freshTypes = getFreshTypeParameters(extension.typeParameters);
-      var freshTypeParameters = freshTypes.freshTypeParameters;
-      var rawExtendedType = freshTypes.substitute(extension.extendedType);
-
-      var inferrer = GenericInferrer(_typeSystem, freshTypeParameters);
-      inferrer.constrainArgument(
-        targetType,
-        rawExtendedType,
-        'extendedType',
-      );
-      var typeArguments = inferrer.infer(
-        freshTypeParameters,
-        failAtError: true,
-        genericMetadataIsEnabled: _genericMetadataIsEnabled,
-      );
-      if (typeArguments == null) {
-        continue;
-      }
-
-      var substitution = Substitution.fromPairs(
-        extension.typeParameters,
-        typeArguments,
-      );
-      var extendedType = substitution.substituteType(
-        extension.extendedType,
-      );
-
-      if (!_typeSystem.isSubtypeOf(targetType, extendedType)) {
-        continue;
-      }
-
-      instantiatedExtensions.add(
-        InstantiatedExtension(candidate, substitution, extendedType),
-      );
-    }
-
-    return instantiatedExtensions;
-  }
-
-  /// Return [extensions] that define a member with the [memberName].
-  List<_CandidateExtension> _withMember(
-    Iterable<ExtensionElement> extensions,
-  ) {
-    var result = <_CandidateExtension>[];
-    for (var extension in extensions) {
-      for (var field in extension.fields) {
-        if (field.name == memberName) {
-          result.add(
-            _CandidateExtension(
-              extension,
-              getter: field.getter,
-              setter: field.setter,
-            ),
-          );
-          break;
-        }
-      }
-      if (memberName == '[]') {
-        ExecutableElement? getter;
-        ExecutableElement? setter;
-        for (var method in extension.methods) {
-          if (method.name == '[]') {
-            getter = method;
-          } else if (method.name == '[]=') {
-            setter = method;
-          }
-        }
-        if (getter != null || setter != null) {
-          result.add(
-            _CandidateExtension(extension, getter: getter, setter: setter),
-          );
-        }
-      } else {
-        for (var method in extension.methods) {
-          if (method.name == memberName) {
-            result.add(
-              _CandidateExtension(extension, getter: method),
-            );
-            break;
-          }
-        }
-      }
-    }
-    return result;
-  }
-}
-
-class InstantiatedExtension {
-  final _CandidateExtension candidate;
+class InstantiatedExtensionWithMember {
+  final _NotInstantiatedExtensionWithMember candidate;
   final MapSubstitution substitution;
   final DartType extendedType;
 
-  InstantiatedExtension(this.candidate, this.substitution, this.extendedType);
+  InstantiatedExtensionWithMember(
+    this.candidate,
+    this.substitution,
+    this.extendedType,
+  );
 
   ResolutionResult get asResolutionResult {
     return ResolutionResult(getter: getter, setter: setter);
@@ -167,11 +46,191 @@
   }
 }
 
-class _CandidateExtension {
+class InstantiatedExtensionWithoutMember {
   final ExtensionElement extension;
+  final MapSubstitution substitution;
+  final DartType extendedType;
+
+  InstantiatedExtensionWithoutMember(
+    this.extension,
+    this.substitution,
+    this.extendedType,
+  );
+}
+
+abstract class _NotInstantiatedExtension<R> {
+  final ExtensionElement extension;
+
+  _NotInstantiatedExtension(this.extension);
+
+  R instantiate({
+    required MapSubstitution substitution,
+    required DartType extendedType,
+  });
+}
+
+class _NotInstantiatedExtensionWithMember
+    extends _NotInstantiatedExtension<InstantiatedExtensionWithMember> {
   final ExecutableElement? getter;
   final ExecutableElement? setter;
 
-  _CandidateExtension(this.extension, {this.getter, this.setter})
-      : assert(getter != null || setter != null);
+  _NotInstantiatedExtensionWithMember(ExtensionElement extension,
+      {this.getter, this.setter})
+      : assert(getter != null || setter != null),
+        super(extension);
+
+  @override
+  InstantiatedExtensionWithMember instantiate({
+    required MapSubstitution substitution,
+    required DartType extendedType,
+  }) {
+    return InstantiatedExtensionWithMember(this, substitution, extendedType);
+  }
+}
+
+/// [_NotInstantiatedExtension] for any [ExtensionElement].
+class _NotInstantiatedExtensionWithoutMember
+    extends _NotInstantiatedExtension<InstantiatedExtensionWithoutMember> {
+  _NotInstantiatedExtensionWithoutMember(ExtensionElement extension)
+      : super(extension);
+
+  @override
+  InstantiatedExtensionWithoutMember instantiate({
+    required MapSubstitution substitution,
+    required DartType extendedType,
+  }) {
+    return InstantiatedExtensionWithoutMember(
+        extension, substitution, extendedType);
+  }
+}
+
+extension ExtensionsExtensions on Iterable<ExtensionElement> {
+  List<_NotInstantiatedExtensionWithMember> hasMemberWithBaseName(
+    String baseName,
+  ) {
+    var result = <_NotInstantiatedExtensionWithMember>[];
+    for (var extension in this) {
+      if (baseName == '[]') {
+        ExecutableElement? getter;
+        ExecutableElement? setter;
+        for (var method in extension.methods) {
+          if (method.name == '[]') {
+            getter = method;
+          } else if (method.name == '[]=') {
+            setter = method;
+          }
+        }
+        if (getter != null || setter != null) {
+          result.add(
+            _NotInstantiatedExtensionWithMember(
+              extension,
+              getter: getter,
+              setter: setter,
+            ),
+          );
+        }
+      } else {
+        for (var field in extension.fields) {
+          if (field.name == baseName) {
+            result.add(
+              _NotInstantiatedExtensionWithMember(
+                extension,
+                getter: field.getter,
+                setter: field.setter,
+              ),
+            );
+            break;
+          }
+        }
+        for (var method in extension.methods) {
+          if (method.name == baseName) {
+            result.add(
+              _NotInstantiatedExtensionWithMember(
+                extension,
+                getter: method,
+              ),
+            );
+            break;
+          }
+        }
+      }
+    }
+    return result;
+  }
+
+  /// Extensions that can be applied, within [targetLibrary], to [targetType].
+  List<InstantiatedExtensionWithoutMember> applicableTo({
+    required LibraryElement targetLibrary,
+    required DartType targetType,
+  }) {
+    return map((e) => _NotInstantiatedExtensionWithoutMember(e)).applicableTo(
+      targetLibrary: targetLibrary,
+      targetType: targetType,
+    );
+  }
+}
+
+extension NotInstantiatedExtensionsExtensions<R>
+    on Iterable<_NotInstantiatedExtension<R>> {
+  /// Extensions that can be applied, within [targetLibrary], to [targetType].
+  List<R> applicableTo({
+    required LibraryElement targetLibrary,
+    required DartType targetType,
+  }) {
+    if (identical(targetType, NeverTypeImpl.instance)) {
+      return <R>[];
+    }
+
+    targetLibrary as LibraryElementImpl;
+    var typeSystem = targetLibrary.typeSystem;
+    var genericMetadataIsEnabled = targetLibrary.featureSet.isEnabled(
+      Feature.generic_metadata,
+    );
+
+    var instantiated = <R>[];
+
+    for (var notInstantiated in this) {
+      var extension = notInstantiated.extension;
+
+      var freshTypes = getFreshTypeParameters(extension.typeParameters);
+      var freshTypeParameters = freshTypes.freshTypeParameters;
+      var rawExtendedType = freshTypes.substitute(extension.extendedType);
+
+      var inferrer = GenericInferrer(typeSystem, freshTypeParameters);
+      inferrer.constrainArgument(
+        targetType,
+        rawExtendedType,
+        'extendedType',
+      );
+      var typeArguments = inferrer.infer(
+        freshTypeParameters,
+        failAtError: true,
+        genericMetadataIsEnabled: genericMetadataIsEnabled,
+      );
+      if (typeArguments == null) {
+        continue;
+      }
+
+      var substitution = Substitution.fromPairs(
+        extension.typeParameters,
+        typeArguments,
+      );
+      var extendedType = substitution.substituteType(
+        extension.extendedType,
+      );
+
+      if (!typeSystem.isSubtypeOf(targetType, extendedType)) {
+        continue;
+      }
+
+      instantiated.add(
+        notInstantiated.instantiate(
+          substitution: substitution,
+          extendedType: extendedType,
+        ),
+      );
+    }
+
+    return instantiated;
+  }
 }
diff --git a/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart b/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart
index a166ff7..517ff5c 100644
--- a/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart
+++ b/pkg/analyzer/lib/src/dart/resolver/extension_member_resolver.dart
@@ -54,11 +54,12 @@
     SyntacticEntity nameEntity,
     String name,
   ) {
-    var extensions = ApplicableExtensions(
-      targetLibrary: _resolver.definingLibrary,
-      targetType: type,
-      memberName: name,
-    ).instantiate(_resolver.definingLibrary.accessibleExtensions);
+    var extensions = _resolver.definingLibrary.accessibleExtensions
+        .hasMemberWithBaseName(name)
+        .applicableTo(
+          targetLibrary: _resolver.definingLibrary,
+          targetType: type,
+        );
 
     if (extensions.isEmpty) {
       return ResolutionResult.none;
@@ -267,10 +268,11 @@
 
   /// Return either the most specific extension, or a list of the extensions
   /// that are ambiguous.
-  Either2<InstantiatedExtension, List<InstantiatedExtension>>
-      _chooseMostSpecific(List<InstantiatedExtension> extensions) {
-    InstantiatedExtension? bestSoFar;
-    var noneMoreSpecific = <InstantiatedExtension>[];
+  Either2<InstantiatedExtensionWithMember,
+          List<InstantiatedExtensionWithMember>>
+      _chooseMostSpecific(List<InstantiatedExtensionWithMember> extensions) {
+    InstantiatedExtensionWithMember? bestSoFar;
+    var noneMoreSpecific = <InstantiatedExtensionWithMember>[];
     for (var candidate in extensions) {
       if (noneMoreSpecific.isNotEmpty) {
         var isMostSpecific = true;
@@ -369,7 +371,8 @@
   }
 
   /// Return `true` is [e1] is more specific than [e2].
-  bool _isMoreSpecific(InstantiatedExtension e1, InstantiatedExtension e2) {
+  bool _isMoreSpecific(
+      InstantiatedExtensionWithMember e1, InstantiatedExtensionWithMember e2) {
     // 1. The latter extension is declared in a platform library, and the
     //    former extension is not.
     // 2. They are both declared in platform libraries, or both declared in
diff --git a/pkg/dds/lib/src/dap/adapters/mixins.dart b/pkg/dds/lib/src/dap/adapters/mixins.dart
index b9f307f..53de6fc 100644
--- a/pkg/dds/lib/src/dap/adapters/mixins.dart
+++ b/pkg/dds/lib/src/dap/adapters/mixins.dart
@@ -160,7 +160,7 @@
     final completer = Completer<Uri>();
     late final StreamSubscription<FileSystemEvent> vmServiceInfoFileWatcher;
 
-    Uri? tryParseServiceInfoFile(FileSystemEvent event) {
+    void tryParseServiceInfoFile(FileSystemEvent event) {
       final uri = _readVmServiceInfoFile(logger, vmServiceInfoFile);
       if (uri != null && !completer.isCompleted) {
         vmServiceInfoFileWatcher.cancel();
@@ -200,6 +200,7 @@
       // It's possible we tried to read the file before it was completely
       // written so ignore and try again on the next event.
       logger?.call('Ignoring error parsing vm-service-info file: $e');
+      return null;
     }
   }
 }
diff --git a/pkg/dds/lib/src/dap/isolate_manager.dart b/pkg/dds/lib/src/dap/isolate_manager.dart
index cbf2087..9fb0adf 100644
--- a/pkg/dds/lib/src/dap/isolate_manager.dart
+++ b/pkg/dds/lib/src/dap/isolate_manager.dart
@@ -375,6 +375,7 @@
         'Debugger failed to evaluate breakpoint $type "$expression": $e\n',
       );
     }
+    return null;
   }
 
   void _handleExit(vm.Event event) {
diff --git a/pkg/front_end/test/spell_checking_list_code.txt b/pkg/front_end/test/spell_checking_list_code.txt
index a132ce2..81e6368 100644
--- a/pkg/front_end/test/spell_checking_list_code.txt
+++ b/pkg/front_end/test/spell_checking_list_code.txt
@@ -47,6 +47,7 @@
 anyone
 ap
 api
+apis
 app
 apparently
 applicable
@@ -73,6 +74,11 @@
 atom
 atoms
 attributes
+augment
+augmentation
+augmentations
+augmenting
+augments
 auto
 automagically
 auxiliary
@@ -140,6 +146,7 @@
 breadcrumbs
 brevity
 brianwilkerson
+bridge
 bs
 bsd
 bslash
@@ -225,15 +232,18 @@
 combinator
 combine2
 combiner
+communication
 compared
 compares
 compilations
+completers
 completes
 complicating
 component's
 comprehensive
 compressed
 compression
+comprise
 concat
 concatenate
 concerned
@@ -252,6 +262,7 @@
 containers
 continuations
 contra
+contribute
 convention
 coordinated
 coordinating
@@ -310,6 +321,7 @@
 deeply
 def
 defaulting
+definitions
 degrades
 degree
 del
@@ -353,6 +365,7 @@
 disallow
 disambiguating
 disambiguator
+discovers
 disjoint
 dispatched
 distribute
@@ -420,6 +433,7 @@
 estimate
 eval
 execute
+executor
 exhausted
 existence
 existentially
@@ -643,10 +657,14 @@
 interval
 intervals
 intl
+introspect
+introspection
+introspector
 ints
 invariants
 io
 is64
+isolate
 isolated
 issuecomment
 issuing
@@ -661,6 +679,7 @@
 java
 jenkins
 jensj
+job
 johnniwinther
 js
 json
@@ -672,6 +691,7 @@
 kallentu
 kernel's
 kernel2kernel
+kill
 klass
 kmillikin
 kotlin
@@ -707,6 +727,7 @@
 libs
 lifted
 lifter
+limiting
 linearized
 linebreak
 linter
@@ -948,6 +969,7 @@
 preexisting
 premark
 preorder
+prepares
 preprocess
 presented
 presubmit
@@ -966,10 +988,12 @@
 promo
 proof
 prop
+proposal
 propose
 proposed
 proto
 protobuf
+protocol
 ps
 pulled
 pure
@@ -1048,6 +1072,7 @@
 reexports
 ref
 reflect
+reflectee
 reflective
 reg
 regis
@@ -1063,6 +1088,8 @@
 relaxes
 released
 relink
+reload
+reloading
 remapped
 remedy
 removal
@@ -1079,11 +1106,14 @@
 repo
 repositories
 repurposed
+requests
 requirement
 res
 residue
 resource
 respond
+response
+responses
 restoring
 restriction
 resumed
@@ -1131,11 +1161,13 @@
 separators
 sequencing
 sequential
+serializable
 serializables
 serializer
 serializers
 serve
 server
+serves
 service
 session
 setable
@@ -1154,6 +1186,8 @@
 shr
 shrinking
 shru
+shut
+shutting
 si
 sibling
 siblings
@@ -1186,6 +1220,8 @@
 sourcemap
 spaced
 sparse
+spawn
+spawns
 spec
 spec'ed
 specialization
@@ -1384,6 +1420,7 @@
 unifiable
 unification
 unifier
+unifies
 unify
 uninstantiable
 uninstantiated
@@ -1456,6 +1493,7 @@
 w
 waiting
 wanting
+wants
 waste
 wasted
 watch
diff --git a/runtime/BUILD.gn b/runtime/BUILD.gn
index 273a109..8b3999a 100644
--- a/runtime/BUILD.gn
+++ b/runtime/BUILD.gn
@@ -238,7 +238,6 @@
 source_set("dart_api") {
   public_configs = [ ":dart_public_config" ]
   sources = [
-    "include/analyze_snapshot_api.h",
     "include/dart_api.h",
     "include/dart_api_dl.c",
     "include/dart_api_dl.h",
@@ -286,11 +285,9 @@
   public_configs = [ ":dart_public_config" ]
   sources = [
     "$target_gen_dir/version.cc",
-    "include/analyze_snapshot_api.h",
     "include/dart_api.h",
     "include/dart_native_api.h",
     "include/dart_tools_api.h",
-    "vm/analyze_snapshot_api_impl.cc",
     "vm/dart_api_impl.cc",
     "vm/native_api_impl.cc",
     "vm/version.h",
diff --git a/runtime/bin/BUILD.gn b/runtime/bin/BUILD.gn
index 04e73a2..ea7d40d 100644
--- a/runtime/bin/BUILD.gn
+++ b/runtime/bin/BUILD.gn
@@ -880,45 +880,6 @@
   extra_deps += [ ":elf_loader_product" ]
 }
 
-dart_executable("analyze_snapshot") {
-  extra_configs = [ "..:dart_precompiled_runtime_config" ]
-  extra_deps = [
-    "..:libdart_precompiled_runtime",
-    "../platform:libdart_platform_precompiled_runtime",
-  ]
-
-  extra_sources = [
-    "analyze_snapshot.cc",
-    "builtin.cc",
-    "loader.cc",
-    "loader.h",
-  ]
-
-  if (dart_runtime_mode == "release") {
-    extra_deps += [ ":elf_loader_product" ]
-  } else {
-    extra_deps += [ ":elf_loader" ]
-  }
-}
-
-dart_executable("analyze_snapshot_product") {
-  use_product_mode = true
-  extra_configs = [ "..:dart_precompiled_runtime_config" ]
-  extra_deps = [
-    "..:libdart_precompiled_runtime_product",
-    "../platform:libdart_platform_precompiled_runtime_product",
-  ]
-
-  extra_sources = [
-    "analyze_snapshot.cc",
-    "builtin.cc",
-    "loader.cc",
-    "loader.h",
-  ]
-
-  extra_deps += [ ":elf_loader_product" ]
-}
-
 executable("process_test") {
   sources = [ "process_test.cc" ]
 }
diff --git a/runtime/bin/analyze_snapshot.cc b/runtime/bin/analyze_snapshot.cc
deleted file mode 100644
index 9bf6202..0000000
--- a/runtime/bin/analyze_snapshot.cc
+++ /dev/null
@@ -1,249 +0,0 @@
-// 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.
-
-#include "bin/elf_loader.h"
-#include "bin/error_exit.h"
-#include "bin/file.h"
-
-#include "bin/options.h"
-#include "bin/platform.h"
-
-#include "include/analyze_snapshot_api.h"
-
-namespace dart {
-namespace bin {
-
-#define STRING_OPTIONS_LIST(V) V(out, out_path)
-
-#define BOOL_OPTIONS_LIST(V)                                                   \
-  V(help, help)                                                                \
-  V(version, version)
-
-#define STRING_OPTION_DEFINITION(flag, variable)                               \
-  static const char* variable = nullptr;                                       \
-  DEFINE_STRING_OPTION(flag, variable)
-STRING_OPTIONS_LIST(STRING_OPTION_DEFINITION)
-#undef STRING_OPTION_DEFINITION
-
-#define BOOL_OPTION_DEFINITION(flag, variable)                                 \
-  static bool variable = false;                                                \
-  DEFINE_BOOL_OPTION(flag, variable)
-BOOL_OPTIONS_LIST(BOOL_OPTION_DEFINITION)
-#undef BOOL_OPTION_DEFINITION
-
-// clang-format off
-static void PrintUsage() {
-  Syslog::PrintErr(
-"Usage: analyze_snapshot [<vm-flags>] [<options>] <snapshot_data>            \n"
-"                                                                            \n"
-"Common options:                                                             \n"
-"--help                                                                      \n"
-"  Display this message.                                                     \n"
-"--version                                                                   \n"
-"  Print the SDK version.                                                    \n"
-"--out                                                                       \n"
-"  Path to generate the analysis results JSON.                               \n"
-"                                                                            \n"
-"If omitting [<vm-flags>] the VM parsing the snapshot is created with the    \n"
-"following default flags:                                                    \n"
-"--enable_mirrors=false                                                      \n"
-"--background_compilation                                                    \n"
-"--lazy_async_stacks                                                         \n"
-"--precompilation                                                            \n"
-"                                                                            \n"
-"\n");
-}
-// clang-format on
-
-const uint8_t* vm_snapshot_data = nullptr;
-const uint8_t* vm_snapshot_instructions = nullptr;
-const uint8_t* vm_isolate_data = nullptr;
-const uint8_t* vm_isolate_instructions = nullptr;
-
-// Parse out the command line arguments. Returns -1 if the arguments
-// are incorrect, 0 otherwise.
-static int ParseArguments(int argc,
-                          char** argv,
-                          CommandLineOptions* vm_options,
-                          CommandLineOptions* inputs) {
-  // Skip the binary name.
-  int i = 1;
-
-  // Parse out the vm options.
-  while ((i < argc) && OptionProcessor::IsValidShortFlag(argv[i])) {
-    if (OptionProcessor::TryProcess(argv[i], vm_options)) {
-      i += 1;
-      continue;
-    }
-    vm_options->AddArgument(argv[i]);
-    i += 1;
-  }
-
-  // Parse out the kernel inputs.
-  while (i < argc) {
-    inputs->AddArgument(argv[i]);
-    i++;
-  }
-
-  if (help) {
-    PrintUsage();
-    Platform::Exit(0);
-  } else if (version) {
-    Syslog::PrintErr("Dart SDK version: %s\n", Dart_VersionString());
-    Platform::Exit(0);
-  }
-
-  // Verify consistency of arguments.
-  if (inputs->count() < 1) {
-    Syslog::PrintErr("At least one input is required\n");
-    return -1;
-  }
-
-  if (out_path == nullptr) {
-    Syslog::PrintErr(
-        "Please specify an output path for analysis with the --out flag.\n\n");
-    return -1;
-  }
-
-  return 0;
-}
-
-PRINTF_ATTRIBUTE(1, 2) static void PrintErrAndExit(const char* format, ...) {
-  va_list args;
-  va_start(args, format);
-  Syslog::VPrintErr(format, args);
-  va_end(args);
-
-  Dart_ExitScope();
-  Dart_ShutdownIsolate();
-  exit(kErrorExitCode);
-}
-
-static File* OpenFile(const char* filename) {
-  File* file = File::Open(nullptr, filename, File::kWriteTruncate);
-  if (file == nullptr) {
-    PrintErrAndExit("Error: Unable to write file: %s\n\n", filename);
-  }
-  return file;
-}
-
-static void WriteFile(const char* filename,
-                      const char* buffer,
-                      const intptr_t size) {
-  File* file = OpenFile(filename);
-  RefCntReleaseScope<File> rs(file);
-  if (!file->WriteFully(buffer, size)) {
-    PrintErrAndExit("Error: Unable to write file: %s\n\n", filename);
-  }
-}
-
-int RunAnalyzer(int argc, char** argv) {
-  // Constant mirrors gen_snapshot binary, subject to change.
-  const int EXTRA_VM_ARGUMENTS = 7;
-  CommandLineOptions vm_options(argc + EXTRA_VM_ARGUMENTS);
-  CommandLineOptions inputs(argc);
-  // Parse command line arguments.
-  if (ParseArguments(argc, argv, &vm_options, &inputs) < 0) {
-    PrintUsage();
-    return kErrorExitCode;
-  }
-
-  // Initialize VM with default flags if none are provided.
-  // TODO(#47924): Implement auto-parsing of flags from the snapshot file.
-  if (vm_options.count() == 0) {
-    vm_options.AddArgument("--enable_mirrors=false");
-    vm_options.AddArgument("--background_compilation");
-    vm_options.AddArgument("--lazy_async_stacks");
-    vm_options.AddArgument("--precompilation");
-  }
-
-  char* error = Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
-  if (error != nullptr) {
-    Syslog::PrintErr("Setting VM flags failed: %s\n", error);
-    free(error);
-    return kErrorExitCode;
-  }
-
-  // Dart_LoadELF will crash on nonexistant file non-gracefully
-  // even though it should return `nullptr`.
-  File* const file =
-      File::Open(/*namespc=*/nullptr, inputs.GetArgument(0), File::kRead);
-  if (file == nullptr) {
-    Syslog::PrintErr("Snapshot file does not exist\n");
-    return kErrorExitCode;
-  }
-  file->Release();
-
-  const char* loader_error = nullptr;
-  Dart_LoadedElf* loaded_elf = Dart_LoadELF(
-      inputs.GetArgument(0), 0, &loader_error, &vm_snapshot_data,
-      &vm_snapshot_instructions, &vm_isolate_data, &vm_isolate_instructions);
-
-  if (loaded_elf == nullptr) {
-    Syslog::PrintErr("Failure calling Dart_LoadELF:\n%s\n", loader_error);
-    return kErrorExitCode;
-  }
-
-  // Begin initialization
-  Dart_InitializeParams init_params = {};
-  memset(&init_params, 0, sizeof(init_params));
-  init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
-  init_params.vm_snapshot_data = vm_snapshot_data;
-  init_params.vm_snapshot_instructions = vm_snapshot_instructions;
-
-  init_params.file_open = DartUtils::OpenFile;
-  init_params.file_read = DartUtils::ReadFile;
-  init_params.file_write = DartUtils::WriteFile;
-  init_params.file_close = DartUtils::CloseFile;
-  init_params.entropy_source = DartUtils::EntropySource;
-
-  error = Dart_Initialize(&init_params);
-  if (error != nullptr) {
-    Syslog::PrintErr("VM initialization failed: %s\n", error);
-    free(error);
-    return kErrorExitCode;
-  }
-
-  auto isolate_group_data = std::unique_ptr<IsolateGroupData>(
-      new IsolateGroupData(nullptr, nullptr, nullptr, false));
-
-  Dart_IsolateFlags isolate_flags;
-  Dart_IsolateFlagsInitialize(&isolate_flags);
-  // Null safety can be determined from the snapshot itself
-  isolate_flags.null_safety =
-      Dart_DetectNullSafety(nullptr, nullptr, nullptr, vm_snapshot_data,
-                            vm_snapshot_instructions, nullptr, -1);
-
-  Dart_CreateIsolateGroup(nullptr, nullptr, vm_isolate_data,
-                          vm_isolate_instructions, &isolate_flags,
-                          isolate_group_data.get(),
-                          /*isolate_data=*/nullptr, &error);
-
-  if (error != nullptr) {
-    Syslog::PrintErr("Dart_CreateIsolateGroup Error: %s\n", error);
-    free(error);
-    return kErrorExitCode;
-  }
-
-  dart::snapshot_analyzer::Dart_SnapshotAnalyzerInformation info = {
-      vm_snapshot_data, vm_snapshot_instructions, vm_isolate_data,
-      vm_isolate_instructions};
-
-  char* out = NULL;
-  intptr_t out_len = 0;
-
-  Dart_EnterScope();
-  Dart_DumpSnapshotInformationAsJson(&out, &out_len, &info);
-  WriteFile(out_path, out, out_len);
-  // Since ownership of the JSON buffer is ours, free before we exit.
-  free(out);
-  Dart_ExitScope();
-  Dart_ShutdownIsolate();
-  return 0;
-}
-}  // namespace bin
-}  // namespace dart
-int main(int argc, char** argv) {
-  return dart::bin::RunAnalyzer(argc, argv);
-}
diff --git a/runtime/include/analyze_snapshot_api.h b/runtime/include/analyze_snapshot_api.h
deleted file mode 100644
index e02f461..0000000
--- a/runtime/include/analyze_snapshot_api.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef RUNTIME_INCLUDE_ANALYZE_SNAPSHOT_API_H_
-#define RUNTIME_INCLUDE_ANALYZE_SNAPSHOT_API_H_
-
-#include <stdint.h>
-
-namespace dart {
-namespace snapshot_analyzer {
-typedef struct {
-  const uint8_t* vm_snapshot_data;
-  const uint8_t* vm_snapshot_instructions;
-  const uint8_t* vm_isolate_data;
-  const uint8_t* vm_isolate_instructions;
-} Dart_SnapshotAnalyzerInformation;
-
-void Dart_DumpSnapshotInformationAsJson(char** buffer,
-                                        intptr_t* buffer_length,
-                                        Dart_SnapshotAnalyzerInformation* info);
-}  // namespace snapshot_analyzer
-}  // namespace dart
-
-#endif  // RUNTIME_INCLUDE_ANALYZE_SNAPSHOT_API_H_
diff --git a/runtime/tests/vm/dart/analyze_snapshot_binary_test.dart b/runtime/tests/vm/dart/analyze_snapshot_binary_test.dart
deleted file mode 100644
index 1cec0b7..0000000
--- a/runtime/tests/vm/dart/analyze_snapshot_binary_test.dart
+++ /dev/null
@@ -1,300 +0,0 @@
-// Copyright (c) 2018, 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:convert';
-import 'dart:io';
-import 'dart:async';
-
-import 'package:expect/expect.dart';
-import 'package:native_stack_traces/elf.dart';
-import 'package:path/path.dart' as path;
-
-import 'use_flag_test_helper.dart';
-
-// Used to ensure we don't have multiple equivalent calls to test.
-final _seenDescriptions = <String>{};
-
-Future<void> testAOT(String dillPath,
-    {bool useAsm = false,
-    bool forceDrops = false,
-    bool useDispatch = true,
-    bool stripUtil = false, // Note: forced true if useAsm.
-    bool stripFlag = false,
-    bool disassemble = false}) async {
-  if (const bool.fromEnvironment('dart.vm.product') && disassemble) {
-    Expect.isFalse(disassemble, 'no use of disassembler in PRODUCT mode');
-  }
-
-  final analyzeSnapshot = path.join(
-      buildDir,
-      bool.fromEnvironment('dart.vm.product')
-          ? 'analyze_snapshot_product'
-          : 'analyze_snapshot');
-
-  // For assembly, we can't test the sizes of the snapshot sections, since we
-  // don't have a Mach-O reader for Mac snapshots and for ELF, the assembler
-  // merges the text/data sections and the VM/isolate section symbols may not
-  // have length information. Thus, we force external stripping so we can test
-  // the approximate size of the stripped snapshot.
-  if (useAsm) {
-    stripUtil = true;
-  }
-
-  final descriptionBuilder = StringBuffer()..write(useAsm ? 'assembly' : 'elf');
-  if (forceDrops) {
-    descriptionBuilder.write('-dropped');
-  }
-  if (!useDispatch) {
-    descriptionBuilder.write('-nodispatch');
-  }
-  if (stripFlag) {
-    descriptionBuilder.write('-intstrip');
-  }
-  if (stripUtil) {
-    descriptionBuilder.write('-extstrip');
-  }
-  if (disassemble) {
-    descriptionBuilder.write('-disassembled');
-  }
-
-  final description = descriptionBuilder.toString();
-  Expect.isTrue(_seenDescriptions.add(description),
-      "test configuration $description would be run multiple times");
-
-  await withTempDir('analyze_snapshot_binary-$description',
-      (String tempDir) async {
-    // Generate the snapshot
-    final snapshotPath = path.join(tempDir, 'test.snap');
-    final commonSnapshotArgs = [
-      if (stripFlag) '--strip', //  gen_snapshot specific and not a VM flag.
-      if (forceDrops) ...[
-        '--dwarf-stack-traces',
-        '--no-retain-function-objects',
-        '--no-retain-code-objects'
-      ],
-      useDispatch ? '--use-table-dispatch' : '--no-use-table-dispatch',
-      if (disassemble) '--disassemble', // Not defined in PRODUCT mode.
-      dillPath,
-    ];
-
-    if (useAsm) {
-      final assemblyPath = path.join(tempDir, 'test.S');
-
-      await run(genSnapshot, <String>[
-        '--snapshot-kind=app-aot-assembly',
-        '--assembly=$assemblyPath',
-        ...commonSnapshotArgs,
-      ]);
-
-      await assembleSnapshot(assemblyPath, snapshotPath);
-    } else {
-      await run(genSnapshot, <String>[
-        '--snapshot-kind=app-aot-elf',
-        '--elf=$snapshotPath',
-        ...commonSnapshotArgs,
-      ]);
-    }
-
-    print("Snapshot generated at $snapshotPath.");
-
-    // May not be ELF, but another format.
-    final elf = Elf.fromFile(snapshotPath);
-    if (!useAsm) {
-      Expect.isNotNull(elf);
-    }
-
-    if (elf != null) {
-      // Verify some ELF file format parameters.
-      final textSections = elf.namedSections(".text");
-      Expect.isNotEmpty(textSections);
-      Expect.isTrue(
-          textSections.length <= 2, "More text sections than expected");
-      final dataSections = elf.namedSections(".rodata");
-      Expect.isNotEmpty(dataSections);
-      Expect.isTrue(
-          dataSections.length <= 2, "More data sections than expected");
-    }
-
-    final analyzerOutputPath = path.join(tempDir, 'analyze_test.json');
-
-    // This will throw if exit code is not 0.
-    await run(analyzeSnapshot, <String>[
-      '--out=$analyzerOutputPath',
-      '$snapshotPath',
-    ]);
-
-    final analyzerJsonBytes = await readFile(analyzerOutputPath);
-    final analyzerJson = json.decode(analyzerJsonBytes);
-    Expect.isFalse(analyzerJson.isEmpty);
-    Expect.isTrue(analyzerJson.keys
-        .toSet()
-        .containsAll(['snapshot_data', 'class_table', 'object_pool']));
-  });
-}
-
-Match? matchComplete(RegExp regexp, String line) {
-  Match? match = regexp.firstMatch(line);
-  if (match == null) return match;
-  if (match.start != 0 || match.end != line.length) return null;
-  return match;
-}
-
-// All fields of "Raw..." classes defined in "raw_object.h" must be included in
-// the giant macro in "raw_object_fields.cc". This function attempts to check
-// that with some basic regexes.
-testMacros() async {
-  const String className = "([a-z0-9A-Z]+)";
-  const String rawClass = "Raw$className";
-  const String fieldName = "([a-z0-9A-Z_]+)";
-
-  final Map<String, Set<String>> fields = {};
-
-  final String rawObjectFieldsPath =
-      path.join(sdkDir, 'runtime', 'vm', 'raw_object_fields.cc');
-  final RegExp fieldEntry = RegExp(" *F\\($className, $fieldName\\) *\\\\?");
-
-  await for (String line in File(rawObjectFieldsPath)
-      .openRead()
-      .cast<List<int>>()
-      .transform(utf8.decoder)
-      .transform(LineSplitter())) {
-    Match? match = matchComplete(fieldEntry, line);
-    if (match != null) {
-      fields
-          .putIfAbsent(match.group(1)!, () => Set<String>())
-          .add(match.group(2)!);
-    }
-  }
-
-  final RegExp classStart = RegExp("class $rawClass : public $rawClass {");
-  final RegExp classEnd = RegExp("}");
-  final RegExp field = RegExp("  $rawClass. +$fieldName;.*");
-
-  final String rawObjectPath =
-      path.join(sdkDir, 'runtime', 'vm', 'raw_object.h');
-
-  String? currentClass;
-  bool hasMissingFields = false;
-  await for (String line in File(rawObjectPath)
-      .openRead()
-      .cast<List<int>>()
-      .transform(utf8.decoder)
-      .transform(LineSplitter())) {
-    Match? match = matchComplete(classStart, line);
-    if (match != null) {
-      currentClass = match.group(1);
-      continue;
-    }
-    match = matchComplete(classEnd, line);
-    if (match != null) {
-      currentClass = null;
-      continue;
-    }
-    match = matchComplete(field, line);
-    if (match != null && currentClass != null) {
-      if (fields[currentClass] == null) {
-        hasMissingFields = true;
-        print("$currentClass is missing entirely.");
-        continue;
-      }
-      if (!fields[currentClass]!.contains(match.group(2)!)) {
-        hasMissingFields = true;
-        print("$currentClass is missing ${match.group(2)!}.");
-      }
-    }
-  }
-
-  if (hasMissingFields) {
-    Expect.fail("$rawObjectFieldsPath is missing some fields. "
-        "Please update it to match $rawObjectPath.");
-  }
-}
-
-main() async {
-  void printSkip(String description) =>
-      print('Skipping $description for ${path.basename(buildDir)} '
-              'on ${Platform.operatingSystem}' +
-          (clangBuildToolsDir == null ? ' without //buildtools' : ''));
-
-  // We don't have access to the SDK on Android.
-  if (Platform.isAndroid) {
-    printSkip('all tests');
-    return;
-  }
-
-  await testMacros();
-
-  await withTempDir('analyze_snapshot_binary', (String tempDir) async {
-    // We only need to generate the dill file once for all JIT tests.
-    final _thisTestPath = path.join(sdkDir, 'runtime', 'tests', 'vm', 'dart',
-        'analyze_snapshot_binary_test.dart');
-
-    // We only need to generate the dill file once for all AOT tests.
-    final aotDillPath = path.join(tempDir, 'aot_test.dill');
-    await run(genKernel, <String>[
-      '--aot',
-      '--platform',
-      platformDill,
-      ...Platform.executableArguments.where((arg) =>
-          arg.startsWith('--enable-experiment=') ||
-          arg == '--sound-null-safety' ||
-          arg == '--no-sound-null-safety'),
-      '-o',
-      aotDillPath,
-      _thisTestPath
-    ]);
-
-    // Just as a reminder for AOT tests:
-    // * If useAsm is true, then stripUtil is forced (as the assembler may add
-    //   extra information that needs stripping), so no need to specify
-    //   stripUtil for useAsm tests.
-
-    // Test unstripped ELF generation directly.
-    await testAOT(aotDillPath);
-    await testAOT(aotDillPath, forceDrops: true);
-    await testAOT(aotDillPath, forceDrops: true, useDispatch: false);
-
-    // Test flag-stripped ELF generation.
-    await testAOT(aotDillPath, stripFlag: true);
-
-    // Since we can't force disassembler support after the fact when running
-    // in PRODUCT mode, skip any --disassemble tests. Do these tests last as
-    // they have lots of output and so the log will be truncated.
-    if (!const bool.fromEnvironment('dart.vm.product')) {
-      // Regression test for dartbug.com/41149.
-      await testAOT(aotDillPath, disassemble: true);
-    }
-
-    // We neither generate assembly nor have a stripping utility on Windows.
-    if (Platform.isWindows) {
-      printSkip('external stripping and assembly tests');
-      return;
-    }
-
-    // The native strip utility on Mac OS X doesn't recognize ELF files.
-    if (Platform.isMacOS && clangBuildToolsDir == null) {
-      printSkip('ELF external stripping test');
-    } else {
-      // Test unstripped ELF generation that is then externally stripped.
-      await testAOT(aotDillPath, stripUtil: true);
-    }
-
-    // TODO(sstrickl): Currently we can't assemble for SIMARM64 on MacOSX.
-    // For example, the test runner still uses blobs for
-    // dartkp-mac-*-simarm64. Change assembleSnapshot and remove this check
-    // when we can.
-    if (Platform.isMacOS && buildDir.endsWith('SIMARM64')) {
-      printSkip('assembly tests');
-      return;
-    }
-    // Test unstripped assembly generation that is then externally stripped.
-    await testAOT(aotDillPath, useAsm: true);
-    // Test stripped assembly generation that is then externally stripped.
-    await testAOT(aotDillPath, useAsm: true, stripFlag: true);
-  });
-}
-
-Future<String> readFile(String file) {
-  return new File(file).readAsString();
-}
diff --git a/runtime/tests/vm/dart/regress_flutter66765_test.dart b/runtime/tests/vm/dart/regress_flutter66765_test.dart
new file mode 100644
index 0000000..c47c966
--- /dev/null
+++ b/runtime/tests/vm/dart/regress_flutter66765_test.dart
@@ -0,0 +1,36 @@
+// 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.
+
+// Regression test for https://github.com/flutter/flutter/issues/66765
+// Verifies that AOT compiler doesn't crash on a particular flow graph.
+
+class TutorialBloc {
+  TutorialBloc();
+
+  Stream<TutorialStates> mapEventToState(TutorialEvents event) async* {
+    switch (event.action) {
+      default:
+        yield TutorialInitState();
+    }
+  }
+}
+
+enum TutorialAction { dummyData }
+
+class TutorialEvents {
+  final TutorialAction action;
+  const TutorialEvents(this.action);
+}
+
+abstract class TutorialStates {}
+
+class TutorialInitState extends TutorialStates {}
+
+List<dynamic> l = [TutorialBloc()];
+
+void main() async {
+  if (l.length > 1) {
+    l[0].mapEventToState(42);
+  }
+}
diff --git a/runtime/tests/vm/dart_2/analyze_snapshot_binary_test.dart b/runtime/tests/vm/dart_2/analyze_snapshot_binary_test.dart
deleted file mode 100644
index 48f91fb..0000000
--- a/runtime/tests/vm/dart_2/analyze_snapshot_binary_test.dart
+++ /dev/null
@@ -1,300 +0,0 @@
-// Copyright (c) 2018, 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.
-
-// @dart = 2.9
-
-import 'dart:convert';
-import 'dart:io';
-import 'dart:async';
-
-import 'package:expect/expect.dart';
-import 'package:native_stack_traces/elf.dart';
-import 'package:path/path.dart' as path;
-
-import 'use_flag_test_helper.dart';
-
-// Used to ensure we don't have multiple equivalent calls to test.
-final _seenDescriptions = <String>{};
-
-Future<void> testAOT(String dillPath,
-    {bool useAsm = false,
-    bool forceDrops = false,
-    bool useDispatch = true,
-    bool stripUtil = false, // Note: forced true if useAsm.
-    bool stripFlag = false,
-    bool disassemble = false}) async {
-  if (const bool.fromEnvironment('dart.vm.product') && disassemble) {
-    Expect.isFalse(disassemble, 'no use of disassembler in PRODUCT mode');
-  }
-
-  final analyzeSnapshot = path.join(
-      buildDir,
-      bool.fromEnvironment('dart.vm.product')
-          ? 'analyze_snapshot_product'
-          : 'analyze_snapshot');
-
-  // For assembly, we can't test the sizes of the snapshot sections, since we
-  // don't have a Mach-O reader for Mac snapshots and for ELF, the assembler
-  // merges the text/data sections and the VM/isolate section symbols may not
-  // have length information. Thus, we force external stripping so we can test
-  // the approximate size of the stripped snapshot.
-  if (useAsm) {
-    stripUtil = true;
-  }
-
-  final descriptionBuilder = StringBuffer()..write(useAsm ? 'assembly' : 'elf');
-  if (forceDrops) {
-    descriptionBuilder.write('-dropped');
-  }
-  if (!useDispatch) {
-    descriptionBuilder.write('-nodispatch');
-  }
-  if (stripFlag) {
-    descriptionBuilder.write('-intstrip');
-  }
-  if (stripUtil) {
-    descriptionBuilder.write('-extstrip');
-  }
-  if (disassemble) {
-    descriptionBuilder.write('-disassembled');
-  }
-
-  final description = descriptionBuilder.toString();
-  Expect.isTrue(_seenDescriptions.add(description),
-      "test configuration $description would be run multiple times");
-
-  await withTempDir('analyze_snapshot_binary-$description',
-      (String tempDir) async {
-    // Generate the snapshot
-    final snapshotPath = path.join(tempDir, 'test.snap');
-    final commonSnapshotArgs = [
-      if (stripFlag) '--strip', //  gen_snapshot specific and not a VM flag.
-      if (forceDrops) ...[
-        '--dwarf-stack-traces',
-        '--no-retain-function-objects',
-        '--no-retain-code-objects'
-      ],
-      useDispatch ? '--use-table-dispatch' : '--no-use-table-dispatch',
-      if (disassemble) '--disassemble', // Not defined in PRODUCT mode.
-      dillPath,
-    ];
-
-    if (useAsm) {
-      final assemblyPath = path.join(tempDir, 'test.S');
-
-      await run(genSnapshot, <String>[
-        '--snapshot-kind=app-aot-assembly',
-        '--assembly=$assemblyPath',
-        ...commonSnapshotArgs,
-      ]);
-
-      await assembleSnapshot(assemblyPath, snapshotPath);
-    } else {
-      await run(genSnapshot, <String>[
-        '--snapshot-kind=app-aot-elf',
-        '--elf=$snapshotPath',
-        ...commonSnapshotArgs,
-      ]);
-    }
-
-    print("Snapshot generated at $snapshotPath.");
-
-    // May not be ELF, but another format.
-    final elf = Elf.fromFile(snapshotPath);
-    if (!useAsm) {
-      Expect.isNotNull(elf);
-    }
-
-    if (elf != null) {
-      // Verify some ELF file format parameters.
-      final textSections = elf.namedSections(".text");
-      Expect.isNotEmpty(textSections);
-      Expect.isTrue(
-          textSections.length <= 2, "More text sections than expected");
-      final dataSections = elf.namedSections(".rodata");
-      Expect.isNotEmpty(dataSections);
-      Expect.isTrue(
-          dataSections.length <= 2, "More data sections than expected");
-    }
-
-    final analyzerOutputPath = path.join(tempDir, 'analyze_test.json');
-
-    // This will throw if exit code is not 0.
-    await run(analyzeSnapshot, <String>[
-      '--out=$analyzerOutputPath',
-      '$snapshotPath',
-    ]);
-
-    final analyzerJsonBytes = await readFile(analyzerOutputPath);
-    final analyzerJson = json.decode(analyzerJsonBytes);
-    Expect.isFalse(analyzerJson.isEmpty);
-    Expect.isTrue(analyzerJson.keys
-        .toSet()
-        .containsAll(['snapshot_data', 'class_table', 'object_pool']));
-  });
-}
-
-Match matchComplete(RegExp regexp, String line) {
-  Match match = regexp.firstMatch(line);
-  if (match == null) return match;
-  if (match.start != 0 || match.end != line.length) return null;
-  return match;
-}
-
-// All fields of "Raw..." classes defined in "raw_object.h" must be included in
-// the giant macro in "raw_object_fields.cc". This function attempts to check
-// that with some basic regexes.
-testMacros() async {
-  const String className = "([a-z0-9A-Z]+)";
-  const String rawClass = "Raw$className";
-  const String fieldName = "([a-z0-9A-Z_]+)";
-
-  final Map<String, Set<String>> fields = {};
-
-  final String rawObjectFieldsPath =
-      path.join(sdkDir, 'runtime', 'vm', 'raw_object_fields.cc');
-  final RegExp fieldEntry = RegExp(" *F\\($className, $fieldName\\) *\\\\?");
-
-  await for (String line in File(rawObjectFieldsPath)
-      .openRead()
-      .cast<List<int>>()
-      .transform(utf8.decoder)
-      .transform(LineSplitter())) {
-    Match match = matchComplete(fieldEntry, line);
-    if (match != null) {
-      fields
-          .putIfAbsent(match.group(1), () => Set<String>())
-          .add(match.group(2));
-    }
-  }
-
-  final RegExp classStart = RegExp("class $rawClass : public $rawClass {");
-  final RegExp classEnd = RegExp("}");
-  final RegExp field = RegExp("  $rawClass. +$fieldName;.*");
-
-  final String rawObjectPath =
-      path.join(sdkDir, 'runtime', 'vm', 'raw_object.h');
-
-  String currentClass;
-  bool hasMissingFields = false;
-  await for (String line in File(rawObjectPath)
-      .openRead()
-      .cast<List<int>>()
-      .transform(utf8.decoder)
-      .transform(LineSplitter())) {
-    Match match = matchComplete(classStart, line);
-    if (match != null) {
-      currentClass = match.group(1);
-      continue;
-    }
-
-    match = matchComplete(classEnd, line);
-    if (match != null) {
-      currentClass = null;
-      continue;
-    }
-
-    match = matchComplete(field, line);
-    if (match != null && currentClass != null) {
-      if (fields[currentClass] == null) {
-        hasMissingFields = true;
-        print("$currentClass is missing entirely.");
-        continue;
-      }
-      if (!fields[currentClass].contains(match.group(2))) {
-        hasMissingFields = true;
-        print("$currentClass is missing ${match.group(2)}.");
-      }
-    }
-  }
-
-  if (hasMissingFields) {
-    Expect.fail("$rawObjectFieldsPath is missing some fields. "
-        "Please update it to match $rawObjectPath.");
-  }
-}
-
-main() async {
-  void printSkip(String description) =>
-      print('Skipping $description for ${path.basename(buildDir)} '
-              'on ${Platform.operatingSystem}' +
-          (clangBuildToolsDir == null ? ' without //buildtools' : ''));
-
-  // We don't have access to the SDK on Android.
-  if (Platform.isAndroid) {
-    printSkip('all tests');
-    return;
-  }
-
-  await testMacros();
-
-  await withTempDir('analyze_snapshot_binary', (String tempDir) async {
-    // We only need to generate the dill file once for all JIT tests.
-    final _thisTestPath = path.join(sdkDir, 'runtime', 'tests', 'vm', 'dart_2',
-        'analyze_snapshot_binary_test.dart');
-
-    // We only need to generate the dill file once for all AOT tests.
-    final aotDillPath = path.join(tempDir, 'aot_test.dill');
-    await run(genKernel, <String>[
-      '--aot',
-      '--platform',
-      platformDill,
-      '-o',
-      aotDillPath,
-      _thisTestPath
-    ]);
-
-    // Just as a reminder for AOT tests:
-    // * If useAsm is true, then stripUtil is forced (as the assembler may add
-    //   extra information that needs stripping), so no need to specify
-    //   stripUtil for useAsm tests.
-
-    // Test unstripped ELF generation directly.
-    await testAOT(aotDillPath);
-    await testAOT(aotDillPath, forceDrops: true);
-    await testAOT(aotDillPath, forceDrops: true, useDispatch: false);
-
-    // Test flag-stripped ELF generation.
-    await testAOT(aotDillPath, stripFlag: true);
-
-    // Since we can't force disassembler support after the fact when running
-    // in PRODUCT mode, skip any --disassemble tests. Do these tests last as
-    // they have lots of output and so the log will be truncated.
-    if (!const bool.fromEnvironment('dart.vm.product')) {
-      // Regression test for dartbug.com/41149.
-      await testAOT(aotDillPath, disassemble: true);
-    }
-
-    // We neither generate assembly nor have a stripping utility on Windows.
-    if (Platform.isWindows) {
-      printSkip('external stripping and assembly tests');
-      return;
-    }
-
-    // The native strip utility on Mac OS X doesn't recognize ELF files.
-    if (Platform.isMacOS && clangBuildToolsDir == null) {
-      printSkip('ELF external stripping test');
-    } else {
-      // Test unstripped ELF generation that is then externally stripped.
-      await testAOT(aotDillPath, stripUtil: true);
-    }
-
-    // TODO(sstrickl): Currently we can't assemble for SIMARM64 on MacOSX.
-    // For example, the test runner still uses blobs for
-    // dartkp-mac-*-simarm64. Change assembleSnapshot and remove this check
-    // when we can.
-    if (Platform.isMacOS && buildDir.endsWith('SIMARM64')) {
-      printSkip('assembly tests');
-      return;
-    }
-    // Test unstripped assembly generation that is then externally stripped.
-    await testAOT(aotDillPath, useAsm: true);
-    // Test stripped assembly generation that is then externally stripped.
-    await testAOT(aotDillPath, useAsm: true, stripFlag: true);
-  });
-}
-
-Future<String> readFile(String file) {
-  return new File(file).readAsString();
-}
diff --git a/runtime/tests/vm/dart_2/regress_flutter66765_test.dart b/runtime/tests/vm/dart_2/regress_flutter66765_test.dart
new file mode 100644
index 0000000..af3337c
--- /dev/null
+++ b/runtime/tests/vm/dart_2/regress_flutter66765_test.dart
@@ -0,0 +1,38 @@
+// 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.
+
+// @dart = 2.9
+
+// Regression test for https://github.com/flutter/flutter/issues/66765
+// Verifies that AOT compiler doesn't crash on a particular flow graph.
+
+class TutorialBloc {
+  TutorialBloc();
+
+  Stream<TutorialStates> mapEventToState(TutorialEvents event) async* {
+    switch (event.action) {
+      default:
+        yield TutorialInitState();
+    }
+  }
+}
+
+enum TutorialAction { dummyData }
+
+class TutorialEvents {
+  final TutorialAction action;
+  const TutorialEvents(this.action);
+}
+
+abstract class TutorialStates {}
+
+class TutorialInitState extends TutorialStates {}
+
+List<dynamic> l = [TutorialBloc()];
+
+void main() async {
+  if (l.length > 1) {
+    l[0].mapEventToState(42);
+  }
+}
diff --git a/runtime/tests/vm/vm.status b/runtime/tests/vm/vm.status
index 5e342f3..f4bc06c 100644
--- a/runtime/tests/vm/vm.status
+++ b/runtime/tests/vm/vm.status
@@ -37,9 +37,7 @@
 dart_2/stack_overflow_shared_test: Pass, Slow # Uses --shared-slow-path-triggers-gc flag.
 
 [ $arch == ia32 ]
-dart/analyze_snapshot_binary_test: SkipByDesign # No IA32 support.
 dart/disassemble_aot_test: SkipByDesign # IA32 does not support AOT.
-dart_2/analyze_snapshot_binary_test: SkipByDesign # No IA32 support.
 dart_2/disassemble_aot_test: SkipByDesign # IA32 does not support AOT.
 
 [ $builder_tag == asan ]
diff --git a/runtime/vm/analyze_snapshot_api_impl.cc b/runtime/vm/analyze_snapshot_api_impl.cc
deleted file mode 100644
index ef73e76..0000000
--- a/runtime/vm/analyze_snapshot_api_impl.cc
+++ /dev/null
@@ -1,202 +0,0 @@
-// 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.
-
-#include "include/analyze_snapshot_api.h"
-#include "vm/dart_api_impl.h"
-#include "vm/json_writer.h"
-#include "vm/object.h"
-#include "vm/object_store.h"
-#include "vm/thread.h"
-
-namespace dart {
-namespace snapshot_analyzer {
-void DumpClassTable(Thread* thread, dart::JSONWriter* js) {
-  auto class_table = thread->isolate_group()->class_table();
-
-  Class& cls = Class::Handle();
-  String& name = String::Handle();
-  js->OpenArray("class_table");
-
-  for (intptr_t i = 1; i < class_table->NumCids(); i++) {
-    if (!class_table->HasValidClassAt(i)) {
-      continue;
-    }
-    cls = class_table->At(i);
-    if (!cls.IsNull()) {
-      name = cls.Name();
-      js->OpenObject();
-      js->PrintProperty("id", i);
-      js->PrintProperty("name", name.ToCString());
-
-      // Note: Some meta info is stripped from the snapshot, it's important
-      // to check every field for NULL to avoid segfaults.
-      const Library& library = Library::Handle(cls.library());
-      if (!library.IsNull()) {
-        String& lib_name = String::Handle();
-        lib_name = String::NewFormatted(
-            Heap::kOld, "%s%s", String::Handle(library.url()).ToCString(),
-            String::Handle(library.private_key()).ToCString());
-        js->PrintProperty("library", lib_name.ToCString());
-      }
-
-      const AbstractType& super_type = AbstractType::Handle(cls.super_type());
-      if (super_type.IsNull()) {
-      } else {
-        const String& super_name = String::Handle(super_type.Name());
-        js->PrintProperty("super_class", super_name.ToCString());
-      }
-
-      const Array& interfaces_array = Array::Handle(cls.interfaces());
-      if (!interfaces_array.IsNull()) {
-        if (interfaces_array.Length() > 0) {
-          js->OpenArray("interfaces");
-          AbstractType& interface = AbstractType::Handle();
-          intptr_t len = interfaces_array.Length();
-          for (intptr_t i = 0; i < len; i++) {
-            interface ^= interfaces_array.At(i);
-            js->PrintValue(interface.ToCString());
-          }
-          js->CloseArray();
-        }
-      }
-      const Array& functions_array = Array::Handle(cls.functions());
-      if (!functions_array.IsNull()) {
-        if (functions_array.Length() > 0) {
-          js->OpenArray("functions");
-          Function& function = Function::Handle();
-          intptr_t len = functions_array.Length();
-          for (intptr_t i = 0; i < len; i++) {
-            function ^= functions_array.At(i);
-            if (function.IsNull() || !function.HasCode()) {
-              continue;
-            }
-            const Code& code = Code::Handle(function.CurrentCode());
-            intptr_t size = code.Size();
-
-            // Note: Some entry points here will be pointing to the VM
-            // instructions buffer.
-
-            // Note: code_entry will contain the address in the memory
-            // In order to resolve it to a relative offset in the instructions
-            // buffer we need to pick the base address and substract it from
-            // the entry point address.
-            auto code_entry = code.EntryPoint();
-            // On different architectures the type of the underlying
-            // dart::uword can result in an unsigned long long vs unsigned long
-            // mismatch.
-            uint64_t code_addr = static_cast<uint64_t>(code_entry);
-            js->OpenObject();
-            js->PrintProperty("name", function.ToCString());
-            js->PrintfProperty("code_entry", "0x%" PRIx64 "", code_addr);
-            js->PrintProperty("size", size);
-            js->CloseObject();
-          }
-          js->CloseArray();
-        }
-      }
-      const Array& fields_array = Array::Handle(cls.fields());
-      if (fields_array.IsNull()) {
-      } else {
-        if (fields_array.Length() > 0) {
-          js->OpenArray("fields");
-          Field& field = Field::Handle();
-          for (intptr_t i = 0; i < fields_array.Length(); i++) {
-            field ^= fields_array.At(i);
-            js->PrintValue(field.ToCString());
-          }
-          js->CloseArray();
-        }
-      }
-    }
-    js->CloseObject();
-  }
-  js->CloseArray();
-}
-void DumpObjectPool(Thread* thread, dart::JSONWriter* js) {
-  js->OpenArray("object_pool");
-
-  auto pool_ptr = thread->isolate_group()->object_store()->global_object_pool();
-  const auto& pool = ObjectPool::Handle(ObjectPool::RawCast(pool_ptr));
-  for (intptr_t i = 0; i < pool.Length(); i++) {
-    auto type = pool.TypeAt(i);
-    // Only interested in tagged objects.
-    // All these checks are required otherwise ToCString() will segfault.
-    if (type != ObjectPool::EntryType::kTaggedObject) {
-      continue;
-    }
-
-    auto entry = pool.ObjectAt(i);
-    if (!entry.IsHeapObject()) {
-      continue;
-    }
-
-    intptr_t cid = entry.GetClassId();
-
-    switch (cid) {
-      case kOneByteStringCid: {
-        js->OpenObject();
-        js->PrintProperty("type", "kOneByteString");
-        js->PrintProperty("id", i);
-        js->PrintProperty("offset", pool.element_offset(i));
-        js->PrintProperty("value", Object::Handle(entry).ToCString());
-        js->CloseObject();
-        break;
-      }
-      case kTwoByteStringCid: {
-        // TODO(#47924): Add support.
-        break;
-      }
-      default:
-        // TODO(#47924): Investigate other types of objects to parse.
-        break;
-    }
-  }
-  js->CloseArray();
-}
-// TODO(#47924): Add processing of the entires in the dispatch table.
-// Below is an example skeleton
-// void DumpDispatchTable(dart::Thread* thread) {
-//   auto dispatch = thread->isolate_group()->dispatch_table();
-//   auto length = dispatch->length();
-// We must unbias the array entries so we don't crash on null access.
-//   auto entries = dispatch->ArrayOrigin() - DispatchTable::OriginElement();
-//   for (intptr_t i = 0; i < length; i++) {
-//     OS::Print("0x%lx at %ld\n", entries[i], i);
-//   }
-// }
-
-void Dart_DumpSnapshotInformationAsJson(
-    char** buffer,
-    intptr_t* buffer_length,
-    Dart_SnapshotAnalyzerInformation* info) {
-  Thread* thread = Thread::Current();
-  DARTSCOPE(thread);
-  JSONWriter js;
-  // Open empty object so output is valid/parsable JSON.
-  js.OpenObject();
-  js.OpenObject("snapshot_data");
-  // Base addreses of the snapshot data, useful to calculate relative offsets.
-  js.PrintfProperty("vm_data", "%p", info->vm_snapshot_data);
-  js.PrintfProperty("vm_instructions", "%p", info->vm_snapshot_instructions);
-  js.PrintfProperty("isolate_data", "%p", info->vm_isolate_data);
-  js.PrintfProperty("isolate_instructions", "%p",
-                    info->vm_isolate_instructions);
-  js.CloseObject();
-
-  {
-    // Debug builds assert that our thread has a lock before accessing
-    // vm internal fields.
-    SafepointReadRwLocker ml(thread, thread->isolate_group()->program_lock());
-    DumpClassTable(thread, &js);
-    DumpObjectPool(thread, &js);
-  }
-
-  // Close our empty object.
-  js.CloseObject();
-
-  // Give ownership to caller.
-  js.Steal(buffer, buffer_length);
-}
-}  // namespace snapshot_analyzer
-}  // namespace dart
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index cd7dcb5..878bcec 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -1299,12 +1299,15 @@
   // TODO(fschneider): Implement a faster way to get the block of an
   // instruction.
   Instruction* result = previous();
-  ASSERT(result != nullptr);
-  while (!result->IsBlockEntry()) {
+  while ((result != nullptr) && !result->IsBlockEntry()) {
     result = result->previous();
-    ASSERT(result != nullptr);
   }
-  return result->AsBlockEntry();
+  // InlineExitCollector::RemoveUnreachableExits may call
+  // Instruction::GetBlock on instructions which are not properly linked
+  // to the flow graph (as collected exits may belong to unreachable
+  // fragments), so this code should gracefully handle the absence of
+  // BlockEntry.
+  return (result != nullptr) ? result->AsBlockEntry() : nullptr;
 }
 
 void ForwardInstructionIterator::RemoveCurrentFromGraph() {
diff --git a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
index 1124ea1..00d4adf 100644
--- a/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
+++ b/runtime/vm/compiler/frontend/base_flow_graph_builder.cc
@@ -28,11 +28,16 @@
 }
 
 Fragment& Fragment::operator+=(const Fragment& other) {
-  if (entry == NULL) {
+  if (entry == nullptr) {
     entry = other.entry;
     current = other.current;
-  } else if (current != NULL && other.entry != NULL) {
-    current->LinkTo(other.entry);
+  } else if (other.entry != nullptr) {
+    if (current != nullptr) {
+      current->LinkTo(other.entry);
+    }
+    // Although [other.entry] could be unreachable (if this fragment is
+    // closed), there could be a yield continuation point in the middle of
+    // [other] fragment so [other.current] is still reachable.
     current = other.current;
   }
   return *this;
diff --git a/sdk/BUILD.gn b/sdk/BUILD.gn
index f5a7544..2b4fa76 100644
--- a/sdk/BUILD.gn
+++ b/sdk/BUILD.gn
@@ -26,7 +26,6 @@
   dart_stripped_binary = "dart"
   dart_precompiled_runtime_stripped_binary = "dart_precompiled_runtime_product"
   gen_snapshot_stripped_binary = "gen_snapshot_product"
-  analyze_snapshot_binary = "analyze_snapshot_product"
 }
 
 # The directory layout of the SDK is as follows:
@@ -331,15 +330,6 @@
   ]
 }
 
-copy("copy_analyze_snapshot") {
-  visibility = [ ":group_dart2native" ]
-  deps = [ "../runtime/bin:analyze_snapshot_product" ]
-  src_dir =
-      get_label_info("../runtime/bin:analyze_snapshot_product", "root_out_dir")
-  sources = [ "$src_dir/${analyze_snapshot_binary}${executable_suffix}" ]
-  outputs = [ "$root_out_dir/$dart_sdk_output/bin/utils/analyze_snapshot${executable_suffix}" ]
-}
-
 copy("copy_vm_platform_strong_product") {
   visibility = [ ":group_dart2native" ]
   deps = [ "../runtime/vm:vm_platform_product" ]
@@ -359,7 +349,6 @@
 
 group("group_dart2native") {
   deps = [
-    ":copy_analyze_snapshot",
     ":copy_dartaotruntime",
     ":copy_gen_kernel_snapshot",
     ":copy_gen_snapshot",
diff --git a/sdk/lib/html/dart2js/html_dart2js.dart b/sdk/lib/html/dart2js/html_dart2js.dart
index 448b653..3298b08 100644
--- a/sdk/lib/html/dart2js/html_dart2js.dart
+++ b/sdk/lib/html/dart2js/html_dart2js.dart
@@ -7061,6 +7061,14 @@
     setProperty('font-weight', value, '');
   }
 
+  /** Gets the value of "gap" */
+  String get gap => getPropertyValue('gap');
+
+  /** Sets the value of "gap" */
+  set gap(String value) {
+    setProperty('gap', value, '');
+  }
+
   /** Gets the value of "grid" */
   String get grid => getPropertyValue('grid');
 
@@ -7117,6 +7125,14 @@
     setProperty('grid-column-end', value, '');
   }
 
+  /** Gets the value of "grid-column-gap" */
+  String get gridColumnGap => getPropertyValue('grid-column-gap');
+
+  /** Sets the value of "grid-column-gap" */
+  set gridColumnGap(String value) {
+    setProperty('grid-column-gap', value, '');
+  }
+
   /** Gets the value of "grid-column-start" */
   String get gridColumnStart => getPropertyValue('grid-column-start');
 
@@ -7141,6 +7157,14 @@
     setProperty('grid-row-end', value, '');
   }
 
+  /** Gets the value of "grid-row-gap" */
+  String get gridRowGap => getPropertyValue('grid-row-gap');
+
+  /** Sets the value of "grid-row-gap" */
+  set gridRowGap(String value) {
+    setProperty('grid-row-gap', value, '');
+  }
+
   /** Gets the value of "grid-row-start" */
   String get gridRowStart => getPropertyValue('grid-row-start');
 
@@ -7997,6 +8021,14 @@
     setProperty('right', value, '');
   }
 
+  /** Gets the value of "row-gap" */
+  String get rowGap => getPropertyValue('row-gap');
+
+  /** Sets the value of "row-gap" */
+  set rowGap(String value) {
+    setProperty('row-gap', value, '');
+  }
+
   /** Gets the value of "rtl-ordering" */
   String get rtlOrdering => getPropertyValue('rtl-ordering');
 
diff --git a/tools/VERSION b/tools/VERSION
index d08d4df..ceb61c5 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 117
+PRERELEASE 118
 PRERELEASE_PATCH 0
\ No newline at end of file
diff --git a/tools/dom/scripts/CSSPropertyNames.in b/tools/dom/scripts/CSSPropertyNames.in
index 39b49ad..cf59dca 100644
--- a/tools/dom/scripts/CSSPropertyNames.in
+++ b/tools/dom/scripts/CSSPropertyNames.in
@@ -288,7 +288,8 @@
 -webkit-column-break-inside
 -webkit-column-count
 column-fill
--webkit-column-gap
+column-gap
+-webkit-column-gap alias_for=column-gap
 -webkit-column-rule
 -webkit-column-rule-color
 -webkit-column-rule-style
@@ -321,12 +322,14 @@
 justify-content
 -webkit-justify-content alias_for=justify-content
 -webkit-font-size-delta
+gap
 grid-auto-columns
 grid-auto-flow
 grid-auto-rows
 grid-area
 grid-column
 grid-column-end
+grid-column-gap
 grid-column-start
 grid
 grid-template
@@ -334,6 +337,7 @@
 grid-template-rows
 grid-row
 grid-row-end
+grid-row-gap
 grid-row-start
 grid-template-areas
 -webkit-highlight
@@ -387,6 +391,7 @@
 -webkit-perspective-origin-x
 -webkit-perspective-origin-y
 -webkit-print-color-adjust
+row-gap
 -webkit-rtl-ordering
 -webkit-ruby-position
 -webkit-text-combine
diff --git a/tools/dom/templates/html/impl/impl_CSSStyleDeclaration.darttemplate b/tools/dom/templates/html/impl/impl_CSSStyleDeclaration.darttemplate
index 914faca..a81ff5a 100644
--- a/tools/dom/templates/html/impl/impl_CSSStyleDeclaration.darttemplate
+++ b/tools/dom/templates/html/impl/impl_CSSStyleDeclaration.darttemplate
@@ -3139,6 +3139,15 @@
     setProperty('font-weight', value, '');
   }
 
+  /** Gets the value of "gap" */
+  String get gap =>
+    getPropertyValue('gap');
+
+  /** Sets the value of "gap" */
+  set gap(String value) {
+    setProperty('gap', value, '');
+  }
+
   /** Gets the value of "grid" */
   String get grid =>
     getPropertyValue('grid');
@@ -3202,6 +3211,15 @@
     setProperty('grid-column-end', value, '');
   }
 
+  /** Gets the value of "grid-column-gap" */
+  String get gridColumnGap =>
+    getPropertyValue('grid-column-gap');
+
+  /** Sets the value of "grid-column-gap" */
+  set gridColumnGap(String value) {
+    setProperty('grid-column-gap', value, '');
+  }
+
   /** Gets the value of "grid-column-start" */
   String get gridColumnStart =>
     getPropertyValue('grid-column-start');
@@ -3229,6 +3247,15 @@
     setProperty('grid-row-end', value, '');
   }
 
+  /** Gets the value of "grid-row-gap" */
+  String get gridRowGap =>
+    getPropertyValue('grid-row-gap');
+
+  /** Sets the value of "grid-row-gap" */
+  set gridRowGap(String value) {
+    setProperty('grid-row-gap', value, '');
+  }
+
   /** Gets the value of "grid-row-start" */
   String get gridRowStart =>
     getPropertyValue('grid-row-start');
@@ -4192,6 +4219,15 @@
     setProperty('right', value, '');
   }
 
+  /** Gets the value of "row-gap" */
+  String get rowGap =>
+    getPropertyValue('row-gap');
+
+  /** Sets the value of "row-gap" */
+  set rowGap(String value) {
+    setProperty('row-gap', value, '');
+  }
+
   /** Gets the value of "rtl-ordering" */
   String get rtlOrdering =>
     getPropertyValue('rtl-ordering');
diff --git a/tools/gn.py b/tools/gn.py
index 32a6953..fe4718d 100755
--- a/tools/gn.py
+++ b/tools/gn.py
@@ -269,8 +269,6 @@
             'exe.stripped/dart_precompiled_runtime_product')
         gn_args['gen_snapshot_stripped_binary'] = (
             'exe.stripped/gen_snapshot_product')
-        gn_args['analyze_snapshot_binary'] = (
-            'exe.stripped/analyze_snapshot_product')
 
     # Setup the user-defined sysroot.
     if UseSysroot(args, gn_args):