diff --git a/pkg/front_end/lib/src/fasta/builder/class_builder.dart b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
index c6b977b..f5454a5 100644
--- a/pkg/front_end/lib/src/fasta/builder/class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
@@ -10,8 +10,6 @@
         Constructor,
         DartType,
         DynamicType,
-        FunctionNode,
-        FunctionType,
         FutureOrType,
         InterfaceType,
         Member,
@@ -19,47 +17,27 @@
         NullType,
         Nullability,
         Supertype,
-        TreeNode,
-        TypeParameter,
         getAsTypeArguments;
-import 'package:kernel/class_hierarchy.dart'
-    show ClassHierarchy, ClassHierarchyMembers;
-import 'package:kernel/core_types.dart' show CoreTypes;
+import 'package:kernel/class_hierarchy.dart' show ClassHierarchy;
 import 'package:kernel/src/legacy_erasure.dart';
 import 'package:kernel/text/text_serialization_verifier.dart';
-import 'package:kernel/type_algebra.dart' show Substitution, substitute;
-import 'package:kernel/type_environment.dart'
-    show SubtypeCheckMode, TypeEnvironment;
 
 import '../fasta_codes.dart';
-import '../kernel/kernel_helper.dart';
-import '../kernel/redirecting_factory_body.dart' show RedirectingFactoryBody;
-import '../loader.dart';
 import '../modifier.dart';
-import '../names.dart' show noSuchMethodName;
 import '../problems.dart' show internalProblem, unhandled;
 import '../scope.dart';
-import '../source/source_factory_builder.dart';
-import '../source/source_library_builder.dart' show SourceLibraryBuilder;
-import '../source/source_loader.dart';
-import '../source/source_member_builder.dart';
 import '../type_inference/type_schema.dart' show UnknownType;
-import '../util/helpers.dart' show DelayedActionPerformer;
 import 'builder.dart';
-import 'constructor_reference_builder.dart';
 import 'declaration_builder.dart';
-import 'function_builder.dart';
 import 'library_builder.dart';
 import 'member_builder.dart';
 import 'metadata_builder.dart';
 import 'named_type_builder.dart';
-import 'never_type_declaration_builder.dart';
 import 'nullability_builder.dart';
 import 'type_alias_builder.dart';
 import 'type_builder.dart';
 import 'type_declaration_builder.dart';
 import 'type_variable_builder.dart';
-import 'void_type_declaration_builder.dart';
 
 abstract class ClassBuilder implements DeclarationBuilder {
   /// The type variables declared on a class, extension or mixin declaration.
@@ -100,12 +78,6 @@
 
   abstract TypeBuilder? mixedInTypeBuilder;
 
-  void buildOutlineExpressions(
-      SourceLibraryBuilder library,
-      ClassHierarchy classHierarchy,
-      List<DelayedActionPerformer> delayedActionPerformers,
-      List<SynthesizedFunctionNode> synthesizedFunctionNodes);
-
   /// Registers a constructor redirection for this class and returns true if
   /// this redirection gives rise to a cycle that has not been reported before.
   bool checkConstructorCyclic(String source, String target);
@@ -147,50 +119,6 @@
   Supertype buildMixedInType(
       LibraryBuilder library, List<TypeBuilder>? arguments);
 
-  void checkSupertypes(CoreTypes coreTypes);
-
-  void handleSeenCovariant(
-      ClassHierarchyMembers memberHierarchy,
-      Member interfaceMember,
-      bool isSetter,
-      callback(Member interfaceMember, bool isSetter));
-
-  bool hasUserDefinedNoSuchMethod(
-      Class klass, ClassHierarchy hierarchy, Class objectClass);
-
-  void checkMixinApplication(ClassHierarchy hierarchy, CoreTypes coreTypes);
-
-  // Computes the function type of a given redirection target. Returns [null] if
-  // the type of the target could not be computed.
-  FunctionType? computeRedirecteeType(
-      RedirectingFactoryBuilder factory, TypeEnvironment typeEnvironment);
-
-  String computeRedirecteeName(ConstructorReferenceBuilder redirectionTarget);
-
-  void checkRedirectingFactory(
-      RedirectingFactoryBuilder factory, TypeEnvironment typeEnvironment);
-
-  void checkRedirectingFactories(TypeEnvironment typeEnvironment);
-
-  /// Returns a map which maps the type variables of [superclass] to their
-  /// respective values as defined by the superclass clause of this class (and
-  /// its superclasses).
-  ///
-  /// It's assumed that [superclass] is a superclass of this class.
-  ///
-  /// For example, given:
-  ///
-  ///     class Box<T> {}
-  ///     class BeatBox extends Box<Beat> {}
-  ///     class Beat {}
-  ///
-  /// We have:
-  ///
-  ///     [[BeatBox]].getSubstitutionMap([[Box]]) -> {[[Box::T]]: Beat]]}.
-  ///
-  /// It's an error if [superclass] isn't a superclass.
-  Map<TypeParameter, DartType> getSubstitutionMap(Class superclass);
-
   /// Looks up the member by [name] on the class built by this class builder.
   ///
   /// If [isSetter] is `false`, only fields, methods, and getters with that name
@@ -306,31 +234,6 @@
     }
   }
 
-  @override
-  void buildOutlineExpressions(
-      SourceLibraryBuilder library,
-      ClassHierarchy classHierarchy,
-      List<DelayedActionPerformer> delayedActionPerformers,
-      List<SynthesizedFunctionNode> synthesizedFunctionNodes) {
-    void build(String ignore, Builder declaration) {
-      SourceMemberBuilder member = declaration as SourceMemberBuilder;
-      member.buildOutlineExpressions(library, classHierarchy,
-          delayedActionPerformers, synthesizedFunctionNodes);
-    }
-
-    MetadataBuilder.buildAnnotations(isPatch ? origin.cls : cls, metadata,
-        library, this, null, fileUri, library.scope);
-    if (typeVariables != null) {
-      for (int i = 0; i < typeVariables!.length; i++) {
-        typeVariables![i].buildOutlineExpressions(library, this, null,
-            classHierarchy, delayedActionPerformers, scope.parent!);
-      }
-    }
-
-    constructors.forEach(build);
-    scope.forEach(build);
-  }
-
   /// Registers a constructor redirection for this class and returns true if
   /// this redirection gives rise to a cycle that has not been reported before.
   @override
@@ -490,44 +393,6 @@
   }
 
   @override
-  int get typeVariablesCount => typeVariables?.length ?? 0;
-
-  @override
-  List<DartType> buildTypeArguments(
-      LibraryBuilder library, List<TypeBuilder>? arguments) {
-    if (arguments == null && typeVariables == null) {
-      return <DartType>[];
-    }
-
-    if (arguments == null && typeVariables != null) {
-      List<DartType> result = new List<DartType>.generate(typeVariables!.length,
-          (int i) => typeVariables![i].defaultType!.build(library),
-          growable: true);
-      if (library is SourceLibraryBuilder) {
-        library.inferredTypes.addAll(result);
-      }
-      return result;
-    }
-
-    if (arguments != null && arguments.length != typeVariablesCount) {
-      // That should be caught and reported as a compile-time error earlier.
-      return unhandled(
-          templateTypeArgumentMismatch
-              .withArguments(typeVariablesCount)
-              .problemMessage,
-          "buildTypeArguments",
-          -1,
-          null);
-    }
-
-    assert(arguments!.length == typeVariablesCount);
-    List<DartType> result = new List<DartType>.generate(
-        arguments!.length, (int i) => arguments[i].build(library),
-        growable: true);
-    return result;
-  }
-
-  @override
   DartType buildType(LibraryBuilder library,
       NullabilityBuilder nullabilityBuilder, List<TypeBuilder>? arguments) {
     return buildTypeWithBuiltArguments(
@@ -565,145 +430,6 @@
   }
 
   @override
-  void checkSupertypes(CoreTypes coreTypes) {
-    // This method determines whether the class (that's being built) its super
-    // class appears both in 'extends' and 'implements' clauses and whether any
-    // interface appears multiple times in the 'implements' clause.
-    // Moreover, it checks that `FutureOr` and `void` are not among the
-    // supertypes.
-
-    void fail(NamedTypeBuilder target, Message message,
-        TypeAliasBuilder? aliasBuilder) {
-      int nameOffset = target.nameOffset;
-      int nameLength = target.nameLength;
-      // TODO(eernst): nameOffset not fully implemented; use backup.
-      if (nameOffset == -1) {
-        nameOffset = this.charOffset;
-        nameLength = noLength;
-      }
-      if (aliasBuilder != null) {
-        addProblem(message, nameOffset, nameLength, context: [
-          messageTypedefCause.withLocation(
-              aliasBuilder.fileUri, aliasBuilder.charOffset, noLength),
-        ]);
-      } else {
-        addProblem(message, nameOffset, nameLength);
-      }
-    }
-
-    // Extract and check superclass (if it exists).
-    ClassBuilder? superClass;
-    TypeBuilder? superClassType = supertypeBuilder;
-    if (superClassType is NamedTypeBuilder) {
-      TypeDeclarationBuilder? decl = superClassType.declaration;
-      TypeAliasBuilder? aliasBuilder; // Non-null if a type alias is use.
-      if (decl is TypeAliasBuilder) {
-        aliasBuilder = decl;
-        decl = aliasBuilder.unaliasDeclaration(superClassType.arguments,
-            isUsedAsClass: true,
-            usedAsClassCharOffset: superClassType.charOffset,
-            usedAsClassFileUri: superClassType.fileUri);
-      }
-      // TODO(eernst): Should gather 'restricted supertype' checks in one place,
-      // e.g., dynamic/int/String/Null and more are checked elsewhere.
-      if (decl is VoidTypeDeclarationBuilder) {
-        fail(superClassType, messageExtendsVoid, aliasBuilder);
-      } else if (decl is NeverTypeDeclarationBuilder) {
-        fail(superClassType, messageExtendsNever, aliasBuilder);
-      } else if (decl is ClassBuilder) {
-        superClass = decl;
-      }
-    }
-    if (interfaceBuilders == null) return;
-
-    // Validate interfaces.
-    Map<ClassBuilder, int>? problems;
-    Map<ClassBuilder, int>? problemsOffsets;
-    Set<ClassBuilder> implemented = new Set<ClassBuilder>();
-    for (TypeBuilder type in interfaceBuilders!) {
-      if (type is NamedTypeBuilder) {
-        int? charOffset = type.charOffset;
-        TypeDeclarationBuilder? typeDeclaration = type.declaration;
-        TypeDeclarationBuilder? decl;
-        TypeAliasBuilder? aliasBuilder; // Non-null if a type alias is used.
-        if (typeDeclaration is TypeAliasBuilder) {
-          aliasBuilder = typeDeclaration;
-          decl = aliasBuilder.unaliasDeclaration(type.arguments,
-              isUsedAsClass: true,
-              usedAsClassCharOffset: type.charOffset,
-              usedAsClassFileUri: type.fileUri);
-        } else {
-          decl = typeDeclaration;
-        }
-        if (decl is ClassBuilder) {
-          ClassBuilder interface = decl;
-          if (superClass == interface) {
-            addProblem(
-                templateImplementsSuperClass.withArguments(interface.name),
-                this.charOffset,
-                noLength);
-          } else if (interface.cls.name == "FutureOr" &&
-              interface.cls.enclosingLibrary.importUri.scheme == "dart" &&
-              interface.cls.enclosingLibrary.importUri.path == "async") {
-            addProblem(messageImplementsFutureOr, this.charOffset, noLength);
-          } else if (implemented.contains(interface)) {
-            // Aggregate repetitions.
-            problems ??= <ClassBuilder, int>{};
-            problems[interface] ??= 0;
-            problems[interface] = problems[interface]! + 1;
-            problemsOffsets ??= <ClassBuilder, int>{};
-            problemsOffsets[interface] ??= charOffset ?? TreeNode.noOffset;
-          } else {
-            implemented.add(interface);
-          }
-        }
-        if (decl != superClass) {
-          // TODO(eernst): Have all 'restricted supertype' checks in one place.
-          if (decl is VoidTypeDeclarationBuilder) {
-            fail(type, messageImplementsVoid, aliasBuilder);
-          } else if (decl is NeverTypeDeclarationBuilder) {
-            fail(type, messageImplementsNever, aliasBuilder);
-          }
-        }
-      }
-    }
-    if (problems != null) {
-      problems.forEach((ClassBuilder interface, int repetitions) {
-        addProblem(
-            templateImplementsRepeated.withArguments(
-                interface.name, repetitions),
-            problemsOffsets![interface]!,
-            noLength);
-      });
-    }
-  }
-
-  @override
-  void handleSeenCovariant(
-      ClassHierarchyMembers memberHierarchy,
-      Member interfaceMember,
-      bool isSetter,
-      callback(Member interfaceMember, bool isSetter)) {
-    // When a parameter is covariant we have to check that we also
-    // override the same member in all parents.
-    for (Supertype supertype in interfaceMember.enclosingClass!.supers) {
-      Member? member = memberHierarchy.getInterfaceMember(
-          supertype.classNode, interfaceMember.name,
-          setter: isSetter);
-      if (member != null) {
-        callback(member, isSetter);
-      }
-    }
-  }
-
-  @override
-  bool hasUserDefinedNoSuchMethod(
-      Class klass, ClassHierarchy hierarchy, Class objectClass) {
-    Member? noSuchMethod = hierarchy.getDispatchTarget(klass, noSuchMethodName);
-    return noSuchMethod != null && noSuchMethod.enclosingClass != objectClass;
-  }
-
-  @override
   String get fullNameForErrors {
     return isMixinApplication && !isNamedMixinApplication
         ? "${supertypeBuilder!.fullNameForErrors} with "
@@ -712,292 +438,6 @@
   }
 
   @override
-  void checkMixinApplication(ClassHierarchy hierarchy, CoreTypes coreTypes) {
-    TypeEnvironment typeEnvironment = new TypeEnvironment(coreTypes, hierarchy);
-    // A mixin declaration can only be applied to a class that implements all
-    // the declaration's superclass constraints.
-    InterfaceType supertype = cls.supertype!.asInterfaceType;
-    Substitution substitution = Substitution.fromSupertype(cls.mixedInType!);
-    for (Supertype constraint in cls.mixedInClass!.superclassConstraints()) {
-      InterfaceType requiredInterface =
-          substitution.substituteSupertype(constraint).asInterfaceType;
-      InterfaceType? implementedInterface = hierarchy.getTypeAsInstanceOf(
-          supertype, requiredInterface.classNode, library.library);
-      if (implementedInterface == null ||
-          !typeEnvironment.areMutualSubtypes(
-              implementedInterface,
-              requiredInterface,
-              library.isNonNullableByDefault
-                  ? SubtypeCheckMode.withNullabilities
-                  : SubtypeCheckMode.ignoringNullabilities)) {
-        library.addProblem(
-            templateMixinApplicationIncompatibleSupertype.withArguments(
-                supertype,
-                requiredInterface,
-                cls.mixedInType!.asInterfaceType,
-                library.isNonNullableByDefault),
-            cls.fileOffset,
-            noLength,
-            cls.fileUri);
-      }
-    }
-  }
-
-  @override
-  FunctionType? computeRedirecteeType(
-      RedirectingFactoryBuilder factory, TypeEnvironment typeEnvironment) {
-    ConstructorReferenceBuilder redirectionTarget = factory.redirectionTarget;
-    Builder? targetBuilder = redirectionTarget.target;
-    FunctionNode targetNode;
-    if (targetBuilder == null) return null;
-    if (targetBuilder is FunctionBuilder) {
-      targetNode = targetBuilder.function;
-    } else if (targetBuilder is AmbiguousBuilder) {
-      // Multiple definitions with the same name: An error has already been
-      // issued.
-      // TODO(http://dartbug.com/35294): Unfortunate error; see also
-      // https://dart-review.googlesource.com/c/sdk/+/85390/.
-      return null;
-    } else {
-      unhandled("${redirectionTarget.target}", "computeRedirecteeType",
-          charOffset, fileUri);
-    }
-
-    List<DartType>? typeArguments = factory.getTypeArguments();
-    FunctionType targetFunctionType =
-        targetNode.computeFunctionType(library.nonNullable);
-    if (typeArguments != null &&
-        targetFunctionType.typeParameters.length != typeArguments.length) {
-      addProblemForRedirectingFactory(
-          factory,
-          templateTypeArgumentMismatch
-              .withArguments(targetFunctionType.typeParameters.length),
-          redirectionTarget.charOffset,
-          noLength);
-      return null;
-    }
-
-    // Compute the substitution of the target class type parameters if
-    // [redirectionTarget] has any type arguments.
-    Substitution? substitution;
-    bool hasProblem = false;
-    if (typeArguments != null && typeArguments.length > 0) {
-      substitution = Substitution.fromPairs(
-          targetFunctionType.typeParameters, typeArguments);
-      for (int i = 0; i < targetFunctionType.typeParameters.length; i++) {
-        TypeParameter typeParameter = targetFunctionType.typeParameters[i];
-        DartType typeParameterBound =
-            substitution.substituteType(typeParameter.bound);
-        DartType typeArgument = typeArguments[i];
-        // Check whether the [typeArgument] respects the bounds of
-        // [typeParameter].
-        Loader loader = library.loader;
-        if (!typeEnvironment.isSubtypeOf(typeArgument, typeParameterBound,
-            SubtypeCheckMode.ignoringNullabilities)) {
-          addProblemForRedirectingFactory(
-              factory,
-              templateRedirectingFactoryIncompatibleTypeArgument.withArguments(
-                  typeArgument,
-                  typeParameterBound,
-                  library.isNonNullableByDefault),
-              redirectionTarget.charOffset,
-              noLength);
-          hasProblem = true;
-        } else if (library.isNonNullableByDefault && loader is SourceLoader) {
-          if (!typeEnvironment.isSubtypeOf(typeArgument, typeParameterBound,
-              SubtypeCheckMode.withNullabilities)) {
-            addProblemForRedirectingFactory(
-                factory,
-                templateRedirectingFactoryIncompatibleTypeArgument
-                    .withArguments(typeArgument, typeParameterBound,
-                        library.isNonNullableByDefault),
-                redirectionTarget.charOffset,
-                noLength);
-            hasProblem = true;
-          }
-        }
-      }
-    } else if (typeArguments == null &&
-        targetFunctionType.typeParameters.length > 0) {
-      // TODO(hillerstrom): In this case, we need to perform type inference on
-      // the redirectee to obtain actual type arguments which would allow the
-      // following program to type check:
-      //
-      //    class A<T> {
-      //       factory A() = B;
-      //    }
-      //    class B<T> implements A<T> {
-      //       B();
-      //    }
-      //
-      return null;
-    }
-
-    // Substitute if necessary.
-    targetFunctionType = substitution == null
-        ? targetFunctionType
-        : (substitution.substituteType(targetFunctionType.withoutTypeParameters)
-            as FunctionType);
-
-    return hasProblem ? null : targetFunctionType;
-  }
-
-  @override
-  String computeRedirecteeName(ConstructorReferenceBuilder redirectionTarget) {
-    String targetName = redirectionTarget.fullNameForErrors;
-    if (targetName == "") {
-      return redirectionTarget.target!.parent!.fullNameForErrors;
-    } else {
-      return targetName;
-    }
-  }
-
-  bool _isCyclicRedirectingFactory(RedirectingFactoryBuilder factory) {
-    // We use the [tortoise and hare algorithm]
-    // (https://en.wikipedia.org/wiki/Cycle_detection#Tortoise_and_hare) to
-    // handle cycles.
-    Builder? tortoise = factory;
-    Builder? hare = factory.redirectionTarget.target;
-    if (hare == factory) {
-      return true;
-    }
-    while (tortoise != hare) {
-      // Hare moves 2 steps forward.
-      if (hare is! RedirectingFactoryBuilder) {
-        return false;
-      }
-      hare = hare.redirectionTarget.target;
-      if (hare == factory) {
-        return true;
-      }
-      if (hare is! RedirectingFactoryBuilder) {
-        return false;
-      }
-      hare = hare.redirectionTarget.target;
-      if (hare == factory) {
-        return true;
-      }
-      // Tortoise moves one step forward. No need to test type of tortoise
-      // as it follows hare which already checked types.
-      tortoise =
-          (tortoise as RedirectingFactoryBuilder).redirectionTarget.target;
-    }
-    // Cycle found, but original factory doesn't belong to a cycle.
-    return false;
-  }
-
-  void addProblemForRedirectingFactory(RedirectingFactoryBuilder factory,
-      Message message, int charOffset, int length) {
-    addProblem(message, charOffset, length);
-    String text = library.loader.target.context
-        .format(
-            message.withLocation(fileUri, charOffset, length), Severity.error)
-        .plain;
-    factory.body = new RedirectingFactoryBody.error(text);
-  }
-
-  @override
-  void checkRedirectingFactory(
-      RedirectingFactoryBuilder factory, TypeEnvironment typeEnvironment) {
-    // Check that factory declaration is not cyclic.
-    if (_isCyclicRedirectingFactory(factory)) {
-      addProblemForRedirectingFactory(
-          factory,
-          templateCyclicRedirectingFactoryConstructors
-              .withArguments("${factory.member.enclosingClass!.name}"
-                  "${factory.name == '' ? '' : '.${factory.name}'}"),
-          factory.charOffset,
-          noLength);
-      return;
-    }
-
-    // The factory type cannot contain any type parameters other than those of
-    // its enclosing class, because constructors cannot specify type parameters
-    // of their own.
-    FunctionType factoryType = factory.function
-        .computeThisFunctionType(library.nonNullable)
-        .withoutTypeParameters;
-    FunctionType? redirecteeType =
-        computeRedirecteeType(factory, typeEnvironment);
-
-    // TODO(hillerstrom): It would be preferable to know whether a failure
-    // happened during [_computeRedirecteeType].
-    if (redirecteeType == null) {
-      return;
-    }
-
-    // Check whether [redirecteeType] <: [factoryType].
-    Loader loader = library.loader;
-    if (!typeEnvironment.isSubtypeOf(
-        redirecteeType, factoryType, SubtypeCheckMode.ignoringNullabilities)) {
-      addProblemForRedirectingFactory(
-          factory,
-          templateIncompatibleRedirecteeFunctionType.withArguments(
-              redirecteeType, factoryType, library.isNonNullableByDefault),
-          factory.redirectionTarget.charOffset,
-          noLength);
-    } else if (library.isNonNullableByDefault && loader is SourceLoader) {
-      if (!typeEnvironment.isSubtypeOf(
-          redirecteeType, factoryType, SubtypeCheckMode.withNullabilities)) {
-        addProblemForRedirectingFactory(
-            factory,
-            templateIncompatibleRedirecteeFunctionType.withArguments(
-                redirecteeType, factoryType, library.isNonNullableByDefault),
-            factory.redirectionTarget.charOffset,
-            noLength);
-      }
-    }
-  }
-
-  @override
-  void checkRedirectingFactories(TypeEnvironment typeEnvironment) {
-    Map<String, MemberBuilder> constructors = this.constructors.local;
-    for (Builder? constructor in constructors.values) {
-      do {
-        if (constructor is RedirectingFactoryBuilder) {
-          checkRedirectingFactory(constructor, typeEnvironment);
-        }
-        constructor = constructor!.next;
-      } while (constructor != null);
-    }
-  }
-
-  @override
-  Map<TypeParameter, DartType> getSubstitutionMap(Class superclass) {
-    Supertype? supertype = cls.supertype;
-    Map<TypeParameter, DartType> substitutionMap = <TypeParameter, DartType>{};
-    List<DartType> arguments;
-    List<TypeParameter> variables;
-    Class? classNode;
-
-    while (classNode != superclass) {
-      classNode = supertype!.classNode;
-      arguments = supertype.typeArguments;
-      variables = classNode.typeParameters;
-      supertype = classNode.supertype;
-      if (variables.isNotEmpty) {
-        Map<TypeParameter, DartType> directSubstitutionMap =
-            <TypeParameter, DartType>{};
-        for (int i = 0; i < variables.length; i++) {
-          DartType argument =
-              i < arguments.length ? arguments[i] : const DynamicType();
-          // ignore: unnecessary_null_comparison
-          if (substitutionMap != null) {
-            // TODO(ahe): Investigate if requiring the caller to use
-            // `substituteDeep` from `package:kernel/type_algebra.dart` instead
-            // of `substitute` is faster. If so, we can simply this code.
-            argument = substitute(argument, substitutionMap);
-          }
-          directSubstitutionMap[variables[i]] = argument;
-        }
-        substitutionMap = directSubstitutionMap;
-      }
-    }
-
-    return substitutionMap;
-  }
-
-  @override
   Member? lookupInstanceMember(ClassHierarchy hierarchy, Name name,
       {bool isSetter: false, bool isSuper: false}) {
     Class? instanceClass = cls;
diff --git a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
index e645c59..3faf679 100644
--- a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
@@ -7,6 +7,7 @@
 import 'package:kernel/ast.dart';
 import 'package:kernel/class_hierarchy.dart'
     show ClassHierarchy, ClassHierarchyMembers;
+import 'package:kernel/core_types.dart';
 import 'package:kernel/reference_from_index.dart' show IndexedClass;
 import 'package:kernel/src/bounds_checks.dart';
 import 'package:kernel/src/legacy_erasure.dart';
@@ -16,6 +17,7 @@
         FreshTypeParameters,
         Substitution,
         getFreshTypeParameters,
+        substitute,
         updateBoundNullabilities;
 import 'package:kernel/type_environment.dart';
 
@@ -28,17 +30,20 @@
 import '../builder/member_builder.dart';
 import '../builder/metadata_builder.dart';
 import '../builder/named_type_builder.dart';
+import '../builder/never_type_declaration_builder.dart';
 import '../builder/nullability_builder.dart';
 import '../builder/type_alias_builder.dart';
 import '../builder/type_builder.dart';
 import '../builder/type_declaration_builder.dart';
 import '../builder/type_variable_builder.dart';
+import '../builder/void_type_declaration_builder.dart';
 import '../dill/dill_member_builder.dart';
 import '../fasta_codes.dart';
 import '../kernel/combined_member_signature.dart';
 import '../kernel/kernel_helper.dart';
 import '../kernel/kernel_target.dart' show KernelTarget;
-import '../kernel/redirecting_factory_body.dart' show redirectingName;
+import '../kernel/redirecting_factory_body.dart'
+    show RedirectingFactoryBody, redirectingName;
 import '../kernel/type_algorithms.dart' show computeTypeVariableBuilderVariance;
 import '../kernel/utils.dart' show compareProcedures;
 import '../names.dart' show equalsName, noSuchMethodName;
@@ -188,7 +193,7 @@
     scope.forEach(buildBuilders);
     constructors.forEach(buildBuilders);
     if (supertypeBuilder != null) {
-      supertypeBuilder = checkSupertype(supertypeBuilder!);
+      supertypeBuilder = _checkSupertype(supertypeBuilder!);
     }
     Supertype? supertype =
         supertypeBuilder?.buildSupertype(library, charOffset, fileUri);
@@ -222,7 +227,7 @@
     actualCls.supertype = supertype;
 
     if (mixedInTypeBuilder != null) {
-      mixedInTypeBuilder = checkSupertype(mixedInTypeBuilder!);
+      mixedInTypeBuilder = _checkSupertype(mixedInTypeBuilder!);
     }
     Supertype? mixedInType =
         mixedInTypeBuilder?.buildMixedInType(library, charOffset, fileUri);
@@ -245,7 +250,7 @@
     cls.isMacro = isMacro;
     if (interfaceBuilders != null) {
       for (int i = 0; i < interfaceBuilders!.length; ++i) {
-        interfaceBuilders![i] = checkSupertype(interfaceBuilders![i]);
+        interfaceBuilders![i] = _checkSupertype(interfaceBuilders![i]);
         Supertype? supertype =
             interfaceBuilders![i].buildSupertype(library, charOffset, fileUri);
         if (supertype != null) {
@@ -314,6 +319,30 @@
     return false;
   }
 
+  void buildOutlineExpressions(
+      SourceLibraryBuilder library,
+      ClassHierarchy classHierarchy,
+      List<DelayedActionPerformer> delayedActionPerformers,
+      List<SynthesizedFunctionNode> synthesizedFunctionNodes) {
+    void build(String ignore, Builder declaration) {
+      SourceMemberBuilder member = declaration as SourceMemberBuilder;
+      member.buildOutlineExpressions(library, classHierarchy,
+          delayedActionPerformers, synthesizedFunctionNodes);
+    }
+
+    MetadataBuilder.buildAnnotations(isPatch ? origin.cls : cls, metadata,
+        library, this, null, fileUri, library.scope);
+    if (typeVariables != null) {
+      for (int i = 0; i < typeVariables!.length; i++) {
+        typeVariables![i].buildOutlineExpressions(library, this, null,
+            classHierarchy, delayedActionPerformers, scope.parent!);
+      }
+    }
+
+    constructors.forEach(build);
+    scope.forEach(build);
+  }
+
   @override
   void forEachConstructor(void Function(String, MemberBuilder) f,
       {bool includeInjectedConstructors: false}) {
@@ -383,6 +412,95 @@
   }
 
   @override
+  int get typeVariablesCount => typeVariables?.length ?? 0;
+
+  @override
+  List<DartType> buildTypeArguments(
+      LibraryBuilder library, List<TypeBuilder>? arguments) {
+    if (arguments == null && typeVariables == null) {
+      return <DartType>[];
+    }
+
+    if (arguments == null && typeVariables != null) {
+      List<DartType> result = new List<DartType>.generate(typeVariables!.length,
+          (int i) => typeVariables![i].defaultType!.build(library),
+          growable: true);
+      if (library is SourceLibraryBuilder) {
+        library.inferredTypes.addAll(result);
+      }
+      return result;
+    }
+
+    if (arguments != null && arguments.length != typeVariablesCount) {
+      // That should be caught and reported as a compile-time error earlier.
+      return unhandled(
+          templateTypeArgumentMismatch
+              .withArguments(typeVariablesCount)
+              .problemMessage,
+          "buildTypeArguments",
+          -1,
+          null);
+    }
+
+    assert(arguments!.length == typeVariablesCount);
+    List<DartType> result = new List<DartType>.generate(
+        arguments!.length, (int i) => arguments[i].build(library),
+        growable: true);
+    return result;
+  }
+
+  /// Returns a map which maps the type variables of [superclass] to their
+  /// respective values as defined by the superclass clause of this class (and
+  /// its superclasses).
+  ///
+  /// It's assumed that [superclass] is a superclass of this class.
+  ///
+  /// For example, given:
+  ///
+  ///     class Box<T> {}
+  ///     class BeatBox extends Box<Beat> {}
+  ///     class Beat {}
+  ///
+  /// We have:
+  ///
+  ///     [[BeatBox]].getSubstitutionMap([[Box]]) -> {[[Box::T]]: Beat]]}.
+  ///
+  /// It's an error if [superclass] isn't a superclass.
+  Map<TypeParameter, DartType> getSubstitutionMap(Class superclass) {
+    Supertype? supertype = cls.supertype;
+    Map<TypeParameter, DartType> substitutionMap = <TypeParameter, DartType>{};
+    List<DartType> arguments;
+    List<TypeParameter> variables;
+    Class? classNode;
+
+    while (classNode != superclass) {
+      classNode = supertype!.classNode;
+      arguments = supertype.typeArguments;
+      variables = classNode.typeParameters;
+      supertype = classNode.supertype;
+      if (variables.isNotEmpty) {
+        Map<TypeParameter, DartType> directSubstitutionMap =
+            <TypeParameter, DartType>{};
+        for (int i = 0; i < variables.length; i++) {
+          DartType argument =
+              i < arguments.length ? arguments[i] : const DynamicType();
+          // ignore: unnecessary_null_comparison
+          if (substitutionMap != null) {
+            // TODO(ahe): Investigate if requiring the caller to use
+            // `substituteDeep` from `package:kernel/type_algebra.dart` instead
+            // of `substitute` is faster. If so, we can simply this code.
+            argument = substitute(argument, substitutionMap);
+          }
+          directSubstitutionMap[variables[i]] = argument;
+        }
+        substitutionMap = directSubstitutionMap;
+      }
+    }
+
+    return substitutionMap;
+  }
+
+  @override
   void applyPatch(Builder patch) {
     if (patch is SourceClassBuilder) {
       patch.actualOrigin = this;
@@ -431,7 +549,357 @@
     }
   }
 
-  TypeBuilder checkSupertype(TypeBuilder supertype) {
+  void checkSupertypes(CoreTypes coreTypes) {
+    // This method determines whether the class (that's being built) its super
+    // class appears both in 'extends' and 'implements' clauses and whether any
+    // interface appears multiple times in the 'implements' clause.
+    // Moreover, it checks that `FutureOr` and `void` are not among the
+    // supertypes.
+
+    void fail(NamedTypeBuilder target, Message message,
+        TypeAliasBuilder? aliasBuilder) {
+      int nameOffset = target.nameOffset;
+      int nameLength = target.nameLength;
+      // TODO(eernst): nameOffset not fully implemented; use backup.
+      if (nameOffset == -1) {
+        nameOffset = this.charOffset;
+        nameLength = noLength;
+      }
+      if (aliasBuilder != null) {
+        addProblem(message, nameOffset, nameLength, context: [
+          messageTypedefCause.withLocation(
+              aliasBuilder.fileUri, aliasBuilder.charOffset, noLength),
+        ]);
+      } else {
+        addProblem(message, nameOffset, nameLength);
+      }
+    }
+
+    // Extract and check superclass (if it exists).
+    ClassBuilder? superClass;
+    TypeBuilder? superClassType = supertypeBuilder;
+    if (superClassType is NamedTypeBuilder) {
+      TypeDeclarationBuilder? decl = superClassType.declaration;
+      TypeAliasBuilder? aliasBuilder; // Non-null if a type alias is use.
+      if (decl is TypeAliasBuilder) {
+        aliasBuilder = decl;
+        decl = aliasBuilder.unaliasDeclaration(superClassType.arguments,
+            isUsedAsClass: true,
+            usedAsClassCharOffset: superClassType.charOffset,
+            usedAsClassFileUri: superClassType.fileUri);
+      }
+      // TODO(eernst): Should gather 'restricted supertype' checks in one place,
+      // e.g., dynamic/int/String/Null and more are checked elsewhere.
+      if (decl is VoidTypeDeclarationBuilder) {
+        fail(superClassType, messageExtendsVoid, aliasBuilder);
+      } else if (decl is NeverTypeDeclarationBuilder) {
+        fail(superClassType, messageExtendsNever, aliasBuilder);
+      } else if (decl is ClassBuilder) {
+        superClass = decl;
+      }
+    }
+    if (interfaceBuilders == null) return;
+
+    // Validate interfaces.
+    Map<ClassBuilder, int>? problems;
+    Map<ClassBuilder, int>? problemsOffsets;
+    Set<ClassBuilder> implemented = new Set<ClassBuilder>();
+    for (TypeBuilder type in interfaceBuilders!) {
+      if (type is NamedTypeBuilder) {
+        int? charOffset = type.charOffset;
+        TypeDeclarationBuilder? typeDeclaration = type.declaration;
+        TypeDeclarationBuilder? decl;
+        TypeAliasBuilder? aliasBuilder; // Non-null if a type alias is used.
+        if (typeDeclaration is TypeAliasBuilder) {
+          aliasBuilder = typeDeclaration;
+          decl = aliasBuilder.unaliasDeclaration(type.arguments,
+              isUsedAsClass: true,
+              usedAsClassCharOffset: type.charOffset,
+              usedAsClassFileUri: type.fileUri);
+        } else {
+          decl = typeDeclaration;
+        }
+        if (decl is ClassBuilder) {
+          ClassBuilder interface = decl;
+          if (superClass == interface) {
+            addProblem(
+                templateImplementsSuperClass.withArguments(interface.name),
+                this.charOffset,
+                noLength);
+          } else if (interface.cls.name == "FutureOr" &&
+              interface.cls.enclosingLibrary.importUri.scheme == "dart" &&
+              interface.cls.enclosingLibrary.importUri.path == "async") {
+            addProblem(messageImplementsFutureOr, this.charOffset, noLength);
+          } else if (implemented.contains(interface)) {
+            // Aggregate repetitions.
+            problems ??= <ClassBuilder, int>{};
+            problems[interface] ??= 0;
+            problems[interface] = problems[interface]! + 1;
+            problemsOffsets ??= <ClassBuilder, int>{};
+            problemsOffsets[interface] ??= charOffset ?? TreeNode.noOffset;
+          } else {
+            implemented.add(interface);
+          }
+        }
+        if (decl != superClass) {
+          // TODO(eernst): Have all 'restricted supertype' checks in one place.
+          if (decl is VoidTypeDeclarationBuilder) {
+            fail(type, messageImplementsVoid, aliasBuilder);
+          } else if (decl is NeverTypeDeclarationBuilder) {
+            fail(type, messageImplementsNever, aliasBuilder);
+          }
+        }
+      }
+    }
+    if (problems != null) {
+      problems.forEach((ClassBuilder interface, int repetitions) {
+        addProblem(
+            templateImplementsRepeated.withArguments(
+                interface.name, repetitions),
+            problemsOffsets![interface]!,
+            noLength);
+      });
+    }
+  }
+
+  void checkMixinApplication(ClassHierarchy hierarchy, CoreTypes coreTypes) {
+    TypeEnvironment typeEnvironment = new TypeEnvironment(coreTypes, hierarchy);
+    // A mixin declaration can only be applied to a class that implements all
+    // the declaration's superclass constraints.
+    InterfaceType supertype = cls.supertype!.asInterfaceType;
+    Substitution substitution = Substitution.fromSupertype(cls.mixedInType!);
+    for (Supertype constraint in cls.mixedInClass!.superclassConstraints()) {
+      InterfaceType requiredInterface =
+          substitution.substituteSupertype(constraint).asInterfaceType;
+      InterfaceType? implementedInterface = hierarchy.getTypeAsInstanceOf(
+          supertype, requiredInterface.classNode, library.library);
+      if (implementedInterface == null ||
+          !typeEnvironment.areMutualSubtypes(
+              implementedInterface,
+              requiredInterface,
+              library.isNonNullableByDefault
+                  ? SubtypeCheckMode.withNullabilities
+                  : SubtypeCheckMode.ignoringNullabilities)) {
+        library.addProblem(
+            templateMixinApplicationIncompatibleSupertype.withArguments(
+                supertype,
+                requiredInterface,
+                cls.mixedInType!.asInterfaceType,
+                library.isNonNullableByDefault),
+            cls.fileOffset,
+            noLength,
+            cls.fileUri);
+      }
+    }
+  }
+
+  // Computes the function type of a given redirection target. Returns [null] if
+  // the type of the target could not be computed.
+  FunctionType? _computeRedirecteeType(
+      RedirectingFactoryBuilder factory, TypeEnvironment typeEnvironment) {
+    ConstructorReferenceBuilder redirectionTarget = factory.redirectionTarget;
+    Builder? targetBuilder = redirectionTarget.target;
+    FunctionNode targetNode;
+    if (targetBuilder == null) return null;
+    if (targetBuilder is FunctionBuilder) {
+      targetNode = targetBuilder.function;
+    } else if (targetBuilder is AmbiguousBuilder) {
+      // Multiple definitions with the same name: An error has already been
+      // issued.
+      // TODO(http://dartbug.com/35294): Unfortunate error; see also
+      // https://dart-review.googlesource.com/c/sdk/+/85390/.
+      return null;
+    } else {
+      unhandled("${redirectionTarget.target}", "computeRedirecteeType",
+          charOffset, fileUri);
+    }
+
+    List<DartType>? typeArguments = factory.getTypeArguments();
+    FunctionType targetFunctionType =
+        targetNode.computeFunctionType(library.nonNullable);
+    if (typeArguments != null &&
+        targetFunctionType.typeParameters.length != typeArguments.length) {
+      _addProblemForRedirectingFactory(
+          factory,
+          templateTypeArgumentMismatch
+              .withArguments(targetFunctionType.typeParameters.length),
+          redirectionTarget.charOffset,
+          noLength);
+      return null;
+    }
+
+    // Compute the substitution of the target class type parameters if
+    // [redirectionTarget] has any type arguments.
+    Substitution? substitution;
+    bool hasProblem = false;
+    if (typeArguments != null && typeArguments.length > 0) {
+      substitution = Substitution.fromPairs(
+          targetFunctionType.typeParameters, typeArguments);
+      for (int i = 0; i < targetFunctionType.typeParameters.length; i++) {
+        TypeParameter typeParameter = targetFunctionType.typeParameters[i];
+        DartType typeParameterBound =
+            substitution.substituteType(typeParameter.bound);
+        DartType typeArgument = typeArguments[i];
+        // Check whether the [typeArgument] respects the bounds of
+        // [typeParameter].
+        if (!typeEnvironment.isSubtypeOf(typeArgument, typeParameterBound,
+            SubtypeCheckMode.ignoringNullabilities)) {
+          _addProblemForRedirectingFactory(
+              factory,
+              templateRedirectingFactoryIncompatibleTypeArgument.withArguments(
+                  typeArgument,
+                  typeParameterBound,
+                  library.isNonNullableByDefault),
+              redirectionTarget.charOffset,
+              noLength);
+          hasProblem = true;
+        } else if (library.isNonNullableByDefault) {
+          if (!typeEnvironment.isSubtypeOf(typeArgument, typeParameterBound,
+              SubtypeCheckMode.withNullabilities)) {
+            _addProblemForRedirectingFactory(
+                factory,
+                templateRedirectingFactoryIncompatibleTypeArgument
+                    .withArguments(typeArgument, typeParameterBound,
+                        library.isNonNullableByDefault),
+                redirectionTarget.charOffset,
+                noLength);
+            hasProblem = true;
+          }
+        }
+      }
+    } else if (typeArguments == null &&
+        targetFunctionType.typeParameters.length > 0) {
+      // TODO(hillerstrom): In this case, we need to perform type inference on
+      // the redirectee to obtain actual type arguments which would allow the
+      // following program to type check:
+      //
+      //    class A<T> {
+      //       factory A() = B;
+      //    }
+      //    class B<T> implements A<T> {
+      //       B();
+      //    }
+      //
+      return null;
+    }
+
+    // Substitute if necessary.
+    targetFunctionType = substitution == null
+        ? targetFunctionType
+        : (substitution.substituteType(targetFunctionType.withoutTypeParameters)
+            as FunctionType);
+
+    return hasProblem ? null : targetFunctionType;
+  }
+
+  bool _isCyclicRedirectingFactory(RedirectingFactoryBuilder factory) {
+    // We use the [tortoise and hare algorithm]
+    // (https://en.wikipedia.org/wiki/Cycle_detection#Tortoise_and_hare) to
+    // handle cycles.
+    Builder? tortoise = factory;
+    Builder? hare = factory.redirectionTarget.target;
+    if (hare == factory) {
+      return true;
+    }
+    while (tortoise != hare) {
+      // Hare moves 2 steps forward.
+      if (hare is! RedirectingFactoryBuilder) {
+        return false;
+      }
+      hare = hare.redirectionTarget.target;
+      if (hare == factory) {
+        return true;
+      }
+      if (hare is! RedirectingFactoryBuilder) {
+        return false;
+      }
+      hare = hare.redirectionTarget.target;
+      if (hare == factory) {
+        return true;
+      }
+      // Tortoise moves one step forward. No need to test type of tortoise
+      // as it follows hare which already checked types.
+      tortoise =
+          (tortoise as RedirectingFactoryBuilder).redirectionTarget.target;
+    }
+    // Cycle found, but original factory doesn't belong to a cycle.
+    return false;
+  }
+
+  void _addProblemForRedirectingFactory(RedirectingFactoryBuilder factory,
+      Message message, int charOffset, int length) {
+    addProblem(message, charOffset, length);
+    String text = library.loader.target.context
+        .format(
+            message.withLocation(fileUri, charOffset, length), Severity.error)
+        .plain;
+    factory.body = new RedirectingFactoryBody.error(text);
+  }
+
+  void _checkRedirectingFactory(
+      RedirectingFactoryBuilder factory, TypeEnvironment typeEnvironment) {
+    // Check that factory declaration is not cyclic.
+    if (_isCyclicRedirectingFactory(factory)) {
+      _addProblemForRedirectingFactory(
+          factory,
+          templateCyclicRedirectingFactoryConstructors
+              .withArguments("${factory.member.enclosingClass!.name}"
+                  "${factory.name == '' ? '' : '.${factory.name}'}"),
+          factory.charOffset,
+          noLength);
+      return;
+    }
+
+    // The factory type cannot contain any type parameters other than those of
+    // its enclosing class, because constructors cannot specify type parameters
+    // of their own.
+    FunctionType factoryType = factory.function
+        .computeThisFunctionType(library.nonNullable)
+        .withoutTypeParameters;
+    FunctionType? redirecteeType =
+        _computeRedirecteeType(factory, typeEnvironment);
+
+    // TODO(hillerstrom): It would be preferable to know whether a failure
+    // happened during [_computeRedirecteeType].
+    if (redirecteeType == null) {
+      return;
+    }
+
+    // Check whether [redirecteeType] <: [factoryType].
+    if (!typeEnvironment.isSubtypeOf(
+        redirecteeType, factoryType, SubtypeCheckMode.ignoringNullabilities)) {
+      _addProblemForRedirectingFactory(
+          factory,
+          templateIncompatibleRedirecteeFunctionType.withArguments(
+              redirecteeType, factoryType, library.isNonNullableByDefault),
+          factory.redirectionTarget.charOffset,
+          noLength);
+    } else if (library.isNonNullableByDefault) {
+      if (!typeEnvironment.isSubtypeOf(
+          redirecteeType, factoryType, SubtypeCheckMode.withNullabilities)) {
+        _addProblemForRedirectingFactory(
+            factory,
+            templateIncompatibleRedirecteeFunctionType.withArguments(
+                redirecteeType, factoryType, library.isNonNullableByDefault),
+            factory.redirectionTarget.charOffset,
+            noLength);
+      }
+    }
+  }
+
+  void checkRedirectingFactories(TypeEnvironment typeEnvironment) {
+    Map<String, MemberBuilder> constructors = this.constructors.local;
+    for (Builder? constructor in constructors.values) {
+      do {
+        if (constructor is RedirectingFactoryBuilder) {
+          _checkRedirectingFactory(constructor, typeEnvironment);
+        }
+        constructor = constructor!.next;
+      } while (constructor != null);
+    }
+  }
+
+  TypeBuilder _checkSupertype(TypeBuilder supertype) {
     if (typeVariables == null) return supertype;
     Message? message;
     for (int i = 0; i < typeVariables!.length; ++i) {
@@ -802,6 +1270,12 @@
     return charOffset.compareTo(other.charOffset);
   }
 
+  bool _hasUserDefinedNoSuchMethod(
+      Class klass, ClassHierarchy hierarchy, Class objectClass) {
+    Member? noSuchMethod = hierarchy.getDispatchTarget(klass, noSuchMethodName);
+    return noSuchMethod != null && noSuchMethod.enclosingClass != objectClass;
+  }
+
   bool _addMissingNoSuchMethodForwarders(
       KernelTarget target, Set<Member> existingForwarders,
       {required bool forSetters}) {
@@ -820,7 +1294,7 @@
     Procedure noSuchMethod = ClassHierarchy.findMemberByName(
         hierarchy.getInterfaceMembers(cls), noSuchMethodName) as Procedure;
     bool clsHasUserDefinedNoSuchMethod =
-        hasUserDefinedNoSuchMethod(cls, hierarchy, target.objectClass);
+        _hasUserDefinedNoSuchMethod(cls, hierarchy, target.objectClass);
 
     bool changed = false;
 
@@ -890,7 +1364,7 @@
         nearestConcreteSuperclass = nearestConcreteSuperclass.superclass;
       }
       if (nearestConcreteSuperclass != null) {
-        bool superHasUserDefinedNoSuchMethod = hasUserDefinedNoSuchMethod(
+        bool superHasUserDefinedNoSuchMethod = _hasUserDefinedNoSuchMethod(
             nearestConcreteSuperclass, hierarchy, target.objectClass);
         {
           List<Member> concrete =
@@ -1085,14 +1559,14 @@
               } else if (targetBuilder is DillMemberBuilder) {
                 targetNode = targetBuilder.member;
               } else if (targetBuilder is AmbiguousBuilder) {
-                addProblemForRedirectingFactory(
+                _addProblemForRedirectingFactory(
                     declaration,
                     templateDuplicatedDeclarationUse
                         .withArguments(redirectionTarget.fullNameForErrors),
                     redirectionTarget.charOffset,
                     noLength);
               } else {
-                addProblemForRedirectingFactory(
+                _addProblemForRedirectingFactory(
                     declaration,
                     templateRedirectionTargetNotFound
                         .withArguments(redirectionTarget.fullNameForErrors),
@@ -1102,7 +1576,7 @@
               if (targetNode != null &&
                   targetNode is Constructor &&
                   targetNode.enclosingClass.isAbstract) {
-                addProblemForRedirectingFactory(
+                _addProblemForRedirectingFactory(
                     declaration,
                     templateAbstractRedirectedClassInstantiation
                         .withArguments(redirectionTarget.fullNameForErrors),
@@ -1127,6 +1601,23 @@
     return count;
   }
 
+  void _handleSeenCovariant(
+      ClassHierarchyMembers memberHierarchy,
+      Member interfaceMember,
+      bool isSetter,
+      callback(Member interfaceMember, bool isSetter)) {
+    // When a parameter is covariant we have to check that we also
+    // override the same member in all parents.
+    for (Supertype supertype in interfaceMember.enclosingClass!.supers) {
+      Member? member = memberHierarchy.getInterfaceMember(
+          supertype.classNode, interfaceMember.name,
+          setter: isSetter);
+      if (member != null) {
+        callback(member, isSetter);
+      }
+    }
+  }
+
   void checkOverride(
       Types types,
       ClassHierarchyMembers memberHierarchy,
@@ -1161,7 +1652,7 @@
               isInterfaceCheck,
               declaredNeedsLegacyErasure);
           if (seenCovariant) {
-            handleSeenCovariant(
+            _handleSeenCovariant(
                 memberHierarchy, interfaceMember, isSetter, callback);
           }
         } else if (declaredMember.kind == ProcedureKind.Getter) {
@@ -1181,7 +1672,7 @@
               isInterfaceCheck,
               declaredNeedsLegacyErasure);
           if (seenCovariant) {
-            handleSeenCovariant(
+            _handleSeenCovariant(
                 memberHierarchy, interfaceMember, isSetter, callback);
           }
         } else {
@@ -1222,7 +1713,7 @@
             isInterfaceCheck,
             declaredNeedsLegacyErasure);
         if (seenCovariant) {
-          handleSeenCovariant(
+          _handleSeenCovariant(
               memberHierarchy, interfaceMember, isSetter, callback);
         }
       }
diff --git a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
index 915ff8d..28267ee 100644
--- a/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_library_builder.dart
@@ -2963,7 +2963,7 @@
     Iterator<Builder> iterator = this.iterator;
     while (iterator.moveNext()) {
       Builder declaration = iterator.current;
-      if (declaration is ClassBuilder) {
+      if (declaration is SourceClassBuilder) {
         declaration.buildOutlineExpressions(this, classHierarchy,
             delayedActionPerformers, synthesizedFunctionNodes);
       } else if (declaration is ExtensionBuilder) {
diff --git a/pkg/front_end/test/patching/patching_test.dart b/pkg/front_end/test/patching/patching_test.dart
index a3b4829..9828fd4 100644
--- a/pkg/front_end/test/patching/patching_test.dart
+++ b/pkg/front_end/test/patching/patching_test.dart
@@ -10,8 +10,8 @@
 import 'package:front_end/src/api_prototype/compiler_options.dart';
 import 'package:front_end/src/api_prototype/experimental_flags.dart';
 import 'package:front_end/src/fasta/builder/builder.dart';
-import 'package:front_end/src/fasta/builder/class_builder.dart';
 import 'package:front_end/src/fasta/builder/member_builder.dart';
+import 'package:front_end/src/fasta/source/source_class_builder.dart';
 import 'package:front_end/src/fasta/source/source_member_builder.dart';
 import 'package:front_end/src/testing/id_testing_helper.dart';
 import 'package:front_end/src/testing/id_testing_utils.dart';
@@ -128,7 +128,8 @@
 
   @override
   Features computeClassValue(Id id, Class cls) {
-    ClassBuilder clsBuilder = lookupClassBuilder(compilerResult, cls)!;
+    SourceClassBuilder clsBuilder =
+        lookupClassBuilder(compilerResult, cls) as SourceClassBuilder;
 
     Features features = new Features();
     if (cls.isAbstract) {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.cc b/runtime/vm/compiler/backend/flow_graph_compiler.cc
index a6d5418..aa1d703 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.cc
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.cc
@@ -3572,60 +3572,6 @@
   }
 }
 
-void FlowGraphCompiler::EmitMoveConst(const compiler::ffi::NativeLocation& dst,
-                                      Location src,
-                                      Representation src_type,
-                                      TemporaryRegisterAllocator* temp) {
-  ASSERT(src.IsConstant());
-  const auto& dst_type = dst.payload_type();
-  if (dst.IsExpressibleAsLocation() &&
-      dst_type.IsExpressibleAsRepresentation() &&
-      dst_type.AsRepresentationOverApprox(zone_) == src_type) {
-    // We can directly emit the const in the right place and representation.
-    const Location dst_loc = dst.AsLocation();
-    EmitMove(dst_loc, src, temp);
-  } else {
-    // We need an intermediate location.
-    Location intermediate;
-    if (dst_type.IsInt()) {
-      if (TMP == kNoRegister) {
-        Register scratch = temp->AllocateTemporary();
-        Location::RegisterLocation(scratch);
-      } else {
-        intermediate = Location::RegisterLocation(TMP);
-      }
-    } else {
-      ASSERT(dst_type.IsFloat());
-      intermediate = Location::FpuRegisterLocation(FpuTMP);
-    }
-
-    if (src.IsPairLocation()) {
-      for (intptr_t i : {0, 1}) {
-        const Representation src_type_split =
-            compiler::ffi::NativeType::FromUnboxedRepresentation(zone_,
-                                                                 src_type)
-                .Split(zone_, i)
-                .AsRepresentation();
-        const auto& intermediate_native =
-            compiler::ffi::NativeLocation::FromLocation(zone_, intermediate,
-                                                        src_type_split);
-        EmitMove(intermediate, src.AsPairLocation()->At(i), temp);
-        EmitNativeMove(dst.Split(zone_, 2, i), intermediate_native, temp);
-      }
-    } else {
-      const auto& intermediate_native =
-          compiler::ffi::NativeLocation::FromLocation(zone_, intermediate,
-                                                      src_type);
-      EmitMove(intermediate, src, temp);
-      EmitNativeMove(dst, intermediate_native, temp);
-    }
-
-    if (dst_type.IsInt() && TMP == kNoRegister) {
-      temp->ReleaseTemporary();
-    }
-  }
-  return;
-}
 
 // The assignment to loading units here must match that in
 // AssignLoadingUnitsCodeVisitor, which runs after compilation is done.
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler.h b/runtime/vm/compiler/backend/flow_graph_compiler.h
index 975e431..f53e11f 100644
--- a/runtime/vm/compiler/backend/flow_graph_compiler.h
+++ b/runtime/vm/compiler/backend/flow_graph_compiler.h
@@ -613,12 +613,6 @@
                           const compiler::ffi::NativeLocation& src,
                           TemporaryRegisterAllocator* temp);
 
-  // Emits a Dart const to a native location.
-  void EmitMoveConst(const compiler::ffi::NativeLocation& dst,
-                     Location src,
-                     Representation src_type,
-                     TemporaryRegisterAllocator* temp);
-
   bool CheckAssertAssignableTypeTestingABILocations(
       const LocationSummary& locs);
 
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
index 878bcec..02daa82 100644
--- a/runtime/vm/compiler/backend/il.cc
+++ b/runtime/vm/compiler/backend/il.cc
@@ -6504,7 +6504,10 @@
 
       ConstantTemporaryAllocator temp_alloc(temp);
       if (origin.IsConstant()) {
-        compiler->EmitMoveConst(def_target, origin, origin_rep, &temp_alloc);
+        // Can't occur because we currently don't inline FFI trampolines (see
+        // http://dartbug.com/45055), which means all incomming arguments
+        // originate from parameters and thus are non-constant.
+        UNREACHABLE();
       } else {
         compiler->EmitMoveToNative(def_target, origin, origin_rep, &temp_alloc);
       }
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index cb4dcdf..4ed246d 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -8173,9 +8173,11 @@
   // being inlined (for now).
   if (ForceOptimize()) {
     if (IsFfiTrampoline()) {
-      // The CallSiteInliner::InlineCall asserts in PrepareGraphs that
-      // GraphEntryInstr::SuccessorCount() == 1, but FFI trampoline has two
-      // entries (a normal and a catch entry).
+      // We currently don't support inlining FFI trampolines. Some of them
+      // are naturally non-inlinable because they contain a try/catch block,
+      // but this condition is broader than strictly necessary.
+      // The work necessary for inlining FFI trampolines is tracked by
+      // http://dartbug.com/45055.
       return false;
     }
     return CompilerState::Current().is_aot();
diff --git a/sdk/lib/core/bigint.dart b/sdk/lib/core/bigint.dart
index 63f9198..e5a871c 100644
--- a/sdk/lib/core/bigint.dart
+++ b/sdk/lib/core/bigint.dart
@@ -8,6 +8,39 @@
 ///
 /// Big integers are signed and can have an arbitrary number of
 /// significant digits, only limited by memory.
+///
+/// To create a big integer from the provided number, use [BigInt.from].
+/// ```dart
+/// var bigInteger = BigInt.from(-1); // -1
+/// bigInteger = BigInt.from(0.9999); // 0
+/// bigInteger = BigInt.from(-10.99); // -10
+/// bigInteger = BigInt.from(0x7FFFFFFFFFFFFFFF); // 9223372036854775807
+/// bigInteger = BigInt.from(1e+30); // 1000000000000000019884624838656
+/// ```
+/// To parse a large integer value from a string, use [parse] or [tryParse].
+/// ```dart
+/// var value = BigInt.parse('0x1ffffffffffffffff'); // 36893488147419103231
+/// value = BigInt.parse('12345678901234567890'); // 12345678901234567890
+/// ```
+/// To check whether a big integer can be represented as an [int] without losing
+/// precision, use [isValidInt].
+/// ```dart continued
+/// print(bigNumber.isValidInt); // false
+/// ```
+/// To convert a big integer into an [int], use [toInt].
+/// To convert a big integer into an [double], use [toDouble].
+/// ```dart
+/// var bigValue = BigInt.from(10).pow(3);
+/// print(bigValue.isValidInt); // true
+/// print(bigValue.toInt()); // 1000
+/// print(bigValue.toDouble()); // 1000.0
+/// ```
+/// **See also:**
+/// * [int]: An integer number.
+/// * [double]: A double-precision floating point number.
+/// * [num]: The super class for [int] and [double].
+/// * [Numbers](https://dart.dev/guides/language/numbers) in
+/// [A tour of the Dart language](https://dart.dev/guides/language/language-tour).
 abstract class BigInt implements Comparable<BigInt> {
   /// A big integer with the numerical value 0.
   external static BigInt get zero;
@@ -39,6 +72,31 @@
   ///
   /// Throws a [FormatException] if the [source] is not a valid integer literal,
   /// optionally prefixed by a sign.
+  /// Examples:
+  /// ```dart
+  /// print(BigInt.parse('-12345678901234567890')); // -12345678901234567890
+  /// print(BigInt.parse('0xFF')); // 255
+  /// print(BigInt.parse('0xffffffffffffffff')); // 18446744073709551615
+  ///
+  /// // From binary (base 2) value.
+  /// print(BigInt.parse('1100', radix: 2)); // 12
+  /// print(BigInt.parse('00011111', radix: 2)); // 31
+  /// print(BigInt.parse('011111100101', radix: 2)); // 2021
+  /// // From octal (base 8) value.
+  /// print(BigInt.parse('14', radix: 8)); // 12
+  /// print(BigInt.parse('37', radix: 8)); // 31
+  /// print(BigInt.parse('3745', radix: 8)); // 2021
+  /// // From hexadecimal (base 16) value.
+  /// print(BigInt.parse('c', radix: 16)); // 12
+  /// print(BigInt.parse('1f', radix: 16)); // 31
+  /// print(BigInt.parse('7e5', radix: 16)); // 2021
+  /// // From base 35 value.
+  /// print(BigInt.parse('y1', radix: 35)); // 1191 == 34 * 35 + 1
+  /// print(BigInt.parse('z1', radix: 35)); // Throws.
+  /// // From base 36 value.
+  /// print(BigInt.parse('y1', radix: 36)); // 1225 == 34 * 36 + 1
+  /// print(BigInt.parse('z1', radix: 36)); // 1261 == 35 * 36 + 1
+  /// ```
   external static BigInt parse(String source, {int? radix});
 
   /// Parses [source] as a, possibly signed, integer literal and returns its
@@ -46,9 +104,42 @@
   ///
   /// As [parse] except that this method returns `null` if the input is not
   /// valid
+  ///
+  /// Examples:
+  /// ```dart
+  /// print(BigInt.tryParse('-12345678901234567890')); // -12345678901234567890
+  /// print(BigInt.tryParse('0xFF')); // 255
+  /// print(BigInt.tryParse('0xffffffffffffffff')); // 18446744073709551615
+  ///
+  /// // From binary (base 2) value.
+  /// print(BigInt.tryParse('1100', radix: 2)); // 12
+  /// print(BigInt.tryParse('00011111', radix: 2)); // 31
+  /// print(BigInt.tryParse('011111100101', radix: 2)); // 2021
+  /// // From octal (base 8) value.
+  /// print(BigInt.tryParse('14', radix: 8)); // 12
+  /// print(BigInt.tryParse('37', radix: 8)); // 31
+  /// print(BigInt.tryParse('3745', radix: 8)); // 2021
+  /// // From hexadecimal (base 16) value.
+  /// print(BigInt.tryParse('c', radix: 16)); // 12
+  /// print(BigInt.tryParse('1f', radix: 16)); // 31
+  /// print(BigInt.tryParse('7e5', radix: 16)); // 2021
+  /// // From base 35 value.
+  /// print(BigInt.tryParse('y1', radix: 35)); // 1191 == 34 * 35 + 1
+  /// print(BigInt.tryParse('z1', radix: 35)); // null
+  /// // From base 36 value.
+  /// print(BigInt.tryParse('y1', radix: 36)); // 1225 == 34 * 36 + 1
+  /// print(BigInt.tryParse('z1', radix: 36)); // 1261 == 35 * 36 + 1
+  /// ```
   external static BigInt? tryParse(String source, {int? radix});
 
-  /// Allocates a big integer from the provided [value] number.
+  /// Creates a big integer from the provided [value] number.
+  ///
+  /// Examples:
+  /// ```dart
+  /// var bigInteger = BigInt.from(1); // 1
+  /// bigInteger = BigInt.from(0.9999); // 0
+  /// bigInteger = BigInt.from(-10.99); // -10
+  /// ```
   external factory BigInt.from(num value);
 
   /// Returns the absolute value of this integer.
@@ -83,7 +174,14 @@
   /// this operation first performs [toDouble] on both this big integer
   /// and [other], then does [double.operator/] on those values and
   /// returns the result.
-  /// The initial [toDouble] conversion may lose precision.
+  ///
+  /// **Note:** The initial [toDouble] conversion may lose precision.
+  ///
+  /// Example:
+  /// ```dart
+  /// print(BigInt.from(1) / BigInt.from(2)); // 0.5
+  /// print(BigInt.from(1.99999) / BigInt.from(2)); // 0.5
+  /// ```
   double operator /(BigInt other);
 
   /// Truncating integer division operator.
@@ -114,6 +212,14 @@
   /// The sign of the returned value `r` is always positive.
   ///
   /// See [remainder] for the remainder of the truncating division.
+  ///
+  /// Example:
+  /// ```dart
+  /// print(BigInt.from(5) % BigInt.from(3)); // 2
+  /// print(BigInt.from(-5) % BigInt.from(3)); // 1
+  /// print(BigInt.from(5) % BigInt.from(-3)); // 2
+  /// print(BigInt.from(-5) % BigInt.from(-3)); // 1
+  /// ```
   BigInt operator %(BigInt other);
 
   /// Returns the remainder of the truncating division of `this` by [other].
@@ -121,6 +227,14 @@
   /// The result `r` of this operation satisfies:
   /// `this == (this ~/ other) * other + r`.
   /// As a consequence the remainder `r` has the same sign as the divider `this`.
+  ///
+  /// Example:
+  /// ```dart
+  /// print(BigInt.from(5).remainder(BigInt.from(3))); // 2
+  /// print(BigInt.from(-5).remainder(BigInt.from(3))); // -2
+  /// print(BigInt.from(5).remainder(BigInt.from(-3))); // 2
+  /// print(BigInt.from(-5).remainder(BigInt.from(-3))); // -2
+  /// ```
   BigInt remainder(BigInt other);
 
   /// Shift the bits of this integer to the left by [shiftAmount].
@@ -198,12 +312,19 @@
   ///
   /// Returns a negative number if `this` is less than `other`, zero if they are
   /// equal, and a positive number if `this` is greater than `other`.
+  ///
+  /// Example:
+  /// ```dart
+  /// print(BigInt.from(1).compareTo(BigInt.from(2))); // => -1
+  /// print(BigInt.from(2).compareTo(BigInt.from(1))); // => 1
+  /// print(BigInt.from(1).compareTo(BigInt.from(1))); // => 0
+  /// ```
   int compareTo(BigInt other);
 
   /// Returns the minimum number of bits required to store this big integer.
   ///
   /// The number of bits excludes the sign bit, which gives the natural length
-  /// for non-negative (unsigned) values.  Negative values are complemented to
+  /// for non-negative (unsigned) values. Negative values are complemented to
   /// return the bit position of the first bit that differs from the sign bit.
   ///
   /// To find the number of bits needed to store the value as a signed value,
@@ -246,6 +367,20 @@
   ///
   /// The result is always equal to the mathematical result of this to the power
   /// [exponent], only limited by the available memory.
+  ///
+  /// Example:
+  /// ```dart
+  /// var value = BigInt.from(1000);
+  /// print(value.pow(0)); // 1
+  /// print(value.pow(1)); // 1000
+  /// print(value.pow(2)); // 1000000
+  /// print(value.pow(3)); // 1000000000
+  /// print(value.pow(4)); // 1000000000000
+  /// print(value.pow(5)); // 1000000000000000
+  /// print(value.pow(6)); // 1000000000000000000
+  /// print(value.pow(7)); // 1000000000000000000000
+  /// print(value.pow(8)); // 1000000000000000000000000
+  /// ```
   BigInt pow(int exponent);
 
   /// Returns this integer to the power of [exponent] modulo [modulus].
@@ -269,15 +404,24 @@
   /// integer dividing both `this` and `other`.
   ///
   /// The greatest common divisor is independent of the order,
-  /// so `x.gcd(y)` is  always the same as `y.gcd(x)`.
+  /// so `x.gcd(y)` is always the same as `y.gcd(x)`.
   ///
   /// For any integer `x`, `x.gcd(x)` is `x.abs()`.
   ///
   /// If both `this` and `other` is zero, the result is also zero.
+  ///
+  /// Example:
+  /// ```dart
+  /// print(BigInt.from(4).gcd(BigInt.from(2))); // 2
+  /// print(BigInt.from(8).gcd(BigInt.from(4))); // 4
+  /// print(BigInt.from(10).gcd(BigInt.from(12))); // 2
+  /// print(BigInt.from(10).gcd(BigInt.from(10))); // 10
+  /// print(BigInt.from(-2).gcd(BigInt.from(-3))); // 1
+  /// ```
   BigInt gcd(BigInt other);
 
   /// Returns the least significant [width] bits of this big integer as a
-  /// non-negative number (i.e. unsigned representation).  The returned value has
+  /// non-negative number (i.e. unsigned representation). The returned value has
   /// zeros in all bit positions higher than [width].
   ///
   /// ```dart
@@ -294,7 +438,7 @@
   /// `q` will count from `0` up to `255` and then wrap around to `0`.
   ///
   /// If the input fits in [width] bits without truncation, the result is the
-  /// same as the input.  The minimum width needed to avoid truncation of `x` is
+  /// same as the input. The minimum width needed to avoid truncation of `x` is
   /// given by `x.bitLength`, i.e.
   ///
   /// ```dart
@@ -303,8 +447,8 @@
   BigInt toUnsigned(int width);
 
   /// Returns the least significant [width] bits of this integer, extending the
-  /// highest retained bit to the sign.  This is the same as truncating the value
-  /// to fit in [width] bits using an signed 2-s complement representation.  The
+  /// highest retained bit to the sign. This is the same as truncating the value
+  /// to fit in [width] bits using an signed 2-s complement representation. The
   /// returned value has the same bit value in all positions higher than [width].
   ///
   /// ```dart
@@ -328,7 +472,7 @@
   /// `127`.
   ///
   /// If the input value fits in [width] bits without truncation, the result is
-  /// the same as the input.  The minimum width needed to avoid truncation of `x`
+  /// the same as the input. The minimum width needed to avoid truncation of `x`
   /// is `x.bitLength + 1`, i.e.
   ///
   /// ```dart
@@ -339,9 +483,18 @@
   /// Whether this big integer can be represented as an `int` without losing
   /// precision.
   ///
-  /// Warning: this function may give a different result on
+  /// **Warning:** this function may give a different result on
   /// dart2js, dev compiler, and the VM, due to the differences in
   /// integer precision.
+  ///
+  /// Example:
+  /// ```dart
+  /// var bigNumber = BigInt.parse('100000000000000000000000');
+  /// print(bigNumber.isValidInt); // false
+  ///
+  /// var value = BigInt.parse('0xFF'); // 255
+  /// print(value.isValidInt); // true
+  /// ```
   bool get isValidInt;
 
   /// Returns this [BigInt] as an [int].
@@ -349,9 +502,15 @@
   /// If the number does not fit, clamps to the max (or min)
   /// integer.
   ///
-  /// Warning: the clamping behaves differently on dart2js, dev
-  /// compiler, and the VM, due to the differences in integer
-  /// precision.
+  /// **Warning:** the clamping behaves differently between the web and
+  /// native platforms due to the differences in integer precision.
+  ///
+  /// Example:
+  /// ```dart
+  /// var bigNumber = BigInt.parse('100000000000000000000000');
+  /// print(bigNumber.isValidInt); // false
+  /// print(bigNumber.toInt()); // 9223372036854775807
+  /// ```
   int toInt();
 
   /// Returns this [BigInt] as a [double].
@@ -359,6 +518,12 @@
   /// If the number is not representable as a [double], an
   /// approximation is returned. For numerically large integers, the
   /// approximation may be infinite.
+  ///
+  /// Example:
+  /// ```dart
+  /// var bigNumber = BigInt.parse('100000000000000000000000');
+  /// print(bigNumber.toDouble()); // 1e+23
+  /// ```
   double toDouble();
 
   /// Returns a String-representation of this integer.
@@ -366,6 +531,12 @@
   /// The returned string is parsable by [parse].
   /// For any `BigInt` `i`, it is guaranteed that
   /// `i == BigInt.parse(i.toString())`.
+  ///
+  /// Example:
+  /// ```dart
+  /// var bigNumber = BigInt.parse('100000000000000000000000');
+  /// print(bigNumber.toString()); // "100000000000000000000000"
+  /// ```
   String toString();
 
   /// Converts [this] to a string representation in the given [radix].
@@ -374,5 +545,24 @@
   /// '9', with 'a' being 10 an 'z' being 35.
   ///
   /// The [radix] argument must be an integer in the range 2 to 36.
+  ///
+  /// Example:
+  /// ```dart
+  /// // Binary (base 2).
+  /// print(BigInt.from(12).toRadixString(2)); // 1100
+  /// print(BigInt.from(31).toRadixString(2)); // 11111
+  /// print(BigInt.from(2021).toRadixString(2)); // 11111100101
+  /// print(BigInt.from(-12).toRadixString(2)); // -1100
+  /// // Octal (base 8).
+  /// print(BigInt.from(12).toRadixString(8)); // 14
+  /// print(BigInt.from(31).toRadixString(8)); // 37
+  /// print(BigInt.from(2021).toRadixString(8)); // 3745
+  /// // Hexadecimal (base 16).
+  /// print(BigInt.from(12).toRadixString(16)); // c
+  /// print(BigInt.from(31).toRadixString(16)); // 1f
+  /// print(BigInt.from(2021).toRadixString(16)); // 7e5
+  /// // Base 36.
+  /// print(BigInt.from(35 * 36 + 1).toRadixString(36)); // z1
+  /// ```
   String toRadixString(int radix);
 }
diff --git a/sdk/lib/core/identical.dart b/sdk/lib/core/identical.dart
index a8bdedf..c13ab27 100644
--- a/sdk/lib/core/identical.dart
+++ b/sdk/lib/core/identical.dart
@@ -5,6 +5,18 @@
 part of dart.core;
 
 /// Check whether two references are to the same object.
+///
+/// Example:
+/// ```dart
+/// var o = new Object();
+/// var isIdentical = identical(o, new Object()); // false, different objects.
+/// isIdentical = identical(o, o); // true, same object
+/// isIdentical = identical(const Object(), const Object()); // true, const canonicalizes
+/// isIdentical = identical([1], [1]); // false
+/// isIdentical = identical(const [1], const [1]); // true
+/// isIdentical = identical(const [1], const [2]); // false
+/// isIdentical = identical(2, 1 + 1); // true, integers canonicalizes
+/// ```
 external bool identical(Object? a, Object? b);
 
 /// The identity hash code of [object].
@@ -14,5 +26,14 @@
 ///
 /// This hash code is compatible with [identical],
 /// which just means that it's guaranteed to be stable over time.
+/// ```dart import:dart:collection
+/// var identitySet = HashSet(equals: identical, hashCode: identityHashCode);
+/// var dt1 = DateTime.now();
+/// var dt2 = DateTime.fromMicrosecondsSinceEpoch(dt1.microsecondsSinceEpoch);
+/// assert(dt1 == dt2);
+/// identitySet.add(dt1);
+/// print(identitySet.contains(dt1)); // true
+/// print(identitySet.contains(dt2)); // false
+/// ```
 @pragma("vm:entry-point")
 external int identityHashCode(Object? object);
diff --git a/sdk/lib/core/map.dart b/sdk/lib/core/map.dart
index f6c6caf..ae091be 100644
--- a/sdk/lib/core/map.dart
+++ b/sdk/lib/core/map.dart
@@ -451,11 +451,32 @@
 }
 
 /// A key/value pair representing an entry in a [Map].
+///
+/// The [Map] interface contains various methods that can
+/// inspect or modify the map based on entry objects.
+/// ```dart
+/// final map = {'1': 'A', '2': 'B'};
+/// map.addEntries([
+///  MapEntry('3', 'C'),
+///  MapEntry('4', 'D'),
+/// ]);
+/// print(map); // {1: A, 2: B, 3: C, 4: D}
+/// ```
 class MapEntry<K, V> {
   /// The key of the entry.
+  /// ```dart
+  /// final map = {'theKey': 'theValue'};
+  /// var entry = map.entries.first;
+  /// print(entry.key); // theKey
+  /// ```
   final K key;
 
   /// The value associated to [key] in the map.
+  /// ```dart
+  /// final map = {'theKey': 'theValue'};
+  /// var entry = map.entries.first;
+  /// print(entry.value); // theValue
+  /// ```
   final V value;
 
   /// Creates an entry with [key] and [value].
diff --git a/tools/VERSION b/tools/VERSION
index 0b7b793..dbe4c2a 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 17
 PATCH 0
-PRERELEASE 5
+PRERELEASE 6
 PRERELEASE_PATCH 0
\ No newline at end of file