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 5bc55d2..840ea47 100644
--- a/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/constant_evaluator.dart
@@ -726,10 +726,10 @@
     Instantiation result =
         super.visitInstantiation(node, removalSentinel) as Instantiation;
     Expression expression = result.expression;
-    if (enableConstructorTearOff && expression is ConstantExpression) {
+    if (expression is ConstantExpression) {
       if (result.typeArguments.every(isInstantiated)) {
         return evaluateAndTransformWithContext(node, result);
-      } else {
+      } else if (enableConstructorTearOff) {
         Constant constant = expression.constant;
         if (constant is TypedefTearOffConstant) {
           Substitution substitution =
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart
index 955feff..f60235a 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart
@@ -2,15 +2,6 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// @dart=2.13
-
-// This test is similar to
-//
-//   constructor_tearoffs/identical_instantiated_function_tearoffs.dart
-//
-// but verifies that before the constructor-tearoffs experiment was enabled,
-// instantiations in non-constant context were not canonicalized.
-
 T id<T>(T t) => t;
 
 int Function(int) implicitInstantiation = id;
@@ -20,10 +11,10 @@
 
 main() {
   expect(true, identical(implicitInstantiation, implicitInstantiation));
-  expect(false, identical(implicitInstantiation, implicitConstInstantiation));
+  expect(true, identical(implicitInstantiation, implicitConstInstantiation));
   expect(false, identical(implicitInstantiation, create<int>()));
 
-  expect(false, identical(implicitConstInstantiation, implicitInstantiation));
+  expect(true, identical(implicitConstInstantiation, implicitInstantiation));
   expect(
       true, identical(implicitConstInstantiation, implicitConstInstantiation));
   expect(false, identical(implicitConstInstantiation, create<int>()));
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline.expect b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline.expect
index 90e26eb..42d4b37 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline.expect
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline.expect
@@ -1,4 +1,3 @@
-// @dart = 2.13
 T id<T>(T t) => t;
 int Function(int) implicitInstantiation = id;
 const int Function(int) implicitConstInstantiation = id;
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline_modelled.expect b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline_modelled.expect
index a0e9251..9a6b746 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline_modelled.expect
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.textual_outline_modelled.expect
@@ -1,4 +1,3 @@
-// @dart = 2.13
 T Function(T) create<T>() => id;
 T id<T>(T t) => t;
 const int Function(int) implicitConstInstantiation = id;
diff --git a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.expect b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.expect
index db34700..1f6296f 100644
--- a/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.expect
+++ b/pkg/front_end/testcases/general/identical_instantiated_function_tearoffs.dart.weak.expect
@@ -2,7 +2,7 @@
 import self as self;
 import "dart:core" as core;
 
-static field (core::int) → core::int implicitInstantiation = #C1<core::int>;
+static field (core::int) → core::int implicitInstantiation = #C2;
 static const field (core::int) → core::int implicitConstInstantiation = #C2;
 static method id<T extends core::Object? = dynamic>(self::id::T% t) → self::id::T%
   return t;
@@ -10,9 +10,9 @@
   return #C1<self::create::T%>;
 static method main() → dynamic {
   self::expect(true, core::identical(self::implicitInstantiation, self::implicitInstantiation));
-  self::expect(false, core::identical(self::implicitInstantiation, #C2));
+  self::expect(true, core::identical(self::implicitInstantiation, #C2));
   self::expect(false, core::identical(self::implicitInstantiation, self::create<core::int>()));
-  self::expect(false, core::identical(#C2, self::implicitInstantiation));
+  self::expect(true, core::identical(#C2, self::implicitInstantiation));
   self::expect(true, core::identical(#C2, #C2));
   self::expect(false, core::identical(#C2, self::create<core::int>()));
 }
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 9e4506e..bf07e2b 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 -> InstantiationConstant(id<int*>)
+Evaluated: Instantiation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:8: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 acbe826..6aa6e81 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
@@ -2,7 +2,7 @@
 import self as self;
 import "dart:core" as core;
 
-static field (core::int) → core::int implicitInstantiation = #C1<core::int>;
+static field (core::int) → core::int implicitInstantiation = #C2;
 static const field (core::int) → core::int implicitConstInstantiation = #C2;
 static method id<T extends core::Object? = dynamic>(self::id::T% t) → self::id::T%
   return t;
@@ -10,9 +10,9 @@
   return #C1<self::create::T%>;
 static method main() → dynamic {
   self::expect(true, core::identical(self::implicitInstantiation, self::implicitInstantiation));
-  self::expect(false, core::identical(self::implicitInstantiation, #C2));
+  self::expect(true, core::identical(self::implicitInstantiation, #C2));
   self::expect(false, core::identical(self::implicitInstantiation, self::create<core::int>()));
-  self::expect(false, core::identical(#C2, self::implicitInstantiation));
+  self::expect(true, core::identical(#C2, self::implicitInstantiation));
   self::expect(true, core::identical(#C2, #C2));
   self::expect(false, core::identical(#C2, self::create<core::int>()));
 }
@@ -27,6 +27,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 -> InstantiationConstant(id<int*>)
-Extra constant evaluation: evaluated: 30, effectively constant: 2
+Evaluated: StaticInvocation @ org-dartlang-testcase:///identical_instantiated_function_tearoffs.dart:19:13 -> BoolConstant(true)
+Extra constant evaluation: evaluated: 29, effectively constant: 1
diff --git a/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.expect b/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.expect
index 759489c..1474987 100644
--- a/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart.weak.expect
@@ -104,42 +104,42 @@
   abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
 }
 static method test() → dynamic {
-  self::takeIII(#C1<core::int*>);
-  self::takeDDD(#C1<core::double*>);
-  self::takeNNN(#C1<core::num*>);
-  self::takeIDN(#C1<core::num*>);
-  self::takeDIN(#C1<core::num*>);
-  self::takeIIN(#C1<core::int*>);
-  self::takeDDN(#C1<core::double*>);
-  self::takeIIO(#C1<core::int*>);
-  self::takeDDO(#C1<core::double*>);
-  self::takeOOI((#C1<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::int*);
+  self::takeIII(#C2);
+  self::takeDDD(#C3);
+  self::takeNNN(#C4);
+  self::takeIDN(#C4);
+  self::takeDIN(#C4);
+  self::takeIIN(#C2);
+  self::takeDDN(#C3);
+  self::takeIIO(#C2);
+  self::takeDDO(#C3);
+  self::takeOOI((#C5) as{TypeError} (core::Object*, core::Object*) →* core::int*);
   self::takeIDI(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:28:73: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'int Function(double, int)'.
       /*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ math.max);
-                                                                        ^" in (#C1<core::num*>) as{TypeError} (core::double*, core::int*) →* core::int*);
+                                                                        ^" in (#C4) as{TypeError} (core::double*, core::int*) →* core::int*);
   self::takeDID(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:30:73: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'double Function(int, double)'.
       /*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ math.max);
-                                                                        ^" in (#C1<core::num*>) as{TypeError} (core::int*, core::double*) →* core::double*);
-  self::takeOON((#C1<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
-  self::takeOOO((#C1<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
-  self::takeIII(#C2<core::int*>);
-  self::takeDDD(#C2<core::double*>);
-  self::takeNNN(#C2<core::num*>);
-  self::takeIDN(#C2<core::num*>);
-  self::takeDIN(#C2<core::num*>);
-  self::takeIIN(#C2<core::int*>);
-  self::takeDDN(#C2<core::double*>);
-  self::takeIIO(#C2<core::int*>);
-  self::takeDDO(#C2<core::double*>);
-  self::takeOOI((#C2<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::int*);
+                                                                        ^" in (#C4) as{TypeError} (core::int*, core::double*) →* core::double*);
+  self::takeOON((#C5) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+  self::takeOOO((#C5) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+  self::takeIII(#C7);
+  self::takeDDD(#C8);
+  self::takeNNN(#C9);
+  self::takeIDN(#C9);
+  self::takeDIN(#C9);
+  self::takeIIN(#C7);
+  self::takeDDN(#C8);
+  self::takeIIO(#C7);
+  self::takeDDO(#C8);
+  self::takeOOI((#C10) as{TypeError} (core::Object*, core::Object*) →* core::int*);
   self::takeIDI(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:46:72: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'int Function(double, int)'.
   takeIDI(/*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ min);
-                                                                       ^" in (#C2<core::num*>) as{TypeError} (core::double*, core::int*) →* core::int*);
+                                                                       ^" in (#C9) as{TypeError} (core::double*, core::int*) →* core::int*);
   self::takeDID(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:47:72: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'double Function(int, double)'.
   takeDID(/*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ min);
-                                                                       ^" in (#C2<core::num*>) as{TypeError} (core::int*, core::double*) →* core::double*);
-  self::takeOON((#C2<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
-  self::takeOOO((#C2<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+                                                                       ^" in (#C9) as{TypeError} (core::int*, core::double*) →* core::double*);
+  self::takeOON((#C10) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+  self::takeOOO((#C10) as{TypeError} (core::Object*, core::Object*) →* core::num*);
   self::takeIII(new self::C::•().{self::C::m}{<T extends core::num*>(T*, T*) →* T*}<core::int*>);
   self::takeDDD(new self::C::•().{self::C::m}{<T extends core::num*>(T*, T*) →* T*}<core::double*>);
   self::takeNNN(new self::C::•().{self::C::m}{<T extends core::num*>(T*, T*) →* T*}<core::num*>);
@@ -177,5 +177,13 @@
 
 constants  {
   #C1 = static-tearoff math::max
-  #C2 = static-tearoff math::min
+  #C2 = instantiation math::max <core::int*>
+  #C3 = instantiation math::max <core::double*>
+  #C4 = instantiation math::max <core::num*>
+  #C5 = instantiation math::max <core::Object*>
+  #C6 = static-tearoff math::min
+  #C7 = instantiation math::min <core::int*>
+  #C8 = instantiation math::min <core::double*>
+  #C9 = instantiation math::min <core::num*>
+  #C10 = instantiation math::min <core::Object*>
 }
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 dbd1d673..1474987 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
@@ -104,42 +104,42 @@
   abstract member-signature get runtimeType() → core::Type*; -> core::Object::runtimeType
 }
 static method test() → dynamic {
-  self::takeIII(#C1<core::int*>);
-  self::takeDDD(#C1<core::double*>);
-  self::takeNNN(#C1<core::num*>);
-  self::takeIDN(#C1<core::num*>);
-  self::takeDIN(#C1<core::num*>);
-  self::takeIIN(#C1<core::int*>);
-  self::takeDDN(#C1<core::double*>);
-  self::takeIIO(#C1<core::int*>);
-  self::takeDDO(#C1<core::double*>);
-  self::takeOOI((#C1<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::int*);
+  self::takeIII(#C2);
+  self::takeDDD(#C3);
+  self::takeNNN(#C4);
+  self::takeIDN(#C4);
+  self::takeDIN(#C4);
+  self::takeIIN(#C2);
+  self::takeDDN(#C3);
+  self::takeIIO(#C2);
+  self::takeDDO(#C3);
+  self::takeOOI((#C5) as{TypeError} (core::Object*, core::Object*) →* core::int*);
   self::takeIDI(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:28:73: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'int Function(double, int)'.
       /*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ math.max);
-                                                                        ^" in (#C1<core::num*>) as{TypeError} (core::double*, core::int*) →* core::int*);
+                                                                        ^" in (#C4) as{TypeError} (core::double*, core::int*) →* core::int*);
   self::takeDID(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:30:73: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'double Function(int, double)'.
       /*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ math.max);
-                                                                        ^" in (#C1<core::num*>) as{TypeError} (core::int*, core::double*) →* core::double*);
-  self::takeOON((#C1<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
-  self::takeOOO((#C1<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
-  self::takeIII(#C2<core::int*>);
-  self::takeDDD(#C2<core::double*>);
-  self::takeNNN(#C2<core::num*>);
-  self::takeIDN(#C2<core::num*>);
-  self::takeDIN(#C2<core::num*>);
-  self::takeIIN(#C2<core::int*>);
-  self::takeDDN(#C2<core::double*>);
-  self::takeIIO(#C2<core::int*>);
-  self::takeDDO(#C2<core::double*>);
-  self::takeOOI((#C2<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::int*);
+                                                                        ^" in (#C4) as{TypeError} (core::int*, core::double*) →* core::double*);
+  self::takeOON((#C5) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+  self::takeOOO((#C5) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+  self::takeIII(#C7);
+  self::takeDDD(#C8);
+  self::takeNNN(#C9);
+  self::takeIDN(#C9);
+  self::takeDIN(#C9);
+  self::takeIIN(#C7);
+  self::takeDDN(#C8);
+  self::takeIIO(#C7);
+  self::takeDDO(#C8);
+  self::takeOOI((#C10) as{TypeError} (core::Object*, core::Object*) →* core::int*);
   self::takeIDI(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:46:72: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'int Function(double, int)'.
   takeIDI(/*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ min);
-                                                                       ^" in (#C2<core::num*>) as{TypeError} (core::double*, core::int*) →* core::int*);
+                                                                       ^" in (#C9) as{TypeError} (core::double*, core::int*) →* core::int*);
   self::takeDID(invalid-expression "pkg/front_end/testcases/inference/generic_methods_infer_generic_instantiation.dart:47:72: Error: The argument type 'num Function(num, num)' can't be assigned to the parameter type 'double Function(int, double)'.
   takeDID(/*error:COULD_NOT_INFER,error:ARGUMENT_TYPE_NOT_ASSIGNABLE*/ min);
-                                                                       ^" in (#C2<core::num*>) as{TypeError} (core::int*, core::double*) →* core::double*);
-  self::takeOON((#C2<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
-  self::takeOOO((#C2<core::Object*>) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+                                                                       ^" in (#C9) as{TypeError} (core::int*, core::double*) →* core::double*);
+  self::takeOON((#C10) as{TypeError} (core::Object*, core::Object*) →* core::num*);
+  self::takeOOO((#C10) as{TypeError} (core::Object*, core::Object*) →* core::num*);
   self::takeIII(new self::C::•().{self::C::m}{<T extends core::num*>(T*, T*) →* T*}<core::int*>);
   self::takeDDD(new self::C::•().{self::C::m}{<T extends core::num*>(T*, T*) →* T*}<core::double*>);
   self::takeNNN(new self::C::•().{self::C::m}{<T extends core::num*>(T*, T*) →* T*}<core::num*>);
@@ -177,32 +177,13 @@
 
 constants  {
   #C1 = static-tearoff math::max
-  #C2 = static-tearoff math::min
+  #C2 = instantiation math::max <core::int*>
+  #C3 = instantiation math::max <core::double*>
+  #C4 = instantiation math::max <core::num*>
+  #C5 = instantiation math::max <core::Object*>
+  #C6 = static-tearoff math::min
+  #C7 = instantiation math::min <core::int*>
+  #C8 = instantiation math::min <core::double*>
+  #C9 = instantiation math::min <core::num*>
+  #C10 = instantiation math::min <core::Object*>
 }
-
-Extra constant evaluation status:
-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: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: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: 111, effectively constant: 24
diff --git a/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.expect b/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.expect
index 3d04d1f..5a16fe2 100644
--- a/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.expect
+++ b/pkg/front_end/testcases/inference/generic_methods_nested_generic_instantiation.dart.weak.expect
@@ -39,10 +39,11 @@
 static method main() → dynamic {
   core::List<self::Trace*>* traces = <self::Trace*>[];
   core::int* longest = traces.{core::Iterable::map}<core::int*>((self::Trace* trace) → core::int* {
-    return trace.{self::Trace::frames}{core::List<self::Frame*>*}.{core::Iterable::map}<core::int*>((self::Frame* frame) → core::int* => frame.{self::Frame::location}{core::String*}.{core::String::length}{core::int*}){((self::Frame*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C1<core::int*>){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
-  }){((self::Trace*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C1<core::int*>){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
+    return trace.{self::Trace::frames}{core::List<self::Frame*>*}.{core::Iterable::map}<core::int*>((self::Frame* frame) → core::int* => frame.{self::Frame::location}{core::String*}.{core::String::length}{core::int*}){((self::Frame*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C2){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
+  }){((self::Trace*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C2){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
 }
 
 constants  {
   #C1 = static-tearoff math::max
+  #C2 = instantiation math::max <core::int*>
 }
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 b46e8a6..39218a6 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
@@ -39,15 +39,11 @@
 static method main() → dynamic {
   core::List<self::Trace*>* traces = core::_GrowableList::•<self::Trace*>(0);
   core::int* longest = traces.{core::Iterable::map}<core::int*>((self::Trace* trace) → core::int* {
-    return trace.{self::Trace::frames}{core::List<self::Frame*>*}.{core::Iterable::map}<core::int*>((self::Frame* frame) → core::int* => frame.{self::Frame::location}{core::String*}.{core::String::length}{core::int*}){((self::Frame*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C1<core::int*>){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
-  }){((self::Trace*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C1<core::int*>){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
+    return trace.{self::Trace::frames}{core::List<self::Frame*>*}.{core::Iterable::map}<core::int*>((self::Frame* frame) → core::int* => frame.{self::Frame::location}{core::String*}.{core::String::length}{core::int*}){((self::Frame*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C2){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
+  }){((self::Trace*) →* core::int*) →* core::Iterable<core::int*>*}.{core::Iterable::fold}<core::int*>(0, #C2){(core::int*, (core::int*, core::int*) →* core::int*) →* core::int*};
 }
 
 constants  {
   #C1 = static-tearoff math::max
+  #C2 = instantiation math::max <core::int*>
 }
-
-Extra constant evaluation status:
-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.expect b/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.expect
index 5d83e0a..ba2952c 100644
--- a/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.expect
+++ b/pkg/front_end/testcases/inference/instantiate_tearoff.dart.weak.expect
@@ -36,14 +36,16 @@
   function h<T extends core::Object* = dynamic>(T* x) → T*
     return x;
   (core::int*) →* core::int* func;
-  func = #C1<core::int*>;
+  func = #C2;
   func = new self::C::•().{self::C::f}{<T extends core::Object* = dynamic>(T*) →* T*}<core::int*>;
-  func = #C2<core::int*>;
+  func = #C4;
   func = h<core::int*>;
 }
 static method main() → dynamic {}
 
 constants  {
   #C1 = static-tearoff self::f
-  #C2 = static-tearoff self::C::g
+  #C2 = instantiation self::f <core::int*>
+  #C3 = static-tearoff self::C::g
+  #C4 = instantiation self::C::g <core::int*>
 }
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 87decf1..ba2952c 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
@@ -36,19 +36,16 @@
   function h<T extends core::Object* = dynamic>(T* x) → T*
     return x;
   (core::int*) →* core::int* func;
-  func = #C1<core::int*>;
+  func = #C2;
   func = new self::C::•().{self::C::f}{<T extends core::Object* = dynamic>(T*) →* T*}<core::int*>;
-  func = #C2<core::int*>;
+  func = #C4;
   func = h<core::int*>;
 }
 static method main() → dynamic {}
 
 constants  {
   #C1 = static-tearoff self::f
-  #C2 = static-tearoff self::C::g
+  #C2 = instantiation self::f <core::int*>
+  #C3 = static-tearoff self::C::g
+  #C4 = instantiation self::C::g <core::int*>
 }
-
-Extra constant evaluation status:
-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/nnbd/issue42433.dart.strong.expect b/pkg/front_end/testcases/nnbd/issue42433.dart.strong.expect
index 81da4f2..66fe67c 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.strong.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.strong.expect
@@ -10,9 +10,10 @@
 }
 static method checkme<T extends self::X>(self::checkme::T? t) → dynamic {}
 static method main() → dynamic {
-  (self::X?) → dynamic t2 = #C1<self::X>;
+  (self::X?) → dynamic t2 = #C2;
 }
 
 constants  {
   #C1 = static-tearoff self::checkme
+  #C2 = instantiation self::checkme <self::X>
 }
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 d4ca87d..66fe67c 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.strong.transformed.expect
@@ -10,13 +10,10 @@
 }
 static method checkme<T extends self::X>(self::checkme::T? t) → dynamic {}
 static method main() → dynamic {
-  (self::X?) → dynamic t2 = #C1<self::X>;
+  (self::X?) → dynamic t2 = #C2;
 }
 
 constants  {
   #C1 = static-tearoff self::checkme
+  #C2 = instantiation self::checkme <self::X>
 }
-
-Extra constant evaluation status:
-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.expect b/pkg/front_end/testcases/nnbd/issue42433.dart.weak.expect
index 81da4f2..17ca8c8 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.weak.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.weak.expect
@@ -10,9 +10,10 @@
 }
 static method checkme<T extends self::X>(self::checkme::T? t) → dynamic {}
 static method main() → dynamic {
-  (self::X?) → dynamic t2 = #C1<self::X>;
+  (self::X?) → dynamic t2 = #C2;
 }
 
 constants  {
   #C1 = static-tearoff self::checkme
+  #C2 = instantiation self::checkme <self::X*>
 }
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 005edee..17ca8c8 100644
--- a/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
+++ b/pkg/front_end/testcases/nnbd/issue42433.dart.weak.transformed.expect
@@ -10,13 +10,10 @@
 }
 static method checkme<T extends self::X>(self::checkme::T? t) → dynamic {}
 static method main() → dynamic {
-  (self::X?) → dynamic t2 = #C1<self::X>;
+  (self::X?) → dynamic t2 = #C2;
 }
 
 constants  {
   #C1 = static-tearoff self::checkme
+  #C2 = instantiation self::checkme <self::X*>
 }
-
-Extra constant evaluation status:
-Evaluated: Instantiation @ org-dartlang-testcase:///issue42433.dart:11:16 -> InstantiationConstant(checkme<X*>)
-Extra constant evaluation: evaluated: 1, effectively constant: 1
diff --git a/pkg/meta/lib/meta.dart b/pkg/meta/lib/meta.dart
index 54768af..584fe42 100644
--- a/pkg/meta/lib/meta.dart
+++ b/pkg/meta/lib/meta.dart
@@ -357,11 +357,29 @@
 })
 class UseResult {
   /// A human-readable explanation of the reason why the value returned by
-  /// accessing this member should be checked.
+  /// accessing this member should be used.
   final String reason;
 
+  /// Names a parameter of a method or function that, when present, signals that
+  /// the annotated member's value is used by that method or function and does
+  /// not need to be further checked.
+  final String? parameterDefined;
+
   /// Initialize a newly created instance to have the given [reason].
-  const UseResult([this.reason = '']);
+  const UseResult([this.reason = '']) : parameterDefined = null;
+
+  /// Initialize a newly created instance to annotate a function or method that
+  /// identifies a parameter [parameterDefined] that when present signals that
+  /// the result is used by the annotated member and does not need to be further
+  /// checked.  For values that need to be used unconditionally, use the unnamed
+  /// `UseResult` constructor, or if no reason is specified, the [useResult]
+  /// constant.
+  ///
+  /// Tools, such as the analyzer, can provide feedback if
+  ///
+  /// * a parameter named by [parameterDefined] is not declared by the annotated
+  ///   method or function.
+  const UseResult.unless({required this.parameterDefined, this.reason = ''});
 }
 
 class _AlwaysThrows {
diff --git a/tests/language/constructor/tear_off_test.dart b/tests/language/constructor/tear_off_test.dart
index a0764886..f70127d 100644
--- a/tests/language/constructor/tear_off_test.dart
+++ b/tests/language/constructor/tear_off_test.dart
@@ -196,21 +196,21 @@
   testImplicit<GFacRedir<int> Function(int)>(GFacRedir.named, GFacRedir.named);
 
   // Using a type variable, not a constant type expression.
-  // Results are not canonicalized and not equal.
+  // Canonicalization is unspecified, but equality holds.
   (<T>() {
     // Tear off with explicit instantation to the same non-constant type.
-    Expect.notEquals(GGen<T>.new, GGen<T>.new);
-    Expect.notEquals(GGen<T>.named, GGen<T>.named);
-    Expect.notEquals(GGenRedir<T>.new, GGenRedir<T>.new);
-    Expect.notEquals(GGenRedir<T>.named, GGenRedir<T>.named);
-    Expect.notEquals(GFac<T>.new, GFac<T>.new);
-    Expect.notEquals(GFac<T>.named, GFac<T>.named);
-    Expect.notEquals(GFacRedir<T>.new, GFacRedir<T>.new);
-    Expect.notEquals(GFacRedir<T>.named, GFacRedir<T>.named);
+    Expect.equals(GGen<T>.new, GGen<T>.new);
+    Expect.equals(GGen<T>.named, GGen<T>.named);
+    Expect.equals(GGenRedir<T>.new, GGenRedir<T>.new);
+    Expect.equals(GGenRedir<T>.named, GGenRedir<T>.named);
+    Expect.equals(GFac<T>.new, GFac<T>.new);
+    Expect.equals(GFac<T>.named, GFac<T>.named);
+    Expect.equals(GFacRedir<T>.new, GFacRedir<T>.new);
+    Expect.equals(GFacRedir<T>.named, GFacRedir<T>.named);
 
     // Tear off with implicit instantiation to the same non-constant type.
     void testImplicit2<T>(T f1, T f2) {
-      Expect.notEquals(f1, f2);
+      Expect.equals(f1, f2);
     }
 
     testImplicit2<GGen<T> Function(int)>(GGen.new, GGen.new);
diff --git a/tests/language/typedef/aliased_constructor_tear_off_test.dart b/tests/language/typedef/aliased_constructor_tear_off_test.dart
index 7d51dfb..9adb357 100644
--- a/tests/language/typedef/aliased_constructor_tear_off_test.dart
+++ b/tests/language/typedef/aliased_constructor_tear_off_test.dart
@@ -209,23 +209,23 @@
   );
 
   (<T extends num>() {
-    // Non-constant type instantiation prevents canonicalization and equality.
-    // Also not constant.
-    Expect.notEquals(Direct<T>.new, Direct<T>.new);
-    Expect.notEquals(Direct<T>.named, Direct<T>.named);
-    Expect.notEquals(Bounded<T>.new, Bounded<T>.new);
-    Expect.notEquals(Bounded<T>.named, Bounded<T>.named);
-    Expect.notEquals(Wrapping<T>.new, Wrapping<T>.new);
-    Expect.notEquals(Wrapping<T>.named, Wrapping<T>.named);
-    Expect.notEquals(Extra<T, String>.new, Extra<T, String>.new);
-    Expect.notEquals(Extra<T, String>.named, Extra<T, String>.named);
+    // Non-constant type instantiation implies non-constant expressions.
+    // Canonicalization is unspecified, but equality holds.
+    Expect.equals(Direct<T>.new, Direct<T>.new);
+    Expect.equals(Direct<T>.named, Direct<T>.named);
+    Expect.equals(Bounded<T>.new, Bounded<T>.new);
+    Expect.equals(Bounded<T>.named, Bounded<T>.named);
+    Expect.equals(Wrapping<T>.new, Wrapping<T>.new);
+    Expect.equals(Wrapping<T>.named, Wrapping<T>.named);
+    Expect.equals(Extra<T, String>.new, Extra<T, String>.new);
+    Expect.equals(Extra<T, String>.named, Extra<T, String>.named);
     // Also if the non-constant type doesn't occur in the expansion.
-    Expect.notEquals(Extra<int, T>.new, Extra<int, T>.new);
-    Expect.notEquals(Extra<int, T>.named, Extra<int, T>.named);
+    Expect.equals(Extra<int, T>.new, Extra<int, T>.new);
+    Expect.equals(Extra<int, T>.named, Extra<int, T>.named);
 
-    Expect.notEquals(Swapped<T, int>.new, Swapped<T, int>.new);
-    Expect.notEquals(Swapped<T, int>.named, Swapped<T, int>.named);
-    Expect.notEquals(Swapped<int, T>.new, Swapped<int, T>.new);
-    Expect.notEquals(Swapped<int, T>.named, Swapped<int, T>.named);
+    Expect.equals(Swapped<T, int>.new, Swapped<T, int>.new);
+    Expect.equals(Swapped<T, int>.named, Swapped<T, int>.named);
+    Expect.equals(Swapped<int, T>.new, Swapped<int, T>.new);
+    Expect.equals(Swapped<int, T>.named, Swapped<int, T>.named);
   }<int>());
 }
diff --git a/tools/VERSION b/tools/VERSION
index c6aab7e..b40e8cf 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 14
 PATCH 0
-PRERELEASE 379
+PRERELEASE 380
 PRERELEASE_PATCH 0
\ No newline at end of file