diff --git a/pkg/analyzer_plugin/CHANGELOG.md b/pkg/analyzer_plugin/CHANGELOG.md
index a2d2707..3ee89a3 100644
--- a/pkg/analyzer_plugin/CHANGELOG.md
+++ b/pkg/analyzer_plugin/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.7.0
+
+- Support verison `2.x` of the `analyzer` package
+
 ## 0.6.0
 - Bug fixes to the protocol.
 
diff --git a/pkg/analyzer_plugin/pubspec.yaml b/pkg/analyzer_plugin/pubspec.yaml
index 2b5441c..b5304b9 100644
--- a/pkg/analyzer_plugin/pubspec.yaml
+++ b/pkg/analyzer_plugin/pubspec.yaml
@@ -7,7 +7,7 @@
   sdk: '>=2.12.0 <3.0.0'
 
 dependencies:
-  analyzer: ^1.5.0
+  analyzer: ^2.0.0
   collection: ^1.15.0
   dart_style: ^2.0.0
   pub_semver: ^2.0.0
diff --git a/pkg/compiler/lib/src/inferrer/builder_kernel.dart b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
index 6c90fb2..0aa7a6e 100644
--- a/pkg/compiler/lib/src/inferrer/builder_kernel.dart
+++ b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
@@ -2314,7 +2314,7 @@
 
   @override
   TypeInformation visitStaticTearOffConstant(ir.StaticTearOffConstant node) {
-    return builder.createStaticGetTypeInformation(node, node.procedure);
+    return builder.createStaticGetTypeInformation(node, node.target);
   }
 
   @override
diff --git a/pkg/compiler/lib/src/ir/impact.dart b/pkg/compiler/lib/src/ir/impact.dart
index 33640a7..8339c43 100644
--- a/pkg/compiler/lib/src/ir/impact.dart
+++ b/pkg/compiler/lib/src/ir/impact.dart
@@ -749,19 +749,14 @@
 
   @override
   void visitStaticTearOffConstant(ir.StaticTearOffConstant node) {
-    ir.Member member = node.procedure;
-    if (member is ir.Procedure) {
-      registry.registerStaticTearOff(member, import);
-    } else {
-      throw new UnsupportedError("Unexpected member (${member.runtimeType}).");
-    }
+    registry.registerStaticTearOff(node.target, import);
   }
 
   @override
   void visitInstantiationConstant(ir.InstantiationConstant node) {
     registry.registerGenericInstantiation(
         node.tearOffConstant.function.computeFunctionType(
-            node.tearOffConstant.member.enclosingLibrary.nonNullable),
+            node.tearOffConstant.target.enclosingLibrary.nonNullable),
         node.types);
     visitConstant(node.tearOffConstant);
   }
diff --git a/pkg/compiler/lib/src/ir/visitors.dart b/pkg/compiler/lib/src/ir/visitors.dart
index 0335a73..cbcfda9 100644
--- a/pkg/compiler/lib/src/ir/visitors.dart
+++ b/pkg/compiler/lib/src/ir/visitors.dart
@@ -213,15 +213,10 @@
 
   @override
   ConstantValue visitStaticTearOffConstant(ir.StaticTearOffConstant node) {
-    ir.Member member = node.procedure;
-    if (member is ir.Procedure) {
-      FunctionEntity function = elementMap.getMethod(member);
-      DartType type = elementMap.getFunctionType(member.function);
-      return new FunctionConstantValue(function, type);
-    } else {
-      throw new UnsupportedError(
-          "Unexpected torn off member kind (${member.runtimeType}).");
-    }
+    ir.Procedure member = node.target;
+    FunctionEntity function = elementMap.getMethod(member);
+    DartType type = elementMap.getFunctionType(member.function);
+    return new FunctionConstantValue(function, type);
   }
 
   @override
diff --git a/pkg/compiler/lib/src/serialization/node_indexer.dart b/pkg/compiler/lib/src/serialization/node_indexer.dart
index e0c56a2..782e2fc 100644
--- a/pkg/compiler/lib/src/serialization/node_indexer.dart
+++ b/pkg/compiler/lib/src/serialization/node_indexer.dart
@@ -313,6 +313,10 @@
   void visitConstructorTearOffConstant(ir.ConstructorTearOffConstant node) {}
 
   @override
+  void visitRedirectingFactoryTearOffConstant(
+      ir.RedirectingFactoryTearOffConstant node) {}
+
+  @override
   void visitInstantiationConstant(ir.InstantiationConstant node) {
     node.tearOffConstant.accept(this);
   }
diff --git a/pkg/compiler/lib/src/ssa/builder_kernel.dart b/pkg/compiler/lib/src/ssa/builder_kernel.dart
index 765039b..ad0375f 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -4491,8 +4491,8 @@
     } else if (closure is ir.ConstantExpression &&
         closure.constant is ir.StaticTearOffConstant) {
       ir.StaticTearOffConstant tearOff = closure.constant;
-      ir.Member member = tearOff.procedure;
-      if (member is ir.Procedure && handleTarget(member)) {
+      ir.Procedure member = tearOff.target;
+      if (handleTarget(member)) {
         return;
       }
     }
diff --git a/pkg/dev_compiler/lib/src/kernel/command.dart b/pkg/dev_compiler/lib/src/kernel/command.dart
index c0e4c51..d6d428c 100644
--- a/pkg/dev_compiler/lib/src/kernel/command.dart
+++ b/pkg/dev_compiler/lib/src/kernel/command.dart
@@ -729,7 +729,8 @@
       : null;
 
   var debugSymbols = emitDebugSymbols
-      ? _emitSymbols(compiler, nameListener.identifierNames, component)
+      ? _emitSymbols(
+          compiler, moduleTree.name, nameListener.identifierNames, component)
       : null;
 
   return JSCode(text, builtMap, symbols: debugSymbols, metadata: debugMetadata);
@@ -741,7 +742,7 @@
 /// Uses information from the [compiler] used to compile the JS module combined
 /// with [identifierNames] that maps JavaScript identifier nodes to their actual
 /// names used when outputting the JavaScript.
-ModuleSymbols _emitSymbols(ProgramCompiler compiler,
+ModuleSymbols _emitSymbols(ProgramCompiler compiler, String moduleName,
     Map<js_ast.Identifier, String> identifierNames, Component component) {
   var classJsNames = <Class, String>{
     for (var e in compiler.classIdentifiers.entries)
@@ -753,7 +754,7 @@
   };
 
   return ModuleSymbolsCollector(
-          classJsNames, compiler.memberNames, variableJsNames)
+          moduleName, classJsNames, compiler.memberNames, variableJsNames)
       .collectSymbolInfo(component);
 }
 
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index c11ced8..2c37a60 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -5853,6 +5853,12 @@
   }
 
   @override
+  js_ast.Expression visitRedirectingFactoryTearOff(
+      RedirectingFactoryTearOff node) {
+    throw UnsupportedError('RedirectingFactory tear off');
+  }
+
+  @override
   js_ast.Expression visitTypedefTearOff(TypedefTearOff node) {
     throw UnsupportedError('Typedef instantiation');
   }
@@ -6241,13 +6247,13 @@
   js_ast.Expression visitConstant(Constant node) {
     if (node is StaticTearOffConstant) {
       // JS() or external JS consts should not be lazily loaded.
-      var isSdk = node.procedure.enclosingLibrary.importUri.scheme == 'dart';
+      var isSdk = node.target.enclosingLibrary.importUri.scheme == 'dart';
       if (_isInForeignJS) {
-        return _emitStaticTarget(node.procedure);
+        return _emitStaticTarget(node.target);
       }
-      if (node.procedure.isExternal && !isSdk) {
+      if (node.target.isExternal && !isSdk) {
         return runtimeCall(
-            'tearoffInterop(#)', [_emitStaticTarget(node.procedure)]);
+            'tearoffInterop(#)', [_emitStaticTarget(node.target)]);
       }
     }
     if (node is TypeLiteralConstant) {
@@ -6426,8 +6432,8 @@
 
   @override
   js_ast.Expression visitStaticTearOffConstant(StaticTearOffConstant node) {
-    _declareBeforeUse(node.procedure.enclosingClass);
-    return _emitStaticGet(node.procedure);
+    _declareBeforeUse(node.target.enclosingClass);
+    return _emitStaticGet(node.target);
   }
 
   @override
diff --git a/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart b/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart
index 7ac69c9..23cc5bb 100644
--- a/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/expression_compiler.dart
@@ -28,7 +28,7 @@
         Member,
         Node,
         Procedure,
-        RedirectingFactoryConstructor,
+        RedirectingFactory,
         TreeNode,
         TypeParameter,
         VariableDeclaration,
@@ -253,7 +253,7 @@
     if (node is Constructor) return node.fileEndOffset;
     if (node is Procedure) return node.fileEndOffset;
     if (node is Field) return node.fileEndOffset;
-    if (node is RedirectingFactoryConstructor) return node.fileEndOffset;
+    if (node is RedirectingFactory) return node.fileEndOffset;
     if (node is FunctionNode) return node.fileEndOffset;
     return noOffset;
   }
diff --git a/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart b/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart
index 253facf..2f16592 100644
--- a/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart
+++ b/pkg/dev_compiler/lib/src/kernel/module_symbols_collector.dart
@@ -14,24 +14,23 @@
   /// The first scope added to the stack should always be the library scope. The
   /// last element in the list represents the current scope.
   final _scopes = <ScopeSymbol>[];
-
-  final _moduleSymbols = ModuleSymbols(
-      // TODO(nshahan) version
-      // TODO(nshahan) moduleName
-      libraries: <LibrarySymbol>[],
-      scripts: <Script>[],
-      classes: <ClassSymbol>[],
-      // TODO(nshahan) functionTypes
-      // TODO(nshahan) functions
-      // TODO(nshahan) scopes
-      variables: <VariableSymbol>[]);
-
+  final ModuleSymbols _moduleSymbols;
   final Map<Class, String> _classJsNames;
   final Map<Member, String> _memberJsNames;
   final Map<VariableDeclaration, String> _variableJsNames;
 
-  ModuleSymbolsCollector(
-      this._classJsNames, this._memberJsNames, this._variableJsNames);
+  ModuleSymbolsCollector(String moduleName, this._classJsNames,
+      this._memberJsNames, this._variableJsNames)
+      : _moduleSymbols = ModuleSymbols(
+            version: ModuleSymbols.current.version,
+            moduleName: moduleName,
+            libraries: <LibrarySymbol>[],
+            scripts: <Script>[],
+            classes: <ClassSymbol>[],
+            // TODO(nshahan) functionTypes
+            // TODO(nshahan) functions
+            // TODO(nshahan) scopes
+            variables: <VariableSymbol>[]);
 
   ModuleSymbols collectSymbolInfo(Component node) {
     node.accept(this);
diff --git a/pkg/front_end/lib/src/api_unstable/dart2js.dart b/pkg/front_end/lib/src/api_unstable/dart2js.dart
index d29d1ea..ee007f5 100644
--- a/pkg/front_end/lib/src/api_unstable/dart2js.dart
+++ b/pkg/front_end/lib/src/api_unstable/dart2js.dart
@@ -240,7 +240,7 @@
 
 /// Desugar API to determine whether [member] is a redirecting factory
 /// constructor.
-// TODO(sigmund): Delete this API once `member.isRedirectingFactoryConstructor`
+// TODO(sigmund): Delete this API once `member.isRedirectingFactory`
 // is implemented correctly for patch files (Issue #33495).
 bool isRedirectingFactory(ir.Procedure member) {
   if (member.kind == ir.ProcedureKind.Factory) {
diff --git a/pkg/front_end/lib/src/fasta/builder/factory_builder.dart b/pkg/front_end/lib/src/fasta/builder/factory_builder.dart
index ddf666e..ae02cb6 100644
--- a/pkg/front_end/lib/src/fasta/builder/factory_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/factory_builder.dart
@@ -203,8 +203,8 @@
     origin._procedure.isExternal = _procedureInternal.isExternal;
     origin._procedure.function = _procedureInternal.function;
     origin._procedure.function.parent = origin._procedure;
-    origin._procedure.isRedirectingFactoryConstructor =
-        _procedureInternal.isRedirectingFactoryConstructor;
+    origin._procedure.isRedirectingFactory =
+        _procedureInternal.isRedirectingFactory;
     return 1;
   }
 }
@@ -264,7 +264,7 @@
     bodyInternal = new RedirectingFactoryBody(target, typeArguments);
     function.body = bodyInternal;
     bodyInternal?.parent = function;
-    _procedure.isRedirectingFactoryConstructor = true;
+    _procedure.isRedirectingFactory = true;
     if (isPatch) {
       // ignore: unnecessary_null_comparison
       if (function.typeParameters != null) {
@@ -299,7 +299,7 @@
     _procedureInternal.isExternal = isExternal;
     _procedureInternal.isConst = isConst;
     _procedureInternal.isStatic = isStatic;
-    _procedureInternal.isRedirectingFactoryConstructor = true;
+    _procedureInternal.isRedirectingFactory = true;
     if (redirectionTarget.typeArguments != null) {
       typeArguments = new List<DartType>.generate(
           redirectionTarget.typeArguments!.length,
diff --git a/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart b/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
index 1fa324b..8950e51 100644
--- a/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
@@ -537,8 +537,7 @@
     origin.procedure.isExternal = _procedure.isExternal;
     origin.procedure.function = _procedure.function;
     origin.procedure.function.parent = origin.procedure;
-    origin.procedure.isRedirectingFactoryConstructor =
-        _procedure.isRedirectingFactoryConstructor;
+    origin.procedure.isRedirectingFactory = _procedure.isRedirectingFactory;
     return 1;
   }
 }
diff --git a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
index 382ee2b..04bbb31 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -453,8 +453,7 @@
       transformTypeParameterList(node.typeParameters, node);
       transformConstructorList(node.constructors, node);
       transformProcedureList(node.procedures, node);
-      transformRedirectingFactoryConstructorList(
-          node.redirectingFactoryConstructors, node);
+      transformRedirectingFactoryList(node.redirectingFactories, node);
     });
     _staticTypeContext = oldStaticTypeContext;
     return node;
@@ -511,17 +510,15 @@
   }
 
   @override
-  RedirectingFactoryConstructor visitRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor node, TreeNode? removalSentinel) {
+  RedirectingFactory visitRedirectingFactory(
+      RedirectingFactory node, TreeNode? removalSentinel) {
     // Currently unreachable as the compiler doesn't produce
     // RedirectingFactoryConstructor.
     StaticTypeContext? oldStaticTypeContext = _staticTypeContext;
     _staticTypeContext = new StaticTypeContext(node, typeEnvironment);
     constantEvaluator.withNewEnvironment(() {
       transformAnnotations(node.annotations, node);
-      transformTypeParameterList(node.typeParameters, node);
-      transformVariableDeclarationList(node.positionalParameters, node);
-      transformVariableDeclarationList(node.namedParameters, node);
+      node.function = transform(node.function)..parent = node;
     });
     _staticTypeContext = oldStaticTypeContext;
     return node;
@@ -3397,7 +3394,7 @@
               node.typeArguments.map((t) => env.substituteType(t)).toList()));
     }
     if (constant is StaticTearOffConstant) {
-      Member constantMember = constant.procedure;
+      Procedure constantMember = constant.target;
       if (constantMember is Procedure) {
         if (node.typeArguments.length ==
             constantMember.function.typeParameters.length) {
@@ -3422,9 +3419,6 @@
               'instantiation does not match the number of type arguments '
               'of the $constant.');
         }
-      } else if (constantMember is Constructor) {
-        // TODO(dmitryas): Add support for instantiated constructor tear-offs.
-        return defaultExpression(node);
       } else {
         // Probably unreachable.
         return createInvalidExpressionConstant(
@@ -3442,6 +3436,12 @@
 
   @override
   Constant visitConstructorTearOff(ConstructorTearOff node) {
+    // TODO(dmitryas): Add support for instantiated constructor tear-offs.
+    return defaultExpression(node);
+  }
+
+  @override
+  Constant visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node) {
     return defaultExpression(node);
   }
 
diff --git a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
index 7fc34a9..0c85ec0 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -217,12 +217,18 @@
   @override
   ExpressionInferenceResult visitConstructorTearOff(
       ConstructorTearOff node, DartType typeContext) {
-    DartType type = node.constructor.function
-        .computeFunctionType(inferrer.library.nonNullable);
+    DartType type =
+        node.target.function!.computeFunctionType(inferrer.library.nonNullable);
     return inferrer.instantiateTearOff(type, typeContext, node);
   }
 
   @override
+  ExpressionInferenceResult visitRedirectingFactoryTearOff(
+      RedirectingFactoryTearOff node, DartType typeContext) {
+    return _unhandledExpression(node, typeContext);
+  }
+
+  @override
   ExpressionInferenceResult visitTypedefTearOff(
       TypedefTearOff node, DartType typeContext) {
     ExpressionInferenceResult expressionResult = inferrer.inferExpression(
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index ef5652b..c3a5e4e 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -598,7 +598,7 @@
     assert(!builder.isExtension);
     // TODO(askesc): Make this check light-weight in the absence of patches.
     if (builder.cls.constructors.isNotEmpty) return;
-    if (builder.cls.redirectingFactoryConstructors.isNotEmpty) return;
+    if (builder.cls.redirectingFactories.isNotEmpty) return;
     for (Procedure proc in builder.cls.procedures) {
       if (proc.isFactory) return;
     }
diff --git a/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart b/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
index aeb1696..8a23b53 100644
--- a/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
@@ -361,7 +361,7 @@
   }
 
   void visitStaticTearOffConstant(StaticTearOffConstant node) {
-    Procedure procedure = node.procedure;
+    Procedure procedure = node.target;
     Class? classNode = procedure.enclosingClass;
     if (classNode != null) {
       result.add(nameForEntity(
@@ -375,8 +375,21 @@
   }
 
   void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
-    Constructor constructor = node.constructor;
-    Class? classNode = constructor.enclosingClass;
+    Member constructor = node.target;
+    Class classNode = constructor.enclosingClass!;
+    result.add(nameForEntity(
+        classNode,
+        classNode.name,
+        classNode.enclosingLibrary.importUri,
+        classNode.enclosingLibrary.fileUri));
+    result.add(".");
+    result.add(constructor.name.text);
+  }
+
+  void visitRedirectingFactoryTearOffConstant(
+      RedirectingFactoryTearOffConstant node) {
+    Member constructor = node.target;
+    Class classNode = constructor.enclosingClass!;
     result.add(nameForEntity(
         classNode,
         classNode.name,
diff --git a/pkg/front_end/lib/src/fasta/kernel/verifier.dart b/pkg/front_end/lib/src/fasta/kernel/verifier.dart
index 363f618..4ac0b50 100644
--- a/pkg/front_end/lib/src/fasta/kernel/verifier.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/verifier.dart
@@ -283,7 +283,7 @@
     // the shape, but aren't of the RedirectingFactoryBody type.
     bool hasBody = isRedirectingFactory(node) ||
         RedirectingFactoryBody.hasRedirectingFactoryBodyShape(node);
-    bool hasFlag = node.isRedirectingFactoryConstructor;
+    bool hasFlag = node.isRedirectingFactory;
     if (hasBody != hasFlag) {
       String hasBodyString = hasBody ? "has" : "doesn't have";
       String hasFlagString = hasFlag ? "has" : "doesn't have";
@@ -291,7 +291,7 @@
           node,
           "Procedure '${node.name}' ${hasBodyString} a body "
           "of a redirecting factory, but ${hasFlagString} the "
-          "'isRedirectingFactoryConstructor' bit set.");
+          "'isRedirectingFactory' bit set.");
     }
 
     super.visitProcedure(node);
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 0a88d80..d81529e 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
@@ -161,8 +161,8 @@
                 cls.addField(member);
               } else if (member is Constructor) {
                 cls.addConstructor(member);
-              } else if (member is RedirectingFactoryConstructor) {
-                cls.addRedirectingFactoryConstructor(member);
+              } else if (member is RedirectingFactory) {
+                cls.addRedirectingFactory(member);
               } else {
                 unhandled("${member.runtimeType}", "getMember",
                     member.fileOffset, member.fileUri);
diff --git a/pkg/front_end/lib/src/testing/id_testing_utils.dart b/pkg/front_end/lib/src/testing/id_testing_utils.dart
index fafad3a..59a5c83 100644
--- a/pkg/front_end/lib/src/testing/id_testing_utils.dart
+++ b/pkg/front_end/lib/src/testing/id_testing_utils.dart
@@ -415,7 +415,7 @@
 
   void visitInstantiationConstant(InstantiationConstant node) {
     sb.write('Instantiation(');
-    sb.write(getMemberName(node.tearOffConstant.member));
+    sb.write(getMemberName(node.tearOffConstant.target));
     sb.write('<');
     typeToText.visitList(node.types);
     sb.write('>)');
@@ -423,7 +423,7 @@
 
   void visitTypedefTearOffConstant(TypedefTearOffConstant node) {
     sb.write('TypedefTearOff(');
-    sb.write(getMemberName(node.tearOffConstant.member));
+    sb.write(getMemberName(node.tearOffConstant.target));
     if (node.parameters.isNotEmpty) {
       sb.write('<');
       for (int i = 0; i < node.parameters.length; i++) {
@@ -451,13 +451,20 @@
 
   void visitStaticTearOffConstant(StaticTearOffConstant node) {
     sb.write('Function(');
-    sb.write(getMemberName(node.procedure));
+    sb.write(getMemberName(node.target));
     sb.write(')');
   }
 
   void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
     sb.write('Constructor(');
-    sb.write(getMemberName(node.constructor));
+    sb.write(getMemberName(node.target));
+    sb.write(')');
+  }
+
+  void visitRedirectingFactoryTearOffConstant(
+      RedirectingFactoryTearOffConstant node) {
+    sb.write('RedirectingFactory(');
+    sb.write(getMemberName(node.target));
     sb.write(')');
   }
 
diff --git a/pkg/front_end/test/desugar_test.dart b/pkg/front_end/test/desugar_test.dart
index 7aa716d..f8078d1 100644
--- a/pkg/front_end/test/desugar_test.dart
+++ b/pkg/front_end/test/desugar_test.dart
@@ -67,7 +67,7 @@
   Expect.isTrue(
       member.kind == ir.ProcedureKind.Factory, "$member is not a factory");
   Expect.isTrue(api.isRedirectingFactory(member));
-  Expect.isTrue(member.isRedirectingFactoryConstructor);
+  Expect.isTrue(member.isRedirectingFactory);
 }
 
 const aSource = '''
diff --git a/pkg/front_end/test/incremental_compiler_leak_test.dart b/pkg/front_end/test/incremental_compiler_leak_test.dart
index d304ccb..922866f 100644
--- a/pkg/front_end/test/incremental_compiler_leak_test.dart
+++ b/pkg/front_end/test/incremental_compiler_leak_test.dart
@@ -243,7 +243,7 @@
     "Field",
     "Library",
     "Procedure",
-    "RedirectingFactoryConstructor",
+    "RedirectingFactory",
     "Typedef",
   };
 
diff --git a/pkg/kernel/binary.md b/pkg/kernel/binary.md
index 4dd9aa7..a2f3687 100644
--- a/pkg/kernel/binary.md
+++ b/pkg/kernel/binary.md
@@ -147,7 +147,7 @@
 
 type ComponentFile {
   UInt32 magic = 0x90ABCDEF;
-  UInt32 formatVersion = 67;
+  UInt32 formatVersion = 68;
   Byte[10] shortSdkHash;
   List<String> problemsAsJson; // Described in problems.md.
   Library[] libraries;
@@ -328,7 +328,7 @@
   List<Field> fields;
   List<Constructor> constructors;
   List<Procedure> procedures;
-  List<RedirectingFactoryConstructor> redirectingFactoryConstructors;
+  List<RedirectingFactory> redirectingFactories;
 
   // Class index. Offsets are used to get start (inclusive) and end (exclusive) byte positions for
   // a specific procedure. Note the "+1" to account for needing the end of the last entry.
@@ -424,7 +424,7 @@
   Byte kind; // Index into the ProcedureKind enum above.
   Byte stubKind; // Index into the ProcedureStubKind enum above.
   UInt flags (isStatic, isAbstract, isExternal, isConst,
-              isRedirectingFactoryConstructor, isExtensionMember,
+              isRedirectingFactory, isExtensionMember,
               isNonNullableByDefault);
   Name name;
   List<Expression> annotations;
@@ -432,7 +432,7 @@
   FunctionNode function;
 }
 
-type RedirectingFactoryConstructor extends Member {
+type RedirectingFactory extends Member {
   Byte tag = 108;
   CanonicalNameReference canonicalName;
   UriReference fileUri;
@@ -703,8 +703,13 @@
 type ConstructorTearOff extends Expression {
   Byte tag = 60;
   FileOffset fileOffset;
-  ConstructorReference constructor;
-  Option<List<DartType>> typeArguments;
+  MemberReference target;
+}
+
+type RedirectingFactoryTearOff extends Expression {
+  Byte tag = 84;
+  FileOffset fileOffset;
+  MemberReference target;
 }
 
 type TypedefTearOff extends Expression {
@@ -1219,6 +1224,11 @@
   CanonicalNameReference constructorReference;
 }
 
+type RedirectingFactoryTearOffConstant extends Constant {
+  Byte tag = 16;
+  CanonicalNameReference constructorReference;
+}
+
 abstract type Statement extends Node {}
 
 type ExpressionStatement extends Statement {
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index 69b540a..3f78529 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -1190,19 +1190,18 @@
     _proceduresView = null;
   }
 
-  List<RedirectingFactoryConstructor> _redirectingFactoryConstructorsInternal;
-  DirtifyingList<RedirectingFactoryConstructor>?
-      _redirectingFactoryConstructorsView;
+  List<RedirectingFactory> _redirectingFactoriesInternal;
+  DirtifyingList<RedirectingFactory>? _redirectingFactoryConstructorsView;
 
   /// Redirecting factory constructors declared in the class.
   ///
   /// For mixin applications this should be empty.
-  List<RedirectingFactoryConstructor> get redirectingFactoryConstructors {
+  List<RedirectingFactory> get redirectingFactories {
     ensureLoaded();
     // If already dirty the caller just might as well add stuff directly too.
-    if (dirty) return _redirectingFactoryConstructorsInternal;
+    if (dirty) return _redirectingFactoriesInternal;
     return _redirectingFactoryConstructorsView ??=
-        new DirtifyingList(this, _redirectingFactoryConstructorsInternal);
+        new DirtifyingList(this, _redirectingFactoriesInternal);
   }
 
   /// Internal. Should *ONLY* be used from within kernel.
@@ -1210,8 +1209,8 @@
   /// Used for adding redirecting factory constructor when reading the dill
   /// file.
   void set redirectingFactoryConstructorsInternal(
-      List<RedirectingFactoryConstructor> redirectingFactoryConstructors) {
-    _redirectingFactoryConstructorsInternal = redirectingFactoryConstructors;
+      List<RedirectingFactory> redirectingFactoryConstructors) {
+    _redirectingFactoriesInternal = redirectingFactoryConstructors;
     _redirectingFactoryConstructorsView = null;
   }
 
@@ -1226,7 +1225,7 @@
       List<Constructor>? constructors,
       List<Procedure>? procedures,
       List<Field>? fields,
-      List<RedirectingFactoryConstructor>? redirectingFactoryConstructors,
+      List<RedirectingFactory>? redirectingFactoryConstructors,
       required this.fileUri,
       Reference? reference})
       // ignore: unnecessary_null_comparison
@@ -1238,14 +1237,14 @@
         this._fieldsInternal = fields ?? <Field>[],
         this._constructorsInternal = constructors ?? <Constructor>[],
         this._proceduresInternal = procedures ?? <Procedure>[],
-        this._redirectingFactoryConstructorsInternal =
-            redirectingFactoryConstructors ?? <RedirectingFactoryConstructor>[],
+        this._redirectingFactoriesInternal =
+            redirectingFactoryConstructors ?? <RedirectingFactory>[],
         super(reference) {
     setParents(this.typeParameters, this);
     setParents(this._constructorsInternal, this);
     setParents(this._proceduresInternal, this);
     setParents(this._fieldsInternal, this);
-    setParents(this._redirectingFactoryConstructorsInternal, this);
+    setParents(this._redirectingFactoriesInternal, this);
     this.isAbstract = isAbstract;
     this.isAnonymousMixin = isAnonymousMixin;
   }
@@ -1270,10 +1269,10 @@
       Constructor member = constructors[i];
       canonicalName.getChildFromConstructor(member).bindTo(member.reference);
     }
-    for (int i = 0; i < redirectingFactoryConstructors.length; ++i) {
-      RedirectingFactoryConstructor member = redirectingFactoryConstructors[i];
+    for (int i = 0; i < redirectingFactories.length; ++i) {
+      RedirectingFactory member = redirectingFactories[i];
       canonicalName
-          .getChildFromRedirectingFactoryConstructor(member)
+          .getChildFromRedirectingFactory(member)
           .bindTo(member.reference);
     }
     dirty = false;
@@ -1300,8 +1299,8 @@
       Constructor member = constructors[i];
       member._relinkNode();
     }
-    for (int i = 0; i < redirectingFactoryConstructors.length; ++i) {
-      RedirectingFactoryConstructor member = redirectingFactoryConstructors[i];
+    for (int i = 0; i < redirectingFactories.length; ++i) {
+      RedirectingFactory member = redirectingFactories[i];
       member._relinkNode();
     }
     dirty = false;
@@ -1345,7 +1344,7 @@
         fields,
         constructors,
         procedures,
-        redirectingFactoryConstructors
+        redirectingFactories
       ].expand((x) => x);
 
   /// The immediately extended, mixed-in, and implemented types.
@@ -1389,11 +1388,10 @@
   }
 
   /// Adds a field to this class.
-  void addRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor redirectingFactoryConstructor) {
+  void addRedirectingFactory(RedirectingFactory redirectingFactory) {
     dirty = true;
-    redirectingFactoryConstructor.parent = this;
-    _redirectingFactoryConstructorsInternal.add(redirectingFactoryConstructor);
+    redirectingFactory.parent = this;
+    _redirectingFactoriesInternal.add(redirectingFactory);
   }
 
   @override
@@ -1446,7 +1444,7 @@
     visitList(constructors, v);
     visitList(procedures, v);
     visitList(fields, v);
-    visitList(redirectingFactoryConstructors, v);
+    visitList(redirectingFactories, v);
   }
 
   @override
@@ -1463,7 +1461,7 @@
     v.transformList(constructors, this);
     v.transformList(procedures, this);
     v.transformList(fields, this);
-    v.transformList(redirectingFactoryConstructors, this);
+    v.transformList(redirectingFactories, this);
   }
 
   @override
@@ -1490,8 +1488,7 @@
     v.transformConstructorList(constructors, this);
     v.transformProcedureList(procedures, this);
     v.transformFieldList(fields, this);
-    v.transformRedirectingFactoryConstructorList(
-        redirectingFactoryConstructors, this);
+    v.transformRedirectingFactoryList(redirectingFactories, this);
   }
 
   @override
@@ -2237,64 +2234,45 @@
 /// be removed from the class.  However, it is needed during the linking phase,
 /// because other modules can refer to that constructor.
 ///
-/// [RedirectingFactoryConstructor]s contain the necessary information for
+/// [RedirectingFactory]s contain the necessary information for
 /// linking and are treated as non-runnable members of classes that merely serve
 /// as containers for that information.
 ///
 /// Redirecting factory constructors can be unnamed.  In this case, the name is
 /// an empty string (in a [Name]).
-class RedirectingFactoryConstructor extends Member {
+class RedirectingFactory extends Member {
   int flags = 0;
 
-  /// [RedirectingFactoryConstructor]s may redirect to constructors or factories
+  /// [RedirectingFactory]s may redirect to constructors or factories
   /// of instantiated generic types, that is, generic types with supplied type
   /// arguments.  The supplied type arguments are stored in this field.
   final List<DartType> typeArguments;
 
   /// Reference to the constructor or the factory that this
-  /// [RedirectingFactoryConstructor] redirects to.
+  /// [RedirectingFactory] redirects to.
   // TODO(johnniwinther): Make this non-nullable.
   Reference? targetReference;
 
-  /// [typeParameters] are duplicates of the type parameters of the enclosing
-  /// class.  Because [RedirectingFactoryConstructor]s aren't instance members,
-  /// references to the type parameters of the enclosing class in the
-  /// redirection target description are encoded with references to the elements
-  /// of [typeParameters].
-  List<TypeParameter> typeParameters;
+  /// [FunctionNode] that holds the type parameters, copied from the enclosing
+  /// class, and the parameters defined on the redirecting factory.
+  ///
+  /// The `FunctionNode.body` is `null` or a synthesized [ConstructorInvocation]
+  /// of the [targetReference] constructor using the [typeArguments] and
+  /// [VariableGet] of the parameters.
+  FunctionNode function;
 
-  /// Positional parameters of [RedirectingFactoryConstructor]s should be
-  /// compatible with that of the target constructor.
-  List<VariableDeclaration> positionalParameters;
-  int requiredParameterCount;
-
-  /// Named parameters of [RedirectingFactoryConstructor]s should be compatible
-  /// with that of the target constructor.
-  List<VariableDeclaration> namedParameters;
-
-  RedirectingFactoryConstructor(this.targetReference,
+  RedirectingFactory(this.targetReference,
       {required Name name,
       bool isConst: false,
       bool isExternal: false,
       int transformerFlags: 0,
       List<DartType>? typeArguments,
-      List<TypeParameter>? typeParameters,
-      List<VariableDeclaration>? positionalParameters,
-      List<VariableDeclaration>? namedParameters,
-      int? requiredParameterCount,
+      required this.function,
       required Uri fileUri,
       Reference? reference})
       : this.typeArguments = typeArguments ?? <DartType>[],
-        this.typeParameters = typeParameters ?? <TypeParameter>[],
-        this.positionalParameters =
-            positionalParameters ?? <VariableDeclaration>[],
-        this.namedParameters = namedParameters ?? <VariableDeclaration>[],
-        this.requiredParameterCount =
-            requiredParameterCount ?? positionalParameters?.length ?? 0,
         super(name, fileUri, reference) {
-    setParents(this.typeParameters, this);
-    setParents(this.positionalParameters, this);
-    setParents(this.namedParameters, this);
+    function.parent = this;
     this.isConst = isConst;
     this.isExternal = isExternal;
     this.transformerFlags = transformerFlags;
@@ -2355,15 +2333,15 @@
   }
 
   @override
-  R accept<R>(MemberVisitor<R> v) => v.visitRedirectingFactoryConstructor(this);
+  R accept<R>(MemberVisitor<R> v) => v.visitRedirectingFactory(this);
 
   @override
   R accept1<R, A>(MemberVisitor1<R, A> v, A arg) =>
-      v.visitRedirectingFactoryConstructor(this, arg);
+      v.visitRedirectingFactory(this, arg);
 
   @override
   R acceptReference<R>(MemberReferenceVisitor<R> v) =>
-      v.visitRedirectingFactoryConstructorReference(this);
+      v.visitRedirectingFactoryReference(this);
 
   @override
   void visitChildren(Visitor v) {
@@ -2371,18 +2349,21 @@
     target?.acceptReference(v);
     visitList(typeArguments, v);
     name.accept(v);
+    function.accept(v);
   }
 
   @override
   void transformChildren(Transformer v) {
     v.transformList(annotations, this);
     v.transformDartTypeList(typeArguments);
+    function = v.transform(function)..parent = this;
   }
 
   @override
   void transformOrRemoveChildren(RemovingTransformer v) {
     v.transformExpressionList(annotations, this);
     v.transformDartTypeList(typeArguments);
+    function = v.transform(function)..parent = this;
   }
 
   @override
@@ -2705,7 +2686,7 @@
   static const int FlagExternal = 1 << 2;
   static const int FlagConst = 1 << 3; // Only for external const factories.
   // TODO(29841): Remove this flag after the issue is resolved.
-  static const int FlagRedirectingFactoryConstructor = 1 << 4;
+  static const int FlagRedirectingFactory = 1 << 4;
   static const int FlagExtensionMember = 1 << 5;
   static const int FlagNonNullableByDefault = 1 << 6;
   static const int FlagSynthetic = 1 << 7;
@@ -2750,8 +2731,8 @@
 
   // Indicates if this [Procedure] represents a redirecting factory constructor
   // and doesn't have a runnable body.
-  bool get isRedirectingFactoryConstructor {
-    return flags & FlagRedirectingFactoryConstructor != 0;
+  bool get isRedirectingFactory {
+    return flags & FlagRedirectingFactory != 0;
   }
 
   /// If set, this flag indicates that this function was not present in the
@@ -2783,10 +2764,10 @@
     flags = value ? (flags | FlagConst) : (flags & ~FlagConst);
   }
 
-  void set isRedirectingFactoryConstructor(bool value) {
+  void set isRedirectingFactory(bool value) {
     flags = value
-        ? (flags | FlagRedirectingFactoryConstructor)
-        : (flags & ~FlagRedirectingFactoryConstructor);
+        ? (flags | FlagRedirectingFactory)
+        : (flags & ~FlagRedirectingFactory);
   }
 
   void set isExtensionMember(bool value) {
@@ -8611,23 +8592,28 @@
 /// Tearing off a constructor of a class.
 class ConstructorTearOff extends Expression {
   /// The reference to the constructor being torn off.
-  Reference constructorReference;
+  Reference targetReference;
 
-  ConstructorTearOff(Constructor constructor)
-      : this.byReference(getNonNullableMemberReferenceGetter(constructor));
+  ConstructorTearOff(Member target)
+      : assert(target is Constructor ||
+            (target is Procedure && target.kind == ProcedureKind.Factory)),
+        this.targetReference = getNonNullableMemberReferenceGetter(target);
 
-  ConstructorTearOff.byReference(this.constructorReference);
+  ConstructorTearOff.byReference(this.targetReference);
 
-  Constructor get constructor => constructorReference.asConstructor;
+  Member get target => targetReference.asMember;
 
-  void set constructor(Constructor constructor) {
-    constructorReference = getNonNullableMemberReferenceGetter(constructor);
+  FunctionNode get function => target.function!;
+
+  void set target(Member member) {
+    assert(member is Constructor ||
+        (member is Procedure && member.kind == ProcedureKind.Factory));
+    targetReference = getNonNullableMemberReferenceGetter(member);
   }
 
   @override
   DartType getStaticTypeInternal(StaticTypeContext context) {
-    return constructorReference.asConstructor.function
-        .computeFunctionType(Nullability.nonNullable);
+    return target.function!.computeFunctionType(Nullability.nonNullable);
   }
 
   @override
@@ -8639,7 +8625,7 @@
 
   @override
   void visitChildren(Visitor v) {
-    constructor.acceptReference(v);
+    target.acceptReference(v);
   }
 
   @override
@@ -8655,7 +8641,60 @@
 
   @override
   void toTextInternal(AstPrinter printer) {
-    printer.writeMemberName(constructorReference);
+    printer.writeMemberName(targetReference);
+  }
+}
+
+/// Tearing off a redirecting factory constructor of a class.
+class RedirectingFactoryTearOff extends Expression {
+  /// The reference to the redirecting factory constructor being torn off.
+  Reference targetReference;
+
+  RedirectingFactoryTearOff(Procedure target)
+      : assert(target.isRedirectingFactory),
+        this.targetReference = getNonNullableMemberReferenceGetter(target);
+
+  RedirectingFactoryTearOff.byReference(this.targetReference);
+
+  Procedure get target => targetReference.asProcedure;
+
+  void set target(Procedure target) {
+    targetReference = getNonNullableMemberReferenceGetter(target);
+  }
+
+  FunctionNode get function => target.function;
+
+  @override
+  DartType getStaticTypeInternal(StaticTypeContext context) {
+    return target.function.computeFunctionType(Nullability.nonNullable);
+  }
+
+  @override
+  R accept<R>(ExpressionVisitor<R> v) => v.visitRedirectingFactoryTearOff(this);
+
+  @override
+  R accept1<R, A>(ExpressionVisitor1<R, A> v, A arg) =>
+      v.visitRedirectingFactoryTearOff(this, arg);
+
+  @override
+  void visitChildren(Visitor v) {
+    target.acceptReference(v);
+  }
+
+  @override
+  void transformChildren(Transformer v) {}
+
+  @override
+  void transformOrRemoveChildren(RemovingTransformer v) {}
+
+  @override
+  String toString() {
+    return "RedirectingFactoryTearOff(${toStringInternal()})";
+  }
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    printer.writeMemberName(targetReference);
   }
 }
 
@@ -12899,32 +12938,30 @@
 }
 
 abstract class TearOffConstant implements Constant {
-  Reference get memberReference;
-  Member get member;
+  Reference get targetReference;
+  Member get target;
   FunctionNode get function;
 }
 
 class StaticTearOffConstant extends Constant implements TearOffConstant {
   @override
-  final Reference memberReference;
+  final Reference targetReference;
 
   StaticTearOffConstant(Procedure procedure)
-      : memberReference = procedure.reference {
+      : targetReference = procedure.reference {
     assert(procedure.isStatic);
   }
 
-  StaticTearOffConstant.byReference(this.memberReference);
+  StaticTearOffConstant.byReference(this.targetReference);
 
   @override
-  Member get member => memberReference.asMember;
+  Procedure get target => targetReference.asProcedure;
 
   @override
-  FunctionNode get function => procedure.function;
-
-  Procedure get procedure => memberReference.asProcedure;
+  FunctionNode get function => target.function;
 
   visitChildren(Visitor v) {
-    memberReference.asProcedure.acceptReference(v);
+    target.acceptReference(v);
   }
 
   R accept<R>(ConstantVisitor<R> v) => v.visitStaticTearOffConstant(this);
@@ -12933,66 +12970,121 @@
 
   @override
   void toTextInternal(AstPrinter printer) {
-    printer.writeMemberName(memberReference);
+    printer.writeMemberName(targetReference);
   }
 
   @override
   String toString() => 'StaticTearOffConstant(${toStringInternal()})';
 
-  int get hashCode => memberReference.hashCode;
+  int get hashCode => targetReference.hashCode;
 
   bool operator ==(Object other) {
     return other is StaticTearOffConstant &&
-        other.memberReference == memberReference;
+        other.targetReference == targetReference;
   }
 
   FunctionType getType(StaticTypeContext context) {
-    return procedure.function.computeFunctionType(context.nonNullable);
+    return target.function.computeFunctionType(context.nonNullable);
   }
 }
 
 class ConstructorTearOffConstant extends Constant implements TearOffConstant {
   @override
-  final Reference memberReference;
+  final Reference targetReference;
 
-  ConstructorTearOffConstant(Constructor constructor)
-      : memberReference = constructor.reference;
+  ConstructorTearOffConstant(Member target)
+      : assert(target is Constructor ||
+            (target is Procedure && target.kind == ProcedureKind.Factory)),
+        this.targetReference = getNonNullableMemberReferenceGetter(target);
 
-  ConstructorTearOffConstant.byReference(this.memberReference);
+  ConstructorTearOffConstant.byReference(this.targetReference);
 
   @override
-  Member get member => memberReference.asMember;
+  Member get target => targetReference.asMember;
 
   @override
-  FunctionNode get function => constructor.function;
+  FunctionNode get function => target.function!;
 
-  Constructor get constructor => memberReference.asConstructor;
-
-  visitChildren(Visitor v) {
-    memberReference.asProcedure.acceptReference(v);
+  @override
+  void visitChildren(Visitor v) {
+    target.acceptReference(v);
   }
 
+  @override
   R accept<R>(ConstantVisitor<R> v) => v.visitConstructorTearOffConstant(this);
+
+  @override
   R acceptReference<R>(Visitor<R> v) =>
       v.visitConstructorTearOffConstantReference(this);
 
   @override
   void toTextInternal(AstPrinter printer) {
-    printer.writeMemberName(memberReference);
+    printer.writeMemberName(targetReference);
   }
 
   @override
   String toString() => 'ConstructorTearOffConstant(${toStringInternal()})';
 
-  int get hashCode => memberReference.hashCode;
+  int get hashCode => targetReference.hashCode;
 
   bool operator ==(Object other) {
     return other is StaticTearOffConstant &&
-        other.memberReference == memberReference;
+        other.targetReference == targetReference;
   }
 
   FunctionType getType(StaticTypeContext context) {
-    return constructor.function.computeFunctionType(context.nonNullable);
+    return function.computeFunctionType(context.nonNullable);
+  }
+}
+
+class RedirectingFactoryTearOffConstant extends Constant
+    implements TearOffConstant {
+  @override
+  final Reference targetReference;
+
+  RedirectingFactoryTearOffConstant(Procedure target)
+      : assert(target.isRedirectingFactory),
+        this.targetReference = getNonNullableMemberReferenceGetter(target);
+
+  RedirectingFactoryTearOffConstant.byReference(this.targetReference);
+
+  @override
+  Procedure get target => targetReference.asProcedure;
+
+  @override
+  FunctionNode get function => target.function;
+
+  @override
+  void visitChildren(Visitor v) {
+    target.acceptReference(v);
+  }
+
+  @override
+  R accept<R>(ConstantVisitor<R> v) =>
+      v.visitRedirectingFactoryTearOffConstant(this);
+
+  @override
+  R acceptReference<R>(Visitor<R> v) =>
+      v.visitRedirectingFactoryTearOffConstantReference(this);
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    printer.writeMemberName(targetReference);
+  }
+
+  @override
+  String toString() =>
+      'RedirectingFactoryTearOffConstant(${toStringInternal()})';
+
+  int get hashCode => targetReference.hashCode;
+
+  bool operator ==(Object other) {
+    return other is StaticTearOffConstant &&
+        other.targetReference == targetReference;
+  }
+
+  FunctionType getType(StaticTypeContext context) {
+    return function.computeFunctionType(context.nonNullable);
   }
 }
 
@@ -14039,12 +14131,11 @@
 final List<Constructor> emptyListOfConstructor =
     List.filled(0, dummyConstructor, growable: false);
 
-/// Almost const <RedirectingFactoryConstructor>[], but not const in an attempt
-/// to avoid polymorphism. See
+/// Almost const <RedirectingFactory>[], but not const in an attempt to avoid
+/// polymorphism. See
 /// https://dart-review.googlesource.com/c/sdk/+/185828.
-final List<RedirectingFactoryConstructor>
-    emptyListOfRedirectingFactoryConstructor =
-    List.filled(0, dummyRedirectingFactoryConstructor, growable: false);
+final List<RedirectingFactory> emptyListOfRedirectingFactory =
+    List.filled(0, dummyRedirectingFactory, growable: false);
 
 /// Almost const <Initializer>[], but not const in an attempt to avoid
 /// polymorphism. See https://dart-review.googlesource.com/c/sdk/+/185828.
@@ -14172,13 +14263,13 @@
 /// constructor.
 final Field dummyField = new Field.mutable(dummyName, fileUri: dummyUri);
 
-/// Non-nullable [RedirectingFactoryConstructor] dummy value.
+/// Non-nullable [RedirectingFactory] dummy value.
 ///
 /// This is used as the removal sentinel in [RemovingTransformer] and can be
 /// used for instance as a dummy initial value for the `List.filled`
 /// constructor.
-final RedirectingFactoryConstructor dummyRedirectingFactoryConstructor =
-    new RedirectingFactoryConstructor(null, name: dummyName, fileUri: dummyUri);
+final RedirectingFactory dummyRedirectingFactory = new RedirectingFactory(null,
+    name: dummyName, fileUri: dummyUri, function: dummyFunctionNode);
 
 /// Non-nullable [Typedef] dummy value.
 ///
@@ -14309,7 +14400,7 @@
   dummyMember,
   dummyProcedure,
   dummyField,
-  dummyRedirectingFactoryConstructor,
+  dummyRedirectingFactory,
   dummyTypedef,
   dummyInitializer,
   dummyFunctionNode,
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index a257708..7f610ca 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -1478,7 +1478,7 @@
     node.fieldsInternal = _readFieldList(node);
     _readConstructorList(node);
     node.proceduresInternal = _readProcedureList(node, procedureOffsets);
-    _readRedirectingFactoryConstructorList(node);
+    _readRedirectingFactoryList(node);
   }
 
   void _readConstructorList(Class node) {
@@ -1494,17 +1494,17 @@
     }
   }
 
-  void _readRedirectingFactoryConstructorList(Class node) {
+  void _readRedirectingFactoryList(Class node) {
     int length = readUInt30();
     if (!useGrowableLists && length == 0) {
       // When lists don't have to be growable anyway, we might as well use a
       // constant one for the empty list.
       node.redirectingFactoryConstructorsInternal =
-          emptyListOfRedirectingFactoryConstructor;
+          emptyListOfRedirectingFactory;
     } else {
       node.redirectingFactoryConstructorsInternal =
-          new List<RedirectingFactoryConstructor>.generate(length,
-              (int index) => readRedirectingFactoryConstructor()..parent = node,
+          new List<RedirectingFactory>.generate(
+              length, (int index) => readRedirectingFactory()..parent = node,
               growable: useGrowableLists);
     }
   }
@@ -1690,13 +1690,12 @@
     return node;
   }
 
-  RedirectingFactoryConstructor readRedirectingFactoryConstructor() {
+  RedirectingFactory readRedirectingFactory() {
     int tag = readByte();
-    assert(tag == Tag.RedirectingFactoryConstructor);
+    assert(tag == Tag.RedirectingFactory);
     CanonicalName canonicalName = readNonNullCanonicalNameReference();
     Reference reference = canonicalName.reference;
-    RedirectingFactoryConstructor? node =
-        reference.node as RedirectingFactoryConstructor?;
+    RedirectingFactory? node = reference.node as RedirectingFactory?;
     if (alwaysCreateNewNamedNodes) {
       node = null;
     }
@@ -1705,39 +1704,34 @@
     int fileEndOffset = readOffset();
     int flags = readByte();
     Name name = readName();
-    if (node == null) {
-      node = new RedirectingFactoryConstructor(null,
-          reference: reference, name: name, fileUri: fileUri);
-    }
-    List<Expression> annotations = readAnnotationList(node);
     assert(() {
       debugPath.add(name.text);
       return true;
     }());
+    List<Expression> annotations = readAnnotationList();
     Reference targetReference = readNonNullMemberReference();
     List<DartType> typeArguments = readDartTypeList();
-    int typeParameterStackHeight = typeParameterStack.length;
-    List<TypeParameter> typeParameters = readAndPushTypeParameterList();
-    readUInt30(); // Total parameter count.
-    int requiredParameterCount = readUInt30();
-    int variableStackHeight = variableStack.length;
-    List<VariableDeclaration> positional = readAndPushVariableDeclarationList();
-    List<VariableDeclaration> named = readAndPushVariableDeclarationList();
-    variableStack.length = variableStackHeight;
-    typeParameterStack.length = typeParameterStackHeight;
-    debugPath.removeLast();
+    FunctionNode function = readFunctionNode(outerEndOffset: fileEndOffset);
+    if (node == null) {
+      node = new RedirectingFactory(targetReference,
+          reference: reference,
+          name: name,
+          fileUri: fileUri,
+          function: function,
+          typeArguments: typeArguments);
+    } else {
+      node.name = name;
+      node.fileUri = fileUri;
+      node.targetReference = targetReference;
+      node.typeArguments.addAll(typeArguments);
+      node.function = function..parent = node;
+    }
     node.fileOffset = fileOffset;
     node.fileEndOffset = fileEndOffset;
     node.flags = flags;
-    node.name = name;
-    node.fileUri = fileUri;
     node.annotations = annotations;
-    node.targetReference = targetReference;
-    node.typeArguments.addAll(typeArguments);
-    node.typeParameters = typeParameters;
-    node.requiredParameterCount = requiredParameterCount;
-    node.positionalParameters = positional;
-    node.namedParameters = named;
+    setParents(annotations, node);
+    debugPath.removeLast();
     return node;
   }
 
@@ -3372,10 +3366,9 @@
   }
 
   @override
-  RedirectingFactoryConstructor readRedirectingFactoryConstructor() {
+  RedirectingFactory readRedirectingFactory() {
     final int nodeOffset = _byteOffset;
-    final RedirectingFactoryConstructor result =
-        super.readRedirectingFactoryConstructor();
+    final RedirectingFactory result = super.readRedirectingFactory();
     return _associateMetadata(result, nodeOffset);
   }
 
diff --git a/pkg/kernel/lib/binary/ast_to_binary.dart b/pkg/kernel/lib/binary/ast_to_binary.dart
index 9018db9..d0d0343 100644
--- a/pkg/kernel/lib/binary/ast_to_binary.dart
+++ b/pkg/kernel/lib/binary/ast_to_binary.dart
@@ -264,11 +264,15 @@
     } else if (constant is StaticTearOffConstant) {
       writeByte(ConstantTag.StaticTearOffConstant);
       writeNonNullCanonicalNameReference(
-          constant.procedure.reference.canonicalName!);
+          constant.targetReference.canonicalName!);
     } else if (constant is ConstructorTearOffConstant) {
       writeByte(ConstantTag.ConstructorTearOffConstant);
       writeNonNullCanonicalNameReference(
-          constant.constructor.reference.canonicalName!);
+          constant.targetReference.canonicalName!);
+    } else if (constant is RedirectingFactoryTearOffConstant) {
+      writeByte(ConstantTag.RedirectingFactoryTearOffConstant);
+      writeNonNullCanonicalNameReference(
+          constant.targetReference.canonicalName!);
     } else if (constant is TypeLiteralConstant) {
       writeByte(ConstantTag.TypeLiteralConstant);
       writeDartType(constant.type);
@@ -373,13 +377,12 @@
     }
   }
 
-  void writeRedirectingFactoryConstructorNodeList(
-      List<RedirectingFactoryConstructor> nodes) {
+  void writeRedirectingFactoryNodeList(List<RedirectingFactory> nodes) {
     final int len = nodes.length;
     writeUInt30(len);
     for (int i = 0; i < len; i++) {
-      final RedirectingFactoryConstructor node = nodes[i];
-      writeRedirectingFactoryConstructorNode(node);
+      final RedirectingFactory node = nodes[i];
+      writeRedirectingFactoryNode(node);
     }
   }
 
@@ -473,8 +476,7 @@
     node.accept(this);
   }
 
-  void writeRedirectingFactoryConstructorNode(
-      RedirectingFactoryConstructor node) {
+  void writeRedirectingFactoryNode(RedirectingFactory node) {
     if (_metadataSubsections != null) {
       _writeNodeMetadata(node);
     }
@@ -1205,8 +1207,7 @@
     procedureOffsets = <int>[];
     writeProcedureNodeList(node.procedures);
     procedureOffsets.add(getBufferOffset());
-    writeRedirectingFactoryConstructorNodeList(
-        node.redirectingFactoryConstructors);
+    writeRedirectingFactoryNodeList(node.redirectingFactories);
     leaveScope(typeParameters: node.typeParameters);
 
     assert(procedureOffsets.length > 0);
@@ -1366,35 +1367,21 @@
   }
 
   @override
-  void visitRedirectingFactoryConstructor(RedirectingFactoryConstructor node) {
+  void visitRedirectingFactory(RedirectingFactory node) {
     if (node.reference.canonicalName == null) {
       throw new ArgumentError('Missing canonical name for $node');
     }
-    writeByte(Tag.RedirectingFactoryConstructor);
-    enterScope(
-        typeParameters: node.typeParameters,
-        memberScope: true,
-        variableScope: true);
+    writeByte(Tag.RedirectingFactory);
     writeNonNullCanonicalNameReference(getCanonicalNameOfMemberGetter(node));
     writeUriReference(node.fileUri);
     writeOffset(node.fileOffset);
     writeOffset(node.fileEndOffset);
     writeByte(node.flags);
     writeName(node.name);
-
     writeAnnotationList(node.annotations);
     writeNonNullReference(node.targetReference!);
     writeNodeList(node.typeArguments);
-    writeNodeList(node.typeParameters);
-    writeUInt30(node.positionalParameters.length + node.namedParameters.length);
-    writeUInt30(node.requiredParameterCount);
-    writeVariableDeclarationList(node.positionalParameters);
-    writeVariableDeclarationList(node.namedParameters);
-
-    leaveScope(
-        typeParameters: node.typeParameters,
-        memberScope: true,
-        variableScope: true);
+    writeFunctionNode(node.function);
   }
 
   @override
@@ -1609,7 +1596,14 @@
   void visitConstructorTearOff(ConstructorTearOff node) {
     writeByte(Tag.ConstructorTearOff);
     writeOffset(node.fileOffset);
-    writeNonNullReference(node.constructorReference);
+    writeNonNullReference(node.targetReference);
+  }
+
+  @override
+  void visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node) {
+    writeByte(Tag.RedirectingFactoryTearOff);
+    writeOffset(node.fileOffset);
+    writeNonNullReference(node.targetReference);
   }
 
   @override
@@ -2687,10 +2681,9 @@
   }
 
   @override
-  void visitRedirectingFactoryConstructorReference(
-      RedirectingFactoryConstructor node) {
+  void visitRedirectingFactoryReference(RedirectingFactory node) {
     throw new UnsupportedError(
-        'serialization of RedirectingFactoryConstructor references');
+        'serialization of RedirectingFactory references');
   }
 
   @override
@@ -2740,6 +2733,13 @@
   }
 
   @override
+  void visitRedirectingFactoryTearOffConstant(
+      RedirectingFactoryTearOffConstant node) {
+    throw new UnsupportedError(
+        'serialization of RedirectingFactoryTearOffConstants ');
+  }
+
+  @override
   void visitStaticTearOffConstantReference(StaticTearOffConstant node) {
     throw new UnsupportedError(
         'serialization of StaticTearOffConstant references');
@@ -2753,6 +2753,13 @@
   }
 
   @override
+  void visitRedirectingFactoryTearOffConstantReference(
+      RedirectingFactoryTearOffConstant node) {
+    throw new UnsupportedError(
+        'serialization of RedirectingFactoryTearOffConstant references');
+  }
+
+  @override
   void visitTypeLiteralConstant(TypeLiteralConstant node) {
     throw new UnsupportedError('serialization of TypeLiteralConstants');
   }
diff --git a/pkg/kernel/lib/binary/tag.dart b/pkg/kernel/lib/binary/tag.dart
index e5291c5..138be00 100644
--- a/pkg/kernel/lib/binary/tag.dart
+++ b/pkg/kernel/lib/binary/tag.dart
@@ -17,7 +17,7 @@
   static const int Field = 4;
   static const int Constructor = 5;
   static const int Procedure = 6;
-  static const int RedirectingFactoryConstructor = 108;
+  static const int RedirectingFactory = 108;
 
   // Initializers
   static const int InvalidInitializer = 7;
@@ -78,6 +78,7 @@
   static const int ConstMapLiteral = 59;
   static const int ConstructorTearOff = 60;
   static const int TypedefTearOff = 83;
+  static const int RedirectingFactoryTearOff = 84;
 
   static const int SetLiteral = 109;
   static const int ConstSetLiteral = 110;
@@ -125,6 +126,7 @@
   static const int AssertBlock = 81;
   // 82 is occupied by [BlockExpression] (expression).
   // 83 is occupied by [TypedefTearOff] (expression).
+  // 84 is occupied by [RedirectingFactoryTearOff] (expression).
 
   // Types
   static const int TypedefType = 87;
@@ -141,7 +143,7 @@
 
   static const int ConstantExpression = 106;
 
-  /// 108 is occupied by [RedirectingFactoryConstructor] (member).
+  /// 108 is occupied by [RedirectingFactory] (member).
   /// 109 is occupied by [SetLiteral] (expression).
   /// 110 is occupied by [ConstSetLiteral] (expression).
   /// 111 is occupied by [ListConcatenation] (expression).
@@ -177,7 +179,7 @@
   /// Internal version of kernel binary format.
   /// Bump it when making incompatible changes in kernel binaries.
   /// Keep in sync with runtime/vm/kernel_binary.h, pkg/kernel/binary.md.
-  static const int BinaryFormatVersion = 67;
+  static const int BinaryFormatVersion = 68;
 }
 
 abstract class ConstantTag {
@@ -198,6 +200,7 @@
   // 13 is occupied by [SetConstant]
   static const int TypedefTearOffConstant = 14;
   static const int ConstructorTearOffConstant = 15;
+  static const int RedirectingFactoryTearOffConstant = 16;
 }
 
 const int sdkHashLength = 10; // Bytes, a Git "short hash".
diff --git a/pkg/kernel/lib/canonical_name.dart b/pkg/kernel/lib/canonical_name.dart
index 21eb6b3..666a24f 100644
--- a/pkg/kernel/lib/canonical_name.dart
+++ b/pkg/kernel/lib/canonical_name.dart
@@ -149,8 +149,8 @@
         .getChildFromQualifiedName(constructor.name);
   }
 
-  CanonicalName getChildFromRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor redirectingFactoryConstructor) {
+  CanonicalName getChildFromRedirectingFactory(
+      RedirectingFactory redirectingFactoryConstructor) {
     return getChild('@factories')
         .getChildFromQualifiedName(redirectingFactoryConstructor.name);
   }
diff --git a/pkg/kernel/lib/clone.dart b/pkg/kernel/lib/clone.dart
index 86e78d6..a5bde19 100644
--- a/pkg/kernel/lib/clone.dart
+++ b/pkg/kernel/lib/clone.dart
@@ -81,8 +81,7 @@
     throw 'Cloning of fields is not implemented here';
   }
 
-  TreeNode visitRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor node) {
+  TreeNode visitRedirectingFactory(RedirectingFactory node) {
     throw 'Cloning of redirecting factory constructors is not implemented here';
   }
 
@@ -738,7 +737,12 @@
 
   @override
   TreeNode visitConstructorTearOff(ConstructorTearOff node) {
-    return new ConstructorTearOff.byReference(node.constructorReference);
+    return new ConstructorTearOff.byReference(node.targetReference);
+  }
+
+  @override
+  TreeNode visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node) {
+    return new RedirectingFactoryTearOff.byReference(node.targetReference);
   }
 
   @override
@@ -856,24 +860,18 @@
     return result;
   }
 
-  RedirectingFactoryConstructor cloneRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor node, Reference? reference) {
+  RedirectingFactory cloneRedirectingFactory(
+      RedirectingFactory node, Reference? reference) {
     final Uri? activeFileUriSaved = _activeFileUri;
     _activeFileUri = node.fileUri;
 
-    prepareTypeParameters(node.typeParameters);
-    RedirectingFactoryConstructor result = new RedirectingFactoryConstructor(
-        node.targetReference,
+    RedirectingFactory result = new RedirectingFactory(node.targetReference,
         name: node.name,
         isConst: node.isConst,
         isExternal: node.isExternal,
         transformerFlags: node.transformerFlags,
         typeArguments: node.typeArguments.map(visitType).toList(),
-        typeParameters: node.typeParameters.map(super.clone).toList(),
-        positionalParameters:
-            node.positionalParameters.map(super.clone).toList(),
-        namedParameters: node.namedParameters.map(super.clone).toList(),
-        requiredParameterCount: node.requiredParameterCount,
+        function: super.clone(node.function),
         fileUri: node.fileUri,
         reference: reference)
       ..annotations = cloneAnnotations && !node.annotations.isEmpty
diff --git a/pkg/kernel/lib/text/ast_to_text.dart b/pkg/kernel/lib/text/ast_to_text.dart
index 53fbe25..7690d8c 100644
--- a/pkg/kernel/lib/text/ast_to_text.dart
+++ b/pkg/kernel/lib/text/ast_to_text.dart
@@ -1243,20 +1243,13 @@
         name: node.name, initializers: node.initializers);
   }
 
-  visitRedirectingFactoryConstructor(RedirectingFactoryConstructor node) {
+  visitRedirectingFactory(RedirectingFactory node) {
     writeAnnotationList(node.annotations);
     writeIndentation();
     writeModifier(node.isExternal, 'external');
     writeModifier(node.isConst, 'const');
     writeWord('redirecting_factory');
-
-    // ignore: unnecessary_null_comparison
-    if (node.name != null) {
-      writeName(node.name);
-    }
-    writeTypeParameterList(node.typeParameters);
-    writeParameterList(node.positionalParameters, node.namedParameters,
-        node.requiredParameterCount);
+    writeFunction(node.function, name: node.name);
     writeSpaced('=');
     writeMemberReferenceFromReference(node.targetReference!);
     if (node.typeArguments.isNotEmpty) {
@@ -1327,7 +1320,7 @@
     node.fields.forEach(writeNode);
     node.constructors.forEach(writeNode);
     node.procedures.forEach(writeNode);
-    node.redirectingFactoryConstructors.forEach(writeNode);
+    node.redirectingFactories.forEach(writeNode);
     --indentation;
     writeIndentation();
     endLine('}');
@@ -2052,7 +2045,7 @@
   }
 
   visitConstructorTearOff(ConstructorTearOff node) {
-    writeMemberReferenceFromReference(node.constructorReference);
+    writeMemberReferenceFromReference(node.targetReference);
   }
 
   visitTypedefTearOff(TypedefTearOff node) {
@@ -2683,7 +2676,7 @@
     writeSpaced('=');
     writeWord('partial-instantiation');
     writeSpace();
-    writeMemberReferenceFromReference(node.tearOffConstant.memberReference);
+    writeMemberReferenceFromReference(node.tearOffConstant.targetReference);
     writeSpace();
     writeSymbol('<');
     writeList(node.types, writeType);
@@ -2704,7 +2697,7 @@
     writeSpaced('=');
     writeWord('tearoff');
     writeSpace();
-    writeMemberReferenceFromReference(node.memberReference);
+    writeMemberReferenceFromReference(node.targetReference);
     endLine();
   }
 
@@ -2924,6 +2917,9 @@
   int visitConstructorTearOff(ConstructorTearOff node) => PRIMARY;
 
   @override
+  int visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node) => PRIMARY;
+
+  @override
   int visitTypedefTearOff(TypedefTearOff node) => EXPRESSION;
 
   @override
diff --git a/pkg/kernel/lib/text/text_serializer.dart b/pkg/kernel/lib/text/text_serializer.dart
index 0c4f26e..7b2c1ef 100644
--- a/pkg/kernel/lib/text/text_serializer.dart
+++ b/pkg/kernel/lib/text/text_serializer.dart
@@ -1836,8 +1836,7 @@
   Procedure.FlagAbstract: "abstract",
   Procedure.FlagExternal: "external",
   Procedure.FlagConst: "const",
-  Procedure.FlagRedirectingFactoryConstructor:
-      "redirecting-factory-constructor",
+  Procedure.FlagRedirectingFactory: "redirecting-factory-constructor",
   Procedure.FlagExtensionMember: "extension-member",
   Procedure.FlagNonNullableByDefault: "non-nullable-by-default",
   Procedure.FlagSynthetic: "synthetic",
@@ -1906,20 +1905,18 @@
     ListSerializer(
         Case(ConstructorFlagTagger(), convertFlagsMap(constructorFlagToName))));
 
-const Map<int, String> redirectingFactoryConstructorFlagToName = const {
-  RedirectingFactoryConstructor.FlagConst: "const",
-  RedirectingFactoryConstructor.FlagExternal: "external",
-  RedirectingFactoryConstructor.FlagNonNullableByDefault:
-      "non-nullable-by-default",
+const Map<int, String> redirectingFactoryFlagToName = const {
+  RedirectingFactory.FlagConst: "const",
+  RedirectingFactory.FlagExternal: "external",
+  RedirectingFactory.FlagNonNullableByDefault: "non-nullable-by-default",
 };
 
-class RedirectingFactoryConstructorFlagTagger implements Tagger<int> {
-  const RedirectingFactoryConstructorFlagTagger();
+class RedirectingFactoryFlagTagger implements Tagger<int> {
+  const RedirectingFactoryFlagTagger();
 
   String tag(int flag) {
-    return redirectingFactoryConstructorFlagToName[flag] ??
-        (throw StateError(
-            "Unknown RedirectingFactoryConstructor flag value: ${flag}."));
+    return redirectingFactoryFlagToName[flag] ??
+        (throw StateError("Unknown RedirectingFactory flag value: ${flag}."));
   }
 }
 
@@ -1929,8 +1926,8 @@
             .where((f) => f != 0)
             .toList(),
         (u) => u.fold(0, (fs, f) => fs |= f),
-        ListSerializer(Case(RedirectingFactoryConstructorFlagTagger(),
-            convertFlagsMap(redirectingFactoryConstructorFlagToName))));
+        ListSerializer(Case(RedirectingFactoryFlagTagger(),
+            convertFlagsMap(redirectingFactoryFlagToName))));
 
 class MemberTagger implements Tagger<Member> {
   const MemberTagger();
@@ -1940,7 +1937,7 @@
       return node.hasSetter ? "mutable-field" : "immutable-field";
     } else if (node is Constructor) {
       return "constructor";
-    } else if (node is RedirectingFactoryConstructor) {
+    } else if (node is RedirectingFactory) {
       return "redirecting-factory-constructor";
     } else if (node is Procedure) {
       switch (node.kind) {
@@ -2036,57 +2033,25 @@
     Tuple4Serializer(nameSerializer, constructorFlagsSerializer,
         functionNodeWithInitializersSerializer, UriSerializer()));
 
-TextSerializer<RedirectingFactoryConstructor>
-    redirectingFactoryConstructorSerializer
+TextSerializer<RedirectingFactory> redirectingFactoryConstructorSerializer
     // Comment added to direct formatter.
     = Wrapped<
-            Tuple5<
-                Name,
-                int,
-                CanonicalName,
-                Tuple2<
-                    List<TypeParameter>,
-                    Tuple4<List<VariableDeclaration>, List<VariableDeclaration>,
-                        List<VariableDeclaration>, List<DartType>>>,
-                Uri>,
-            RedirectingFactoryConstructor>(
-        (w) => Tuple5(
-            w.name,
-            w.flags,
-            w.targetReference!.canonicalName!,
-            Tuple2(
-                w.typeParameters,
-                Tuple4(
-                    w.positionalParameters
-                        .take(w.requiredParameterCount)
-                        .toList(),
-                    w.positionalParameters
-                        .skip(w.requiredParameterCount)
-                        .toList(),
-                    w.namedParameters,
-                    w.typeArguments)),
-            w.fileUri),
-        (u) => RedirectingFactoryConstructor(u.third.reference,
+            Tuple6<Name, int, FunctionNode, CanonicalName, List<DartType>, Uri>,
+            RedirectingFactory>(
+        (w) => Tuple6(w.name, w.flags, w.function,
+            w.targetReference!.canonicalName!, w.typeArguments, w.fileUri),
+        (u) => RedirectingFactory(u.fourth.reference,
             name: u.first,
-            typeParameters: u.fourth.first,
-            positionalParameters:
-                u.fourth.second.first + u.fourth.second.second,
-            requiredParameterCount: u.fourth.second.first.length,
-            namedParameters: u.fourth.second.third,
-            typeArguments: u.fourth.second.fourth,
-            fileUri: u.fifth)
+            function: u.third,
+            typeArguments: u.fifth,
+            fileUri: u.sixth)
           ..flags = u.second,
-        Tuple5Serializer(
+        Tuple6Serializer(
             nameSerializer,
             redirectingFactoryConstructorFlagsSerializer,
+            functionNodeSerializer,
             CanonicalNameSerializer(),
-            Bind(
-                typeParametersSerializer,
-                Tuple4Serializer(
-                    ListSerializer(variableDeclarationSerializer),
-                    ListSerializer(variableDeclarationSerializer),
-                    ListSerializer(variableDeclarationSerializer),
-                    ListSerializer(dartTypeSerializer))),
+            ListSerializer(dartTypeSerializer),
             UriSerializer()));
 
 Case<Member> memberSerializer = new Case.uninitialized(const MemberTagger());
@@ -2281,7 +2246,7 @@
 
 TextSerializer<StaticTearOffConstant> tearOffConstantSerializer =
     Wrapped<CanonicalName, StaticTearOffConstant>(
-        (w) => w.memberReference.canonicalName!,
+        (w) => w.targetReference.canonicalName!,
         (u) => StaticTearOffConstant.byReference(u.reference),
         CanonicalNameSerializer());
 
diff --git a/pkg/kernel/lib/type_checker.dart b/pkg/kernel/lib/type_checker.dart
index af4d5e3..68d7596 100644
--- a/pkg/kernel/lib/type_checker.dart
+++ b/pkg/kernel/lib/type_checker.dart
@@ -208,7 +208,7 @@
     handleFunctionNode(node.function);
   }
 
-  visitRedirectingFactoryConstructor(RedirectingFactoryConstructor node) {
+  visitRedirectingFactory(RedirectingFactory node) {
     currentReturnType = null;
     currentYieldType = null;
   }
@@ -521,8 +521,12 @@
 
   @override
   DartType visitConstructorTearOff(ConstructorTearOff node) {
-    return node.constructorReference.asConstructor.function
-        .computeFunctionType(Nullability.nonNullable);
+    return node.function.computeFunctionType(Nullability.nonNullable);
+  }
+
+  @override
+  DartType visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node) {
+    return node.function.computeFunctionType(Nullability.nonNullable);
   }
 
   @override
diff --git a/pkg/kernel/lib/visitor.dart b/pkg/kernel/lib/visitor.dart
index 1f71e2c..ebbb991 100644
--- a/pkg/kernel/lib/visitor.dart
+++ b/pkg/kernel/lib/visitor.dart
@@ -82,6 +82,8 @@
   R visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) =>
       defaultExpression(node);
   R visitConstructorTearOff(ConstructorTearOff node) => defaultExpression(node);
+  R visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node) =>
+      defaultExpression(node);
   R visitTypedefTearOff(TypedefTearOff node) => defaultExpression(node);
 }
 
@@ -124,7 +126,7 @@
   R visitConstructor(Constructor node) => defaultMember(node);
   R visitProcedure(Procedure node) => defaultMember(node);
   R visitField(Field node) => defaultMember(node);
-  R visitRedirectingFactoryConstructor(RedirectingFactoryConstructor node) {
+  R visitRedirectingFactory(RedirectingFactory node) {
     return defaultMember(node);
   }
 }
@@ -137,8 +139,7 @@
   R visitConstructor(Constructor node, A arg) => defaultMember(node, arg);
   R visitProcedure(Procedure node, A arg) => defaultMember(node, arg);
   R visitField(Field node, A arg) => defaultMember(node, arg);
-  R visitRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor node, A arg) {
+  R visitRedirectingFactory(RedirectingFactory node, A arg) {
     return defaultMember(node, arg);
   }
 }
@@ -258,6 +259,8 @@
   R visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) =>
       defaultExpression(node);
   R visitConstructorTearOff(ConstructorTearOff node) => defaultExpression(node);
+  R visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node) =>
+      defaultExpression(node);
   R visitTypedefTearOff(TypedefTearOff node) => defaultExpression(node);
 
   // Statements
@@ -292,7 +295,7 @@
   R visitConstructor(Constructor node) => defaultMember(node);
   R visitProcedure(Procedure node) => defaultMember(node);
   R visitField(Field node) => defaultMember(node);
-  R visitRedirectingFactoryConstructor(RedirectingFactoryConstructor node) {
+  R visitRedirectingFactory(RedirectingFactory node) {
     return defaultMember(node);
   }
 
@@ -436,6 +439,8 @@
       defaultExpression(node, arg);
   R visitConstructorTearOff(ConstructorTearOff node, A arg) =>
       defaultExpression(node, arg);
+  R visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node, A arg) =>
+      defaultExpression(node, arg);
   R visitTypedefTearOff(TypedefTearOff node, A arg) =>
       defaultExpression(node, arg);
 
@@ -480,8 +485,7 @@
   R visitConstructor(Constructor node, A arg) => defaultMember(node, arg);
   R visitProcedure(Procedure node, A arg) => defaultMember(node, arg);
   R visitField(Field node, A arg) => defaultMember(node, arg);
-  R visitRedirectingFactoryConstructor(
-      RedirectingFactoryConstructor node, A arg) {
+  R visitRedirectingFactory(RedirectingFactory node, A arg) {
     return defaultMember(node, arg);
   }
 
@@ -589,6 +593,9 @@
       defaultConstant(node);
   R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
       defaultConstant(node);
+  R visitRedirectingFactoryTearOffConstant(
+          RedirectingFactoryTearOffConstant node) =>
+      defaultConstant(node);
   R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
   R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
 }
@@ -610,6 +617,8 @@
   R visitTypedefTearOffConstant(TypedefTearOffConstant node);
   R visitStaticTearOffConstant(StaticTearOffConstant node);
   R visitConstructorTearOffConstant(ConstructorTearOffConstant node);
+  R visitRedirectingFactoryTearOffConstant(
+      RedirectingFactoryTearOffConstant node);
   R visitTypeLiteralConstant(TypeLiteralConstant node);
   R visitUnevaluatedConstant(UnevaluatedConstant node);
 }
@@ -636,6 +645,11 @@
       _callback.visitConstructorTearOffConstant(node);
 
   @override
+  R visitRedirectingFactoryTearOffConstant(
+          RedirectingFactoryTearOffConstant node) =>
+      _callback.visitRedirectingFactoryTearOffConstant(node);
+
+  @override
   R visitInstantiationConstant(InstantiationConstant node) =>
       _callback.visitInstantiationConstant(node);
 
@@ -730,6 +744,9 @@
       defaultConstant(node);
   R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
       defaultConstant(node);
+  R visitRedirectingFactoryTearOffConstant(
+          RedirectingFactoryTearOffConstant node) =>
+      defaultConstant(node);
   R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
   R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
 }
@@ -774,6 +791,9 @@
       defaultConstant(node);
   void visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
       defaultConstant(node);
+  void visitRedirectingFactoryTearOffConstant(
+          RedirectingFactoryTearOffConstant node) =>
+      defaultConstant(node);
   void visitTypeLiteralConstant(TypeLiteralConstant node) =>
       defaultConstant(node);
   void visitUnevaluatedConstant(UnevaluatedConstant node) =>
@@ -788,8 +808,7 @@
   R visitFieldReference(Field node) => defaultMemberReference(node);
   R visitConstructorReference(Constructor node) => defaultMemberReference(node);
   R visitProcedureReference(Procedure node) => defaultMemberReference(node);
-  R visitRedirectingFactoryConstructorReference(
-      RedirectingFactoryConstructor node) {
+  R visitRedirectingFactoryReference(RedirectingFactory node) {
     return defaultMemberReference(node);
   }
 }
@@ -839,6 +858,9 @@
       defaultConstant(node);
   R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
       defaultConstant(node);
+  R visitRedirectingFactoryTearOffConstant(
+          RedirectingFactoryTearOffConstant node) =>
+      defaultConstant(node);
   R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
   R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
 
@@ -878,6 +900,9 @@
       defaultConstantReference(node);
   R visitConstructorTearOffConstantReference(ConstructorTearOffConstant node) =>
       defaultConstantReference(node);
+  R visitRedirectingFactoryTearOffConstantReference(
+          RedirectingFactoryTearOffConstant node) =>
+      defaultConstantReference(node);
   R visitTypeLiteralConstantReference(TypeLiteralConstant node) =>
       defaultConstantReference(node);
   R visitUnevaluatedConstantReference(UnevaluatedConstant node) =>
@@ -889,8 +914,7 @@
   R visitFieldReference(Field node) => defaultMemberReference(node);
   R visitConstructorReference(Constructor node) => defaultMemberReference(node);
   R visitProcedureReference(Procedure node) => defaultMemberReference(node);
-  R visitRedirectingFactoryConstructorReference(
-      RedirectingFactoryConstructor node) {
+  R visitRedirectingFactoryReference(RedirectingFactory node) {
     return defaultMemberReference(node);
   }
 
@@ -1346,14 +1370,14 @@
     transformList(nodes, parent, dummyField);
   }
 
-  /// Transforms or removes [RedirectingFactoryConstructor] nodes in [nodes] as
+  /// Transforms or removes [RedirectingFactory] nodes in [nodes] as
   /// children of [parent].
   ///
   /// This is convenience method for calling [transformList] with removal
-  /// sentinel for [RedirectingFactoryConstructor] nodes.
-  void transformRedirectingFactoryConstructorList(
-      List<RedirectingFactoryConstructor> nodes, TreeNode parent) {
-    transformList(nodes, parent, dummyRedirectingFactoryConstructor);
+  /// sentinel for [RedirectingFactory] nodes.
+  void transformRedirectingFactoryList(
+      List<RedirectingFactory> nodes, TreeNode parent) {
+    transformList(nodes, parent, dummyRedirectingFactory);
   }
 
   /// Transforms or removes [Typedef] nodes in [nodes] as children of [parent].
@@ -1581,6 +1605,8 @@
       defaultExpression(node, arg);
   R visitConstructorTearOff(ConstructorTearOff node, T arg) =>
       defaultExpression(node, arg);
+  R visitRedirectingFactoryTearOff(RedirectingFactoryTearOff node, T arg) =>
+      defaultExpression(node, arg);
   R visitTypedefTearOff(TypedefTearOff node, T arg) =>
       defaultExpression(node, arg);
 }
diff --git a/pkg/kernel/test/verify_test.dart b/pkg/kernel/test/verify_test.dart
index 9803f71..8c1a8bf 100644
--- a/pkg/kernel/test/verify_test.dart
+++ b/pkg/kernel/test/verify_test.dart
@@ -729,8 +729,8 @@
       enclosingClass.addField(node);
     } else if (node is Constructor) {
       enclosingClass.addConstructor(node);
-    } else if (node is RedirectingFactoryConstructor) {
-      enclosingClass.addRedirectingFactoryConstructor(node);
+    } else if (node is RedirectingFactory) {
+      enclosingClass.addRedirectingFactory(node);
     } else {
       throw "Unexpected class member: ${node.runtimeType}";
     }
diff --git a/pkg/vm/lib/transformations/type_flow/native_code.dart b/pkg/vm/lib/transformations/type_flow/native_code.dart
index e24408b..ebecc27 100644
--- a/pkg/vm/lib/transformations/type_flow/native_code.dart
+++ b/pkg/vm/lib/transformations/type_flow/native_code.dart
@@ -79,13 +79,13 @@
     var type = _annotationsDefineRoot(proc.annotations);
     if (type == null) return;
 
-    if (proc.isRedirectingFactoryConstructor) {
+    if (proc.isRedirectingFactory) {
       if (type != PragmaEntryPointType.CallOnly &&
           type != PragmaEntryPointType.Default) {
         throw "Error: factory $proc doesn't have a setter or getter";
       }
       Member target = proc;
-      while (target is Procedure && target.isRedirectingFactoryConstructor) {
+      while (target is Procedure && target.isRedirectingFactory) {
         target = getRedirectingFactoryBody(target).target;
         assert(target != null);
         assert(
diff --git a/pkg/vm/lib/transformations/type_flow/summary_collector.dart b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
index 362bc5c..1527a11 100644
--- a/pkg/vm/lib/transformations/type_flow/summary_collector.dart
+++ b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
@@ -605,7 +605,7 @@
         "${member}${fieldSummaryType == FieldSummaryType.kFieldGuard ? " (guard)" : ""}";
     debugPrint("===== $summaryName =====");
     assert(!member.isAbstract);
-    assert(!(member is Procedure && member.isRedirectingFactoryConstructor));
+    assert(!(member is Procedure && member.isRedirectingFactory));
 
     _protobufHandler?.beforeSummaryCreation(member);
 
@@ -2483,7 +2483,7 @@
 
   @override
   Type visitStaticTearOffConstant(StaticTearOffConstant constant) {
-    final Member member = constant.procedure;
+    final Member member = constant.target;
     summaryCollector._entryPointsListener
         .addRawCall(new DirectSelector(member));
     if (member is Constructor) {
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index 285990d..fb4dec7 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -1129,8 +1129,7 @@
     transformConstructorList(node.constructors, node);
     transformProcedureList(node.procedures, node);
     transformFieldList(node.fields, node);
-    transformRedirectingFactoryConstructorList(
-        node.redirectingFactoryConstructors, node);
+    transformRedirectingFactoryList(node.redirectingFactories, node);
     return node;
   }
 
@@ -1811,7 +1810,7 @@
 
   @override
   visitStaticTearOffConstant(StaticTearOffConstant constant) {
-    shaker.addUsedMember(constant.procedure);
+    shaker.addUsedMember(constant.target);
   }
 
   @override
diff --git a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
index 7a07552..68734d6 100644
--- a/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
+++ b/runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc
@@ -230,7 +230,7 @@
     bool has_field_initializers = false;
     for (intptr_t i = 0; i < list_length; ++i) {
       if (PeekTag() == kRedirectingInitializer ||
-          PeekTag() == kRedirectingFactoryConstructor) {
+          PeekTag() == kRedirectingFactory) {
         is_redirecting_constructor = true;
       } else if (PeekTag() == kFieldInitializer) {
         has_field_initializers = true;
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.h b/runtime/vm/compiler/frontend/kernel_translation_helper.h
index c8e3ca3..e9a4807 100644
--- a/runtime/vm/compiler/frontend/kernel_translation_helper.h
+++ b/runtime/vm/compiler/frontend/kernel_translation_helper.h
@@ -554,7 +554,7 @@
     kConst = 1 << 3,  // Only for external const factories.
 
     // TODO(29841): Remove this line after the issue is resolved.
-    kRedirectingFactoryConstructor = 1 << 4,
+    kRedirectingFactory = 1 << 4,
     kExtensionMember = 1 << 5,
     kSyntheticProcedure = 1 << 7,
   };
@@ -579,8 +579,8 @@
     return stub_kind_ == kAbstractForwardingStubKind ||
            stub_kind_ == kConcreteForwardingStubKind;
   }
-  bool IsRedirectingFactoryConstructor() const {
-    return (flags_ & kRedirectingFactoryConstructor) != 0;
+  bool IsRedirectingFactory() const {
+    return (flags_ & kRedirectingFactory) != 0;
   }
   bool IsNoSuchMethodForwarder() const {
     return stub_kind_ == kNoSuchMethodForwarderStubKind;
diff --git a/runtime/vm/compiler/frontend/scope_builder.cc b/runtime/vm/compiler/frontend/scope_builder.cc
index b2a6031..34249a3 100644
--- a/runtime/vm/compiler/frontend/scope_builder.cc
+++ b/runtime/vm/compiler/frontend/scope_builder.cc
@@ -604,13 +604,11 @@
     LocalVariable* future = scope_->LookupVariable(Symbols::_future(), true);
     ASSERT(future != nullptr);
     future->set_is_chained_future();
-    future->set_expected_context_index(Context::kFutureTimeoutFutureIndex);
   } else if (function.recognized_kind() == MethodRecognizer::kFutureWait &&
              depth_.function_ == 1) {
     LocalVariable* future = scope_->LookupVariable(Symbols::_future(), true);
     ASSERT(future != nullptr);
     future->set_is_chained_future();
-    future->set_expected_context_index(Context::kFutureWaitFutureIndex);
   }
 }
 
diff --git a/runtime/vm/kernel_binary.h b/runtime/vm/kernel_binary.h
index 57b229a..c30f759 100644
--- a/runtime/vm/kernel_binary.h
+++ b/runtime/vm/kernel_binary.h
@@ -20,8 +20,8 @@
 static const uint32_t kMagicProgramFile = 0x90ABCDEFu;
 
 // Both version numbers are inclusive.
-static const uint32_t kMinSupportedKernelFormatVersion = 67;
-static const uint32_t kMaxSupportedKernelFormatVersion = 67;
+static const uint32_t kMinSupportedKernelFormatVersion = 68;
+static const uint32_t kMaxSupportedKernelFormatVersion = 68;
 
 // Keep in sync with package:kernel/lib/binary/tag.dart
 #define KERNEL_TAG_LIST(V)                                                     \
@@ -33,7 +33,7 @@
   V(Field, 4)                                                                  \
   V(Constructor, 5)                                                            \
   V(Procedure, 6)                                                              \
-  V(RedirectingFactoryConstructor, 108)                                        \
+  V(RedirectingFactory, 108)                                                   \
   V(InvalidInitializer, 7)                                                     \
   V(FieldInitializer, 8)                                                       \
   V(SuperInitializer, 9)                                                       \
@@ -98,6 +98,7 @@
   V(ConstMapLiteral, 59)                                                       \
   V(ConstructorTearOff, 60)                                                    \
   V(TypedefTearOff, 83)                                                        \
+  V(RedirectingFactoryTearOff, 84)                                             \
   V(ExpressionStatement, 61)                                                   \
   V(Block, 62)                                                                 \
   V(EmptyStatement, 63)                                                        \
@@ -175,6 +176,7 @@
   kUnevaluatedConstant = 12,
   kTypedefTearOffConstant = 14,
   kConstructorTearOffConstant = 15,
+  kRedirectingFactoryTearOffConstant = 16,
 };
 
 // Keep in sync with package:kernel/lib/ast.dart
diff --git a/runtime/vm/kernel_loader.cc b/runtime/vm/kernel_loader.cc
index d6cbc64..a45e80c 100644
--- a/runtime/vm/kernel_loader.cc
+++ b/runtime/vm/kernel_loader.cc
@@ -1946,7 +1946,7 @@
   // additional functions can cause strain on the VM. They are therefore skipped
   // in jit mode and their associated origin function is used instead as
   // interface call target.
-  if (procedure_helper.IsRedirectingFactoryConstructor() ||
+  if (procedure_helper.IsRedirectingFactory() ||
       (!FLAG_precompiled_mode && procedure_helper.IsMemberSignature())) {
     helper_.SetOffset(procedure_end);
     return;
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 3046b1a..3b80f79 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -6747,8 +6747,6 @@
   static const intptr_t kControllerIndex = 1;
   // Expected context index of chained futures in recognized async functions.
   // These are used to unwind async stacks.
-  static const intptr_t kFutureTimeoutFutureIndex = 2;
-  static const intptr_t kFutureWaitFutureIndex = 2;
   static const intptr_t kIsSyncIndex = 2;
 
   struct ArrayTraits {
diff --git a/runtime/vm/object_store.h b/runtime/vm/object_store.h
index 404f142..e502c01 100644
--- a/runtime/vm/object_store.h
+++ b/runtime/vm/object_store.h
@@ -173,6 +173,8 @@
   RW(Function, complete_on_async_return)                                       \
   RW(Function, complete_on_async_error)                                        \
   RW(Class, async_star_stream_controller)                                      \
+  RW(Smi, future_timeout_future_index)                                         \
+  RW(Smi, future_wait_future_index)                                            \
   RW(CompressedStackMaps, canonicalized_stack_map_entries)                     \
   RW(ObjectPool, global_object_pool)                                           \
   RW(Array, unique_dynamic_targets)                                            \
diff --git a/runtime/vm/object_test.cc b/runtime/vm/object_test.cc
index 2553f7c..9c07f25 100644
--- a/runtime/vm/object_test.cc
+++ b/runtime/vm/object_test.cc
@@ -2532,8 +2532,8 @@
   const VariableIndex first_local_index(-1);
   bool found_captured_vars = false;
   VariableIndex next_index = parent_scope->AllocateVariables(
-      first_parameter_index, num_parameters, first_local_index, NULL,
-      &found_captured_vars);
+      Function::null_function(), first_parameter_index, num_parameters,
+      first_local_index, NULL, &found_captured_vars);
   // Variables a, c and var_ta are captured, therefore are not allocated in
   // frame.
   EXPECT_EQ(0, next_index.value() -
diff --git a/runtime/vm/parser.cc b/runtime/vm/parser.cc
index 866d0aa..7c6592f 100644
--- a/runtime/vm/parser.cc
+++ b/runtime/vm/parser.cc
@@ -287,7 +287,7 @@
   VariableIndex first_local_index =
       VariableIndex(parameter_index_start.value() > 0 ? 0 : -num_params);
   VariableIndex next_free_index = scope->AllocateVariables(
-      parameter_index_start, num_params, first_local_index, NULL,
+      function(), parameter_index_start, num_params, first_local_index, NULL,
       &found_captured_variables);
 
   num_stack_locals_ = -next_free_index.value();
diff --git a/runtime/vm/program_visitor.cc b/runtime/vm/program_visitor.cc
index 3020106b..6eb0c25 100644
--- a/runtime/vm/program_visitor.cc
+++ b/runtime/vm/program_visitor.cc
@@ -1436,7 +1436,7 @@
   ObjectPtr* from = object_store->from();
   ObjectPtr* to = object_store->to_snapshot(Snapshot::kFullAOT);
   for (ObjectPtr* p = from; p <= to; p++) {
-    if ((*p)->IsCode()) {
+    if ((*p)->IsHeapObject() && (*p)->IsCode()) {
       code ^= *p;
       inst = code.instructions();
       thread->heap()->SetLoadingUnit(inst.ptr(), LoadingUnit::kRootId);
diff --git a/runtime/vm/scopes.cc b/runtime/vm/scopes.cc
index c643b46..b2e773d 100644
--- a/runtime/vm/scopes.cc
+++ b/runtime/vm/scopes.cc
@@ -7,6 +7,7 @@
 
 #include "vm/compiler/backend/slot.h"
 #include "vm/object.h"
+#include "vm/object_store.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ -194,7 +195,8 @@
       &Slot::GetContextVariableSlotFor(Thread::Current(), *variable));
 }
 
-VariableIndex LocalScope::AllocateVariables(VariableIndex first_parameter_index,
+VariableIndex LocalScope::AllocateVariables(const Function& function,
+                                            VariableIndex first_parameter_index,
                                             int num_parameters,
                                             VariableIndex first_local_index,
                                             LocalScope* context_owner,
@@ -252,8 +254,17 @@
   if (chained_future != nullptr) {
     AllocateContextVariable(chained_future, &context_owner);
     *found_captured_variables = true;
-    ASSERT(chained_future->index().value() ==
-           chained_future->expected_context_index());
+    // Remember context indices of _future variables in _Future.timeout and
+    // Future.wait. They are used while collecting async stack traces.
+    if (function.recognized_kind() == MethodRecognizer::kFutureTimeout) {
+      IsolateGroup::Current()->object_store()->set_future_timeout_future_index(
+          Smi::Handle(Smi::New(chained_future->index().value())));
+    } else if (function.recognized_kind() == MethodRecognizer::kFutureWait) {
+      IsolateGroup::Current()->object_store()->set_future_wait_future_index(
+          Smi::Handle(Smi::New(chained_future->index().value())));
+    } else {
+      UNREACHABLE();
+    }
   }
   if (is_sync != nullptr) {
     AllocateContextVariable(is_sync, &context_owner);
@@ -312,7 +323,7 @@
     // No parameters in children scopes.
     const int num_parameters_in_child = 0;
     VariableIndex child_next_index = child->AllocateVariables(
-        dummy_parameter_index, num_parameters_in_child, next_index,
+        function, dummy_parameter_index, num_parameters_in_child, next_index,
         context_owner, found_captured_variables);
     if (child_next_index.value() < min_index.value()) {
       min_index = child_next_index;
diff --git a/runtime/vm/scopes.h b/runtime/vm/scopes.h
index 593e186..ff80167 100644
--- a/runtime/vm/scopes.h
+++ b/runtime/vm/scopes.h
@@ -94,7 +94,6 @@
         covariance_mode_(kNotCovariant),
         is_late_(false),
         is_chained_future_(false),
-        expected_context_index_(-1),
         late_init_offset_(0),
         type_check_mode_(kDoTypeCheck),
         index_() {
@@ -136,11 +135,6 @@
   bool is_chained_future() const { return is_chained_future_; }
   void set_is_chained_future() { is_chained_future_ = true; }
 
-  intptr_t expected_context_index() const { return expected_context_index_; }
-  void set_expected_context_index(int index) {
-    expected_context_index_ = index;
-  }
-
   intptr_t late_init_offset() const { return late_init_offset_; }
   void set_late_init_offset(intptr_t late_init_offset) {
     late_init_offset_ = late_init_offset;
@@ -244,7 +238,6 @@
   CovarianceMode covariance_mode_;
   bool is_late_;
   bool is_chained_future_;
-  intptr_t expected_context_index_;
   intptr_t late_init_offset_;
   TypeCheckMode type_check_mode_;
   VariableIndex index_;
@@ -476,7 +469,8 @@
   // Two locals in different sibling scopes may share the same frame slot.
   //
   // Return the index of the next available frame slot.
-  VariableIndex AllocateVariables(VariableIndex first_parameter_index,
+  VariableIndex AllocateVariables(const Function& function,
+                                  VariableIndex first_parameter_index,
                                   int num_parameters,
                                   VariableIndex first_local_index,
                                   LocalScope* context_owner,
diff --git a/runtime/vm/stack_trace.cc b/runtime/vm/stack_trace.cc
index 74fa21a..1f29e90 100644
--- a/runtime/vm/stack_trace.cc
+++ b/runtime/vm/stack_trace.cc
@@ -5,6 +5,7 @@
 #include "vm/stack_trace.h"
 
 #include "vm/dart_api_impl.h"
+#include "vm/object_store.h"
 #include "vm/stack_frame.h"
 #include "vm/symbols.h"
 
@@ -242,14 +243,26 @@
     parent_function_ = receiver_function_.parent_function();
     if (parent_function_.recognized_kind() ==
         MethodRecognizer::kFutureTimeout) {
-      context_entry_ = receiver_context_.At(Context::kFutureTimeoutFutureIndex);
+      ASSERT(IsolateGroup::Current()
+                 ->object_store()
+                 ->future_timeout_future_index() != Object::null());
+      const intptr_t future_index =
+          Smi::Value(IsolateGroup::Current()
+                         ->object_store()
+                         ->future_timeout_future_index());
+      context_entry_ = receiver_context_.At(future_index);
       return GetCallerInFutureImpl(context_entry_);
     }
 
     if (parent_function_.recognized_kind() == MethodRecognizer::kFutureWait) {
       receiver_context_ = receiver_context_.parent();
       ASSERT(!receiver_context_.IsNull());
-      context_entry_ = receiver_context_.At(Context::kFutureWaitFutureIndex);
+      ASSERT(
+          IsolateGroup::Current()->object_store()->future_wait_future_index() !=
+          Object::null());
+      const intptr_t future_index = Smi::Value(
+          IsolateGroup::Current()->object_store()->future_wait_future_index());
+      context_entry_ = receiver_context_.At(future_index);
       return GetCallerInFutureImpl(context_entry_);
     }
   }
diff --git a/tools/VERSION b/tools/VERSION
index d81caa4..21e7eeb 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 334
+PRERELEASE 335
 PRERELEASE_PATCH 0
\ No newline at end of file