From 34561fac0a0d13947c7a5bb3930b331858e342e6 Mon Sep 17 00:00:00 2001
From: Paul Berry <paulberry@google.com>
Date: Thu, 4 Apr 2024 21:24:34 +0000
Subject: [PATCH] Additional improvements to `inference-update-3` tests.

This CL makes the following improvements (suggested in the code review
of https://dart-review.googlesource.com/c/sdk/+/356303):

- Add parenthetical comment "(Testing this case here. Otherwise
  continued below.)", to reduce confusion for a reader reading the
  tests for the first time.

- In all test cases using a promotable variable `o`, declare `Object?
  o;` first, then assign `o = ... as Object?;`. This makes the test
  cases more symmetrical, since `o = ... as Object?;` now appears in
  every test case, rather than getting coalesced with the variable
  declaration in some test cases but not others.

- Consistently use `e` rather than `E` to refer to the whole
  expression being tested.

- Expand on the explanation for how each test case matches up to the
  type metavariables K, T1, T2, etc., and why the expected result
  occurs.

- Remove tickmarks around type metavariables.

- Clarify that the type S is chosen, rather than T, only when the
  feature is enabled.

Change-Id: I149b323daeac9fc44104681370cea33ee010faa4
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/357204
Reviewed-by: Lasse Nielsen <lrn@google.com>
Commit-Queue: Paul Berry <paulberry@google.com>
---
 .../conditional_expression_disabled_test.dart | 116 +++++--
 .../conditional_expression_test.dart          | 140 +++++++--
 ...ension_index_expression_disabled_test.dart | 229 ++++++++++----
 ...licit_extension_index_expression_test.dart | 253 ++++++++++++----
 ..._aware_index_expression_disabled_test.dart | 248 ++++++++++-----
 ...sion_null_aware_index_expression_test.dart | 276 ++++++++++++-----
 ...ion_null_aware_property_disabled_test.dart | 248 ++++++++++-----
 ...it_extension_null_aware_property_test.dart | 276 ++++++++++++-----
 ...icit_extension_property_disabled_test.dart | 229 ++++++++++----
 ...ment_explicit_extension_property_test.dart | 253 ++++++++++++----
 ...extension_this_property_disabled_test.dart | 220 ++++++++++----
 ...explicit_extension_this_property_test.dart | 244 +++++++++++----
 ..._explicit_this_property_disabled_test.dart | 220 ++++++++++----
 ...ssignment_explicit_this_property_test.dart | 244 +++++++++++----
 ..._explicit_this_property_disabled_test.dart | 220 ++++++++++----
 ...extension_explicit_this_property_test.dart | 244 +++++++++++----
 ..._implicit_this_property_disabled_test.dart | 220 ++++++++++----
 ...extension_implicit_this_property_test.dart | 244 +++++++++++----
 ...ension_index_expression_disabled_test.dart | 229 ++++++++++----
 ...licit_extension_index_expression_test.dart | 253 ++++++++++++----
 ..._aware_index_expression_disabled_test.dart | 248 ++++++++++-----
 ...sion_null_aware_index_expression_test.dart | 276 ++++++++++++-----
 ...ion_null_aware_property_disabled_test.dart | 248 ++++++++++-----
 ...it_extension_null_aware_property_test.dart | 276 ++++++++++++-----
 ...icit_extension_property_disabled_test.dart | 229 ++++++++++----
 ...ment_implicit_extension_property_test.dart | 253 ++++++++++++----
 ..._implicit_this_property_disabled_test.dart | 220 ++++++++++----
 ...ssignment_implicit_this_property_test.dart | 244 +++++++++++----
 ...gnment_index_expression_disabled_test.dart | 229 ++++++++++----
 ...null_assignment_index_expression_test.dart | 253 ++++++++++++----
 ...f_null_assignment_local_disabled_test.dart | 260 +++++++++++-----
 .../if_null_assignment_local_test.dart        | 284 +++++++++++++-----
 ..._aware_index_expression_disabled_test.dart | 248 ++++++++++-----
 ...ment_null_aware_index_expression_test.dart | 276 ++++++++++++-----
 ...ent_null_aware_property_disabled_test.dart | 248 ++++++++++-----
 ...l_assignment_null_aware_property_test.dart | 276 ++++++++++++-----
 ...ull_assignment_property_disabled_test.dart | 229 ++++++++++----
 .../if_null_assignment_property_test.dart     | 253 ++++++++++++----
 ...ignment_static_property_disabled_test.dart | 229 ++++++++++----
 ..._null_assignment_static_property_test.dart | 253 ++++++++++++----
 ..._super_index_expression_disabled_test.dart | 240 +++++++++++----
 ...ssignment_super_index_expression_test.dart | 261 +++++++++++-----
 ...signment_super_property_disabled_test.dart | 220 ++++++++++----
 ...f_null_assignment_super_property_test.dart | 244 +++++++++++----
 ...t_this_index_expression_disabled_test.dart | 240 +++++++++++----
 ...assignment_this_index_expression_test.dart | 261 +++++++++++-----
 ...ment_top_level_property_disabled_test.dart | 229 ++++++++++----
 ...ll_assignment_top_level_property_test.dart | 253 ++++++++++++----
 .../if_null_disabled_test.dart                | 120 ++++++--
 .../inference_update_3/if_null_test.dart      | 145 ++++++---
 .../switch_expression_disabled_test.dart      | 115 +++++--
 .../switch_expression_test.dart               | 139 +++++++--
 52 files changed, 8915 insertions(+), 3190 deletions(-)

diff --git a/tests/language/inference_update_3/conditional_expression_disabled_test.dart b/tests/language/inference_update_3/conditional_expression_disabled_test.dart
index 18879243247..0ec56e6e2b4 100644
--- a/tests/language/inference_update_3/conditional_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/conditional_expression_disabled_test.dart
@@ -16,11 +16,11 @@ import '../static_type_helper.dart';
 Object? contextIterable<T>(Iterable<T> x) => x;
 
 test(bool b) {
-  // - A conditional expression `E` of the form `b ? e1 : e2` with context type
-  //   `K` is analyzed as follows:
+  // - A conditional expression `e` of the form `b ? e1 : e2` with context type
+  //   K is analyzed as follows:
   //
-  //   - Let `T1` be the type of `e1` inferred with context type `K`.
-  //   - Let `T2` be the type of `e2` inferred with context type `K`.
+  //   - Let T1 be the type of `e1` inferred with context type K.
+  //   - Let T2 be the type of `e2` inferred with context type K.
   {
     // Check the context type of `e1` and `e2`:
     // - Where the context is established using a function call argument.
@@ -29,7 +29,8 @@ test(bool b) {
         : (contextType('')..expectStaticType<Exactly<String>>()));
 
     // - Where the context is established using local variable promotion.
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String) {
       o = b
           ? (contextType('')..expectStaticType<Exactly<String>>())
@@ -37,62 +38,123 @@ test(bool b) {
     }
   }
 
-  //   - Let `T` be `UP(T1, T2)`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(T1, T2).
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int, and T2=double, therefore T=num and S=Object, so T <: S,
-    // and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int
+    // - T2 = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var i = 1;
     var d = 2.0;
     context<Object>((b ? i : d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>, and T2=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>
+    // - T2 = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableInt = <int>[] as Iterable<int>;
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((b ? iterableInt : iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  //   - Otherwise, if `T1 <: S` and `T2 <: S`, then the type of `E` is `S` if
-  //     `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if T1 <: S and T2 <: S, and `inference-update-3` is enabled,
+  //     then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>, and T2=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but T1 <: S and T2 <: S, hence the
-    // type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>
+    // - T2 = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var iterableInt = <int>[] as Iterable<int>;
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (b ? iterableInt : listNum)..expectStaticType<Exactly<Object>>();
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var i = 1;
-    var o = '' as Object?;
+    Object? o;
     var d = 2.0;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=Null, and T2=int, therefore T=int? and S=String?, so T is
-      // not <: S. T1 <: S, but T2 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = Null
+      // - T2 = int
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <: S
+      // - T2 <!: S
+      // The fact that T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (b ? null : i)..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=Null, therefore T=int? and S=String?, so T is
-      // not <: S. T2 <: S, but T1 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = Null
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <: S
+      // The fact that T1 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (b ? i : null)..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=double, therefore T=num and S=String?, so
-      // none of T, T1, nor T2 are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <!: S
+      // The fact that T1 <!: S and T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (b ? i : d)..expectStaticType<Exactly<num>>();
     }
diff --git a/tests/language/inference_update_3/conditional_expression_test.dart b/tests/language/inference_update_3/conditional_expression_test.dart
index edcfe6e4835..7bd58ba21a4 100644
--- a/tests/language/inference_update_3/conditional_expression_test.dart
+++ b/tests/language/inference_update_3/conditional_expression_test.dart
@@ -29,11 +29,11 @@ class C2<T> implements B1<T>, B2<T> {}
 Object? contextB1<T>(B1<T> x) => x;
 
 test(bool b) {
-  // - A conditional expression `E` of the form `b ? e1 : e2` with context type
-  //   `K` is analyzed as follows:
+  // - A conditional expression `e` of the form `b ? e1 : e2` with context type
+  //   K is analyzed as follows:
   //
-  //   - Let `T1` be the type of `e1` inferred with context type `K`.
-  //   - Let `T2` be the type of `e2` inferred with context type `K`.
+  //   - Let T1 be the type of `e1` inferred with context type K.
+  //   - Let T2 be the type of `e2` inferred with context type K.
   {
     // Check the context type of `e1` and `e2`:
     // - Where the context is established using a function call argument.
@@ -42,7 +42,8 @@ test(bool b) {
         : (contextType('')..expectStaticType<Exactly<String>>()));
 
     // - Where the context is established using local variable promotion.
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String) {
       o = b
           ? (contextType('')..expectStaticType<Exactly<String>>())
@@ -50,71 +51,148 @@ test(bool b) {
     }
   }
 
-  //   - Let `T` be `UP(T1, T2)`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(T1, T2).
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int, and T2=double, therefore T=num and S=Object, so T <: S,
-    // and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int
+    // - T2 = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var i = 1;
     var d = 2.0;
     context<Object>((b ? i : d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>, and T2=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>
+    // - T2 = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableInt = <int>[] as Iterable<int>;
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((b ? iterableInt : iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  //   - Otherwise, if `T1 <: S` and `T2 <: S`, then the type of `E` is `S`.
+  //   - Otherwise, if T1 <: S and T2 <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>, and T2=C2<double>, therefore T=A and S=B1<Object?>,
-    // so T is not <: S, but T1 <: S and T2 <: S, hence the type of E is
-    // B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>
+    // - T2 = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c1Int = C1<int>();
     var c2Double = C2<double>();
     contextB1((b ? c1Int : c2Double)..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>, and T2=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but T1 <: S and T2 <: S, hence the type
-    // of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>
+    // - T2 = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>(
         (b ? c1Int : c2Double)..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>, and T2=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but T1 <: S and T2 <: S, hence the
-    // type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>
+    // - T2 = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var iterableInt = <int>[] as Iterable<int>;
     var listNum = <num>[];
     context<Iterable<num>>((b ? iterableInt : listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var i = 1;
-    var o = '' as Object?;
+    Object? o;
     var d = 2.0;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=Null, and T2=int, therefore T=int? and S=String?, so T is
-      // not <: S. T1 <: S, but T2 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = Null
+      // - T2 = int
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <: S
+      // - T2 <!: S
+      // The fact that T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (b ? null : i)..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=Null, therefore T=int? and S=String?, so T is
-      // not <: S. T2 <: S, but T1 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = Null
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <: S
+      // The fact that T1 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (b ? i : null)..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=double, therefore T=num and S=String?, so
-      // none of T, T1, nor T2 are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <!: S
+      // The fact that T1 <!: S and T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (b ? i : d)..expectStaticType<Exactly<num>>();
     }
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_disabled_test.dart
index f8f1121d2c2..6d4f3226c49 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_disabled_test.dart
@@ -48,18 +48,18 @@ extension Extension<ReadType, WriteType> on Indexable<ReadType, WriteType> {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -70,62 +70,106 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((Extension(Indexable<int?, Object?>(null))[0] ??= d)
       ..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Extension(Indexable<Iterable<int>?, Object?>(null))[0] ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Extension(Indexable<Function?, Function?>(null))[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<Iterable<int>?, Object?>(null))[0] ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -136,32 +180,65 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<int?, Object?>(null))[0] ??= d)
         ..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<double?, Object?>(null))[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<int?, Object?>(null))[0] ??= d)
         ..expectStaticType<Exactly<num>>();
@@ -170,10 +247,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<C1<int> Function()?, Function?>(null))[0] ??=
           callableClassC2Int)
@@ -182,10 +269,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<C1<int> Function()?, Function?>(null))[0] ??=
           callableClassC2Int)
@@ -194,10 +291,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<C1<int> Function()?, Function?>(null))[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_test.dart
index 869b6fe1efb..a7f41e09870 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_index_expression_test.dart
@@ -51,18 +51,18 @@ extension Extension<ReadType, WriteType> on Indexable<ReadType, WriteType> {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -73,73 +73,131 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((Extension(Indexable<int?, Object?>(null))[0] ??= d)
       ..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Extension(Indexable<Iterable<int>?, Object?>(null))[0] ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Extension(Indexable<Function?, Function?>(null))[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((Extension(Indexable<C1<int>?, Object?>(null))[0] ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((Extension(Indexable<C1<int>?, Object?>(null))[0] ??=
         c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>(
         (Extension(Indexable<Iterable<int>?, Object?>(null))[0] ??= listNum)
           ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>(
         (Extension(Indexable<C1<int> Function()?, Function?>(null))[0] ??=
@@ -147,32 +205,65 @@ main() {
           ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<int?, Object?>(null))[0] ??= d)
         ..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<double?, Object?>(null))[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<int?, Object?>(null))[0] ??= d)
         ..expectStaticType<Exactly<num>>();
@@ -181,10 +272,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<C1<int> Function()?, Function?>(null))[0] ??=
           callableClassC2Int)
@@ -193,10 +294,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<C1<int> Function()?, Function?>(null))[0] ??=
           callableClassC2Int)
@@ -205,10 +316,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(Indexable<C1<int> Function()?, Function?>(null))[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_disabled_test.dart
index 223eeb02a57..8e7b318d058 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_disabled_test.dart
@@ -52,18 +52,18 @@ Indexable<ReadType, WriteType>? maybeIndexable<ReadType, WriteType>(
     Indexable<ReadType, WriteType>(value);
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -74,42 +74,65 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>((Extension(maybeIndexable<int?, Object?>(null))?[0] ??= d)
       ..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion(
         (Extension(maybeIndexable<Iterable<int>?, Object?>(null))?[0] ??=
             iterableDouble)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>(
         (Extension(maybeIndexable<Function?, Function?>(null))?[0] ??=
@@ -117,15 +140,26 @@ main() {
           ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Object (which becomes Object? after null
-    // shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
+    // (Which becomes Object? after null shorting completes.)
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>?) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<Iterable<int>?, Object?>(null))?[0] ??=
@@ -133,11 +167,21 @@ main() {
         ..expectStaticType<Exactly<Object?>>();
     }
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function() (which becomes A Function()? after
-    // null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
+    // (Which becomes A Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()?) {
@@ -148,24 +192,46 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<int?, Object?>(null))?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<double?, Object?>(null))?[0] ??=
           intQuestion)
@@ -173,9 +239,21 @@ main() {
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<int?, Object?>(null))?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
@@ -184,11 +262,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<C1<int> Function()?, Function?>(null))?[
           0] ??= callableClassC2Int)
@@ -197,11 +285,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<C1<int> Function()?, Function?>(null))?[
           0] ??= callableClassC2Int)
@@ -210,11 +308,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<C1<int> Function()?, Function?>(null))?[
           0] ??= callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_test.dart
index 73738340615..e86077eff4d 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_index_expression_test.dart
@@ -55,18 +55,18 @@ Indexable<ReadType, WriteType>? maybeIndexable<ReadType, WriteType>(
     Indexable<ReadType, WriteType>(value);
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -77,42 +77,65 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>((Extension(maybeIndexable<int?, Object?>(null))?[0] ??= d)
       ..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion(
         (Extension(maybeIndexable<Iterable<int>?, Object?>(null))?[0] ??=
             iterableDouble)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>(
         (Extension(maybeIndexable<Function?, Function?>(null))?[0] ??=
@@ -120,41 +143,76 @@ main() {
           ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is B1<Object?> (which becomes B1<Object?>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<_>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
+    // (Which becomes B1<Object?>? after null shorting completes.)
     var c2Double = C2<double>();
     contextB1Question(
         (Extension(maybeIndexable<C1<int>?, Object?>(null))?[0] ??= c2Double)
           ..expectStaticType<Exactly<B1<Object?>?>>());
 
-    // K=B1<Object>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object> (which becomes B1<Object>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<Object>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
+    // (Which becomes B1<Object>? after null shorting completes.)
     contextB1Question<Object>(
         (Extension(maybeIndexable<C1<int>?, Object?>(null))?[0] ??= c2Double)
           ..expectStaticType<Exactly<B1<Object>?>>());
 
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Iterable<num> (which becomes
-    // Iterable<num>? after null shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var listNum = <num>[];
     context<Iterable<num>?>(
         (Extension(maybeIndexable<Iterable<int>?, Object?>(null))?[0] ??=
             listNum)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function() (which becomes B1<int>
-    // Function()? after null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
+    // (Which becomes B1<int> Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()?>(
         (Extension(maybeIndexable<C1<int> Function()?, Function?>(null))?[0] ??=
@@ -162,24 +220,46 @@ main() {
           ..expectStaticType<Exactly<B1<int> Function()?>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<int?, Object?>(null))?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<double?, Object?>(null))?[0] ??=
           intQuestion)
@@ -187,9 +267,21 @@ main() {
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<int?, Object?>(null))?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
@@ -198,11 +290,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<C1<int> Function()?, Function?>(null))?[
           0] ??= callableClassC2Int)
@@ -211,11 +313,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<C1<int> Function()?, Function?>(null))?[
           0] ??= callableClassC2Int)
@@ -224,11 +336,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(maybeIndexable<C1<int> Function()?, Function?>(null))?[
           0] ??= callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_disabled_test.dart
index db6289fdfb7..8ccc86a401d 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_disabled_test.dart
@@ -56,18 +56,18 @@ extension Extension on String {
 main() {
   var s = '' as String?;
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -78,66 +78,110 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>(
         (Extension(s)?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion((Extension(s)?.pIterableIntQuestion ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((Extension(s)?.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Object (which becomes Object? after null
-    // shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
+    // (Which becomes Object? after null shorting completes.)
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>?) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object?>>();
     }
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function() (which becomes A Function()? after
-    // null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
+    // (Which becomes A Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()?) {
@@ -147,32 +191,66 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
@@ -180,11 +258,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -192,11 +280,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -204,11 +302,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_test.dart
index ac11279db92..b4210b8cf7d 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_null_aware_property_test.dart
@@ -61,18 +61,18 @@ extension Extension on String {
 main() {
   var s = '' as String?;
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -83,109 +83,201 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>(
         (Extension(s)?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion((Extension(s)?.pIterableIntQuestion ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((Extension(s)?.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is B1<Object?> (which becomes B1<Object?>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<_>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
+    // (Which becomes B1<Object?>? after null shorting completes.)
     var c2Double = C2<double>();
     contextB1Question((Extension(s)?.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>?>>());
 
-    // K=B1<Object>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object> (which becomes B1<Object>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<Object>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
+    // (Which becomes B1<Object>? after null shorting completes.)
     contextB1Question<Object>((Extension(s)?.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>?>>());
 
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Iterable<num> (which becomes
-    // Iterable<num>? after null shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var listNum = <num>[];
     context<Iterable<num>?>((Extension(s)?.pIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function() (which becomes B1<int>
-    // Function()? after null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
+    // (Which becomes B1<int> Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()?>((Extension(s)?.pC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()?>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
@@ -193,11 +285,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -205,11 +307,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -217,11 +329,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension(s)?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_disabled_test.dart
index 165c700f75a..bdb78ccba9a 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_disabled_test.dart
@@ -54,18 +54,18 @@ extension Extension on String {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -76,60 +76,104 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (Extension('').pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Extension('').pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Extension('').pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -139,31 +183,64 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -171,10 +248,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -182,10 +269,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -193,10 +290,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_test.dart
index 475055be400..950afbde759 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_property_test.dart
@@ -59,18 +59,18 @@ extension Extension on String {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -81,100 +81,191 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (Extension('').pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Extension('').pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Extension('').pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((Extension('').pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((Extension('').pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>((Extension('').pIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>((Extension('').pC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -182,10 +273,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -193,10 +294,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -204,10 +315,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Extension('').pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_disabled_test.dart
index 078f3dece53..843664e0654 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_disabled_test.dart
@@ -53,15 +53,15 @@ extension Extension on String {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -75,61 +75,104 @@ extension Extension on String {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>((Extension(this).pIntQuestion ??= d)
         ..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((Extension(this).pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((Extension(this).pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S` if `inference-update-3` is enabled, else the type of `E` is
-    //     `T`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+    //     is enabled, then the type of `e` is S.
     {
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Object.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = Object.
       var listNum = <num>[];
-      var o = [0] as Object?;
+      Object? o;
+      o = [0] as Object?;
       if (o is Iterable<num>) {
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pIterableIntQuestion ??= listNum)
           ..expectStaticType<Exactly<Object>>();
       }
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is A Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = A Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => B1<int>()) as Object?;
       if (o is B1<int> Function()) {
@@ -139,32 +182,65 @@ extension Extension on String {
       }
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pIntQuestion ??= d)
           ..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pIntQuestion ??= d)
           ..expectStaticType<Exactly<num>>();
@@ -173,10 +249,20 @@ extension Extension on String {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -184,10 +270,20 @@ extension Extension on String {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -195,10 +291,20 @@ extension Extension on String {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_test.dart
index e0c7de16bb5..33d7e78e6b0 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_extension_this_property_test.dart
@@ -58,15 +58,15 @@ extension Extension on String {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -80,101 +80,193 @@ extension Extension on String {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>((Extension(this).pIntQuestion ??= d)
         ..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((Extension(this).pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((Extension(this).pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is
+    //     S.
     {
-      // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object?>.
+      // This example has:
+      // - K = B1<_>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object?>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object?>.
       var c2Double = C2<double>();
       contextB1((Extension(this).pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object?>>>());
 
-      // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object>.
+      // This example has:
+      // - K = B1<Object>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object>.
       contextB1<Object>((Extension(this).pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object>>>());
 
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = Iterable<num>.
       var listNum = <num>[];
       context<Iterable<num>>((Extension(this).pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is B1<int> Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<int> Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       context<B1<int> Function()>((Extension(this).pC1IntFunctionQuestion ??=
           callableClassC2Int)
         ..expectStaticType<Exactly<B1<int> Function()>>());
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pIntQuestion ??= d)
           ..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pIntQuestion ??= d)
           ..expectStaticType<Exactly<num>>();
@@ -183,10 +275,20 @@ extension Extension on String {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -194,10 +296,20 @@ extension Extension on String {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -205,10 +317,20 @@ extension Extension on String {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (Extension(this).pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_this_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_this_property_disabled_test.dart
index 7d3c01d60d2..3ca3d0136e1 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_this_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_this_property_disabled_test.dart
@@ -53,15 +53,15 @@ class Test {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -74,61 +74,104 @@ class Test {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>(
           (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((this.pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((this.pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S` if `inference-update-3` is enabled, else the type of `E` is
-    //     `T`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+    //     is enabled, then the type of `e` is S.
     {
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Object.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = Object.
       var listNum = <num>[];
-      var o = [0] as Object?;
+      Object? o;
+      o = [0] as Object?;
       if (o is Iterable<num>) {
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIterableIntQuestion ??= listNum)
           ..expectStaticType<Exactly<Object>>();
       }
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is A Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = A Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => B1<int>()) as Object?;
       if (o is B1<int> Function()) {
@@ -138,31 +181,64 @@ class Test {
       }
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -170,10 +246,20 @@ class Test {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -181,10 +267,20 @@ class Test {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -192,10 +288,20 @@ class Test {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_explicit_this_property_test.dart b/tests/language/inference_update_3/if_null_assignment_explicit_this_property_test.dart
index 149fb89d59f..b119156911a 100644
--- a/tests/language/inference_update_3/if_null_assignment_explicit_this_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_explicit_this_property_test.dart
@@ -58,15 +58,15 @@ class Test {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -79,100 +79,192 @@ class Test {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>(
           (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((this.pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((this.pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is
+    //     S.
     {
-      // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object?>.
+      // This example has:
+      // - K = B1<_>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object?>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object?>.
       var c2Double = C2<double>();
       contextB1((this.pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object?>>>());
 
-      // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object>.
+      // This example has:
+      // - K = B1<Object>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object>.
       contextB1<Object>((this.pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object>>>());
 
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = Iterable<num>.
       var listNum = <num>[];
       context<Iterable<num>>((this.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is B1<int> Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<int> Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       context<B1<int> Function()>((this.pC1IntFunctionQuestion ??=
           callableClassC2Int)
         ..expectStaticType<Exactly<B1<int> Function()>>());
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -180,10 +272,20 @@ class Test {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -191,10 +293,20 @@ class Test {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -202,10 +314,20 @@ class Test {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_disabled_test.dart
index bc84c2a954d..bd523d18569 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_disabled_test.dart
@@ -53,15 +53,15 @@ extension on String {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -74,61 +74,104 @@ extension on String {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>(
           (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((this.pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((this.pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S` if `inference-update-3` is enabled, else the type of `E` is
-    //     `T`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+    //     is enabled, then the type of `e` is S.
     {
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Object.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = Object.
       var listNum = <num>[];
-      var o = [0] as Object?;
+      Object? o;
+      o = [0] as Object?;
       if (o is Iterable<num>) {
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIterableIntQuestion ??= listNum)
           ..expectStaticType<Exactly<Object>>();
       }
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is A Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = A Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => B1<int>()) as Object?;
       if (o is B1<int> Function()) {
@@ -138,31 +181,64 @@ extension on String {
       }
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -170,10 +246,20 @@ extension on String {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -181,10 +267,20 @@ extension on String {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -192,10 +288,20 @@ extension on String {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_test.dart
index d1eca47c0c0..5c7c016a085 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_explicit_this_property_test.dart
@@ -58,15 +58,15 @@ extension on String {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -79,100 +79,192 @@ extension on String {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>(
           (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((this.pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((this.pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is
+    //     S.
     {
-      // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object?>.
+      // This example has:
+      // - K = B1<_>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object?>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object?>.
       var c2Double = C2<double>();
       contextB1((this.pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object?>>>());
 
-      // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object>.
+      // This example has:
+      // - K = B1<Object>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object>.
       contextB1<Object>((this.pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object>>>());
 
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = Iterable<num>.
       var listNum = <num>[];
       context<Iterable<num>>((this.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is B1<int> Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<int> Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       context<B1<int> Function()>((this.pC1IntFunctionQuestion ??=
           callableClassC2Int)
         ..expectStaticType<Exactly<B1<int> Function()>>());
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -180,10 +272,20 @@ extension on String {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -191,10 +293,20 @@ extension on String {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -202,10 +314,20 @@ extension on String {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (this.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_disabled_test.dart
index c2217218347..7c0586065c7 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_disabled_test.dart
@@ -53,15 +53,15 @@ extension on String {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -73,60 +73,103 @@ extension on String {
       pStringQuestion ??= contextType('')..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>((pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S` if `inference-update-3` is enabled, else the type of `E` is
-    //     `T`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+    //     is enabled, then the type of `e` is S.
     {
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Object.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = Object.
       var listNum = <num>[];
-      var o = [0] as Object?;
+      Object? o;
+      o = [0] as Object?;
       if (o is Iterable<num>) {
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIterableIntQuestion ??= listNum)
           ..expectStaticType<Exactly<Object>>();
       }
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is A Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = A Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => B1<int>()) as Object?;
       if (o is B1<int> Function()) {
@@ -136,31 +179,64 @@ extension on String {
       }
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -168,10 +244,20 @@ extension on String {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -179,10 +265,20 @@ extension on String {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -190,10 +286,20 @@ extension on String {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_test.dart
index 515399f6983..69eaf2796f3 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_implicit_this_property_test.dart
@@ -58,15 +58,15 @@ extension on String {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -78,99 +78,191 @@ extension on String {
       pStringQuestion ??= contextType('')..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>((pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is
+    //     S.
     {
-      // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object?>.
+      // This example has:
+      // - K = B1<_>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object?>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object?>.
       var c2Double = C2<double>();
       contextB1((pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object?>>>());
 
-      // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object>.
+      // This example has:
+      // - K = B1<Object>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object>.
       contextB1<Object>((pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object>>>());
 
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = Iterable<num>.
       var listNum = <num>[];
       context<Iterable<num>>((pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is B1<int> Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<int> Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       context<B1<int> Function()>((pC1IntFunctionQuestion ??=
           callableClassC2Int)
         ..expectStaticType<Exactly<B1<int> Function()>>());
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -178,10 +270,20 @@ extension on String {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -189,10 +291,20 @@ extension on String {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -200,10 +312,20 @@ extension on String {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_disabled_test.dart
index f9e93c44e28..5e9dbaa77be 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_disabled_test.dart
@@ -48,18 +48,18 @@ extension<ReadType, WriteType> on Indexable<ReadType, WriteType> {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -70,62 +70,106 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((Indexable<int?, Object?>(null)[0] ??= d)
       ..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Indexable<Iterable<int>?, Object?>(null)[0] ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Indexable<Function?, Function?>(null)[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<Iterable<int>?, Object?>(null)[0] ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -136,32 +180,65 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<double?, Object?>(null)[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
@@ -170,10 +247,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -182,10 +269,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -194,10 +291,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_test.dart
index b393dfd7cd0..b3315514943 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_index_expression_test.dart
@@ -51,18 +51,18 @@ extension<ReadType, WriteType> on Indexable<ReadType, WriteType> {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -73,72 +73,130 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((Indexable<int?, Object?>(null)[0] ??= d)
       ..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Indexable<Iterable<int>?, Object?>(null)[0] ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Indexable<Function?, Function?>(null)[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((Indexable<C1<int>?, Object?>(null)[0] ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((Indexable<C1<int>?, Object?>(null)[0] ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>((Indexable<Iterable<int>?, Object?>(null)[0] ??=
         listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>(
         (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
@@ -146,32 +204,65 @@ main() {
           ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<double?, Object?>(null)[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
@@ -180,10 +271,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -192,10 +293,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -204,10 +315,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_disabled_test.dart
index be97afa2430..9f3f788fef9 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_disabled_test.dart
@@ -52,18 +52,18 @@ Indexable<ReadType, WriteType>? maybeIndexable<ReadType, WriteType>(
     Indexable<ReadType, WriteType>(value);
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -74,67 +74,111 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>((maybeIndexable<int?, Object?>(null)?[0] ??= d)
       ..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion(
         (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= iterableDouble)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((maybeIndexable<Function?, Function?>(null)?[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Object (which becomes Object? after null
-    // shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
+    // (Which becomes Object? after null shorting completes.)
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>?) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= listNum)
         ..expectStaticType<Exactly<Object?>>();
     }
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function() (which becomes A Function()? after
-    // null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
+    // (Which becomes A Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()?) {
@@ -145,33 +189,67 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<double?, Object?>(null)?[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
@@ -180,11 +258,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -193,11 +281,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -206,11 +304,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_test.dart
index a1beb092238..fd16a7700c8 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_index_expression_test.dart
@@ -55,18 +55,18 @@ Indexable<ReadType, WriteType>? maybeIndexable<ReadType, WriteType>(
     Indexable<ReadType, WriteType>(value);
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -77,80 +77,138 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>((maybeIndexable<int?, Object?>(null)?[0] ??= d)
       ..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion(
         (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= iterableDouble)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((maybeIndexable<Function?, Function?>(null)?[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is B1<Object?> (which becomes B1<Object?>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<_>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
+    // (Which becomes B1<Object?>? after null shorting completes.)
     var c2Double = C2<double>();
     contextB1Question((maybeIndexable<C1<int>?, Object?>(null)?[0] ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>?>>());
 
-    // K=B1<Object>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object> (which becomes B1<Object>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<Object>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
+    // (Which becomes B1<Object>? after null shorting completes.)
     contextB1Question<Object>((maybeIndexable<C1<int>?, Object?>(null)?[0] ??=
         c2Double)
       ..expectStaticType<Exactly<B1<Object>?>>());
 
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Iterable<num> (which becomes
-    // Iterable<num>? after null shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var listNum = <num>[];
     context<Iterable<num>?>(
         (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= listNum)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function() (which becomes B1<int>
-    // Function()? after null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
+    // (Which becomes B1<int> Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()?>(
         (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
@@ -158,33 +216,67 @@ main() {
           ..expectStaticType<Exactly<B1<int> Function()?>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<double?, Object?>(null)?[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
@@ -193,11 +285,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -206,11 +308,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -219,11 +331,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_disabled_test.dart
index 97cc8fed4a5..018312aedaf 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_disabled_test.dart
@@ -55,18 +55,18 @@ extension on String {
 main() {
   var s = '' as String?;
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -76,65 +76,109 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>(
         (s?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion((s?.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((s?.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Object (which becomes Object? after null
-    // shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
+    // (Which becomes Object? after null shorting completes.)
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>?) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object?>>();
     }
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function() (which becomes A Function()? after
-    // null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
+    // (Which becomes A Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()?) {
@@ -144,32 +188,66 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
@@ -177,11 +255,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -189,11 +277,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -201,11 +299,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_test.dart
index d850a646e36..0420c090dbf 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_null_aware_property_test.dart
@@ -61,18 +61,18 @@ extension on String {
 main() {
   var s = '' as String?;
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -82,108 +82,200 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>(
         (s?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion((s?.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((s?.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is B1<Object?> (which becomes B1<Object?>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<_>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
+    // (Which becomes B1<Object?>? after null shorting completes.)
     var c2Double = C2<double>();
     contextB1Question((s?.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>?>>());
 
-    // K=B1<Object>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object> (which becomes B1<Object>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<Object>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
+    // (Which becomes B1<Object>? after null shorting completes.)
     contextB1Question<Object>((s?.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>?>>());
 
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Iterable<num> (which becomes
-    // Iterable<num>? after null shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var listNum = <num>[];
     context<Iterable<num>?>((s?.pIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function() (which becomes B1<int>
-    // Function()? after null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
+    // (Which becomes B1<int> Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()?>((s?.pC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()?>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
@@ -191,11 +283,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -203,11 +305,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -215,11 +327,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (s?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_disabled_test.dart
index 5d3755f3e42..123361bc54a 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_disabled_test.dart
@@ -53,18 +53,18 @@ extension on String {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -74,59 +74,103 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((''.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((''.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((''.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -136,31 +180,64 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -168,10 +245,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -179,10 +266,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -190,10 +287,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_test.dart
index 04317cf558e..43d41cf126a 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_extension_property_test.dart
@@ -58,18 +58,18 @@ extension on String {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -79,99 +79,190 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((''.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((''.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((''.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((''.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((''.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>((''.pIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>((''.pC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -179,10 +270,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -190,10 +291,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -201,10 +312,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (''.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_this_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_this_property_disabled_test.dart
index 9785583142e..9a8166877ad 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_this_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_this_property_disabled_test.dart
@@ -53,15 +53,15 @@ class Test {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -73,60 +73,103 @@ class Test {
       pStringQuestion ??= contextType('')..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>((pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S` if `inference-update-3` is enabled, else the type of `E` is
-    //     `T`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+    //     is enabled, then the type of `e` is S.
     {
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Object.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = Object.
       var listNum = <num>[];
-      var o = [0] as Object?;
+      Object? o;
+      o = [0] as Object?;
       if (o is Iterable<num>) {
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIterableIntQuestion ??= listNum)
           ..expectStaticType<Exactly<Object>>();
       }
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is A Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = A Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => B1<int>()) as Object?;
       if (o is B1<int> Function()) {
@@ -136,31 +179,64 @@ class Test {
       }
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -168,10 +244,20 @@ class Test {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -179,10 +265,20 @@ class Test {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -190,10 +286,20 @@ class Test {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_implicit_this_property_test.dart b/tests/language/inference_update_3/if_null_assignment_implicit_this_property_test.dart
index 80a9ddf62f7..8700575c715 100644
--- a/tests/language/inference_update_3/if_null_assignment_implicit_this_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_implicit_this_property_test.dart
@@ -58,15 +58,15 @@ class Test {
   set pStringQuestion(String? value) {}
 
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -78,99 +78,191 @@ class Test {
       pStringQuestion ??= contextType('')..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>((pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is
+    //     S.
     {
-      // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object?>.
+      // This example has:
+      // - K = B1<_>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object?>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object?>.
       var c2Double = C2<double>();
       contextB1((pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object?>>>());
 
-      // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object>.
+      // This example has:
+      // - K = B1<Object>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object>.
       contextB1<Object>((pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object>>>());
 
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = Iterable<num>.
       var listNum = <num>[];
       context<Iterable<num>>((pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is B1<int> Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<int> Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       context<B1<int> Function()>((pC1IntFunctionQuestion ??=
           callableClassC2Int)
         ..expectStaticType<Exactly<B1<int> Function()>>());
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -178,10 +270,20 @@ class Test {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -189,10 +291,20 @@ class Test {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -200,10 +312,20 @@ class Test {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_index_expression_disabled_test.dart
index d23b321b340..dc89c3f707d 100644
--- a/tests/language/inference_update_3/if_null_assignment_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_index_expression_disabled_test.dart
@@ -43,18 +43,18 @@ class Indexable<ReadType, WriteType> {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -65,62 +65,106 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((Indexable<int?, Object?>(null)[0] ??= d)
       ..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Indexable<Iterable<int>?, Object?>(null)[0] ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Indexable<Function?, Function?>(null)[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<Iterable<int>?, Object?>(null)[0] ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -131,32 +175,65 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<double?, Object?>(null)[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
@@ -165,10 +242,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -177,10 +264,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -189,10 +286,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_index_expression_test.dart
index c317821e172..da7e67b8520 100644
--- a/tests/language/inference_update_3/if_null_assignment_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_index_expression_test.dart
@@ -46,18 +46,18 @@ class Indexable<ReadType, WriteType> {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -68,72 +68,130 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((Indexable<int?, Object?>(null)[0] ??= d)
       ..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Indexable<Iterable<int>?, Object?>(null)[0] ??=
         iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Indexable<Function?, Function?>(null)[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((Indexable<C1<int>?, Object?>(null)[0] ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((Indexable<C1<int>?, Object?>(null)[0] ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>((Indexable<Iterable<int>?, Object?>(null)[0] ??=
         listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>(
         (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
@@ -141,32 +199,65 @@ main() {
           ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<double?, Object?>(null)[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<int?, Object?>(null)[0] ??= d)
         ..expectStaticType<Exactly<num>>();
@@ -175,10 +266,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -187,10 +288,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
@@ -199,10 +310,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Indexable<C1<int> Function()?, Function?>(null)[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_local_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_local_disabled_test.dart
index 0401df19c76..7bd822afaf3 100644
--- a/tests/language/inference_update_3/if_null_assignment_local_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_local_disabled_test.dart
@@ -30,18 +30,18 @@ class CallableClass<T> {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     var string = '';
@@ -51,39 +51,54 @@ main() {
     var numQuestion = null as num?;
     numQuestion ??= contextType(0)..expectStaticType<Exactly<num?>>();
 
-    numQuestion = null as num?;
     if (numQuestion is int?) {
       numQuestion ??= contextType(0)..expectStaticType<Exactly<int?>>();
     }
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
-    var local1 = null as Object?;
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    Object? local1;
     var d = 2.0;
+    local1 = null as Object?;
     if (local1 is int?) {
       // We avoid having a compile-time error because `local1` can be demoted.
       context<Object>((local1 ??= d)..expectStaticType<Exactly<num>>());
     }
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     local1 = null as Object?;
     if (local1 is Iterable<int>?) {
@@ -92,17 +107,34 @@ main() {
         ..expectStaticType<Exactly<Iterable<num>>>());
     }
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
-    var local2 = null as Function?;
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    Function? local2;
     var callableClassInt = CallableClass<int>();
+    local2 = null as Function?;
     context<Function>(
         (local2 ??= callableClassInt)..expectStaticType<Exactly<Function>>());
 
     // Verify that the RHS is not coerced to the promoted type.
-    // K=Object, T1=Function?, and T2'=CallableClass<int>, therefore T=Object
-    // and S=Object, so T <: S, and hence the type of E is Object.
+    // This example has:
+    // - K = Object
+    // - T1 = Function?
+    // - T2' = CallableClass<int>
+    // Which implies:
+    // - T = Object
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Object.
     local1 = null as Object?;
     if (local1 is Function?) {
       // We avoid having a compile-time error because `local1` can be demoted.
@@ -111,27 +143,50 @@ main() {
     }
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
-    var local1 = null as Object?;
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
+    Object? local1;
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    local1 = null as Object?;
+    o = [0] as Object?;
     if (local1 is Iterable<int>? && o is Iterable<num>) {
       // We avoid having a compile-time error because `local1` and `o` can be
       // demoted.
       o = (local1 ??= listNum)..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
-    var local2 = null as Function?;
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
+    Function? local2;
     var callableClassC2Int = CallableClass<C2<int>>();
+    local2 = null as Function?;
     o = (() => B1<int>()) as Object?;
     if (local2 is C1<int> Function()? && o is B1<int> Function()) {
       // We avoid having a compile-time error because `local2` and `o` can be
@@ -141,16 +196,28 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
-    var local1 = null as Object?;
+    Object? local1;
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    local1 = null as Object?;
+    o = 0 as Object?;
     if (local1 is int? && o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `local1` and `o` can be
       // demoted.
       o = (local1 ??= d)..expectStaticType<Exactly<num>>();
@@ -158,9 +225,19 @@ main() {
     local1 = null as Object?;
     o = 0 as Object?;
     if (local1 is double? && o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `local1` and `o` can be
       // demoted.
       o = (local1 ??= intQuestion)..expectStaticType<Exactly<num?>>();
@@ -168,21 +245,44 @@ main() {
     local1 = null as Object?;
     o = '' as Object?;
     if (local1 is int? && o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `local1` and `o` can be
       // demoted.
       o = (local1 ??= d)..expectStaticType<Exactly<num>>();
     }
 
-    var local2 = null as Function?;
+    Function? local2;
     var callableClassC2Int = CallableClass<C2<int>>();
+    local2 = null as Function?;
     o = (() => C1<int>()) as Object?;
     if (local2 is C1<int> Function()? && o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `local2` and `o` can be
       // demoted.
       o = (local2 ??= callableClassC2Int)
@@ -192,10 +292,20 @@ main() {
     local2 = null as Function?;
     o = (() => C2<int>()) as Object?;
     if (local2 is C1<int> Function()? && o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `local2` and `o` can be
       // demoted.
       o = (local2 ??= callableClassC2Int)
@@ -205,10 +315,20 @@ main() {
     local2 = null as Function?;
     o = 0 as Object?;
     if (local2 is C1<int> Function()? && o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `local2` and `o` can be
       // demoted.
       o = (local2 ??= callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_local_test.dart b/tests/language/inference_update_3/if_null_assignment_local_test.dart
index d0ba1451b04..b6d45ddd115 100644
--- a/tests/language/inference_update_3/if_null_assignment_local_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_local_test.dart
@@ -33,18 +33,18 @@ class CallableClass<T> {
 Object? contextB1<T>(B1<T> x) => x;
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     var string = '';
@@ -54,39 +54,54 @@ main() {
     var numQuestion = null as num?;
     numQuestion ??= contextType(0)..expectStaticType<Exactly<num?>>();
 
-    numQuestion = null as num?;
     if (numQuestion is int?) {
       numQuestion ??= contextType(0)..expectStaticType<Exactly<int?>>();
     }
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
-    var local1 = null as Object?;
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    Object? local1;
     var d = 2.0;
+    local1 = null as Object?;
     if (local1 is int?) {
       // We avoid having a compile-time error because `local1` can be demoted.
       context<Object>((local1 ??= d)..expectStaticType<Exactly<num>>());
     }
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     local1 = null as Object?;
     if (local1 is Iterable<int>?) {
@@ -95,17 +110,34 @@ main() {
         ..expectStaticType<Exactly<Iterable<num>>>());
     }
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
-    var local2 = null as Function?;
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    Function? local2;
     var callableClassInt = CallableClass<int>();
+    local2 = null as Function?;
     context<Function>(
         (local2 ??= callableClassInt)..expectStaticType<Exactly<Function>>());
 
     // Verify that the RHS is not coerced to the promoted type.
-    // K=Object, T1=Function?, and T2'=CallableClass<int>, therefore T=Object
-    // and S=Object, so T <: S, and hence the type of E is Object.
+    // This example has:
+    // - K = Object
+    // - T1 = Function?
+    // - T2' = CallableClass<int>
+    // Which implies:
+    // - T = Object
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Object.
     local1 = null as Object?;
     if (local1 is Function?) {
       // We avoid having a compile-time error because `local1` can be demoted.
@@ -114,23 +146,41 @@ main() {
     }
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
-    var local1 = null as Object?;
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
+    Object? local1;
     var c2Double = C2<double>();
+    local1 = null as Object?;
     if (local1 is C1<int>?) {
       // We avoid having a compile-time error because `local1` can be demoted.
       contextB1(
           (local1 ??= c2Double)..expectStaticType<Exactly<B1<Object?>>>());
     }
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     local1 = null as Object?;
     if (local1 is C1<int>?) {
       // We avoid having a compile-time error because `local1` can be demoted.
@@ -138,9 +188,18 @@ main() {
           (local1 ??= c2Double)..expectStaticType<Exactly<B1<Object>>>());
     }
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     local1 = null as Object?;
     if (local1 is Iterable<int>?) {
@@ -149,12 +208,22 @@ main() {
           (local1 ??= listNum)..expectStaticType<Exactly<Iterable<num>>>());
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
-    var local2 = null as Function?;
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
+    Function? local2;
     var callableClassC2Int = CallableClass<C2<int>>();
+    local2 = null as Function?;
     if (local2 is C1<int> Function()?) {
       // We avoid having a compile-time error because `local2` can be demoted.
       context<B1<int> Function()>((local2 ??= callableClassC2Int)
@@ -162,16 +231,28 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
-    var local1 = null as Object?;
+    Object? local1;
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    local1 = null as Object?;
+    o = 0 as Object?;
     if (local1 is int? && o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `local1` and `o` can be
       // demoted.
       o = (local1 ??= d)..expectStaticType<Exactly<num>>();
@@ -179,9 +260,19 @@ main() {
     local1 = null as Object?;
     o = 0 as Object?;
     if (local1 is double? && o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `local1` and `o` can be
       // demoted.
       o = (local1 ??= intQuestion)..expectStaticType<Exactly<num?>>();
@@ -189,21 +280,44 @@ main() {
     local1 = null as Object?;
     o = '' as Object?;
     if (local1 is int? && o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `local1` and `o` can be
       // demoted.
       o = (local1 ??= d)..expectStaticType<Exactly<num>>();
     }
 
-    var local2 = null as Function?;
+    Function? local2;
     var callableClassC2Int = CallableClass<C2<int>>();
+    local2 = null as Function?;
     o = (() => C1<int>()) as Object?;
     if (local2 is C1<int> Function()? && o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `local2` and `o` can be
       // demoted.
       o = (local2 ??= callableClassC2Int)
@@ -213,10 +327,20 @@ main() {
     local2 = null as Function?;
     o = (() => C2<int>()) as Object?;
     if (local2 is C1<int> Function()? && o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `local2` and `o` can be
       // demoted.
       o = (local2 ??= callableClassC2Int)
@@ -226,10 +350,20 @@ main() {
     local2 = null as Function?;
     o = 0 as Object?;
     if (local2 is C1<int> Function()? && o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `local2` and `o` can be
       // demoted.
       o = (local2 ??= callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_disabled_test.dart
index 27bc5cf39d5..d59e189ad26 100644
--- a/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_disabled_test.dart
@@ -47,18 +47,18 @@ Indexable<ReadType, WriteType>? maybeIndexable<ReadType, WriteType>(
     Indexable<ReadType, WriteType>(value);
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -69,67 +69,111 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>((maybeIndexable<int?, Object?>(null)?[0] ??= d)
       ..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion(
         (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= iterableDouble)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((maybeIndexable<Function?, Function?>(null)?[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Object (which becomes Object? after null
-    // shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
+    // (Which becomes Object? after null shorting completes.)
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>?) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= listNum)
         ..expectStaticType<Exactly<Object?>>();
     }
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function() (which becomes A Function()? after
-    // null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
+    // (Which becomes A Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()?) {
@@ -140,33 +184,67 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<double?, Object?>(null)?[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
@@ -175,11 +253,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -188,11 +276,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -201,11 +299,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_test.dart
index 96ef25bcc76..cc72f707aff 100644
--- a/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_null_aware_index_expression_test.dart
@@ -50,18 +50,18 @@ Indexable<ReadType, WriteType>? maybeIndexable<ReadType, WriteType>(
     Indexable<ReadType, WriteType>(value);
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -72,80 +72,138 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>((maybeIndexable<int?, Object?>(null)?[0] ??= d)
       ..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion(
         (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= iterableDouble)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((maybeIndexable<Function?, Function?>(null)?[0] ??=
         callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is B1<Object?> (which becomes B1<Object?>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<_>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
+    // (Which becomes B1<Object?>? after null shorting completes.)
     var c2Double = C2<double>();
     contextB1Question((maybeIndexable<C1<int>?, Object?>(null)?[0] ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>?>>());
 
-    // K=B1<Object>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object> (which becomes B1<Object>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<Object>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
+    // (Which becomes B1<Object>? after null shorting completes.)
     contextB1Question<Object>((maybeIndexable<C1<int>?, Object?>(null)?[0] ??=
         c2Double)
       ..expectStaticType<Exactly<B1<Object>?>>());
 
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Iterable<num> (which becomes
-    // Iterable<num>? after null shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var listNum = <num>[];
     context<Iterable<num>?>(
         (maybeIndexable<Iterable<int>?, Object?>(null)?[0] ??= listNum)
           ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function() (which becomes B1<int>
-    // Function()? after null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
+    // (Which becomes B1<int> Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()?>(
         (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
@@ -153,33 +211,67 @@ main() {
           ..expectStaticType<Exactly<B1<int> Function()?>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<double?, Object?>(null)?[0] ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<int?, Object?>(null)?[0] ??= d)
         ..expectStaticType<Exactly<num?>>();
@@ -188,11 +280,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -201,11 +303,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
@@ -214,11 +326,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (maybeIndexable<C1<int> Function()?, Function?>(null)?[0] ??=
           callableClassC2Int)
diff --git a/tests/language/inference_update_3/if_null_assignment_null_aware_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_null_aware_property_disabled_test.dart
index 7abb4d3ab5a..9e69f7a6518 100644
--- a/tests/language/inference_update_3/if_null_assignment_null_aware_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_null_aware_property_disabled_test.dart
@@ -55,18 +55,18 @@ class Test {
 main() {
   var test = Test() as Test?;
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -76,65 +76,109 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>(
         (test?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion((test?.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((test?.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Object (which becomes Object? after null
-    // shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
+    // (Which becomes Object? after null shorting completes.)
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>?) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object?>>();
     }
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function() (which becomes A Function()? after
-    // null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
+    // (Which becomes A Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()?) {
@@ -144,32 +188,66 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
@@ -177,11 +255,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -189,11 +277,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -201,11 +299,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_null_aware_property_test.dart b/tests/language/inference_update_3/if_null_assignment_null_aware_property_test.dart
index 0f463092625..a18601bb7a0 100644
--- a/tests/language/inference_update_3/if_null_assignment_null_aware_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_null_aware_property_test.dart
@@ -60,18 +60,18 @@ class Test {
 main() {
   var test = Test() as Test?;
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -81,108 +81,200 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object?, T1=int?, and T2'=double, therefore T=num and S=Object?, so T
-    // <: S, and hence the type of E is num (which becomes num? after null
-    // shorting completes).
+    // This example has:
+    // - K = Object?
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
+    // (Which becomes num? after null shorting completes.)
     var d = 2.0;
     context<Object?>(
         (test?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>());
 
-    // K=Iterable<_>?, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>?, so T <: S, and hence the type
-    // of E is Iterable<num> (which becomes Iterable<num>? after null shorting
-    // completes).
+    // This example has:
+    // - K = Iterable<_>?
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterableQuestion((test?.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=Function?, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function?, so T <: S,
-    // and hence the type of E is Function (which becomes Function? after null
-    // shorting completes).
+    // This example has:
+    // - K = Function?
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function?
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
+    // (Which becomes Function? after null shorting completes.)
     var callableClassInt = CallableClass<int>();
     context<Function?>((test?.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function?>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is B1<Object?> (which becomes B1<Object?>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<_>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
+    // (Which becomes B1<Object?>? after null shorting completes.)
     var c2Double = C2<double>();
     contextB1Question((test?.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>?>>());
 
-    // K=B1<Object>?, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>?, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object> (which becomes B1<Object>? after null
-    // shorting completes).
+    // This example has:
+    // - K = B1<Object>?
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
+    // (Which becomes B1<Object>? after null shorting completes.)
     contextB1Question<Object>((test?.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>?>>());
 
-    // K=Iterable<num>?, T1=Iterable<int>?, and T2'=List<num>, therefore
-    // T=Object and S=Iterable<num>?, so T is not <: S, but NonNull(T1) <: S and
-    // T2' <: S, hence the type of E is Iterable<num> (which becomes
-    // Iterable<num>? after null shorting completes).
+    // This example has:
+    // - K = Iterable<num>?
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
+    // (Which becomes Iterable<num>? after null shorting completes.)
     var listNum = <num>[];
     context<Iterable<num>?>((test?.pIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>?>>());
 
-    // K=B1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function()?, so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function() (which becomes B1<int>
-    // Function()? after null shorting completes).
+    // This example has:
+    // - K = B1<int> Function()?
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()?
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
+    // (Which becomes B1<int> Function()? after null shorting completes.)
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()?>((test?.pC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()?>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num
-      // (which becomes num? after null shorting completes).
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
+      // (Which becomes num? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pIntQuestion ??= d)..expectStaticType<Exactly<num?>>();
     }
@@ -190,11 +282,21 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()?) {
-      // K=C1<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function()?, so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C1<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -202,11 +304,21 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()?) {
-      // K=C2<int> Function()?, T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function()?, so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function() (which
-      // becomes A Function()? after null shorting completes).
+      // This example has:
+      // - K = C2<int> Function()?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
@@ -214,11 +326,21 @@ main() {
 
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-      // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int?,
-      // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type
-      // of E is A Function() (which becomes A Function()? after null shorting
-      // completes).
+      // This example has:
+      // - K = int?
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
+      // (Which becomes A Function()? after null shorting completes.)
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test?.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()?>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_property_disabled_test.dart
index 46c018b1dfa..fb4c0ff6e02 100644
--- a/tests/language/inference_update_3/if_null_assignment_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_property_disabled_test.dart
@@ -55,18 +55,18 @@ class Test {
 main() {
   var test = Test();
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -76,60 +76,104 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (test.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((test.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((test.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -139,31 +183,64 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -171,10 +248,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -182,10 +269,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -193,10 +290,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_property_test.dart b/tests/language/inference_update_3/if_null_assignment_property_test.dart
index 6d636ab6634..7f172c19ab8 100644
--- a/tests/language/inference_update_3/if_null_assignment_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_property_test.dart
@@ -60,18 +60,18 @@ class Test {
 main() {
   var test = Test();
 
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -81,100 +81,191 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (test.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((test.pIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((test.pFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((test.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((test.pC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>((test.pIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>((test.pC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -182,10 +273,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -193,10 +294,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -204,10 +315,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (test.pC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_static_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_static_property_disabled_test.dart
index 7f1a7968f04..90466a901b6 100644
--- a/tests/language/inference_update_3/if_null_assignment_static_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_static_property_disabled_test.dart
@@ -53,18 +53,18 @@ class Test {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -74,60 +74,104 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (Test.staticIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Test.staticIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Test.staticFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -137,31 +181,64 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -169,10 +246,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -180,10 +267,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -191,10 +288,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_static_property_test.dart b/tests/language/inference_update_3/if_null_assignment_static_property_test.dart
index ff18c4f4b1d..7fce7c4f7d7 100644
--- a/tests/language/inference_update_3/if_null_assignment_static_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_static_property_test.dart
@@ -58,18 +58,18 @@ class Test {
 }
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -79,100 +79,191 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (Test.staticIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((Test.staticIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((Test.staticFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((Test.staticC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((Test.staticC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>((Test.staticIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>((Test.staticC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -180,10 +271,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -191,10 +292,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -202,10 +313,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (Test.staticC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_super_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_super_index_expression_disabled_test.dart
index c398730b8bf..947dbd1c186 100644
--- a/tests/language/inference_update_3/if_null_assignment_super_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_super_index_expression_disabled_test.dart
@@ -42,15 +42,15 @@ class Indexable<ReadType, WriteType> {
   operator []=(int index, WriteType value) {}
 }
 
-// - An if-null assignment `E` of the form `e1 ??= e2` with context type `K` is
+// - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
 //   analyzed as follows:
 //
-//   - Let `T1` be the read type of `e1`. This is the static type that `e1`
-//     would have as an expression with a context type schema of `_`.
-//   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-//     - If the lvalue is a local variable, `J` is the current (possibly
-//       promoted) type of the variable.
-//     - Otherwise, `J` is the write type `e1`. This is the type schema that the
+//   - Let T1 be the read type of `e1`. This is the static type that `e1` would
+//     have as an expression with a context type schema of `_`.
+//   - Let T2 be the type of `e2` inferred with context type J, where:
+//     - If the lvalue is a local variable, J is the current (possibly promoted)
+//       type of the variable.
+//     - Otherwise, J is the write type `e1`. This is the type schema that the
 //       setter associated with `e1` imposes on its single argument (or, for the
 //       case of indexed assignment, the type schema that `operator[]=` imposes
 //       on its second argument).
@@ -71,24 +71,33 @@ class Test2 extends Indexable<String?, String?> {
   }
 }
 
-//   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-//     - If `e1` is a local variable, `J'` is the declared (unpromoted) type of
+//   - Let J' be the unpromoted write type of `e1`, defined as follows:
+//     - If `e1` is a local variable, J' is the declared (unpromoted) type of
 //       `e1`.
-//     - Otherwise `J' = J`.
-//   - Let `T2'` be the coerced type of `e2`, defined as follows:
-//     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is needed).
-//     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-//       subtype of `J'`, then apply that coercion and let `T2'` be the type
+//     - Otherwise J' = J.
+//   - Let T2' be the coerced type of `e2`, defined as follows:
+//     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+//     - Otherwise, if T2 can be coerced to a some other type which *is* a
+//       subtype of J', then apply that coercion and let T2' be the type
 //       resulting from the coercion.
 //     - Otherwise, it is a compile-time error.
-//   - Let `T` be `UP(NonNull(T1), T2')`.
-//   - Let `S` be the greatest closure of `K`.
-//   - If `T <: S`, then the type of `E` is `T`.
+//   - Let T be UP(NonNull(T1), T2').
+//   - Let S be the greatest closure of K.
+//   - If T <: S, then the type of `e` is T.
+//     (Testing this case here. Otherwise continued below.)
 class Test3 extends Indexable<int?, Object?> {
   Test3() : super(null);
   test() {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((super[0] ??= d)..expectStaticType<Exactly<num>>());
   }
@@ -97,9 +106,16 @@ class Test3 extends Indexable<int?, Object?> {
 class Test4 extends Indexable<Iterable<int>?, Object?> {
   Test4() : super(null);
   test() {
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((super[0] ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
@@ -109,25 +125,44 @@ class Test4 extends Indexable<Iterable<int>?, Object?> {
 class Test5 extends Indexable<Function?, Function?> {
   Test5() : super(null);
   test() {
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>(
         (super[0] ??= callableClassInt)..expectStaticType<Exactly<Function>>());
   }
 }
 
-//   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E` is
-//     `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+//   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3` is
+//     enabled, then the type of `e` is S.
 class Test6 extends Indexable<Iterable<int>?, Object?> {
   Test6() : super(null);
   test() {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= listNum)..expectStaticType<Exactly<Object>>();
@@ -138,12 +173,23 @@ class Test6 extends Indexable<Iterable<int>?, Object?> {
 class Test7 extends Indexable<C1<int> Function()?, Function?> {
   Test7() : super(null);
   test() {
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => B1<int>()) as Object?;
+    Object? o;
+    o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= callableClassC2Int)
@@ -152,16 +198,27 @@ class Test7 extends Indexable<C1<int> Function()?, Function?> {
   }
 }
 
-//   - Otherwise, the type of `E` is `T`.
+//   - Otherwise, the type of `e` is T.
 class Test8 extends Indexable<int?, Object?> {
   Test8() : super(null);
   test() {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -172,11 +229,22 @@ class Test9 extends Indexable<double?, Object?> {
   Test9() : super(null);
   test() {
     var intQuestion = null as int?;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= intQuestion)..expectStaticType<Exactly<num?>>();
     }
@@ -187,10 +255,23 @@ class Test10 extends Indexable<int?, Object?> {
   Test10() : super(null);
   test() {
     var d = 2.0;
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -201,12 +282,23 @@ class Test11 extends Indexable<C1<int> Function()?, Function?> {
   Test11() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C1<int>()) as Object?;
+    Object? o;
+    o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -218,12 +310,23 @@ class Test12 extends Indexable<C1<int> Function()?, Function?> {
   Test12() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C2<int>()) as Object?;
+    Object? o;
+    o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -235,12 +338,23 @@ class Test13 extends Indexable<C1<int> Function()?, Function?> {
   Test13() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_super_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_super_index_expression_test.dart
index 4a20e5b71e9..4d6fbcb591d 100644
--- a/tests/language/inference_update_3/if_null_assignment_super_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_super_index_expression_test.dart
@@ -46,15 +46,15 @@ class Indexable<ReadType, WriteType> {
   operator []=(int index, WriteType value) {}
 }
 
-// - An if-null assignment `E` of the form `e1 ??= e2` with context type `K` is
+// - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
 //   analyzed as follows:
 //
-//   - Let `T1` be the read type of `e1`. This is the static type that `e1`
-//     would have as an expression with a context type schema of `_`.
-//   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-//     - If the lvalue is a local variable, `J` is the current (possibly
-//       promoted) type of the variable.
-//     - Otherwise, `J` is the write type `e1`. This is the type schema that the
+//   - Let T1 be the read type of `e1`. This is the static type that `e1` would
+//     have as an expression with a context type schema of `_`.
+//   - Let T2 be the type of `e2` inferred with context type J, where:
+//     - If the lvalue is a local variable, J is the current (possibly promoted)
+//       type of the variable.
+//     - Otherwise, J is the write type `e1`. This is the type schema that the
 //       setter associated with `e1` imposes on its single argument (or, for the
 //       case of indexed assignment, the type schema that `operator[]=` imposes
 //       on its second argument).
@@ -75,24 +75,33 @@ class Test2 extends Indexable<String?, String?> {
   }
 }
 
-//   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-//     - If `e1` is a local variable, `J'` is the declared (unpromoted) type of
+//   - Let J' be the unpromoted write type of `e1`, defined as follows:
+//     - If `e1` is a local variable, J' is the declared (unpromoted) type of
 //       `e1`.
-//     - Otherwise `J' = J`.
-//   - Let `T2'` be the coerced type of `e2`, defined as follows:
-//     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is needed).
-//     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-//       subtype of `J'`, then apply that coercion and let `T2'` be the type
+//     - Otherwise J' = J.
+//   - Let T2' be the coerced type of `e2`, defined as follows:
+//     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+//     - Otherwise, if T2 can be coerced to a some other type which *is* a
+//       subtype of J', then apply that coercion and let T2' be the type
 //       resulting from the coercion.
 //     - Otherwise, it is a compile-time error.
-//   - Let `T` be `UP(NonNull(T1), T2')`.
-//   - Let `S` be the greatest closure of `K`.
-//   - If `T <: S`, then the type of `E` is `T`.
+//   - Let T be UP(NonNull(T1), T2').
+//   - Let S be the greatest closure of K.
+//   - If T <: S, then the type of `e` is T.
+//     (Testing this case here. Otherwise continued below.)
 class Test3 extends Indexable<int?, Object?> {
   Test3() : super(null);
   test() {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((super[0] ??= d)..expectStaticType<Exactly<num>>());
   }
@@ -101,9 +110,16 @@ class Test3 extends Indexable<int?, Object?> {
 class Test4 extends Indexable<Iterable<int>?, Object?> {
   Test4() : super(null);
   test() {
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((super[0] ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
@@ -113,23 +129,39 @@ class Test4 extends Indexable<Iterable<int>?, Object?> {
 class Test5 extends Indexable<Function?, Function?> {
   Test5() : super(null);
   test() {
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>(
         (super[0] ??= callableClassInt)..expectStaticType<Exactly<Function>>());
   }
 }
 
-//   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E` is
-//     `S`.
+//   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
 class Test6 extends Indexable<C1<int>?, Object?> {
   Test6() : super(null);
   test() {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1(
         (super[0] ??= c2Double)..expectStaticType<Exactly<B1<Object?>>>());
@@ -139,9 +171,18 @@ class Test6 extends Indexable<C1<int>?, Object?> {
 class Test7 extends Indexable<C1<int>?, Object?> {
   Test7() : super(null);
   test() {
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     var c2Double = C2<double>();
     contextB1<Object>(
         (super[0] ??= c2Double)..expectStaticType<Exactly<B1<Object>>>());
@@ -151,9 +192,18 @@ class Test7 extends Indexable<C1<int>?, Object?> {
 class Test8 extends Indexable<Iterable<int>?, Object?> {
   Test8() : super(null);
   test() {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>(
         (super[0] ??= listNum)..expectStaticType<Exactly<Iterable<num>>>());
@@ -163,26 +213,46 @@ class Test8 extends Indexable<Iterable<int>?, Object?> {
 class Test9 extends Indexable<C1<int> Function()?, Function?> {
   Test9() : super(null);
   test() {
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>((super[0] ??= callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 }
 
-//   - Otherwise, the type of `E` is `T`.
+//   - Otherwise, the type of `e` is T.
 class Test10 extends Indexable<int?, Object?> {
   Test10() : super(null);
   test() {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -193,11 +263,22 @@ class Test11 extends Indexable<double?, Object?> {
   Test11() : super(null);
   test() {
     var intQuestion = null as int?;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= intQuestion)..expectStaticType<Exactly<num?>>();
     }
@@ -208,10 +289,23 @@ class Test12 extends Indexable<int?, Object?> {
   Test12() : super(null);
   test() {
     var d = 2.0;
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -222,12 +316,23 @@ class Test13 extends Indexable<C1<int> Function()?, Function?> {
   Test13() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C1<int>()) as Object?;
+    Object? o;
+    o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -239,12 +344,23 @@ class Test14 extends Indexable<C1<int> Function()?, Function?> {
   Test14() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C2<int>()) as Object?;
+    Object? o;
+    o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -256,12 +372,23 @@ class Test15 extends Indexable<C1<int> Function()?, Function?> {
   Test15() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (super[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_super_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_super_property_disabled_test.dart
index c04566c3790..c496aceb7c5 100644
--- a/tests/language/inference_update_3/if_null_assignment_super_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_super_property_disabled_test.dart
@@ -55,15 +55,15 @@ class Base {
 
 class Test extends Base {
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -76,61 +76,104 @@ class Test extends Base {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>(
           (super.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((super.pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((super.pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S` if `inference-update-3` is enabled, else the type of `E` is
-    //     `T`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+    //     is enabled, then the type of `e` is S.
     {
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Object.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = Object.
       var listNum = <num>[];
-      var o = [0] as Object?;
+      Object? o;
+      o = [0] as Object?;
       if (o is Iterable<num>) {
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pIterableIntQuestion ??= listNum)
           ..expectStaticType<Exactly<Object>>();
       }
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is A Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // However, inference-update-3 is not enabled.
+      // Therefore the type of `e` is T = A Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => B1<int>()) as Object?;
       if (o is B1<int> Function()) {
@@ -140,31 +183,64 @@ class Test extends Base {
       }
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -172,10 +248,20 @@ class Test extends Base {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -183,10 +269,20 @@ class Test extends Base {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -194,10 +290,20 @@ class Test extends Base {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_super_property_test.dart b/tests/language/inference_update_3/if_null_assignment_super_property_test.dart
index 99738d9355c..9986d752694 100644
--- a/tests/language/inference_update_3/if_null_assignment_super_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_super_property_test.dart
@@ -60,15 +60,15 @@ class Base {
 
 class Test extends Base {
   test() {
-    // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
+    // - An if-null assignment `e` of the form `e1 ??= e2` with context type K
     //   is analyzed as follows:
     //
-    //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+    //   - Let T1 be the read type of `e1`. This is the static type that `e1`
     //     would have as an expression with a context type schema of `_`.
-    //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-    //     - If the lvalue is a local variable, `J` is the current (possibly
+    //   - Let T2 be the type of `e2` inferred with context type J, where:
+    //     - If the lvalue is a local variable, J is the current (possibly
     //       promoted) type of the variable.
-    //     - Otherwise, `J` is the write type `e1`. This is the type schema that
+    //     - Otherwise, J is the write type `e1`. This is the type schema that
     //       the setter associated with `e1` imposes on its single argument (or,
     //       for the case of indexed assignment, the type schema that
     //       `operator[]=` imposes on its second argument).
@@ -81,100 +81,192 @@ class Test extends Base {
         ..expectStaticType<Exactly<String?>>();
     }
 
-    //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-    //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
+    //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+    //     - If `e1` is a local variable, J' is the declared (unpromoted) type
     //       of `e1`.
-    //     - Otherwise `J' = J`.
-    //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-    //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-    //       needed).
-    //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-    //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+    //     - Otherwise J' = J.
+    //   - Let T2' be the coerced type of `e2`, defined as follows:
+    //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+    //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+    //       subtype of J', then apply that coercion and let T2' be the type
     //       resulting from the coercion.
     //     - Otherwise, it is a compile-time error.
-    //   - Let `T` be `UP(NonNull(T1), T2')`.
-    //   - Let `S` be the greatest closure of `K`.
-    //   - If `T <: S`, then the type of `E` is `T`.
+    //   - Let T be UP(NonNull(T1), T2').
+    //   - Let S be the greatest closure of K.
+    //   - If T <: S, then the type of `e` is T.
+    //     (Testing this case here. Otherwise continued below.)
     {
-      // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T
-      // <: S, and hence the type of E is num.
+      // This example has:
+      // - K = Object
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = Object
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = num.
       var d = 2.0;
       context<Object>(
           (super.pIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-      // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-      // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type
-      // of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<_>
+      // - T1 = Iterable<int>?
+      // - T2' = Iterable<double>
+      // Which implies:
+      // - T = Iterable<num>
+      // - S = Iterable<Object?>
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Iterable<num>.
       var iterableDouble = <double>[] as Iterable<double>;
       contextIterable((super.pIterableIntQuestion ??= iterableDouble)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=Function, T1=Function?, and T2'=int Function() (coerced from
-      // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-      // and hence the type of E is Function.
+      // This example has:
+      // - K = Function
+      // - T1 = Function?
+      // - T2' = int Function()
+      //    (coerced from T2=CallableClass<int>)
+      // Which implies:
+      // - T = Function
+      // - S = Function
+      // We have:
+      // - T <: S
+      // Therefore the type of `e` is T = Function.
       var callableClassInt = CallableClass<int>();
       context<Function>((super.pFunctionQuestion ??= callableClassInt)
         ..expectStaticType<Exactly<Function>>());
     }
 
-    //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-    //     is `S`.
+    //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is
+    //     S.
     {
-      // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object?>.
+      // This example has:
+      // - K = B1<_>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object?>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object?>.
       var c2Double = C2<double>();
       contextB1((super.pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object?>>>());
 
-      // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-      // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-      // hence the type of E is B1<Object>.
+      // This example has:
+      // - K = B1<Object>
+      // - T1 = C1<int>?
+      // - T2' = C2<double>
+      // Which implies:
+      // - T = A
+      // - S = B1<Object>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<Object>.
       contextB1<Object>((super.pC1IntQuestion ??= c2Double)
         ..expectStaticType<Exactly<B1<Object>>>());
 
-      // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore
-      // T=Object and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S
-      // and T2' <: S, hence the type of E is Iterable<num>.
+      // This example has:
+      // - K = Iterable<num>
+      // - T1 = Iterable<int>?
+      // - T2' = List<num>
+      // Which implies:
+      // - T = Object
+      // - S = Iterable<num>
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = Iterable<num>.
       var listNum = <num>[];
       context<Iterable<num>>((super.pIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Iterable<num>>>());
 
-      // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=B1<int> Function(), so T is not <: S, but NonNull(T1)
-      // <: S and T2' <: S, hence the type of E is B1<int> Function().
+      // This example has:
+      // - K = B1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = B1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <: S
+      // Therefore the type of `e` is S = B1<int> Function().
       var callableClassC2Int = CallableClass<C2<int>>();
       context<B1<int> Function()>((super.pC1IntFunctionQuestion ??=
           callableClassC2Int)
         ..expectStaticType<Exactly<B1<int> Function()>>());
     }
 
-    //   - Otherwise, the type of `E` is `T`.
+    //   - Otherwise, the type of `e` is T.
     {
       var d = 2.0;
-      var o = 0 as Object?;
+      Object? o;
       var intQuestion = null as int?;
+      o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-        // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E
-        // is num.
+        // This example has:
+        // - K = int?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
       o = 0 as Object?;
       if (o is int?) {
-        // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T
-        // is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of
-        // E is num?.
+        // This example has:
+        // - K = int?
+        // - T1 = double?
+        // - T2' = int?
+        // Which implies:
+        // - T = num?
+        // - S = int?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = num?.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pDoubleQuestion ??= intQuestion)
           ..expectStaticType<Exactly<num?>>();
       }
       o = '' as Object?;
       if (o is String?) {
-        // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-        // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+        // This example has:
+        // - K = String?
+        // - T1 = int?
+        // - T2' = double
+        // Which implies:
+        // - T = num
+        // - S = String?
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <!: S
+        // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+        // static type.
+        // Therefore the type of `e` is T = num.
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pIntQuestion ??= d)..expectStaticType<Exactly<num>>();
       }
@@ -182,10 +274,20 @@ class Test extends Base {
       var callableClassC2Int = CallableClass<C2<int>>();
       o = (() => C1<int>()) as Object?;
       if (o is C1<int> Function()) {
-        // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-        // S, but T2' is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C1<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C1<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <: S
+        // - T2' <!: S
+        // The fact that T2' <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -193,10 +295,20 @@ class Test extends Base {
 
       o = (() => C2<int>()) as Object?;
       if (o is C2<int> Function()) {
-        // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-        // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-        // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-        // NonNull(T1) is not <: S. Hence the type of E is A Function().
+        // This example has:
+        // - K = C2<int> Function()
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = C2<int> Function()
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
@@ -204,10 +316,20 @@ class Test extends Base {
 
       o = 0 as Object?;
       if (o is int) {
-        // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced
-        // from T2=CallableClass<C2<int>>), therefore T=A Function() and S=int,
-        // so T is not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the
-        // type of E is A Function().
+        // This example has:
+        // - K = int
+        // - T1 = C1<int> Function()?
+        // - T2' = C2<int> Function()
+        //    (coerced from T2=CallableClass<C2<int>>)
+        // Which implies:
+        // - T = A Function()
+        // - S = int
+        // We have:
+        // - T <!: S
+        // - NonNull(T1) <!: S
+        // - T2' <: S
+        // The fact that NonNull(T1) <!: S precludes using S as static type.
+        // Therefore the type of `e` is T = A Function().
         // We avoid having a compile-time error because `o` can be demoted.
         o = (super.pC1IntFunctionQuestion ??= callableClassC2Int)
           ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_this_index_expression_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_this_index_expression_disabled_test.dart
index ec9e85950be..c628d4c62ed 100644
--- a/tests/language/inference_update_3/if_null_assignment_this_index_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_this_index_expression_disabled_test.dart
@@ -42,15 +42,15 @@ class Indexable<ReadType, WriteType> {
   operator []=(int index, WriteType value) {}
 }
 
-// - An if-null assignment `E` of the form `e1 ??= e2` with context type `K` is
+// - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
 //   analyzed as follows:
 //
-//   - Let `T1` be the read type of `e1`. This is the static type that `e1`
-//     would have as an expression with a context type schema of `_`.
-//   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-//     - If the lvalue is a local variable, `J` is the current (possibly
-//       promoted) type of the variable.
-//     - Otherwise, `J` is the write type `e1`. This is the type schema that the
+//   - Let T1 be the read type of `e1`. This is the static type that `e1` would
+//     have as an expression with a context type schema of `_`.
+//   - Let T2 be the type of `e2` inferred with context type J, where:
+//     - If the lvalue is a local variable, J is the current (possibly promoted)
+//       type of the variable.
+//     - Otherwise, J is the write type `e1`. This is the type schema that the
 //       setter associated with `e1` imposes on its single argument (or, for the
 //       case of indexed assignment, the type schema that `operator[]=` imposes
 //       on its second argument).
@@ -71,24 +71,33 @@ class Test2 extends Indexable<String?, String?> {
   }
 }
 
-//   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-//     - If `e1` is a local variable, `J'` is the declared (unpromoted) type of
+//   - Let J' be the unpromoted write type of `e1`, defined as follows:
+//     - If `e1` is a local variable, J' is the declared (unpromoted) type of
 //       `e1`.
-//     - Otherwise `J' = J`.
-//   - Let `T2'` be the coerced type of `e2`, defined as follows:
-//     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is needed).
-//     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-//       subtype of `J'`, then apply that coercion and let `T2'` be the type
+//     - Otherwise J' = J.
+//   - Let T2' be the coerced type of `e2`, defined as follows:
+//     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+//     - Otherwise, if T2 can be coerced to a some other type which *is* a
+//       subtype of J', then apply that coercion and let T2' be the type
 //       resulting from the coercion.
 //     - Otherwise, it is a compile-time error.
-//   - Let `T` be `UP(NonNull(T1), T2')`.
-//   - Let `S` be the greatest closure of `K`.
-//   - If `T <: S`, then the type of `E` is `T`.
+//   - Let T be UP(NonNull(T1), T2').
+//   - Let S be the greatest closure of K.
+//   - If T <: S, then the type of `e` is T.
+//     (Testing this case here. Otherwise continued below.)
 class Test3 extends Indexable<int?, Object?> {
   Test3() : super(null);
   test() {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((this[0] ??= d)..expectStaticType<Exactly<num>>());
   }
@@ -97,9 +106,16 @@ class Test3 extends Indexable<int?, Object?> {
 class Test4 extends Indexable<Iterable<int>?, Object?> {
   Test4() : super(null);
   test() {
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((this[0] ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
@@ -109,25 +125,44 @@ class Test4 extends Indexable<Iterable<int>?, Object?> {
 class Test5 extends Indexable<Function?, Function?> {
   Test5() : super(null);
   test() {
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>(
         (this[0] ??= callableClassInt)..expectStaticType<Exactly<Function>>());
   }
 }
 
-//   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E` is
-//     `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+//   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3` is
+//     enabled, then the type of `e` is S.
 class Test6 extends Indexable<Iterable<int>?, Object?> {
   Test6() : super(null);
   test() {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= listNum)..expectStaticType<Exactly<Object>>();
@@ -138,12 +173,23 @@ class Test6 extends Indexable<Iterable<int>?, Object?> {
 class Test7 extends Indexable<C1<int> Function()?, Function?> {
   Test7() : super(null);
   test() {
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => B1<int>()) as Object?;
+    Object? o;
+    o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= callableClassC2Int)
@@ -152,16 +198,27 @@ class Test7 extends Indexable<C1<int> Function()?, Function?> {
   }
 }
 
-//   - Otherwise, the type of `E` is `T`.
+//   - Otherwise, the type of `e` is T.
 class Test8 extends Indexable<int?, Object?> {
   Test8() : super(null);
   test() {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -172,11 +229,22 @@ class Test9 extends Indexable<double?, Object?> {
   Test9() : super(null);
   test() {
     var intQuestion = null as int?;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= intQuestion)..expectStaticType<Exactly<num?>>();
     }
@@ -187,10 +255,23 @@ class Test10 extends Indexable<int?, Object?> {
   Test10() : super(null);
   test() {
     var d = 2.0;
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -201,12 +282,23 @@ class Test11 extends Indexable<C1<int> Function()?, Function?> {
   Test11() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C1<int>()) as Object?;
+    Object? o;
+    o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -218,12 +310,23 @@ class Test12 extends Indexable<C1<int> Function()?, Function?> {
   Test12() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C2<int>()) as Object?;
+    Object? o;
+    o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -235,12 +338,23 @@ class Test13 extends Indexable<C1<int> Function()?, Function?> {
   Test13() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_this_index_expression_test.dart b/tests/language/inference_update_3/if_null_assignment_this_index_expression_test.dart
index 06e181e1735..2cd5e83f7d8 100644
--- a/tests/language/inference_update_3/if_null_assignment_this_index_expression_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_this_index_expression_test.dart
@@ -46,15 +46,15 @@ class Indexable<ReadType, WriteType> {
   operator []=(int index, WriteType value) {}
 }
 
-// - An if-null assignment `E` of the form `e1 ??= e2` with context type `K` is
+// - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
 //   analyzed as follows:
 //
-//   - Let `T1` be the read type of `e1`. This is the static type that `e1`
-//     would have as an expression with a context type schema of `_`.
-//   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-//     - If the lvalue is a local variable, `J` is the current (possibly
-//       promoted) type of the variable.
-//     - Otherwise, `J` is the write type `e1`. This is the type schema that the
+//   - Let T1 be the read type of `e1`. This is the static type that `e1` would
+//     have as an expression with a context type schema of `_`.
+//   - Let T2 be the type of `e2` inferred with context type J, where:
+//     - If the lvalue is a local variable, J is the current (possibly promoted)
+//       type of the variable.
+//     - Otherwise, J is the write type `e1`. This is the type schema that the
 //       setter associated with `e1` imposes on its single argument (or, for the
 //       case of indexed assignment, the type schema that `operator[]=` imposes
 //       on its second argument).
@@ -75,24 +75,33 @@ class Test2 extends Indexable<String?, String?> {
   }
 }
 
-//   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-//     - If `e1` is a local variable, `J'` is the declared (unpromoted) type of
+//   - Let J' be the unpromoted write type of `e1`, defined as follows:
+//     - If `e1` is a local variable, J' is the declared (unpromoted) type of
 //       `e1`.
-//     - Otherwise `J' = J`.
-//   - Let `T2'` be the coerced type of `e2`, defined as follows:
-//     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is needed).
-//     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-//       subtype of `J'`, then apply that coercion and let `T2'` be the type
+//     - Otherwise J' = J.
+//   - Let T2' be the coerced type of `e2`, defined as follows:
+//     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+//     - Otherwise, if T2 can be coerced to a some other type which *is* a
+//       subtype of J', then apply that coercion and let T2' be the type
 //       resulting from the coercion.
 //     - Otherwise, it is a compile-time error.
-//   - Let `T` be `UP(NonNull(T1), T2')`.
-//   - Let `S` be the greatest closure of `K`.
-//   - If `T <: S`, then the type of `E` is `T`.
+//   - Let T be UP(NonNull(T1), T2').
+//   - Let S be the greatest closure of K.
+//   - If T <: S, then the type of `e` is T.
+//     (Testing this case here. Otherwise continued below.)
 class Test3 extends Indexable<int?, Object?> {
   Test3() : super(null);
   test() {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>((this[0] ??= d)..expectStaticType<Exactly<num>>());
   }
@@ -101,9 +110,16 @@ class Test3 extends Indexable<int?, Object?> {
 class Test4 extends Indexable<Iterable<int>?, Object?> {
   Test4() : super(null);
   test() {
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((this[0] ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
@@ -113,23 +129,39 @@ class Test4 extends Indexable<Iterable<int>?, Object?> {
 class Test5 extends Indexable<Function?, Function?> {
   Test5() : super(null);
   test() {
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>(
         (this[0] ??= callableClassInt)..expectStaticType<Exactly<Function>>());
   }
 }
 
-//   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E` is
-//     `S`.
+//   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
 class Test6 extends Indexable<C1<int>?, Object?> {
   Test6() : super(null);
   test() {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((this[0] ??= c2Double)..expectStaticType<Exactly<B1<Object?>>>());
   }
@@ -138,9 +170,18 @@ class Test6 extends Indexable<C1<int>?, Object?> {
 class Test7 extends Indexable<C1<int>?, Object?> {
   Test7() : super(null);
   test() {
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     var c2Double = C2<double>();
     contextB1<Object>(
         (this[0] ??= c2Double)..expectStaticType<Exactly<B1<Object>>>());
@@ -150,9 +191,18 @@ class Test7 extends Indexable<C1<int>?, Object?> {
 class Test8 extends Indexable<Iterable<int>?, Object?> {
   Test8() : super(null);
   test() {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>(
         (this[0] ??= listNum)..expectStaticType<Exactly<Iterable<num>>>());
@@ -162,26 +212,46 @@ class Test8 extends Indexable<Iterable<int>?, Object?> {
 class Test9 extends Indexable<C1<int> Function()?, Function?> {
   Test9() : super(null);
   test() {
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>((this[0] ??= callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 }
 
-//   - Otherwise, the type of `E` is `T`.
+//   - Otherwise, the type of `e` is T.
 class Test10 extends Indexable<int?, Object?> {
   Test10() : super(null);
   test() {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -192,11 +262,22 @@ class Test11 extends Indexable<double?, Object?> {
   Test11() : super(null);
   test() {
     var intQuestion = null as int?;
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= intQuestion)..expectStaticType<Exactly<num?>>();
     }
@@ -207,10 +288,23 @@ class Test12 extends Indexable<int?, Object?> {
   Test12() : super(null);
   test() {
     var d = 2.0;
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -221,12 +315,23 @@ class Test13 extends Indexable<C1<int> Function()?, Function?> {
   Test13() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C1<int>()) as Object?;
+    Object? o;
+    o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -238,12 +343,23 @@ class Test14 extends Indexable<C1<int> Function()?, Function?> {
   Test14() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = (() => C2<int>()) as Object?;
+    Object? o;
+    o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -255,12 +371,23 @@ class Test15 extends Indexable<C1<int> Function()?, Function?> {
   Test15() : super(null);
   test() {
     var callableClassC2Int = CallableClass<C2<int>>();
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (this[0] ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_top_level_property_disabled_test.dart b/tests/language/inference_update_3/if_null_assignment_top_level_property_disabled_test.dart
index 63ba40a9eae..741314f7c17 100644
--- a/tests/language/inference_update_3/if_null_assignment_top_level_property_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_top_level_property_disabled_test.dart
@@ -50,18 +50,18 @@ String? get topLevelStringQuestion => null;
 set topLevelStringQuestion(String? value) {}
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -71,60 +71,104 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (topLevelIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((topLevelIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((topLevelFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, and `inference-update-3`
+  //     is enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelIterableIntQuestion ??= listNum)
         ..expectStaticType<Exactly<Object>>();
     }
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is A Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = A Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => B1<int>()) as Object?;
     if (o is B1<int> Function()) {
@@ -134,31 +178,64 @@ main() {
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -166,10 +243,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -177,10 +264,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -188,10 +285,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_assignment_top_level_property_test.dart b/tests/language/inference_update_3/if_null_assignment_top_level_property_test.dart
index 7dfaaa20c81..bb46abd3466 100644
--- a/tests/language/inference_update_3/if_null_assignment_top_level_property_test.dart
+++ b/tests/language/inference_update_3/if_null_assignment_top_level_property_test.dart
@@ -54,18 +54,18 @@ String? get topLevelStringQuestion => null;
 set topLevelStringQuestion(String? value) {}
 
 main() {
-  // - An if-null assignment `E` of the form `e1 ??= e2` with context type `K`
-  //   is analyzed as follows:
+  // - An if-null assignment `e` of the form `e1 ??= e2` with context type K is
+  //   analyzed as follows:
   //
-  //   - Let `T1` be the read type of `e1`. This is the static type that `e1`
+  //   - Let T1 be the read type of `e1`. This is the static type that `e1`
   //     would have as an expression with a context type schema of `_`.
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If the lvalue is a local variable, `J` is the current (possibly
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If the lvalue is a local variable, J is the current (possibly
   //       promoted) type of the variable.
-  //     - Otherwise, `J` is the write type `e1`. This is the type schema that
-  //       the setter associated with `e1` imposes on its single argument (or,
-  //       for the case of indexed assignment, the type schema that
-  //       `operator[]=` imposes on its second argument).
+  //     - Otherwise, J is the write type `e1`. This is the type schema that the
+  //       setter associated with `e1` imposes on its single argument (or, for
+  //       the case of indexed assignment, the type schema that `operator[]=`
+  //       imposes on its second argument).
   {
     // Check the context type of `e`.
     // ignore: dead_null_aware_expression
@@ -75,100 +75,191 @@ main() {
       ..expectStaticType<Exactly<String?>>();
   }
 
-  //   - Let `J'` be the unpromoted write type of `e1`, defined as follows:
-  //     - If `e1` is a local variable, `J'` is the declared (unpromoted) type
-  //       of `e1`.
-  //     - Otherwise `J' = J`.
-  //   - Let `T2'` be the coerced type of `e2`, defined as follows:
-  //     - If `T2` is a subtype of `J'`, then `T2' = T2` (no coercion is
-  //       needed).
-  //     - Otherwise, if `T2` can be coerced to a some other type which *is* a
-  //       subtype of `J'`, then apply that coercion and let `T2'` be the type
+  //   - Let J' be the unpromoted write type of `e1`, defined as follows:
+  //     - If `e1` is a local variable, J' is the declared (unpromoted) type of
+  //       `e1`.
+  //     - Otherwise J' = J.
+  //   - Let T2' be the coerced type of `e2`, defined as follows:
+  //     - If T2 is a subtype of J', then T2' = T2 (no coercion is needed).
+  //     - Otherwise, if T2 can be coerced to a some other type which *is* a
+  //       subtype of J', then apply that coercion and let T2' be the type
   //       resulting from the coercion.
   //     - Otherwise, it is a compile-time error.
-  //   - Let `T` be `UP(NonNull(T1), T2')`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2').
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2'=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2' = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (topLevelIntQuestion ??= d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2'=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2' = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((topLevelIterableIntQuestion ??= iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=Function, T1=Function?, and T2'=int Function() (coerced from
-    // T2=CallableClass<int>), therefore T=Function and S=Function, so T <: S,
-    // and hence the type of E is Function.
+    // This example has:
+    // - K = Function
+    // - T1 = Function?
+    // - T2' = int Function()
+    //    (coerced from T2=CallableClass<int>)
+    // Which implies:
+    // - T = Function
+    // - S = Function
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Function.
     var callableClassInt = CallableClass<int>();
     context<Function>((topLevelFunctionQuestion ??= callableClassInt)
       ..expectStaticType<Exactly<Function>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2' <: S`, then the type of `E`
-  //     is `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2' <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object?>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c2Double = C2<double>();
     contextB1((topLevelC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2'=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2' <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2' = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((topLevelC1IntQuestion ??= c2Double)
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2'=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2' <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2' = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var listNum = <num>[];
     context<Iterable<num>>((topLevelIterableIntQuestion ??= listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
 
-    // K=B1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int> Function()
-    // (coerced from T2=CallableClass<C2<int>>), therefore T=A Function() and
-    // S=B1<int> Function(), so T is not <: S, but NonNull(T1) <: S and T2' <:
-    // S, hence the type of E is B1<int> Function().
+    // This example has:
+    // - K = B1<int> Function()
+    // - T1 = C1<int> Function()?
+    // - T2' = C2<int> Function()
+    //    (coerced from T2=CallableClass<C2<int>>)
+    // Which implies:
+    // - T = A Function()
+    // - S = B1<int> Function()
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2' <: S
+    // Therefore the type of `e` is S = B1<int> Function().
     var callableClassC2Int = CallableClass<C2<int>>();
     context<B1<int> Function()>((topLevelC1IntFunctionQuestion ??=
         callableClassC2Int)
       ..expectStaticType<Exactly<B1<int> Function()>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var intQuestion = null as int?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2'=double, therefore T=num and S=int?, so T is
-      // not <: S. NonNull(T1) <: S, but T2' is not <: S. Hence the type of E is
-      // num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2'=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2' = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelDoubleQuestion ??= intQuestion)
         ..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2'=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2' are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2' = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <!: S
+      // The fact that NonNull(T1) <!: S and T2' <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelIntQuestion ??= d)..expectStaticType<Exactly<num>>();
     }
@@ -176,10 +267,20 @@ main() {
     var callableClassC2Int = CallableClass<C2<int>>();
     o = (() => C1<int>()) as Object?;
     if (o is C1<int> Function()) {
-      // K=C1<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C1<int> Function(), so T is not <: S. NonNull(T1) <:
-      // S, but T2' is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C1<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C1<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2' <!: S
+      // The fact that T2' <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -187,10 +288,20 @@ main() {
 
     o = (() => C2<int>()) as Object?;
     if (o is C2<int> Function()) {
-      // K=C2<int> Function(), T1=C1<int> Function()?, and T2'=C2<int>
-      // Function() (coerced from T2=CallableClass<C2<int>>), therefore T=A
-      // Function() and S=C2<int> Function(), so T is not <: S. T2' <: S, but
-      // NonNull(T1) is not <: S. Hence the type of E is A Function().
+      // This example has:
+      // - K = C2<int> Function()
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = C2<int> Function()
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
@@ -198,10 +309,20 @@ main() {
 
     o = 0 as Object?;
     if (o is int) {
-      // K=int, T1=C1<int> Function()?, and T2'=C2<int> Function() (coerced from
-      // T2=CallableClass<C2<int>>), therefore T=A Function() and S=int, so T is
-      // not <: S. T2' <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // A Function().
+      // This example has:
+      // - K = int
+      // - T1 = C1<int> Function()?
+      // - T2' = C2<int> Function()
+      //    (coerced from T2=CallableClass<C2<int>>)
+      // Which implies:
+      // - T = A Function()
+      // - S = int
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2' <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = A Function().
       // We avoid having a compile-time error because `o` can be demoted.
       o = (topLevelC1IntFunctionQuestion ??= callableClassC2Int)
         ..expectStaticType<Exactly<A Function()>>();
diff --git a/tests/language/inference_update_3/if_null_disabled_test.dart b/tests/language/inference_update_3/if_null_disabled_test.dart
index 57a9c67de73..a51fc99ddc1 100644
--- a/tests/language/inference_update_3/if_null_disabled_test.dart
+++ b/tests/language/inference_update_3/if_null_disabled_test.dart
@@ -20,10 +20,10 @@ Object? contextUnknown<T>(T x) => x;
 Object? contextIterable<T>(Iterable<T> x) => x;
 
 main() {
-  // - An if-null expression `E` of the form `e1 ?? e2` with context type `K` is
+  // - An if-null expression `e` of the form `e1 ?? e2` with context type K is
   //   analyzed as follows:
   //
-  //   - Let `T1` be the type of `e1` inferred with context type `K?`.
+  //   - Let T1 be the type of `e1` inferred with context type K?.
   {
     // Check the context type of `e1`:
     // - Where the context is established using a function call argument.
@@ -31,7 +31,8 @@ main() {
     context<num>((contextType(1)..expectStaticType<Exactly<num?>>()) ?? 2);
 
     // - Where the context is established using local variable promotion.
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is num?) {
       o = (contextType(1)..expectStaticType<Exactly<num?>>()) ?? 2;
     }
@@ -41,8 +42,8 @@ main() {
     }
   }
 
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If `K` is `_`, `J = T1`.
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If K is `_`, J = T1.
   {
     // Check the context type of `e2`.
     var string = '';
@@ -54,7 +55,7 @@ main() {
         (contextType('')..expectStaticType<Exactly<String?>>()));
   }
 
-  //     - Otherwise, `J = K`.
+  //     - Otherwise, J = K.
   {
     var intQuestion = null as int?;
     context<num?>(
@@ -63,64 +64,125 @@ main() {
         intQuestion ?? (contextType(2)..expectStaticType<Exactly<num>>()));
   }
 
-  //   - Let `T` be `UP(NonNull(T1), T2)`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2).
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2 = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var intQuestion = null as int?;
     var d = 2.0;
     context<Object>((intQuestion ?? d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2 = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableIntQuestion = null as Iterable<int>?;
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((iterableIntQuestion ?? iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2 <: S`, then the type of `E` is
-  //     `S` if `inference-update-3` is enabled, else the type of `E` is `T`.
+  //   - Otherwise, if NonNull(T1) <: S and T2 <: S, and `inference-update-3` is
+  //     enabled, then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>?, and T2=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2 <: S,
-    // hence the type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2 = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2 <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var iterableIntQuestion = null as Iterable<int>?;
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (iterableIntQuestion ?? listNum)..expectStaticType<Exactly<Object>>();
     }
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var intQuestion = null as int?;
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var doubleQuestion = null as double?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2=double, therefore T=num and S=int?, so T is not
-      // <: S. NonNull(T1) <: S, but T2 is not <: S. Hence the type of E is num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2 <!: S
+      // The fact that T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (intQuestion ?? d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2 <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2 = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2 <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (doubleQuestion ?? intQuestion)..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2 are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2 <!: S
+      // The fact that NonNull(T1) <!: S and T2 <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (intQuestion ?? d)..expectStaticType<Exactly<num>>();
     }
diff --git a/tests/language/inference_update_3/if_null_test.dart b/tests/language/inference_update_3/if_null_test.dart
index ab022423d64..71f67e49bee 100644
--- a/tests/language/inference_update_3/if_null_test.dart
+++ b/tests/language/inference_update_3/if_null_test.dart
@@ -33,10 +33,10 @@ class C2<T> implements B1<T>, B2<T> {}
 Object? contextB1<T>(B1<T> x) => x;
 
 main() {
-  // - An if-null expression `E` of the form `e1 ?? e2` with context type `K` is
+  // - An if-null expression `e` of the form `e1 ?? e2` with context type K is
   //   analyzed as follows:
   //
-  //   - Let `T1` be the type of `e1` inferred with context type `K?`.
+  //   - Let T1 be the type of `e1` inferred with context type K?.
   {
     // Check the context type of `e1`:
     // - Where the context is established using a function call argument.
@@ -44,7 +44,8 @@ main() {
     context<num>((contextType(1)..expectStaticType<Exactly<num?>>()) ?? 2);
 
     // - Where the context is established using local variable promotion.
-    var o = 0 as Object?;
+    Object? o;
+    o = 0 as Object?;
     if (o is num?) {
       o = (contextType(1)..expectStaticType<Exactly<num?>>()) ?? 2;
     }
@@ -54,8 +55,8 @@ main() {
     }
   }
 
-  //   - Let `T2` be the type of `e2` inferred with context type `J`, where:
-  //     - If `K` is `_`, `J = T1`.
+  //   - Let T2 be the type of `e2` inferred with context type J, where:
+  //     - If K is `_`, J = T1.
   {
     // Check the context type of `e2`.
     var string = '';
@@ -67,7 +68,7 @@ main() {
         (contextType('')..expectStaticType<Exactly<String?>>()));
   }
 
-  //     - Otherwise, `J = K`.
+  //     - Otherwise, J = K.
   {
     var intQuestion = null as int?;
     context<num?>(
@@ -76,75 +77,151 @@ main() {
         intQuestion ?? (contextType(2)..expectStaticType<Exactly<num>>()));
   }
 
-  //   - Let `T` be `UP(NonNull(T1), T2)`.
-  //   - Let `S` be the greatest closure of `K`.
-  //   - If `T <: S`, then the type of `E` is `T`.
+  //   - Let T be UP(NonNull(T1), T2).
+  //   - Let S be the greatest closure of K.
+  //   - If T <: S, then the type of `e` is T.
+  //     (Testing this case here. Otherwise continued below.)
   {
-    // K=Object, T1=int?, and T2=double, therefore T=num and S=Object, so T <:
-    // S, and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int?
+    // - T2 = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var intQuestion = null as int?;
     var d = 2.0;
     context<Object>((intQuestion ?? d)..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>?, and T2=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>?
+    // - T2 = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableIntQuestion = null as Iterable<int>?;
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((iterableIntQuestion ?? iterableDouble)
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  //   - Otherwise, if `NonNull(T1) <: S` and `T2 <: S`, then the type of `E` is
-  //     `S`.
+  //   - Otherwise, if NonNull(T1) <: S and T2 <: S, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>?, and T2=C2<double>, therefore T=A and S=B1<Object?>,
-    // so T is not <: S, but NonNull(T1) <: S and T2 <: S, hence the type of E
-    // is B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>?
+    // - T2 = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c1IntQuestion = null as C1<int>?;
     var c2Double = C2<double>();
     contextB1(
         (c1IntQuestion ?? c2Double)..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>?, and T2=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but NonNull(T1) <: S and T2 <: S, hence
-    // the type of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>?
+    // - T2 = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>(
         (c1IntQuestion ?? c2Double)..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>?, and T2=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but NonNull(T1) <: S and T2 <: S,
-    // hence the type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>?
+    // - T2 = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - NonNull(T1) <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var iterableIntQuestion = null as Iterable<int>?;
     var listNum = <num>[];
     context<Iterable<num>>((iterableIntQuestion ?? listNum)
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  //   - Otherwise, the type of `E` is `T`.
+  //   - Otherwise, the type of `e` is T.
   {
     var intQuestion = null as int?;
     var d = 2.0;
-    var o = 0 as Object?;
+    Object? o;
     var doubleQuestion = null as double?;
+    o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=int?, and T2=double, therefore T=num and S=int?, so T is not
-      // <: S. NonNull(T1) <: S, but T2 is not <: S. Hence the type of E is num.
+      // This example has:
+      // - K = int?
+      // - T1 = int?
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <: S
+      // - T2 <!: S
+      // The fact that T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (intQuestion ?? d)..expectStaticType<Exactly<num>>();
     }
     o = 0 as Object?;
     if (o is int?) {
-      // K=int?, T1=double?, and T2=int?, therefore T=num? and S=int?, so T is
-      // not <: S. T2 <: S, but NonNull(T1) is not <: S. Hence the type of E is
-      // num?.
+      // This example has:
+      // - K = int?
+      // - T1 = double?
+      // - T2 = int?
+      // Which implies:
+      // - T = num?
+      // - S = int?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2 <: S
+      // The fact that NonNull(T1) <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (doubleQuestion ?? intQuestion)..expectStaticType<Exactly<num?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int?, and T2=double, therefore T=num and S=String?, so
-      // none of T, NonNull(T1), nor T2 are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int?
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - NonNull(T1) <!: S
+      // - T2 <!: S
+      // The fact that NonNull(T1) <!: S and T2 <!: S precludes using S as
+      // static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (intQuestion ?? d)..expectStaticType<Exactly<num>>();
     }
diff --git a/tests/language/inference_update_3/switch_expression_disabled_test.dart b/tests/language/inference_update_3/switch_expression_disabled_test.dart
index fde9641c270..23c0d22d651 100644
--- a/tests/language/inference_update_3/switch_expression_disabled_test.dart
+++ b/tests/language/inference_update_3/switch_expression_disabled_test.dart
@@ -16,13 +16,13 @@ import '../static_type_helper.dart';
 Object? contextIterable<T>(Iterable<T> x) => x;
 
 test(int i) {
-  // The static type of a switch expression `E` of the form `switch (e0) { p1 =>
-  // e1, p2 => e2, ... pn => en }` with context type `K` is computed as follows:
+  // The static type of a switch expression `e` of the form `switch (e0) { p1 =>
+  // e1, p2 => e2, ... pn => en }` with context type K is computed as follows:
   //
   // - The scrutinee (`e0`) is first analyzed with context type `_`.
   // - If the switch expression has no cases, its static type is `Never`.
-  // - Otherwise, for each case `pi => ei`, let `Ti` be the type of `ei`
-  //   inferred with context type `K`.
+  // - Otherwise, for each case `pi => ei`, let Ti be the type of `ei` inferred
+  //   with context type K.
   {
     // Check the context type of each `ei`:
     // - Where the context is established using a function call argument.
@@ -33,7 +33,8 @@ test(int i) {
     });
 
     // - Where the context is established using local variable promotion.
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String) {
       o = switch (i) {
         0 => (contextType('')..expectStaticType<Exactly<String>>()),
@@ -43,35 +44,61 @@ test(int i) {
     }
   }
 
-  // - Let `T` be the least upper bound of the static types of all the case
+  // - Let T be the least upper bound of the static types of all the case
   //   expressions.
-  // - Let `S` be the greatest closure of `K`.
-  // - If `T <: S`, then the type of `E` is `T`.
+  // - Let S be the greatest closure of K.
+  // - If T <: S, then the type of `e` is T.
   {
-    // K=Object, T1=int, and T2=double, therefore T=num and S=Object, so T <: S,
-    // and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int
+    // - T2 = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (switch (i) { 0 => i, _ => d })..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>, and T2=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>
+    // - T2 = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableInt = <int>[] as Iterable<int>;
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((switch (i) { 0 => iterableInt, _ => iterableDouble })
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  // - Otherwise, if `Ti <: S` for all `i`, then the type of `E` is `S` if
-  //   `inference-update-3` is enabled, else the type of `E` is `T`.
+  // - Otherwise, if Ti <: S for all i, and `inference-update-3` is enabled,
+  //   then the type of `e` is S.
   {
-    // K=Iterable<num>, T1=Iterable<int>, and T2=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but T1 <: S and T2 <: S, hence the
-    // type of E is Object.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>
+    // - T2 = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // However, inference-update-3 is not enabled.
+    // Therefore the type of `e` is T = Object.
     var iterableInt = <int>[] as Iterable<int>;
     var listNum = <num>[];
-    var o = [0] as Object?;
+    Object? o;
+    o = [0] as Object?;
     if (o is Iterable<num>) {
       // We avoid having a compile-time error because `o` can be demoted.
       o = (switch (i) { 0 => iterableInt, _ => listNum })
@@ -79,27 +106,61 @@ test(int i) {
     }
   }
 
-  // - Otherwise, the type of `E` is `T`.
+  // - Otherwise, the type of `e` is T.
   {
-    var o = '' as Object?;
+    Object? o;
     var d = 2.0;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=Null, and T2=int, therefore T=int? and S=String?, so T is
-      // not <: S. T1 <: S, but T2 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = Null
+      // - T2 = int
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <: S
+      // - T2 <!: S
+      // The fact that T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (switch (i) { 0 => null, _ => i })..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=Null, therefore T=int? and S=String?, so T is
-      // not <: S. T2 <: S, but T1 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = Null
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <: S
+      // The fact that T1 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (switch (i) { 0 => i, _ => null })..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=double, therefore T=num and S=String?, so
-      // none of T, T1, nor T2 are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <!: S
+      // The fact that T1 <!: S and T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (switch (i) { 0 => i, _ => d })..expectStaticType<Exactly<num>>();
     }
diff --git a/tests/language/inference_update_3/switch_expression_test.dart b/tests/language/inference_update_3/switch_expression_test.dart
index 2c7057e068a..2744f665dfb 100644
--- a/tests/language/inference_update_3/switch_expression_test.dart
+++ b/tests/language/inference_update_3/switch_expression_test.dart
@@ -29,13 +29,13 @@ class C2<T> implements B1<T>, B2<T> {}
 Object? contextB1<T>(B1<T> x) => x;
 
 test(int i) {
-  // The static type of a switch expression `E` of the form `switch (e0) { p1 =>
-  // e1, p2 => e2, ... pn => en }` with context type `K` is computed as follows:
+  // The static type of a switch expression `e` of the form `switch (e0) { p1 =>
+  // e1, p2 => e2, ... pn => en }` with context type K is computed as follows:
   //
   // - The scrutinee (`e0`) is first analyzed with context type `_`.
   // - If the switch expression has no cases, its static type is `Never`.
-  // - Otherwise, for each case `pi => ei`, let `Ti` be the type of `ei`
-  //   inferred with context type `K`.
+  // - Otherwise, for each case `pi => ei`, let Ti be the type of `ei` inferred
+  //   with context type K.
   {
     // Check the context type of each `ei`:
     // - Where the context is established using a function call argument.
@@ -46,7 +46,8 @@ test(int i) {
     });
 
     // - Where the context is established using local variable promotion.
-    var o = '' as Object?;
+    Object? o;
+    o = '' as Object?;
     if (o is String) {
       o = switch (i) {
         0 => (contextType('')..expectStaticType<Exactly<String>>()),
@@ -56,72 +57,148 @@ test(int i) {
     }
   }
 
-  // - Let `T` be the least upper bound of the static types of all the case
+  // - Let T be the least upper bound of the static types of all the case
   //   expressions.
-  // - Let `S` be the greatest closure of `K`.
-  // - If `T <: S`, then the type of `E` is `T`.
+  // - Let S be the greatest closure of K.
+  // - If T <: S, then the type of `e` is T.
   {
-    // K=Object, T1=int, and T2=double, therefore T=num and S=Object, so T <: S,
-    // and hence the type of E is num.
+    // This example has:
+    // - K = Object
+    // - T1 = int
+    // - T2 = double
+    // Which implies:
+    // - T = num
+    // - S = Object
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = num.
     var d = 2.0;
     context<Object>(
         (switch (i) { 0 => i, _ => d })..expectStaticType<Exactly<num>>());
 
-    // K=Iterable<_>, T1=Iterable<int>, and T2=Iterable<double>, therefore
-    // T=Iterable<num> and S=Iterable<Object?>, so T <: S, and hence the type of
-    // E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<_>
+    // - T1 = Iterable<int>
+    // - T2 = Iterable<double>
+    // Which implies:
+    // - T = Iterable<num>
+    // - S = Iterable<Object?>
+    // We have:
+    // - T <: S
+    // Therefore the type of `e` is T = Iterable<num>.
     var iterableInt = <int>[] as Iterable<int>;
     var iterableDouble = <double>[] as Iterable<double>;
     contextIterable((switch (i) { 0 => iterableInt, _ => iterableDouble })
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  // - Otherwise, if `Ti <: S` for all `i`, then the type of `E` is `S`.
+  // - Otherwise, if Ti <: S for all i, then the type of `e` is S.
   {
-    // K=B1<_>, T1=C1<int>, and T2=C2<double>, therefore T=A and S=B1<Object?>,
-    // so T is not <: S, but T1 <: S and T2 <: S, hence the type of E is
-    // B1<Object?>.
+    // This example has:
+    // - K = B1<_>
+    // - T1 = C1<int>
+    // - T2 = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object?>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = B1<Object?>.
     var c1Int = C1<int>();
     var c2Double = C2<double>();
     contextB1((switch (i) { 0 => c1Int, _ => c2Double })
       ..expectStaticType<Exactly<B1<Object?>>>());
 
-    // K=B1<Object>, T1=C1<int>, and T2=C2<double>, therefore T=A and
-    // S=B1<Object>, so T is not <: S, but T1 <: S and T2 <: S, hence the type
-    // of E is B1<Object>.
+    // This example has:
+    // - K = B1<Object>
+    // - T1 = C1<int>
+    // - T2 = C2<double>
+    // Which implies:
+    // - T = A
+    // - S = B1<Object>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = B1<Object>.
     contextB1<Object>((switch (i) { 0 => c1Int, _ => c2Double })
       ..expectStaticType<Exactly<B1<Object>>>());
 
-    // K=Iterable<num>, T1=Iterable<int>, and T2=List<num>, therefore T=Object
-    // and S=Iterable<num>, so T is not <: S, but T1 <: S and T2 <: S, hence the
-    // type of E is Iterable<num>.
+    // This example has:
+    // - K = Iterable<num>
+    // - T1 = Iterable<int>
+    // - T2 = List<num>
+    // Which implies:
+    // - T = Object
+    // - S = Iterable<num>
+    // We have:
+    // - T <!: S
+    // - T1 <: S
+    // - T2 <: S
+    // Therefore the type of `e` is S = Iterable<num>.
     var iterableInt = <int>[] as Iterable<int>;
     var listNum = <num>[];
     context<Iterable<num>>((switch (i) { 0 => iterableInt, _ => listNum })
       ..expectStaticType<Exactly<Iterable<num>>>());
   }
 
-  // - Otherwise, the type of `E` is `T`.
+  // - Otherwise, the type of `e` is T.
   {
-    var o = '' as Object?;
+    Object? o;
     var d = 2.0;
+    o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=Null, and T2=int, therefore T=int? and S=String?, so T is
-      // not <: S. T1 <: S, but T2 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = Null
+      // - T2 = int
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <: S
+      // - T2 <!: S
+      // The fact that T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (switch (i) { 0 => null, _ => i })..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=Null, therefore T=int? and S=String?, so T is
-      // not <: S. T2 <: S, but T1 is not <: S. Hence the type of E is int?.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = Null
+      // Which implies:
+      // - T = int?
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <: S
+      // The fact that T1 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = int?.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (switch (i) { 0 => i, _ => null })..expectStaticType<Exactly<int?>>();
     }
     o = '' as Object?;
     if (o is String?) {
-      // K=String?, T1=int, and T2=double, therefore T=num and S=String?, so
-      // none of T, T1, nor T2 are <: S. Hence the type of E is num.
+      // This example has:
+      // - K = String?
+      // - T1 = int
+      // - T2 = double
+      // Which implies:
+      // - T = num
+      // - S = String?
+      // We have:
+      // - T <!: S
+      // - T1 <!: S
+      // - T2 <!: S
+      // The fact that T1 <!: S and T2 <!: S precludes using S as static type.
+      // Therefore the type of `e` is T = num.
       // We avoid having a compile-time error because `o` can be demoted.
       o = (switch (i) { 0 => i, _ => d })..expectStaticType<Exactly<num>>();
     }