diff --git a/DEPS b/DEPS
index e569bfd..e7492f9 100644
--- a/DEPS
+++ b/DEPS
@@ -73,7 +73,7 @@
 
   # Revisions of /third_party/* dependencies.
   "args_rev": "d8fea36c10ef96797be02e3d132d572445cd86f4",
-  "async_rev": "b8850b3851026676083413c67fa0a22f63a8edbc",
+  "async_rev": "92e7119aa068bfb86a6a9519d44037ffff5eece8",
   "bazel_worker_rev": "0885637b037979afbf5bcd05fd748b309fd669c0",
   "benchmark_harness_rev": "c546dbd9f639f75cd2f75de8df2eb9f8ea15e8e7",
   "boolean_selector_rev": "665e6921ab246569420376f827bff4585dff0b14",
diff --git a/pkg/compiler/lib/src/inferrer/builder_kernel.dart b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
index d6def19..40e1ebe 100644
--- a/pkg/compiler/lib/src/inferrer/builder_kernel.dart
+++ b/pkg/compiler/lib/src/inferrer/builder_kernel.dart
@@ -2284,14 +2284,13 @@
   }
 
   @override
-  TypeInformation visitPartialInstantiationConstant(
-      ir.PartialInstantiationConstant node) {
+  TypeInformation visitInstantiationConstant(ir.InstantiationConstant node) {
     return builder.createInstantiationTypeInformation(
         visitConstant(node.tearOffConstant));
   }
 
   @override
-  TypeInformation visitTearOffConstant(ir.TearOffConstant node) {
+  TypeInformation visitStaticTearOffConstant(ir.StaticTearOffConstant node) {
     return builder.createStaticGetTypeInformation(node, node.procedure);
   }
 
diff --git a/pkg/compiler/lib/src/ir/constants.dart b/pkg/compiler/lib/src/ir/constants.dart
index c951716..4a936f6 100644
--- a/pkg/compiler/lib/src/ir/constants.dart
+++ b/pkg/compiler/lib/src/ir/constants.dart
@@ -124,7 +124,7 @@
   bool visitUnevaluatedConstant(ir.UnevaluatedConstant node) => true;
 
   @override
-  bool visitPartialInstantiationConstant(ir.PartialInstantiationConstant node) {
+  bool visitInstantiationConstant(ir.InstantiationConstant node) {
     return node.tearOffConstant.accept(this);
   }
 
diff --git a/pkg/compiler/lib/src/ir/impact.dart b/pkg/compiler/lib/src/ir/impact.dart
index 7fabac6..33640a7 100644
--- a/pkg/compiler/lib/src/ir/impact.dart
+++ b/pkg/compiler/lib/src/ir/impact.dart
@@ -748,20 +748,30 @@
   }
 
   @override
-  void visitTearOffConstant(ir.TearOffConstant node) {
-    registry.registerStaticTearOff(node.procedure, import);
+  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}).");
+    }
   }
 
   @override
-  void visitPartialInstantiationConstant(ir.PartialInstantiationConstant node) {
+  void visitInstantiationConstant(ir.InstantiationConstant node) {
     registry.registerGenericInstantiation(
-        node.tearOffConstant.procedure.function.computeFunctionType(
-            node.tearOffConstant.procedure.enclosingLibrary.nonNullable),
+        node.tearOffConstant.function.computeFunctionType(
+            node.tearOffConstant.member.enclosingLibrary.nonNullable),
         node.types);
     visitConstant(node.tearOffConstant);
   }
 
   @override
+  void visitTypedefTearOffConstant(ir.TypedefTearOffConstant node) {
+    defaultConstant(node);
+  }
+
+  @override
   void visitInstanceConstant(ir.InstanceConstant node) {
     registry.registerConstInstantiation(
         node.classNode, node.typeArguments, import);
diff --git a/pkg/compiler/lib/src/ir/visitors.dart b/pkg/compiler/lib/src/ir/visitors.dart
index 31b5158..0335a73 100644
--- a/pkg/compiler/lib/src/ir/visitors.dart
+++ b/pkg/compiler/lib/src/ir/visitors.dart
@@ -212,15 +212,20 @@
   }
 
   @override
-  ConstantValue visitTearOffConstant(ir.TearOffConstant node) {
-    FunctionEntity function = elementMap.getMethod(node.procedure);
-    DartType type = elementMap.getFunctionType(node.procedure.function);
-    return new FunctionConstantValue(function, type);
+  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}).");
+    }
   }
 
   @override
-  ConstantValue visitPartialInstantiationConstant(
-      ir.PartialInstantiationConstant node) {
+  ConstantValue visitInstantiationConstant(ir.InstantiationConstant node) {
     List<DartType> typeArguments = [];
     for (ir.DartType type in node.types) {
       typeArguments.add(elementMap.getDartType(type));
diff --git a/pkg/compiler/lib/src/serialization/node_indexer.dart b/pkg/compiler/lib/src/serialization/node_indexer.dart
index 663e593..e0c56a2 100644
--- a/pkg/compiler/lib/src/serialization/node_indexer.dart
+++ b/pkg/compiler/lib/src/serialization/node_indexer.dart
@@ -307,10 +307,18 @@
   void visitTypeLiteralConstant(ir.TypeLiteralConstant node) {}
 
   @override
-  void visitTearOffConstant(ir.TearOffConstant node) {}
+  void visitStaticTearOffConstant(ir.StaticTearOffConstant node) {}
 
   @override
-  void visitPartialInstantiationConstant(ir.PartialInstantiationConstant node) {
+  void visitConstructorTearOffConstant(ir.ConstructorTearOffConstant node) {}
+
+  @override
+  void visitInstantiationConstant(ir.InstantiationConstant node) {
+    node.tearOffConstant.accept(this);
+  }
+
+  @override
+  void visitTypedefTearOffConstant(ir.TypedefTearOffConstant 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 ad8f434..765039b 100644
--- a/pkg/compiler/lib/src/ssa/builder_kernel.dart
+++ b/pkg/compiler/lib/src/ssa/builder_kernel.dart
@@ -4489,9 +4489,10 @@
         }
       }
     } else if (closure is ir.ConstantExpression &&
-        closure.constant is ir.TearOffConstant) {
-      ir.TearOffConstant tearOff = closure.constant;
-      if (handleTarget(tearOff.procedure)) {
+        closure.constant is ir.StaticTearOffConstant) {
+      ir.StaticTearOffConstant tearOff = closure.constant;
+      ir.Member member = tearOff.procedure;
+      if (member is ir.Procedure && handleTarget(member)) {
         return;
       }
     }
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index c384ce9..3bd5de9 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -5851,6 +5851,11 @@
   }
 
   @override
+  js_ast.Expression visitTypedefTearOff(TypedefTearOff node) {
+    throw UnsupportedError('Typedef instantiation');
+  }
+
+  @override
   js_ast.Expression visitIsExpression(IsExpression node) {
     return _emitIsExpression(node.operand, node.type);
   }
@@ -6232,7 +6237,7 @@
 
   @override
   js_ast.Expression visitConstant(Constant node) {
-    if (node is TearOffConstant) {
+    if (node is StaticTearOffConstant) {
       // JS() or external JS consts should not be lazily loaded.
       var isSdk = node.procedure.enclosingLibrary.importUri.scheme == 'dart';
       if (_isInForeignJS) {
@@ -6418,7 +6423,7 @@
   }
 
   @override
-  js_ast.Expression visitTearOffConstant(TearOffConstant node) {
+  js_ast.Expression visitStaticTearOffConstant(StaticTearOffConstant node) {
     _declareBeforeUse(node.procedure.enclosingClass);
     return _emitStaticGet(node.procedure);
   }
@@ -6428,8 +6433,7 @@
       _emitTypeLiteral(node.type);
 
   @override
-  js_ast.Expression visitPartialInstantiationConstant(
-          PartialInstantiationConstant node) =>
+  js_ast.Expression visitInstantiationConstant(InstantiationConstant node) =>
       canonicalizeConstObject(runtimeCall('gbind(#, #)', [
         visitConstant(node.tearOffConstant),
         node.types.map(_emitType).toList()
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 737f649..fa2b398 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -328,8 +328,7 @@
   }
 
   @override
-  Constant? visitPartialInstantiationConstant(
-      PartialInstantiationConstant node) {
+  Constant? visitInstantiationConstant(InstantiationConstant node) {
     List<DartType>? types;
     for (int index = 0; index < node.types.length; index++) {
       DartType? type = computeConstCanonicalType(
@@ -341,13 +340,13 @@
       }
     }
     if (types != null) {
-      return new PartialInstantiationConstant(node.tearOffConstant, types);
+      return new InstantiationConstant(node.tearOffConstant, types);
     }
     return null;
   }
 
   @override
-  Constant? visitTearOffConstant(TearOffConstant node) => null;
+  Constant? visitStaticTearOffConstant(StaticTearOffConstant node) => null;
 
   @override
   Constant? visitTypeLiteralConstant(TypeLiteralConstant node) {
@@ -2917,7 +2916,7 @@
                 .withArguments(target.name.text));
       } else if (target is Procedure) {
         if (target.kind == ProcedureKind.Method) {
-          return canonicalize(new TearOffConstant(target));
+          return canonicalize(new StaticTearOffConstant(target));
         }
         return createErrorConstant(
             node,
@@ -2936,7 +2935,7 @@
       final Member target = node.target;
       if (target is Procedure) {
         if (target.kind == ProcedureKind.Method) {
-          return canonicalize(new TearOffConstant(target));
+          return canonicalize(new StaticTearOffConstant(target));
         }
         return createErrorConstant(
             node,
@@ -3402,28 +3401,42 @@
           new Instantiation(extract(constant),
               node.typeArguments.map((t) => env.substituteType(t)).toList()));
     }
-    if (constant is TearOffConstant) {
-      if (node.typeArguments.length ==
-          constant.procedure.function.typeParameters.length) {
-        List<DartType>? types = _evaluateDartTypes(node, node.typeArguments);
-        if (types == null) {
-          AbortConstant error = _gotError!;
-          _gotError = null;
-          return error;
-        }
-        assert(_gotError == null);
-        // ignore: unnecessary_null_comparison
-        assert(types != null);
+    if (constant is StaticTearOffConstant) {
+      Member constantMember = constant.procedure;
+      if (constantMember is Procedure) {
+        if (node.typeArguments.length ==
+            constantMember.function.typeParameters.length) {
+          List<DartType>? types = _evaluateDartTypes(node, node.typeArguments);
+          if (types == null) {
+            AbortConstant error = _gotError!;
+            _gotError = null;
+            return error;
+          }
+          assert(_gotError == null);
+          // ignore: unnecessary_null_comparison
+          assert(types != null);
 
-        final List<DartType> typeArguments = convertTypes(types);
-        return canonicalize(
-            new PartialInstantiationConstant(constant, typeArguments));
+          final List<DartType> typeArguments = convertTypes(types);
+          return canonicalize(
+              new InstantiationConstant(constant, typeArguments));
+        } else {
+          // Probably unreachable.
+          return createInvalidExpressionConstant(
+              node,
+              'The number of type arguments supplied in the partial '
+              '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(
+            node,
+            "Unsupported kind of a torn off member: "
+            "'${constantMember.runtimeType}'.");
       }
-      // Probably unreachable.
-      return createInvalidExpressionConstant(
-          node,
-          'The number of type arguments supplied in the partial instantiation '
-          'does not match the number of type arguments of the $constant.');
     }
     // The inner expression in an instantiation can never be null, since
     // instantiations are only inferred on direct references to declarations.
@@ -3438,6 +3451,11 @@
   }
 
   @override
+  Constant visitTypedefTearOff(TypedefTearOff node) {
+    return defaultExpression(node);
+  }
+
+  @override
   Constant visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) {
     return createErrorConstant(node,
         templateConstEvalDeferredLibrary.withArguments(node.import.name!));
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 3ff0062..d8265a8 100644
--- a/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/inference_visitor.dart
@@ -221,6 +221,12 @@
   }
 
   @override
+  ExpressionInferenceResult visitTypedefTearOff(
+      TypedefTearOff node, DartType typeContext) {
+    return _unhandledExpression(node, typeContext);
+  }
+
+  @override
   ExpressionInferenceResult visitListConcatenation(
       ListConcatenation node, DartType typeContext) {
     return _unhandledExpression(node, typeContext);
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 9ac22d9..aeb1696 100644
--- a/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/type_labeler.dart
@@ -360,7 +360,7 @@
     result.add("}");
   }
 
-  void visitTearOffConstant(TearOffConstant node) {
+  void visitStaticTearOffConstant(StaticTearOffConstant node) {
     Procedure procedure = node.procedure;
     Class? classNode = procedure.enclosingClass;
     if (classNode != null) {
@@ -374,7 +374,19 @@
     result.add(procedure.name.text);
   }
 
-  void visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+  void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
+    Constructor constructor = node.constructor;
+    Class? classNode = constructor.enclosingClass;
+    result.add(nameForEntity(
+        classNode,
+        classNode.name,
+        classNode.enclosingLibrary.importUri,
+        classNode.enclosingLibrary.fileUri));
+    result.add(".");
+    result.add(constructor.name.text);
+  }
+
+  void visitInstantiationConstant(InstantiationConstant node) {
     node.tearOffConstant.accept(this);
     if (node.types.isNotEmpty) {
       result.add("<");
@@ -388,6 +400,36 @@
     }
   }
 
+  void visitTypedefTearOffConstant(TypedefTearOffConstant node) {
+    node.tearOffConstant.accept(this);
+    if (node.parameters.isNotEmpty) {
+      result.add("<");
+      bool first = true;
+      for (TypeParameter param in node.parameters) {
+        if (!first) result.add(", ");
+        result.add(param.name ?? '');
+        if (isObject(param.bound) && param.defaultType is DynamicType) {
+          // Bound was not specified, and therefore should not be printed.
+        } else {
+          result.add(" extends ");
+          param.bound.accept(this);
+        }
+        first = false;
+      }
+      result.add(">");
+    }
+    if (node.types.isNotEmpty) {
+      result.add("<");
+      bool first = true;
+      for (DartType typeArg in node.types) {
+        if (!first) result.add(", ");
+        typeArg.accept(this);
+        first = false;
+      }
+      result.add(">");
+    }
+  }
+
   void visitTypeLiteralConstant(TypeLiteralConstant node) {
     node.type.accept(this);
   }
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 68cbf92..eaba8c7 100644
--- a/pkg/front_end/lib/src/testing/id_testing_utils.dart
+++ b/pkg/front_end/lib/src/testing/id_testing_utils.dart
@@ -401,20 +401,54 @@
     sb.write(')');
   }
 
-  void visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+  void visitInstantiationConstant(InstantiationConstant node) {
     sb.write('Instantiation(');
-    sb.write(getMemberName(node.tearOffConstant.procedure));
+    sb.write(getMemberName(node.tearOffConstant.member));
     sb.write('<');
     typeToText.visitList(node.types);
     sb.write('>)');
   }
 
-  void visitTearOffConstant(TearOffConstant node) {
+  void visitTypedefTearOffConstant(TypedefTearOffConstant node) {
+    sb.write('TypedefTearOff(');
+    sb.write(getMemberName(node.tearOffConstant.member));
+    if (node.parameters.isNotEmpty) {
+      sb.write('<');
+      for (int i = 0; i < node.parameters.length; i++) {
+        if (i > 0) {
+          sb.write(',');
+          if (typeToText.typeRepresentation ==
+              TypeRepresentation.analyzerNonNullableByDefault) {
+            sb.write(' ');
+          }
+        }
+        TypeParameter typeParameter = node.parameters[i];
+        sb.write(typeParameter.name);
+        DartType bound = typeParameter.bound;
+        if (!(bound is InterfaceType && bound.classNode.name == 'Object')) {
+          sb.write(' extends ');
+          typeToText.visit(bound);
+        }
+      }
+      sb.write('>');
+    }
+    sb.write('<');
+    typeToText.visitList(node.types);
+    sb.write('>)');
+  }
+
+  void visitStaticTearOffConstant(StaticTearOffConstant node) {
     sb.write('Function(');
     sb.write(getMemberName(node.procedure));
     sb.write(')');
   }
 
+  void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
+    sb.write('Constructor(');
+    sb.write(getMemberName(node.constructor));
+    sb.write(')');
+  }
+
   void visitTypeLiteralConstant(TypeLiteralConstant node) {
     sb.write('TypeLiteral(');
     typeToText.visit(node.type);
diff --git a/pkg/front_end/test/incremental_bulk_compiler_full.dart b/pkg/front_end/test/incremental_bulk_compiler_full.dart
index ac018cb..b067117 100644
--- a/pkg/front_end/test/incremental_bulk_compiler_full.dart
+++ b/pkg/front_end/test/incremental_bulk_compiler_full.dart
@@ -97,6 +97,7 @@
       bulkSerialized = util.postProcess(bulkCompiledComponent);
     } catch (e) {
       bulkFailed = true;
+      context.compiler = null;
     }
 
     // Compile again - the serialized output should be the same.
@@ -112,6 +113,7 @@
       bulkSerialized2 = util.postProcess(bulkCompiledComponent);
     } catch (e) {
       bulk2Failed = true;
+      context.compiler = null;
     }
 
     if (bulkFailed || oneShotFailed) {
diff --git a/pkg/front_end/test/type_labeler_test.dart b/pkg/front_end/test/type_labeler_test.dart
index 3acfa34..cde0695 100644
--- a/pkg/front_end/test/type_labeler_test.dart
+++ b/pkg/front_end/test/type_labeler_test.dart
@@ -285,11 +285,11 @@
   ]);
   check({mapConst: "<bool, num>{true: 2, false: 2.5}"}, 0);
 
-  Constant tearOffConst = new TearOffConstant(gooMethod);
+  Constant tearOffConst = new StaticTearOffConstant(gooMethod);
   check({tearOffConst: "Foo.goo"}, 1);
 
   Constant partialInstantiationConst =
-      new PartialInstantiationConstant(tearOffConst, [intType]);
+      new InstantiationConstant(tearOffConst, [intType]);
   check({partialInstantiationConst: "Foo.goo<int>"}, 1);
 
   Constant typeLiteralConst = new TypeLiteralConstant(foo);
diff --git a/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect b/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect
index d3f2e88..4ccf7ac 100644
--- a/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/constructor_tearoffs/identical_instantiated_function_tearoffs.dart.weak.outline.expect
@@ -17,6 +17,6 @@
 
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:9:54 -> PartialInstantiationConstant(id<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:10:38 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:9:54 -> InstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:10:38 -> InstantiationConstant(id<int*>)
 Extra constant evaluation: evaluated: 2, effectively constant: 2
diff --git a/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect b/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect
index 4722f57..1023df5 100644
--- a/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/constants/various.dart.weak.outline.expect
@@ -445,7 +445,7 @@
 Evaluated: EqualsCall @ org-dartlang-testcase:///various.dart:195:24 -> BoolConstant(false)
 Evaluated: ConditionalExpression @ org-dartlang-testcase:///various.dart:200:66 -> NullConstant(null)
 Evaluated: AsExpression @ org-dartlang-testcase:///various.dart:203:39 -> NullConstant(null)
-Evaluated: AsExpression @ org-dartlang-testcase:///various.dart:205:39 -> PartialInstantiationConstant(id1<int*>)
+Evaluated: AsExpression @ org-dartlang-testcase:///various.dart:205:39 -> InstantiationConstant(id1<int*>)
 Evaluated: Not @ org-dartlang-testcase:///various.dart:208:20 -> BoolConstant(false)
 Evaluated: ConditionalExpression @ org-dartlang-testcase:///various.dart:210:46 -> BoolConstant(true)
 Evaluated: ConditionalExpression @ org-dartlang-testcase:///various.dart:211:38 -> BoolConstant(false)
diff --git a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect
index 91fb49a..373d6b4 100644
--- a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.outline.expect
@@ -78,7 +78,7 @@
 
 Extra constant evaluation status:
 Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2.dart:10:27 -> TypeLiteralConstant(Object*)
-Evaluated: Instantiation @ org-dartlang-testcase:///various_2.dart:11:52 -> PartialInstantiationConstant(id1<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///various_2.dart:11:52 -> InstantiationConstant(id1<int*>)
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2.dart:12:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2.dart:13:25 -> InstanceConstant(const Class<dynamic>{Class.field: const <int*>[42]})
 Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2.dart:15:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
@@ -94,8 +94,8 @@
 Evaluated: MapConcatenation @ org-dartlang-testcase:///various_2.dart:32:7 -> MapConstant(const <int*, String*>{0: "foo"})
 Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:35:5 -> BoolConstant(true)
 Evaluated with empty environment: StaticInvocation @ org-dartlang-testcase:///various_2.dart:37:5 -> BoolConstant(false)
-Evaluated: StaticGet @ org-dartlang-testcase:///various_2.dart:37:15 -> PartialInstantiationConstant(id1<int*>)
-Evaluated with empty environment: StaticGet @ org-dartlang-testcase:///various_2.dart:37:41 -> PartialInstantiationConstant(id2<int*>)
+Evaluated: StaticGet @ org-dartlang-testcase:///various_2.dart:37:15 -> InstantiationConstant(id1<int*>)
+Evaluated with empty environment: StaticGet @ org-dartlang-testcase:///various_2.dart:37:41 -> InstantiationConstant(id2<int*>)
 Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:38:27 -> BoolConstant(true)
 Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:39:28 -> BoolConstant(true)
 Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:41:5 -> BoolConstant(true)
@@ -110,13 +110,13 @@
 Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:53:5 -> BoolConstant(true)
 Evaluated: StaticInvocation @ org-dartlang-testcase:///various_2.dart:55:5 -> BoolConstant(true)
 Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2_lib.dart:17:27 -> TypeLiteralConstant(Object*)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:18:12 -> TearOffConstant(identical)
-Evaluated with empty environment: ConditionalExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> PartialInstantiationConstant(id2<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:18:12 -> StaticTearOffConstant(identical)
+Evaluated with empty environment: ConditionalExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> InstantiationConstant(id2<int*>)
 Evaluated with empty environment: FactoryConstructorInvocationJudgment @ org-dartlang-testcase:///various_2_lib.dart:20:11 -> BoolConstant(false)
-Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> PartialInstantiationConstant(id1<int*>)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> TearOffConstant(id1)
-Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> PartialInstantiationConstant(id2<int*>)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> TearOffConstant(id2)
+Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> InstantiationConstant(id1<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:41 -> StaticTearOffConstant(id1)
+Evaluated with empty environment: Instantiation @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> InstantiationConstant(id2<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///various_2_lib.dart:20:47 -> StaticTearOffConstant(id2)
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2_lib.dart:21:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///various_2_lib.dart:22:25 -> InstanceConstant(const Class<dynamic>{Class.field: const <int*>[42]})
 Evaluated: TypeLiteral @ org-dartlang-testcase:///various_2_lib.dart:23:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
diff --git a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect
index 3e10527..2830193 100644
--- a/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/constants/with_unevaluated_agnostic/various_2.dart.weak.transformed.expect
@@ -130,10 +130,10 @@
 }
 
 Extra constant evaluation status:
-Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:15:28 -> PartialInstantiationConstant(id2<int*>)
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:15:28 -> InstantiationConstant(id2<int*>)
 Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:37:5 -> BoolConstant(false)
 Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2.dart:37:5 -> BoolConstant(false)
-Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> PartialInstantiationConstant(id2<int*>)
+Evaluated with empty environment: ConstantExpression @ org-dartlang-testcase:///various_2_lib.dart:20:39 -> InstantiationConstant(id2<int*>)
 Extra constant evaluation: evaluated: 41, effectively constant: 4
 
 
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect
index 02a352f..9e4506e 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.outline.expect
@@ -15,5 +15,5 @@
 
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:17:54 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:17:54 -> InstantiationConstant(id<int*>)
 Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect
index ad67316..e0f574c 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.transformed.expect
@@ -28,5 +28,5 @@
 
 Extra constant evaluation status:
 Evaluated: StaticInvocation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:28:13 -> BoolConstant(true)
-Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:16:43 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:16:43 -> InstantiationConstant(id<int*>)
 Extra constant evaluation: evaluated: 30, effectively constant: 2
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect
index d465ca9..9dc6b9b 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.transformed.expect
@@ -181,32 +181,32 @@
 }
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:16:16 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:17:16 -> PartialInstantiationConstant(max<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:18:16 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:19:16 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:20:16 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:21:16 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:22:16 -> PartialInstantiationConstant(max<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:23:16 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:24:16 -> PartialInstantiationConstant(max<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:26:70 -> PartialInstantiationConstant(max<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:28:73 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:30:73 -> PartialInstantiationConstant(max<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:31:70 -> PartialInstantiationConstant(max<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:32:70 -> PartialInstantiationConstant(max<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:35:11 -> PartialInstantiationConstant(min<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:36:11 -> PartialInstantiationConstant(min<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:37:11 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:38:11 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:39:11 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:40:11 -> PartialInstantiationConstant(min<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:41:11 -> PartialInstantiationConstant(min<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:42:11 -> PartialInstantiationConstant(min<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:43:11 -> PartialInstantiationConstant(min<double*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:45:65 -> PartialInstantiationConstant(min<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:46:72 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:47:72 -> PartialInstantiationConstant(min<num*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:48:65 -> PartialInstantiationConstant(min<Object*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:49:65 -> PartialInstantiationConstant(min<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:16:16 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:17:16 -> InstantiationConstant(max<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:18:16 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:19:16 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:20:16 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:21:16 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:22:16 -> InstantiationConstant(max<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:23:16 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:24:16 -> InstantiationConstant(max<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:26:70 -> InstantiationConstant(max<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:28:73 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:30:73 -> InstantiationConstant(max<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:31:70 -> InstantiationConstant(max<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:32:70 -> InstantiationConstant(max<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:35:11 -> InstantiationConstant(min<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:36:11 -> InstantiationConstant(min<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:37:11 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:38:11 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:39:11 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:40:11 -> InstantiationConstant(min<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:41:11 -> InstantiationConstant(min<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:42:11 -> InstantiationConstant(min<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:43:11 -> InstantiationConstant(min<double*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:45:65 -> InstantiationConstant(min<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:46:72 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:47:72 -> InstantiationConstant(min<num*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:48:65 -> InstantiationConstant(min<Object*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_infer_generic_instantiation.dart:49:65 -> InstantiationConstant(min<Object*>)
 Extra constant evaluation: evaluated: 133, effectively constant: 28
diff --git a/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect
index 947bd81..8af73b0 100644
--- a/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.transformed.expect
@@ -48,6 +48,6 @@
 }
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:28:71 -> PartialInstantiationConstant(max<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:29:67 -> PartialInstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:28:71 -> InstantiationConstant(max<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///generic_methods_nested_generic_instantiation.dart:29:67 -> InstantiationConstant(max<int*>)
 Extra constant evaluation: evaluated: 16, effectively constant: 2
diff --git a/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect b/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect
index 8efaf12..4c5080b 100644
--- a/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.transformed.expect
@@ -49,6 +49,6 @@
 }
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:25:10 -> PartialInstantiationConstant(f<int*>)
-Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:27:12 -> PartialInstantiationConstant(C.g<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:25:10 -> InstantiationConstant(f<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///instantiate_tearoff.dart:27:12 -> InstantiationConstant(C.g<int*>)
 Extra constant evaluation: evaluated: 18, effectively constant: 2
diff --git a/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect b/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect
index b473f71..b2c575b 100644
--- a/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/inference/static_method_tear_off.dart.weak.outline.expect
@@ -24,5 +24,5 @@
 
 
 Extra constant evaluation status:
-Evaluated: StaticTearOff @ org-dartlang-testcase:///static_method_tear_off.dart:8:13 -> TearOffConstant(C.f)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///static_method_tear_off.dart:8:13 -> StaticTearOffConstant(C.f)
 Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect
index b25d8c4..1d425f6 100644
--- a/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/constants.dart.weak.outline.expect
@@ -64,7 +64,7 @@
 
 Extra constant evaluation status:
 Evaluated: TypeLiteral @ org-dartlang-testcase:///constants.dart:10:27 -> TypeLiteralConstant(Object*)
-Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:11:52 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:11:52 -> InstantiationConstant(id<int*>)
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants.dart:12:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
 Evaluated: TypeLiteral @ org-dartlang-testcase:///constants.dart:13:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
 Evaluated: TypeLiteral @ org-dartlang-testcase:///constants.dart:14:36 -> TypeLiteralConstant(T* Function<T>(T*)*)
@@ -86,8 +86,8 @@
 Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:37:5 -> BoolConstant(true)
 Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:39:5 -> BoolConstant(true)
 Evaluated: TypeLiteral @ org-dartlang-testcase:///constants_lib.dart:16:27 -> TypeLiteralConstant(Object*)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:17:12 -> TearOffConstant(identical)
-Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:18:48 -> PartialInstantiationConstant(id<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:17:12 -> StaticTearOffConstant(identical)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:18:48 -> InstantiationConstant(id<int*>)
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants_lib.dart:19:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
 Evaluated: TypeLiteral @ org-dartlang-testcase:///constants_lib.dart:20:29 -> TypeLiteralConstant(dynamic Function(dynamic)*)
 Evaluated: TypeLiteral @ org-dartlang-testcase:///constants_lib.dart:21:36 -> TypeLiteralConstant(T* Function<T>(T*)*)
diff --git a/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect b/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
index bb2b62a..62a035b 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
@@ -18,5 +18,5 @@
 }
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> PartialInstantiationConstant(checkme<X>)
+Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> InstantiationConstant(checkme<X>)
 Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect b/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
index 4754890..0fd30a8 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
@@ -18,5 +18,5 @@
 }
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> PartialInstantiationConstant(checkme<X*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> InstantiationConstant(checkme<X*>)
 Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect
index b3e41d5..c031ded 100644
--- a/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/potentially_constant_type_as.dart.weak.outline.expect
@@ -49,5 +49,5 @@
 
 Extra constant evaluation status:
 Evaluated: StaticGet @ org-dartlang-testcase:///potentially_constant_type_as.dart:22:36 -> IntConstant(3)
-Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_as.dart:11:43 -> PartialInstantiationConstant(idFunction<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_as.dart:11:43 -> InstantiationConstant(idFunction<int*>)
 Extra constant evaluation: evaluated: 11, effectively constant: 2
diff --git a/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect
index ba55100..b22c34f 100644
--- a/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd/potentially_constant_type_is.dart.weak.outline.expect
@@ -45,5 +45,5 @@
 
 Extra constant evaluation status:
 Evaluated: StaticGet @ org-dartlang-testcase:///potentially_constant_type_is.dart:22:36 -> IntConstant(3)
-Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_is.dart:11:43 -> PartialInstantiationConstant(idFunction<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///potentially_constant_type_is.dart:11:43 -> InstantiationConstant(idFunction<int*>)
 Extra constant evaluation: evaluated: 11, effectively constant: 2
diff --git a/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect b/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect
index 9f91d26..6e8783d 100644
--- a/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect
+++ b/pkg/front_end/testcases/nnbd_mixed/constants.dart.weak.outline.expect
@@ -62,7 +62,7 @@
 
 
 Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:7:52 -> PartialInstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants.dart:7:52 -> InstantiationConstant(id<int*>)
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants.dart:8:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
 Evaluated: ListLiteral @ org-dartlang-testcase:///constants.dart:9:26 -> ListConstant(const <int*>[0])
 Evaluated: SetLiteral @ org-dartlang-testcase:///constants.dart:10:25 -> InstanceConstant(const _UnmodifiableSet<int*>{_UnmodifiableSet._map: const _ImmutableMap<int*, Null>{_ImmutableMap._kvPairs: const <dynamic>[0, null]}})
@@ -78,8 +78,8 @@
 Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:23:5 -> BoolConstant(true)
 Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:25:5 -> BoolConstant(true)
 Evaluated: StaticInvocation @ org-dartlang-testcase:///constants.dart:27:5 -> BoolConstant(true)
-Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:18:12 -> TearOffConstant(identical)
-Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:19:48 -> PartialInstantiationConstant(id<int*>)
+Evaluated: StaticTearOff @ org-dartlang-testcase:///constants_lib.dart:18:12 -> StaticTearOffConstant(identical)
+Evaluated: Instantiation @ org-dartlang-testcase:///constants_lib.dart:19:48 -> InstantiationConstant(id<int*>)
 Evaluated: ConstructorInvocation @ org-dartlang-testcase:///constants_lib.dart:20:24 -> InstanceConstant(const Class<int*>{Class.field: 0})
 Evaluated: ListLiteral @ org-dartlang-testcase:///constants_lib.dart:21:26 -> ListConstant(const <int*>[0])
 Evaluated: SetLiteral @ org-dartlang-testcase:///constants_lib.dart:22:25 -> InstanceConstant(const _UnmodifiableSet<int*>{_UnmodifiableSet._map: const _ImmutableMap<int*, Null>{_ImmutableMap._kvPairs: const <dynamic>[0, null]}})
diff --git a/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect b/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect
index fd27fff..f510042 100644
--- a/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/rasta/static.dart.weak.transformed.expect
@@ -340,9 +340,9 @@
 
 Extra constant evaluation status:
 Evaluated: VariableGet @ org-dartlang-testcase:///static.dart:32:13 -> IntConstant(42)
-Evaluated: VariableGet @ org-dartlang-testcase:///static.dart:36:13 -> TearOffConstant(Foo.staticFunction)
+Evaluated: VariableGet @ org-dartlang-testcase:///static.dart:36:13 -> StaticTearOffConstant(Foo.staticFunction)
 Evaluated: ConditionalExpression @ org-dartlang-testcase:///static.dart:75:24 -> NullConstant(null)
 Evaluated: Let @ org-dartlang-testcase:///static.dart:76:28 -> IntConstant(42)
 Evaluated: ConditionalExpression @ org-dartlang-testcase:///static.dart:79:24 -> NullConstant(null)
-Evaluated: Let @ org-dartlang-testcase:///static.dart:80:28 -> TearOffConstant(Foo.staticFunction)
+Evaluated: Let @ org-dartlang-testcase:///static.dart:80:28 -> StaticTearOffConstant(Foo.staticFunction)
 Extra constant evaluation: evaluated: 122, effectively constant: 6
diff --git a/pkg/kernel/binary.md b/pkg/kernel/binary.md
index dfed538..4dd9aa7 100644
--- a/pkg/kernel/binary.md
+++ b/pkg/kernel/binary.md
@@ -147,7 +147,7 @@
 
 type ComponentFile {
   UInt32 magic = 0x90ABCDEF;
-  UInt32 formatVersion = 66;
+  UInt32 formatVersion = 67;
   Byte[10] shortSdkHash;
   List<String> problemsAsJson; // Described in problems.md.
   Library[] libraries;
@@ -707,6 +707,13 @@
   Option<List<DartType>> typeArguments;
 }
 
+type TypedefTearOff extends Expression {
+  Byte tag = 83;
+  List<TypeParameter> typeParameters;
+  Expression expression;
+  List<DartType> typeArguments;
+}
+
 type StaticSet extends Expression {
   Byte tag = 27;
   FileOffset fileOffset;
@@ -1179,13 +1186,13 @@
   List<Pair<FieldReference, ConstantReference>> values;
 }
 
-type PartialInstantiationConstant extends Constant {
+type InstantiationConstant extends Constant {
   Byte tag = 9;
   ConstantReference tearOffConstant;
   List<DartType> typeArguments;
 }
 
-type TearOffConstant extends Constant {
+type StaticTearOffConstant extends Constant {
   Byte tag = 10;
   CanonicalNameReference staticProcedureReference;
 }
@@ -1200,6 +1207,18 @@
   Expression expression;
 }
 
+type TypedefTearOffConstant extends Constant {
+  Byte tag = 14;
+  List<TypeParameter> parameters;
+  CanonicalNameReference staticProcedureReference;
+  List<DartType> types;
+}
+
+type ConstructorTearOffConstant extends Constant {
+  Byte tag = 15;
+  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 3e8f7b2..4a2284a 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -8659,6 +8659,82 @@
   }
 }
 
+class TypedefTearOff extends Expression {
+  final List<TypeParameter> typeParameters;
+  Expression expression;
+  final List<DartType> typeArguments;
+
+  TypedefTearOff(this.typeParameters, this.expression, this.typeArguments) {
+    expression.parent = this;
+    setParents(typeParameters, this);
+  }
+
+  @override
+  DartType getStaticTypeInternal(StaticTypeContext context) {
+    FreshTypeParameters freshTypeParameters =
+        getFreshTypeParameters(typeParameters);
+    FunctionType type = expression.getStaticType(context) as FunctionType;
+    type = Substitution.combine(
+            Substitution.fromPairs(type.typeParameters, typeArguments),
+            freshTypeParameters.substitution)
+        .substituteType(type.withoutTypeParameters) as FunctionType;
+    return new FunctionType(
+        type.positionalParameters, type.returnType, type.declaredNullability,
+        namedParameters: type.namedParameters,
+        typeParameters: freshTypeParameters.freshTypeParameters,
+        requiredParameterCount: type.requiredParameterCount,
+        typedefType: null);
+  }
+
+  @override
+  R accept<R>(ExpressionVisitor<R> v) => v.visitTypedefTearOff(this);
+
+  @override
+  R accept1<R, A>(ExpressionVisitor1<R, A> v, A arg) =>
+      v.visitTypedefTearOff(this, arg);
+
+  @override
+  void visitChildren(Visitor v) {
+    expression.accept(v);
+    visitList(typeParameters, v);
+    visitList(typeArguments, v);
+  }
+
+  @override
+  void transformChildren(Transformer v) {
+    // ignore: unnecessary_null_comparison
+    if (expression != null) {
+      expression = v.transform(expression);
+      expression.parent = this;
+    }
+    v.transformList(typeParameters, this);
+    v.transformDartTypeList(typeArguments);
+  }
+
+  @override
+  void transformOrRemoveChildren(RemovingTransformer v) {
+    // ignore: unnecessary_null_comparison
+    if (expression != null) {
+      expression = v.transform(expression);
+      expression.parent = this;
+    }
+    v.transformList(typeParameters, this, dummyTypeParameter);
+    v.transformDartTypeList(typeArguments);
+  }
+
+  @override
+  String toString() {
+    return "TypedefTearOff(${toStringInternal()})";
+  }
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    printer.writeExpression(expression);
+    printer.writeTypeParameters(typeParameters);
+    printer.writeTypeArguments(typeArguments);
+  }
+}
+
 // ------------------------------------------------------------------------
 //                              STATEMENTS
 // ------------------------------------------------------------------------
@@ -12777,21 +12853,20 @@
       new InterfaceType(classNode, context.nonNullable, typeArguments);
 }
 
-class PartialInstantiationConstant extends Constant {
+class InstantiationConstant extends Constant {
   final TearOffConstant tearOffConstant;
   final List<DartType> types;
 
-  PartialInstantiationConstant(this.tearOffConstant, this.types);
+  InstantiationConstant(this.tearOffConstant, this.types);
 
   visitChildren(Visitor v) {
     tearOffConstant.acceptReference(v);
     visitList(types, v);
   }
 
-  R accept<R>(ConstantVisitor<R> v) =>
-      v.visitPartialInstantiationConstant(this);
+  R accept<R>(ConstantVisitor<R> v) => v.visitInstantiationConstant(this);
   R acceptReference<R>(Visitor<R> v) =>
-      v.visitPartialInstantiationConstantReference(this);
+      v.visitInstantiationConstantReference(this);
 
   @override
   void toTextInternal(AstPrinter printer) {
@@ -12800,19 +12875,19 @@
   }
 
   @override
-  String toString() => 'PartialInstantiationConstant(${toStringInternal()})';
+  String toString() => 'InstantiationConstant(${toStringInternal()})';
 
   int get hashCode => _Hash.combineFinish(
       tearOffConstant.hashCode, _Hash.combineListHash(types));
 
   bool operator ==(Object other) {
-    return other is PartialInstantiationConstant &&
+    return other is InstantiationConstant &&
         other.tearOffConstant == tearOffConstant &&
         listEquals(other.types, types);
   }
 
   DartType getType(StaticTypeContext context) {
-    final FunctionType type = tearOffConstant.getType(context);
+    final FunctionType type = tearOffConstant.getType(context) as FunctionType;
     final Map<TypeParameter, DartType> mapping = <TypeParameter, DartType>{};
     for (final TypeParameter parameter in type.typeParameters) {
       mapping[parameter] = types[mapping.length];
@@ -12821,38 +12896,52 @@
   }
 }
 
-class TearOffConstant extends Constant {
-  final Reference procedureReference;
+abstract class TearOffConstant implements Constant {
+  Reference get memberReference;
+  Member get member;
+  FunctionNode get function;
+}
 
-  TearOffConstant(Procedure procedure)
-      : procedureReference = procedure.reference {
+class StaticTearOffConstant extends Constant implements TearOffConstant {
+  @override
+  final Reference memberReference;
+
+  StaticTearOffConstant(Procedure procedure)
+      : memberReference = procedure.reference {
     assert(procedure.isStatic);
   }
 
-  TearOffConstant.byReference(this.procedureReference);
+  StaticTearOffConstant.byReference(this.memberReference);
 
-  Procedure get procedure => procedureReference.asProcedure;
+  @override
+  Member get member => memberReference.asMember;
+
+  @override
+  FunctionNode get function => procedure.function;
+
+  Procedure get procedure => memberReference.asProcedure;
 
   visitChildren(Visitor v) {
-    procedureReference.asProcedure.acceptReference(v);
+    memberReference.asProcedure.acceptReference(v);
   }
 
-  R accept<R>(ConstantVisitor<R> v) => v.visitTearOffConstant(this);
-  R acceptReference<R>(Visitor<R> v) => v.visitTearOffConstantReference(this);
+  R accept<R>(ConstantVisitor<R> v) => v.visitStaticTearOffConstant(this);
+  R acceptReference<R>(Visitor<R> v) =>
+      v.visitStaticTearOffConstantReference(this);
 
   @override
   void toTextInternal(AstPrinter printer) {
-    printer.writeMemberName(procedureReference);
+    printer.writeMemberName(memberReference);
   }
 
   @override
-  String toString() => 'TearOffConstant(${toStringInternal()})';
+  String toString() => 'StaticTearOffConstant(${toStringInternal()})';
 
-  int get hashCode => procedureReference.hashCode;
+  int get hashCode => memberReference.hashCode;
 
   bool operator ==(Object other) {
-    return other is TearOffConstant &&
-        other.procedureReference == procedureReference;
+    return other is StaticTearOffConstant &&
+        other.memberReference == memberReference;
   }
 
   FunctionType getType(StaticTypeContext context) {
@@ -12860,6 +12949,114 @@
   }
 }
 
+class ConstructorTearOffConstant extends Constant implements TearOffConstant {
+  @override
+  final Reference memberReference;
+
+  ConstructorTearOffConstant(Constructor constructor)
+      : memberReference = constructor.reference;
+
+  ConstructorTearOffConstant.byReference(this.memberReference);
+
+  @override
+  Member get member => memberReference.asMember;
+
+  @override
+  FunctionNode get function => constructor.function;
+
+  Constructor get constructor => memberReference.asConstructor;
+
+  visitChildren(Visitor v) {
+    memberReference.asProcedure.acceptReference(v);
+  }
+
+  R accept<R>(ConstantVisitor<R> v) => v.visitConstructorTearOffConstant(this);
+  R acceptReference<R>(Visitor<R> v) =>
+      v.visitConstructorTearOffConstantReference(this);
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    printer.writeMemberName(memberReference);
+  }
+
+  @override
+  String toString() => 'ConstructorTearOffConstant(${toStringInternal()})';
+
+  int get hashCode => memberReference.hashCode;
+
+  bool operator ==(Object other) {
+    return other is StaticTearOffConstant &&
+        other.memberReference == memberReference;
+  }
+
+  FunctionType getType(StaticTypeContext context) {
+    return constructor.function.computeFunctionType(context.nonNullable);
+  }
+}
+
+class TypedefTearOffConstant extends Constant {
+  final List<TypeParameter> parameters;
+  final TearOffConstant tearOffConstant;
+  final List<DartType> types;
+
+  TypedefTearOffConstant(this.parameters, this.tearOffConstant, this.types);
+
+  visitChildren(Visitor v) {
+    visitList(parameters, v);
+    tearOffConstant.acceptReference(v);
+    visitList(types, v);
+  }
+
+  R accept<R>(ConstantVisitor<R> v) => v.visitTypedefTearOffConstant(this);
+  R acceptReference<R>(Visitor<R> v) => v.visitTypedefTearOffConstant(this);
+
+  @override
+  void toTextInternal(AstPrinter printer) {
+    printer.writeConstant(tearOffConstant);
+    printer.writeTypeParameters(parameters);
+    printer.writeTypeArguments(types);
+  }
+
+  @override
+  String toString() => 'TypedefTearOffConstant(${toStringInternal()})';
+
+  bool operator ==(Object other) {
+    if (other is! TypedefTearOffConstant) return false;
+    if (other.tearOffConstant != tearOffConstant) return false;
+    if (other.parameters.length != parameters.length) return false;
+    if (parameters.isNotEmpty) {
+      Map<TypeParameter, DartType> substitutionMap =
+          <TypeParameter, DartType>{};
+      for (int i = 0; i < parameters.length; ++i) {
+        substitutionMap[parameters[i]] = new TypeParameterType.forAlphaRenaming(
+            other.parameters[i], parameters[i]);
+      }
+      Substitution substitution = Substitution.fromMap(substitutionMap);
+      for (int i = 0; i < parameters.length; ++i) {
+        if (types[i] != substitution.substituteType(other.types[i])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  DartType getType(StaticTypeContext context) {
+    FunctionType type = tearOffConstant.getType(context) as FunctionType;
+    FreshTypeParameters freshTypeParameters =
+        getFreshTypeParameters(parameters);
+    type = freshTypeParameters.substitute(
+            Substitution.fromPairs(parameters, types).substituteType(type))
+        as FunctionType;
+    return new FunctionType(
+        type.positionalParameters, type.returnType, type.declaredNullability,
+        namedParameters: type.namedParameters,
+        typeParameters: freshTypeParameters.freshTypeParameters,
+        requiredParameterCount: type.requiredParameterCount,
+        typedefType: null);
+  }
+}
+
 class TypeLiteralConstant extends Constant {
   final DartType type;
 
diff --git a/pkg/kernel/lib/binary/ast_from_binary.dart b/pkg/kernel/lib/binary/ast_from_binary.dart
index 54b51cc..a257708 100644
--- a/pkg/kernel/lib/binary/ast_from_binary.dart
+++ b/pkg/kernel/lib/binary/ast_from_binary.dart
@@ -365,10 +365,14 @@
         return _readSetConstant();
       case ConstantTag.InstanceConstant:
         return _readInstanceConstant();
-      case ConstantTag.PartialInstantiationConstant:
-        return _readPartialInstantiationConstant();
-      case ConstantTag.TearOffConstant:
-        return _readTearOffConstant();
+      case ConstantTag.InstantiationConstant:
+        return _readInstantiationConstant();
+      case ConstantTag.TypedefTearOffConstant:
+        return _readTypedefTearOffConstant();
+      case ConstantTag.StaticTearOffConstant:
+        return _readStaticTearOffConstant();
+      case ConstantTag.ConstructorTearOffConstant:
+        return _readConstructorTearOffConstant();
       case ConstantTag.TypeLiteralConstant:
         return _readTypeLiteralConstant();
       case ConstantTag.UnevaluatedConstant:
@@ -441,16 +445,29 @@
     return new InstanceConstant(classReference, typeArguments, fieldValues);
   }
 
-  Constant _readPartialInstantiationConstant() {
-    final TearOffConstant tearOffConstant =
-        readConstantReference() as TearOffConstant;
+  Constant _readInstantiationConstant() {
+    final StaticTearOffConstant tearOffConstant =
+        readConstantReference() as StaticTearOffConstant;
     final List<DartType> types = readDartTypeList();
-    return new PartialInstantiationConstant(tearOffConstant, types);
+    return new InstantiationConstant(tearOffConstant, types);
   }
 
-  Constant _readTearOffConstant() {
+  Constant _readTypedefTearOffConstant() {
+    final List<TypeParameter> parameters = readAndPushTypeParameterList();
+    final StaticTearOffConstant tearOffConstant =
+        readConstantReference() as StaticTearOffConstant;
+    final List<DartType> types = readDartTypeList();
+    return new TypedefTearOffConstant(parameters, tearOffConstant, types);
+  }
+
+  Constant _readStaticTearOffConstant() {
     final Reference reference = readNonNullCanonicalNameReference().reference;
-    return new TearOffConstant.byReference(reference);
+    return new StaticTearOffConstant.byReference(reference);
+  }
+
+  Constant _readConstructorTearOffConstant() {
+    final Reference reference = readNonNullCanonicalNameReference().reference;
+    return new ConstructorTearOffConstant.byReference(reference);
   }
 
   Constant _readTypeLiteralConstant() {
@@ -1968,6 +1985,8 @@
         return _readStaticSet();
       case Tag.ConstructorTearOff:
         return _readConstructorTearOff();
+      case Tag.TypedefTearOff:
+        return _readTypedefTearOff();
       case Tag.MethodInvocation:
         return _readMethodInvocation();
       case Tag.InstanceInvocation:
@@ -2204,6 +2223,14 @@
       ..fileOffset = offset;
   }
 
+  Expression _readTypedefTearOff() {
+    List<TypeParameter> typeParameters = readAndPushTypeParameterList();
+    Expression expression = readExpression();
+    List<DartType> typeArguments = readDartTypeList();
+    typeParameterStack.length -= typeParameters.length;
+    return new TypedefTearOff(typeParameters, expression, typeArguments);
+  }
+
   Expression _readStaticTearOff() {
     int offset = readOffset();
     return new StaticTearOff.byReference(readNonNullMemberReference())
diff --git a/pkg/kernel/lib/binary/ast_to_binary.dart b/pkg/kernel/lib/binary/ast_to_binary.dart
index 01e46ba..5460a6e 100644
--- a/pkg/kernel/lib/binary/ast_to_binary.dart
+++ b/pkg/kernel/lib/binary/ast_to_binary.dart
@@ -253,24 +253,39 @@
         writeNonNullCanonicalNameReference(fieldRef.canonicalName!);
         writeConstantReference(value);
       });
-    } else if (constant is PartialInstantiationConstant) {
-      writeByte(ConstantTag.PartialInstantiationConstant);
+    } else if (constant is InstantiationConstant) {
+      writeByte(ConstantTag.InstantiationConstant);
       writeConstantReference(constant.tearOffConstant);
       final int length = constant.types.length;
       writeUInt30(length);
       for (int i = 0; i < length; ++i) {
         writeDartType(constant.types[i]);
       }
-    } else if (constant is TearOffConstant) {
-      writeByte(ConstantTag.TearOffConstant);
+    } else if (constant is StaticTearOffConstant) {
+      writeByte(ConstantTag.StaticTearOffConstant);
       writeNonNullCanonicalNameReference(
           constant.procedure.reference.canonicalName!);
+    } else if (constant is ConstructorTearOffConstant) {
+      writeByte(ConstantTag.ConstructorTearOffConstant);
+      writeNonNullCanonicalNameReference(
+          constant.constructor.reference.canonicalName!);
     } else if (constant is TypeLiteralConstant) {
       writeByte(ConstantTag.TypeLiteralConstant);
       writeDartType(constant.type);
     } else if (constant is UnevaluatedConstant) {
       writeByte(ConstantTag.UnevaluatedConstant);
       writeNode(constant.expression);
+    } else if (constant is TypedefTearOffConstant) {
+      writeByte(ConstantTag.TypedefTearOffConstant);
+      enterScope(typeParameters: constant.parameters);
+      writeNodeList(constant.parameters);
+      writeConstantReference(constant.tearOffConstant);
+      final int length = constant.types.length;
+      writeUInt30(length);
+      for (int i = 0; i < length; ++i) {
+        writeDartType(constant.types[i]);
+      }
+      leaveScope(typeParameters: constant.parameters);
     } else {
       throw new ArgumentError('Unsupported constant $constant');
     }
@@ -1598,6 +1613,14 @@
   }
 
   @override
+  void visitTypedefTearOff(TypedefTearOff node) {
+    writeByte(Tag.TypedefTearOff);
+    writeNodeList(node.typeParameters);
+    writeNode(node.expression);
+    writeNodeList(node.typeArguments);
+  }
+
+  @override
   void visitStaticTearOff(StaticTearOff node) {
     writeByte(Tag.StaticTearOff);
     writeOffset(node.fileOffset);
@@ -2689,26 +2712,42 @@
   }
 
   @override
-  void visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+  void visitInstantiationConstant(InstantiationConstant node) {
+    throw new UnsupportedError('serialization of InstantiationConstants ');
+  }
+
+  @override
+  void visitInstantiationConstantReference(InstantiationConstant node) {
     throw new UnsupportedError(
-        'serialization of PartialInstantiationConstants ');
+        'serialization of InstantiationConstant references');
   }
 
   @override
-  void visitPartialInstantiationConstantReference(
-      PartialInstantiationConstant node) {
+  void visitTypedefTearOffConstant(TypedefTearOffConstant node) {
+    throw new UnsupportedError('serialization of TypedefTearOffConstants ');
+  }
+
+  @override
+  void visitStaticTearOffConstant(StaticTearOffConstant node) {
+    throw new UnsupportedError('serialization of StaticTearOffConstants ');
+  }
+
+  @override
+  void visitConstructorTearOffConstant(ConstructorTearOffConstant node) {
+    throw new UnsupportedError('serialization of ConstructorTearOffConstants ');
+  }
+
+  @override
+  void visitStaticTearOffConstantReference(StaticTearOffConstant node) {
     throw new UnsupportedError(
-        'serialization of PartialInstantiationConstant references');
+        'serialization of StaticTearOffConstant references');
   }
 
   @override
-  void visitTearOffConstant(TearOffConstant node) {
-    throw new UnsupportedError('serialization of TearOffConstants ');
-  }
-
-  @override
-  void visitTearOffConstantReference(TearOffConstant node) {
-    throw new UnsupportedError('serialization of TearOffConstant references');
+  void visitConstructorTearOffConstantReference(
+      ConstructorTearOffConstant node) {
+    throw new UnsupportedError(
+        'serialization of ConstructorTearOffConstant references');
   }
 
   @override
diff --git a/pkg/kernel/lib/binary/tag.dart b/pkg/kernel/lib/binary/tag.dart
index 9c0d0f9..e5291c5 100644
--- a/pkg/kernel/lib/binary/tag.dart
+++ b/pkg/kernel/lib/binary/tag.dart
@@ -77,6 +77,7 @@
   static const int ConstListLiteral = 58;
   static const int ConstMapLiteral = 59;
   static const int ConstructorTearOff = 60;
+  static const int TypedefTearOff = 83;
 
   static const int SetLiteral = 109;
   static const int ConstSetLiteral = 110;
@@ -123,6 +124,7 @@
   static const int AsyncForInStatement = 80;
   static const int AssertBlock = 81;
   // 82 is occupied by [BlockExpression] (expression).
+  // 83 is occupied by [TypedefTearOff] (expression).
 
   // Types
   static const int TypedefType = 87;
@@ -175,7 +177,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 = 66;
+  static const int BinaryFormatVersion = 67;
 }
 
 abstract class ConstantTag {
@@ -189,11 +191,13 @@
   static const int ListConstant = 7;
   static const int SetConstant = 13;
   static const int InstanceConstant = 8;
-  static const int PartialInstantiationConstant = 9;
-  static const int TearOffConstant = 10;
+  static const int InstantiationConstant = 9;
+  static const int StaticTearOffConstant = 10;
   static const int TypeLiteralConstant = 11;
   static const int UnevaluatedConstant = 12;
   // 13 is occupied by [SetConstant]
+  static const int TypedefTearOffConstant = 14;
+  static const int ConstructorTearOffConstant = 15;
 }
 
 const int sdkHashLength = 10; // Bytes, a Git "short hash".
diff --git a/pkg/kernel/lib/clone.dart b/pkg/kernel/lib/clone.dart
index efbe399..86e78d6 100644
--- a/pkg/kernel/lib/clone.dart
+++ b/pkg/kernel/lib/clone.dart
@@ -507,7 +507,7 @@
     }
   }
 
-  visitTypeParameter(TypeParameter node) {
+  TypeParameter visitTypeParameter(TypeParameter node) {
     TypeParameter newNode = typeParams[node]!;
     newNode.bound = visitType(node.bound);
     // ignore: unnecessary_null_comparison
@@ -740,6 +740,15 @@
   TreeNode visitConstructorTearOff(ConstructorTearOff node) {
     return new ConstructorTearOff.byReference(node.constructorReference);
   }
+
+  @override
+  TreeNode visitTypedefTearOff(TypedefTearOff node) {
+    prepareTypeParameters(node.typeParameters);
+    return new TypedefTearOff(
+        node.typeParameters.map(visitTypeParameter).toList(),
+        clone(node.expression),
+        node.typeArguments.map(visitType).toList());
+  }
 }
 
 /// Visitor that return a clone of a tree, maintaining references to cloned
diff --git a/pkg/kernel/lib/text/ast_to_text.dart b/pkg/kernel/lib/text/ast_to_text.dart
index 0017fd4..b9ab3da 100644
--- a/pkg/kernel/lib/text/ast_to_text.dart
+++ b/pkg/kernel/lib/text/ast_to_text.dart
@@ -49,7 +49,7 @@
           // Name everything in post-order visit of DAG.
           getName(value);
         }
-      } else if (constant is TearOffConstant) {
+      } else if (constant is StaticTearOffConstant) {
         // We only care about naming the constants themselves. [TearOffConstant]
         // has no Constant children.
         // Avoid visiting `TearOffConstant.procedureReference`.
@@ -2659,13 +2659,13 @@
     endLine('}');
   }
 
-  visitPartialInstantiationConstant(PartialInstantiationConstant node) {
+  visitInstantiationConstant(InstantiationConstant node) {
     writeIndentation();
     writeConstantReference(node);
     writeSpaced('=');
     writeWord('partial-instantiation');
     writeSpace();
-    writeMemberReferenceFromReference(node.tearOffConstant.procedureReference);
+    writeMemberReferenceFromReference(node.tearOffConstant.memberReference);
     writeSpace();
     writeSymbol('<');
     writeList(node.types, writeType);
@@ -2680,13 +2680,13 @@
     endLine('"${escapeString(node.value)}"');
   }
 
-  visitTearOffConstant(TearOffConstant node) {
+  visitStaticTearOffConstant(StaticTearOffConstant node) {
     writeIndentation();
     writeConstantReference(node);
     writeSpaced('=');
     writeWord('tearoff');
     writeSpace();
-    writeMemberReferenceFromReference(node.procedureReference);
+    writeMemberReferenceFromReference(node.memberReference);
     endLine();
   }
 
@@ -2906,6 +2906,9 @@
   int visitConstructorTearOff(ConstructorTearOff node) => PRIMARY;
 
   @override
+  int visitTypedefTearOff(TypedefTearOff node) => EXPRESSION;
+
+  @override
   int visitLet(Let node) => EXPRESSION;
 
   @override
diff --git a/pkg/kernel/lib/text/text_serializer.dart b/pkg/kernel/lib/text/text_serializer.dart
index c96bed2..0c4f26e 100644
--- a/pkg/kernel/lib/text/text_serializer.dart
+++ b/pkg/kernel/lib/text/text_serializer.dart
@@ -2204,12 +2204,13 @@
   String visitListConstant(ListConstant node) => "const-list";
   String visitMapConstant(MapConstant node) => "const-map";
   String visitNullConstant(NullConstant node) => "const-null";
-  String visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+  String visitInstantiationConstant(InstantiationConstant node) =>
       "const-apply";
   String visitSetConstant(SetConstant node) => "const-set";
   String visitStringConstant(StringConstant node) => "const-string";
   String visitSymbolConstant(SymbolConstant node) => "const-symbol";
-  String visitTearOffConstant(TearOffConstant node) => "const-tearoff";
+  String visitStaticTearOffConstant(StaticTearOffConstant node) =>
+      "const-tearoff";
   String visitTypeLiteralConstant(TypeLiteralConstant node) => "const-type";
   String visitUnevaluatedConstant(UnevaluatedConstant node) => "const-expr";
 
@@ -2254,12 +2255,10 @@
 TextSerializer<NullConstant> nullConstantSerializer =
     Wrapped<void, NullConstant>((w) => null, (u) => NullConstant(), Nothing());
 
-TextSerializer<PartialInstantiationConstant>
-    partialInstantiationConstantSerializer = Wrapped<
-            Tuple2<TearOffConstant, List<DartType>>,
-            PartialInstantiationConstant>(
+TextSerializer<InstantiationConstant> instantiationConstantSerializer =
+    Wrapped<Tuple2<TearOffConstant, List<DartType>>, InstantiationConstant>(
         (w) => Tuple2(w.tearOffConstant, w.types),
-        (u) => PartialInstantiationConstant(u.first, u.second),
+        (u) => InstantiationConstant(u.first, u.second),
         Tuple2Serializer(
             tearOffConstantSerializer, ListSerializer(dartTypeSerializer)));
 
@@ -2280,10 +2279,10 @@
         (u) => SymbolConstant(u.first, u.second?.reference),
         Tuple2Serializer(DartString(), Optional(CanonicalNameSerializer())));
 
-TextSerializer<TearOffConstant> tearOffConstantSerializer =
-    Wrapped<CanonicalName, TearOffConstant>(
-        (w) => w.procedureReference.canonicalName!,
-        (u) => TearOffConstant.byReference(u.reference),
+TextSerializer<StaticTearOffConstant> tearOffConstantSerializer =
+    Wrapped<CanonicalName, StaticTearOffConstant>(
+        (w) => w.memberReference.canonicalName!,
+        (u) => StaticTearOffConstant.byReference(u.reference),
         CanonicalNameSerializer());
 
 TextSerializer<TypeLiteralConstant> typeLiteralConstantSerializer =
@@ -2656,7 +2655,7 @@
     "const-list": listConstantSerializer,
     "const-map": mapConstantSerializer,
     "const-null": nullConstantSerializer,
-    "const-apply": partialInstantiationConstantSerializer,
+    "const-apply": instantiationConstantSerializer,
     "const-set": setConstantSerializer,
     "const-string": stringConstantSerializer,
     "const-symbol": symbolConstantSerializer,
diff --git a/pkg/kernel/lib/type_checker.dart b/pkg/kernel/lib/type_checker.dart
index 777875d..af4d5e3 100644
--- a/pkg/kernel/lib/type_checker.dart
+++ b/pkg/kernel/lib/type_checker.dart
@@ -526,6 +526,31 @@
   }
 
   @override
+  DartType visitTypedefTearOff(TypedefTearOff node) {
+    DartType type = visitExpression(node.expression);
+    if (type is! FunctionType) {
+      fail(node, 'Not a function type: $type');
+      return NeverType.fromNullability(currentLibrary!.nonNullable);
+    }
+    FunctionType functionType = type;
+    if (functionType.typeParameters.length != node.typeArguments.length) {
+      fail(node, 'Wrong number of type arguments');
+      return NeverType.fromNullability(currentLibrary!.nonNullable);
+    }
+    FreshTypeParameters freshTypeParameters =
+        getFreshTypeParameters(node.typeParameters);
+    FunctionType result = freshTypeParameters.substitute(_instantiateFunction(
+            functionType.typeParameters, node.typeArguments, node)
+        .substituteType(functionType.withoutTypeParameters)) as FunctionType;
+    return new FunctionType(result.positionalParameters, result.returnType,
+        result.declaredNullability,
+        namedParameters: result.namedParameters,
+        typeParameters: freshTypeParameters.freshTypeParameters,
+        requiredParameterCount: result.requiredParameterCount,
+        typedefType: null);
+  }
+
+  @override
   DartType visitListLiteral(ListLiteral node) {
     for (int i = 0; i < node.expressions.length; ++i) {
       node.expressions[i] =
diff --git a/pkg/kernel/lib/visitor.dart b/pkg/kernel/lib/visitor.dart
index ae31864b..1f71e2c 100644
--- a/pkg/kernel/lib/visitor.dart
+++ b/pkg/kernel/lib/visitor.dart
@@ -82,6 +82,7 @@
   R visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) =>
       defaultExpression(node);
   R visitConstructorTearOff(ConstructorTearOff node) => defaultExpression(node);
+  R visitTypedefTearOff(TypedefTearOff node) => defaultExpression(node);
 }
 
 abstract class StatementVisitor<R> {
@@ -257,6 +258,7 @@
   R visitCheckLibraryIsLoaded(CheckLibraryIsLoaded node) =>
       defaultExpression(node);
   R visitConstructorTearOff(ConstructorTearOff node) => defaultExpression(node);
+  R visitTypedefTearOff(TypedefTearOff node) => defaultExpression(node);
 
   // Statements
   R defaultStatement(Statement node) => defaultTreeNode(node);
@@ -434,6 +436,8 @@
       defaultExpression(node, arg);
   R visitConstructorTearOff(ConstructorTearOff node, A arg) =>
       defaultExpression(node, arg);
+  R visitTypedefTearOff(TypedefTearOff node, A arg) =>
+      defaultExpression(node, arg);
 
   // Statements
   R defaultStatement(Statement node, A arg) => defaultTreeNode(node, arg);
@@ -577,9 +581,14 @@
   R visitListConstant(ListConstant node) => defaultConstant(node);
   R visitSetConstant(SetConstant node) => defaultConstant(node);
   R visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
-  R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+  R visitInstantiationConstant(InstantiationConstant node) =>
       defaultConstant(node);
-  R visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+  R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+      defaultConstant(node);
+  R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+      defaultConstant(node);
+  R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+      defaultConstant(node);
   R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
   R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
 }
@@ -597,8 +606,10 @@
   R visitListConstant(ListConstant node);
   R visitSetConstant(SetConstant node);
   R visitInstanceConstant(InstanceConstant node);
-  R visitPartialInstantiationConstant(PartialInstantiationConstant node);
-  R visitTearOffConstant(TearOffConstant node);
+  R visitInstantiationConstant(InstantiationConstant node);
+  R visitTypedefTearOffConstant(TypedefTearOffConstant node);
+  R visitStaticTearOffConstant(StaticTearOffConstant node);
+  R visitConstructorTearOffConstant(ConstructorTearOffConstant node);
   R visitTypeLiteralConstant(TypeLiteralConstant node);
   R visitUnevaluatedConstant(UnevaluatedConstant node);
 }
@@ -617,12 +628,20 @@
       _callback.visitTypeLiteralConstant(node);
 
   @override
-  R visitTearOffConstant(TearOffConstant node) =>
-      _callback.visitTearOffConstant(node);
+  R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+      _callback.visitStaticTearOffConstant(node);
 
   @override
-  R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
-      _callback.visitPartialInstantiationConstant(node);
+  R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+      _callback.visitConstructorTearOffConstant(node);
+
+  @override
+  R visitInstantiationConstant(InstantiationConstant node) =>
+      _callback.visitInstantiationConstant(node);
+
+  @override
+  R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+      _callback.visitTypedefTearOffConstant(node);
 
   @override
   R visitInstanceConstant(InstanceConstant node) =>
@@ -703,9 +722,14 @@
   R visitListConstant(ListConstant node) => defaultConstant(node);
   R visitSetConstant(SetConstant node) => defaultConstant(node);
   R visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
-  R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+  R visitInstantiationConstant(InstantiationConstant node) =>
       defaultConstant(node);
-  R visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+  R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+      defaultConstant(node);
+  R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+      defaultConstant(node);
+  R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+      defaultConstant(node);
   R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
   R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
 }
@@ -744,9 +768,12 @@
   void visitListConstant(ListConstant node) => defaultConstant(node);
   void visitSetConstant(SetConstant node) => defaultConstant(node);
   void visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
-  void visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+  void visitInstantiationConstant(InstantiationConstant node) =>
       defaultConstant(node);
-  void visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+  void visitStaticTearOffConstant(StaticTearOffConstant node) =>
+      defaultConstant(node);
+  void visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+      defaultConstant(node);
   void visitTypeLiteralConstant(TypeLiteralConstant node) =>
       defaultConstant(node);
   void visitUnevaluatedConstant(UnevaluatedConstant node) =>
@@ -804,9 +831,14 @@
   R visitListConstant(ListConstant node) => defaultConstant(node);
   R visitSetConstant(SetConstant node) => defaultConstant(node);
   R visitInstanceConstant(InstanceConstant node) => defaultConstant(node);
-  R visitPartialInstantiationConstant(PartialInstantiationConstant node) =>
+  R visitInstantiationConstant(InstantiationConstant node) =>
       defaultConstant(node);
-  R visitTearOffConstant(TearOffConstant node) => defaultConstant(node);
+  R visitTypedefTearOffConstant(TypedefTearOffConstant node) =>
+      defaultConstant(node);
+  R visitStaticTearOffConstant(StaticTearOffConstant node) =>
+      defaultConstant(node);
+  R visitConstructorTearOffConstant(ConstructorTearOffConstant node) =>
+      defaultConstant(node);
   R visitTypeLiteralConstant(TypeLiteralConstant node) => defaultConstant(node);
   R visitUnevaluatedConstant(UnevaluatedConstant node) => defaultConstant(node);
 
@@ -840,10 +872,11 @@
       defaultConstantReference(node);
   R visitInstanceConstantReference(InstanceConstant node) =>
       defaultConstantReference(node);
-  R visitPartialInstantiationConstantReference(
-          PartialInstantiationConstant node) =>
+  R visitInstantiationConstantReference(InstantiationConstant node) =>
       defaultConstantReference(node);
-  R visitTearOffConstantReference(TearOffConstant node) =>
+  R visitStaticTearOffConstantReference(StaticTearOffConstant node) =>
+      defaultConstantReference(node);
+  R visitConstructorTearOffConstantReference(ConstructorTearOffConstant node) =>
       defaultConstantReference(node);
   R visitTypeLiteralConstantReference(TypeLiteralConstant node) =>
       defaultConstantReference(node);
@@ -1548,6 +1581,8 @@
       defaultExpression(node, arg);
   R visitConstructorTearOff(ConstructorTearOff node, T arg) =>
       defaultExpression(node, arg);
+  R visitTypedefTearOff(TypedefTearOff node, T arg) =>
+      defaultExpression(node, arg);
 }
 
 abstract class StatementVisitor1<R, T> {
diff --git a/pkg/vm/lib/transformations/ffi_use_sites.dart b/pkg/vm/lib/transformations/ffi_use_sites.dart
index 8cce3b0..4600fde 100644
--- a/pkg/vm/lib/transformations/ffi_use_sites.dart
+++ b/pkg/vm/lib/transformations/ffi_use_sites.dart
@@ -770,7 +770,8 @@
 
   void _ensureIsStaticFunction(Expression node) {
     if ((node is StaticGet && node.target is Procedure) ||
-        (node is ConstantExpression && node.constant is TearOffConstant)) {
+        (node is ConstantExpression &&
+            node.constant is StaticTearOffConstant)) {
       return;
     }
     diagnosticReporter.report(
diff --git a/pkg/vm/lib/transformations/type_flow/summary_collector.dart b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
index 0986d7e..fac8e00 100644
--- a/pkg/vm/lib/transformations/type_flow/summary_collector.dart
+++ b/pkg/vm/lib/transformations/type_flow/summary_collector.dart
@@ -2474,17 +2474,20 @@
   }
 
   @override
-  Type visitTearOffConstant(TearOffConstant constant) {
-    final Procedure procedure = constant.procedure;
+  Type visitStaticTearOffConstant(StaticTearOffConstant constant) {
+    final Member member = constant.procedure;
     summaryCollector._entryPointsListener
-        .addRawCall(new DirectSelector(procedure));
-    summaryCollector._entryPointsListener.recordTearOff(procedure);
+        .addRawCall(new DirectSelector(member));
+    if (member is Constructor) {
+      summaryCollector._entryPointsListener
+          .addAllocatedClass(member.enclosingClass);
+    }
+    summaryCollector._entryPointsListener.recordTearOff(member);
     return _getStaticType(constant);
   }
 
   @override
-  Type visitPartialInstantiationConstant(
-      PartialInstantiationConstant constant) {
+  Type visitInstantiationConstant(InstantiationConstant constant) {
     constant.tearOffConstant.accept(this);
     return _getStaticType(constant);
   }
diff --git a/pkg/vm/lib/transformations/type_flow/transformer.dart b/pkg/vm/lib/transformations/type_flow/transformer.dart
index 47cce1b..e9473dd 100644
--- a/pkg/vm/lib/transformations/type_flow/transformer.dart
+++ b/pkg/vm/lib/transformations/type_flow/transformer.dart
@@ -1794,12 +1794,12 @@
   }
 
   @override
-  visitTearOffConstant(TearOffConstant constant) {
+  visitStaticTearOffConstant(StaticTearOffConstant constant) {
     shaker.addUsedMember(constant.procedure);
   }
 
   @override
-  visitPartialInstantiationConstant(PartialInstantiationConstant constant) {
+  visitInstantiationConstant(InstantiationConstant constant) {
     analyzeConstant(constant.tearOffConstant);
   }
 
diff --git a/runtime/vm/compiler/frontend/constant_reader.cc b/runtime/vm/compiler/frontend/constant_reader.cc
index a9bd54f..f2c7656 100644
--- a/runtime/vm/compiler/frontend/constant_reader.cc
+++ b/runtime/vm/compiler/frontend/constant_reader.cc
@@ -310,7 +310,7 @@
       }
       break;
     }
-    case kPartialInstantiationConstant: {
+    case kInstantiationConstant: {
       // Recurse into lazily evaluating the "sub" constant
       // needed to evaluate the current constant.
       const intptr_t entry_index = reader.ReadUInt();
@@ -345,7 +345,7 @@
                               type_arguments, function, context, Heap::kOld);
       break;
     }
-    case kTearOffConstant: {
+    case kStaticTearOffConstant: {
       const NameIndex index = reader.ReadCanonicalNameReference();
       Function& function =
           Function::Handle(Z, H.LookupStaticMethodByKernelProcedure(index));
diff --git a/runtime/vm/kernel_binary.h b/runtime/vm/kernel_binary.h
index 1c55440..57b229a 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 = 66;
-static const uint32_t kMaxSupportedKernelFormatVersion = 66;
+static const uint32_t kMinSupportedKernelFormatVersion = 67;
+static const uint32_t kMaxSupportedKernelFormatVersion = 67;
 
 // Keep in sync with package:kernel/lib/binary/tag.dart
 #define KERNEL_TAG_LIST(V)                                                     \
@@ -97,6 +97,7 @@
   V(ConstSetLiteral, 110)                                                      \
   V(ConstMapLiteral, 59)                                                       \
   V(ConstructorTearOff, 60)                                                    \
+  V(TypedefTearOff, 83)                                                        \
   V(ExpressionStatement, 61)                                                   \
   V(Block, 62)                                                                 \
   V(EmptyStatement, 63)                                                        \
@@ -166,12 +167,14 @@
   kListConstant = 7,
   kSetConstant = 13,
   kInstanceConstant = 8,
-  kPartialInstantiationConstant = 9,
-  kTearOffConstant = 10,
+  kInstantiationConstant = 9,
+  kStaticTearOffConstant = 10,
   kTypeLiteralConstant = 11,
   // These constants are not expected to be seen by the VM, because all
   // constants are fully evaluated.
   kUnevaluatedConstant = 12,
+  kTypedefTearOffConstant = 14,
+  kConstructorTearOffConstant = 15,
 };
 
 // Keep in sync with package:kernel/lib/ast.dart
diff --git a/tools/VERSION b/tools/VERSION
index 4a7410b..d53fa3f 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 260
+PRERELEASE 261
 PRERELEASE_PATCH 0
\ No newline at end of file