diff --git a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
index 974b9ac..b34c637 100644
--- a/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
+++ b/pkg/analysis_server/lib/src/services/correction/fix/data_driven/transform_set_parser.dart
@@ -564,16 +564,17 @@
       }
       // TODO(brianwilkerson) Version information is currently being ignored,
       //  but needs to be used to select a translator.
-      var transformations = _translateList(
+      var transforms = _translateList(
           node.valueAt(_transformsKey),
           ErrorContext(key: _transformsKey, parentNode: node),
           _translateTransform);
-      if (transformations == null) {
+      if (transforms == null) {
         // The error has already been reported.
         return null;
       }
+      transforms.sort((first, second) => first.date.compareTo(second.date));
       var set = TransformSet();
-      for (var transform in transformations) {
+      for (var transform in transforms) {
         set.addTransform(transform);
       }
       return set;
diff --git a/pkg/dev_compiler/lib/src/kernel/compiler.dart b/pkg/dev_compiler/lib/src/kernel/compiler.dart
index 284c144..8a9fa88 100644
--- a/pkg/dev_compiler/lib/src/kernel/compiler.dart
+++ b/pkg/dev_compiler/lib/src/kernel/compiler.dart
@@ -867,16 +867,21 @@
     var savedTopLevelClass = _classEmittingExtends;
     _classEmittingExtends = c;
 
-    // Unroll mixins.
+    // Refers to 'S' in `class C extends S`. Set this to null to avoid
+    // referencing deferred supertypes in _emitClassConstructor's JS output.
+    js_ast.Expression baseClass;
+
     if (shouldDefer(supertype)) {
       deferredSupertypes.add(runtimeStatement('setBaseClass(#, #)', [
         getBaseClass(isMixinAliasClass(c) ? 0 : mixins.length),
         emitDeferredType(supertype),
       ]));
+      // Refers to 'supertype' without any type arguments.
       supertype =
           _coreTypes.rawType(supertype.classNode, _currentLibrary.nonNullable);
+    } else {
+      baseClass = emitClassRef(supertype);
     }
-    var baseClass = emitClassRef(supertype);
 
     if (isMixinAliasClass(c)) {
       // Given `class C = Object with M [implements I1, I2 ...];`
diff --git a/runtime/tests/vm/dart/split_aot_kernel_generation2_test.dart b/runtime/tests/vm/dart/split_aot_kernel_generation2_test.dart
index 32b4f00..b54e3cb 100644
--- a/runtime/tests/vm/dart/split_aot_kernel_generation2_test.dart
+++ b/runtime/tests/vm/dart/split_aot_kernel_generation2_test.dart
@@ -2,7 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// OtherResources=../../../../tests/language/vm/regress_flutter_55345_test.dart
+// OtherResources=../../../../tests/language/mixin/regress_flutter_55345_test.dart
 
 // Runs regress_flutter_55345_test.dart using AOT kernel generation split into
 // 2 steps using '--from-dill' option.
@@ -14,5 +14,5 @@
 
 main() async {
   await runSplitAOTKernelGenerationTest(Platform.script.resolve(
-      '../../../../tests/language/vm/regress_flutter_55345_test.dart'));
+      '../../../../tests/language/mixin/regress_flutter_55345_test.dart'));
 }
diff --git a/runtime/tests/vm/dart_2/split_aot_kernel_generation2_test.dart b/runtime/tests/vm/dart_2/split_aot_kernel_generation2_test.dart
index da7925a..5d49f2c 100644
--- a/runtime/tests/vm/dart_2/split_aot_kernel_generation2_test.dart
+++ b/runtime/tests/vm/dart_2/split_aot_kernel_generation2_test.dart
@@ -2,7 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
-// OtherResources=../../../../tests/language_2/vm/regress_flutter_55345_test.dart
+// OtherResources=../../../../tests/language_2/mixin/regress_flutter_55345_test.dart
 
 // Runs regress_flutter_55345_test.dart using AOT kernel generation split into
 // 2 steps using '--from-dill' option.
@@ -14,5 +14,5 @@
 
 main() async {
   await runSplitAOTKernelGenerationTest(Platform.script.resolve(
-      '../../../../tests/language_2/vm/regress_flutter_55345_test.dart'));
+      '../../../../tests/language_2/mixin/regress_flutter_55345_test.dart'));
 }
diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc
index 34cc58e..9732d93 100644
--- a/runtime/vm/class_finalizer.cc
+++ b/runtime/vm/class_finalizer.cc
@@ -626,22 +626,26 @@
           if (super_type_arg.IsBeingFinalized()) {
             // The super_type_arg was instantiated from a type being finalized.
             // We need to finish finalizing its type arguments.
-            ASSERT(super_type_arg.IsTypeRef());
-            AbstractType& ref_super_type_arg =
-                AbstractType::Handle(TypeRef::Cast(super_type_arg).type());
-            if (FLAG_trace_type_finalization) {
-              THR_Print("Instantiated TypeRef '%s': '%s'\n",
-                        String::Handle(super_type_arg.Name()).ToCString(),
-                        ref_super_type_arg.ToCString());
+            AbstractType& unfinalized_type = AbstractType::Handle();
+            if (super_type_arg.IsTypeRef()) {
+              unfinalized_type = TypeRef::Cast(super_type_arg).type();
+            } else {
+              ASSERT(super_type_arg.IsType());
+              unfinalized_type = super_type_arg.raw();
             }
-            CheckRecursiveType(cls, ref_super_type_arg, pending_types);
-            pending_types->Add(ref_super_type_arg);
+            if (FLAG_trace_type_finalization) {
+              THR_Print("Instantiated unfinalized '%s': '%s'\n",
+                        String::Handle(unfinalized_type.Name()).ToCString(),
+                        unfinalized_type.ToCString());
+            }
+            CheckRecursiveType(cls, unfinalized_type, pending_types);
+            pending_types->Add(unfinalized_type);
             const Class& super_cls =
-                Class::Handle(ref_super_type_arg.type_class());
+                Class::Handle(unfinalized_type.type_class());
             const TypeArguments& super_args =
-                TypeArguments::Handle(ref_super_type_arg.arguments());
+                TypeArguments::Handle(unfinalized_type.arguments());
             // Mark as finalized before finalizing to avoid cycles.
-            ref_super_type_arg.SetIsFinalized();
+            unfinalized_type.SetIsFinalized();
             // Although the instantiator is different between cls and super_cls,
             // we still need to pass the current instantiation trail as to avoid
             // divergence. Finalizing the type arguments of super_cls may indeed
@@ -652,9 +656,9 @@
                 super_cls.NumTypeArguments() - super_cls.NumTypeParameters(),
                 pending_types, trail);
             if (FLAG_trace_type_finalization) {
-              THR_Print("Finalized instantiated TypeRef '%s': '%s'\n",
-                        String::Handle(super_type_arg.Name()).ToCString(),
-                        ref_super_type_arg.ToCString());
+              THR_Print("Finalized instantiated '%s': '%s'\n",
+                        String::Handle(unfinalized_type.Name()).ToCString(),
+                        unfinalized_type.ToCString());
             }
           }
         }
diff --git a/tests/language/class/cyclic_hierarchy_test.dart b/tests/language/class/cyclic_hierarchy_test.dart
new file mode 100644
index 0000000..0a892f3
--- /dev/null
+++ b/tests/language/class/cyclic_hierarchy_test.dart
@@ -0,0 +1,13 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// Test for cyclic class hierarchy seen in: https://github.com/flutter/flutter/issues/64011
+
+class A extends B<C> {}
+
+class C extends A {}
+
+class B<T> {}
+
+main() => print(A());
diff --git a/tests/language/vm/regress_flutter_55345_const_test.dart b/tests/language/mixin/regress_flutter_55345_const_test.dart
similarity index 94%
rename from tests/language/vm/regress_flutter_55345_const_test.dart
rename to tests/language/mixin/regress_flutter_55345_const_test.dart
index a30bb11..ccf04a9 100644
--- a/tests/language/vm/regress_flutter_55345_const_test.dart
+++ b/tests/language/mixin/regress_flutter_55345_const_test.dart
@@ -34,4 +34,5 @@
     },
     'abc'
   ]);
+  // No compile time or runtime errors.
 }
diff --git a/tests/language/vm/regress_flutter_55345_test.dart b/tests/language/mixin/regress_flutter_55345_test.dart
similarity index 95%
rename from tests/language/vm/regress_flutter_55345_test.dart
rename to tests/language/mixin/regress_flutter_55345_test.dart
index 3fbe990..70df054 100644
--- a/tests/language/vm/regress_flutter_55345_test.dart
+++ b/tests/language/mixin/regress_flutter_55345_test.dart
@@ -38,4 +38,5 @@
   var x3 = foo(x2);
   var x4 = bar(x3);
   x4(x3);
+  // No compile time or runtime errors.
 }
diff --git a/tests/language/nnbd/flow_analysis/never_runtime_check_nnbd.dart b/tests/language/nnbd/flow_analysis/never_runtime_check_nnbd.dart
index 78681be..7a18cec 100644
--- a/tests/language/nnbd/flow_analysis/never_runtime_check_nnbd.dart
+++ b/tests/language/nnbd/flow_analysis/never_runtime_check_nnbd.dart
@@ -12,8 +12,24 @@
 class C {
   static int staticField = 0;
 
+  static int get staticGetterSetter => staticField;
+
+  static set staticGetterSetter(int? value) {}
+
   int instanceField;
 
+  int get instanceGetterSetter => instanceField;
+
+  set instanceGetterSetter(int? value) {}
+
+  int operator [](int index) => instanceField;
+
+  operator []=(int index, int? value) {}
+
+  static late String error;
+
+  get throwingGetter => throw error;
+
   C(this.instanceField);
 }
 
@@ -24,6 +40,39 @@
     super.instanceField ??= f(); // ignore: dead_null_aware_expression
     // Should throw if `instanceField` returns null (rather than calling `f`).
   }
+
+  void ifNullAssignSuper_nullableSetter(int f()) {
+    super.instanceGetterSetter ??= f(); // ignore: dead_null_aware_expression
+    // Should throw if `instanceGetterSetter` returns null (rather than calling
+    // `f`).
+  }
+
+  void ifNullAssignSuperIndex(int f()) {
+    super[0] ??= f(); // ignore: dead_null_aware_expression
+    // Should throw if `super[0]` returns null (rather than calling `f`).
+  }
+}
+
+class E {
+  int instanceField;
+
+  E(this.instanceField);
+}
+
+extension EExt on E {
+  int get instanceGetterSetter => instanceField;
+
+  set instanceGetterSetter(int? value) {}
+
+  int operator [](int index) => instanceField;
+
+  operator []=(int index, int? value) {}
+}
+
+extension IntQExt on int? {
+  int extendedMethod(int value) => value;
+
+  int get extendedGetter => 0;
 }
 
 class NeverField {
@@ -50,34 +99,63 @@
   // Should throw if `i` is null.
 }
 
+void isPromoteToNever_noIf(int i) {
+  i is int;
+  // Should throw if `i` is null.
+}
+
 void isNotPromoteToNever(int i) {
   if (i is! int) {
     // Should throw if `i` is null.
   }
 }
 
+void isNotPromoteToNever_noIf(int i) {
+  i is! int;
+}
+
 void equalNullPromoteToNever(int f()) {
   if (f() == null) { // ignore: unnecessary_null_comparison
     // Should throw if `f` returns null.
   }
 }
 
+void equalNullPromoteToNever_noIf(int f()) {
+  f() == null; // ignore: unnecessary_null_comparison
+  // Should throw if `f` returns null.
+}
+
 void notEqualNullPromoteToNever(int f()) {
   if (f() != null) return; // ignore: unnecessary_null_comparison
   // Should throw if `f` returns null.
 }
 
+void notEqualNullPromoteToNever_noIf(int f()) {
+  f() != null; // ignore: unnecessary_null_comparison
+  // Should throw if `f` returns null.
+}
+
 void nullEqualPromoteToNever(int f()) {
   if (null == f()) { // ignore: unnecessary_null_comparison
     // Should throw if `f` returns null.
   }
 }
 
+void nullEqualPromoteToNever_noIf(int f()) {
+  null == f(); // ignore: unnecessary_null_comparison
+  // Should throw if `f` returns null.
+}
+
 void nullNotEqualPromoteToNever(int f()) {
   if (null != f()) return; // ignore: unnecessary_null_comparison
   // Should throw if `f` returns null.
 }
 
+void nullNotEqualPromoteToNever_noIf(int f()) {
+  null != f(); // ignore: unnecessary_null_comparison
+  // Should throw if `f` returns null.
+}
+
 int unnecessaryIfNull(int f(), int g()) {
   return f() ?? g(); // ignore: dead_null_aware_expression
   // Should throw if `f` returns null (rather than calling `g`).
@@ -93,20 +171,72 @@
   // Should throw if `staticField` returns null (rather than calling `f`).
 }
 
+void ifNullAssignStaticGetter_nullableSetter(int f()) {
+  C.staticGetterSetter ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `staticGetterSetter` returns null (rather than calling
+  // `f`).
+}
+
 void ifNullAssignField(C c, int f()) {
   c.instanceField ??= f(); // ignore: dead_null_aware_expression
   // Should throw if `instanceField` returns null (rather than calling `f`).
 }
 
+void ifNullAssignGetter_nullableSetter(C c, int f()) {
+  c.instanceGetterSetter ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `instanceGetterSetter` returns null (rather than calling
+  // `f`).
+}
+
+void ifNullAssignGetter_implicitExtension(E e, int f()) {
+  e.instanceGetterSetter ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `instanceGetterSetter` returns null (rather than calling
+  // `f`).
+}
+
+void ifNullAssignGetter_explicitExtension(E e, int f()) {
+  EExt(e).instanceGetterSetter ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `instanceGetterSetter` returns null (rather than calling
+  // `f`).
+}
+
 void ifNullAssignIndex(List<int> x, int f()) {
   x[0] ??= f(); // ignore: dead_null_aware_expression
   // Should throw if `x[0]` returns null (rather than calling `f`).
 }
 
+void ifNullAssignIndex_nullAware(List<int>? x, int f()) {
+  x?[0] ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `x[0]` returns null (rather than calling `f`).
+}
+
+void ifNullAssignIndex_nullableSetter(C x, int f()) {
+  x[0] ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `x[0]` returns null (rather than calling `f`).
+}
+
+void ifNullAssignIndex_implicitExtension(E x, int f()) {
+  x[0] ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `x[0]` returns null (rather than calling `f`).
+}
+
+void ifNullAssignIndex_explicitExtension(E x, int f()) {
+  EExt(x)[0] ??= f(); // ignore: dead_null_aware_expression
+  // Should throw if `x[0]` returns null (rather than calling `f`).
+}
+
 void ifNullAssignSuper(D d, int f()) {
   d.ifNullAssignSuper(f);
 }
 
+void ifNullAssignSuper_nullableSetter(D d, int f()) {
+  d.ifNullAssignSuper_nullableSetter(f);
+}
+
+void ifNullAssignSuperIndex(D d, int f()) {
+  d.ifNullAssignSuperIndex(f);
+}
+
 int? ifNullAssignNullAwareField(C? c, int f()) {
   return c?.instanceField ??= f(); // ignore: dead_null_aware_expression
   // Should throw if `instanceField` returns null (rather than calling `f`).
@@ -122,6 +252,77 @@
   // Should throw if `f` returns null.
 }
 
+void unnecessaryNullAwareAccess_cascaded(int f(), String error) {
+  f()?..gcd(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_methodOnObject(int f(), String error) {
+  f()?.toString().compareTo(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_cascaded_methodOnObject(int f(), String error) {
+  f()?..toString().compareTo(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_methodOnExtension(int f(), String error) {
+  f()?.extendedMethod(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_cascaded_methodOnExtension(
+    int f(), String error) {
+  f()?..extendedMethod(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_methodOnExtension_explicit(
+    int f(), String error) {
+  IntQExt(f())?.extendedMethod(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_getter(C f(), String error) {
+  C.error = error;
+  f()?.throwingGetter; // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_cascaded_getter(C f(), String error) {
+  C.error = error;
+  f()?..throwingGetter; // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_getterOnObject(int f(), String error) {
+  f()?.hashCode.remainder(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_cascaded_getterOnObject(int f(), String error) {
+  f()?..hashCode.remainder(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_getterOnExtension(int f(), String error) {
+  f()?.extendedGetter.remainder(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_cascaded_getterOnExtension(
+    int f(), String error) {
+  f()?..extendedGetter.remainder(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
+void unnecessaryNullAwareAccess_getterOnExtension_explicit(
+    int f(), String error) {
+  IntQExt(f())?.extendedGetter.remainder(throw error); // ignore: invalid_null_aware_operator
+  // Should throw if `f` returns null.
+}
+
 void getterReturnsNever(A a) {
   a.getter;
   // Should throw if `getter` completes normally.
@@ -152,19 +353,22 @@
   // Should throw if `method` completes normally.
 }
 
-
 void switchOnBool(bool b) {
   switch (b) {
-    case true: return;
-    case false: return;
+    case true:
+      return;
+    case false:
+      return;
   }
   // Should throw if the implicit `default` branch is taken.
 }
 
 void switchOnEnum(Hand hand) {
   switch (hand) {
-    case Hand.left: return;
-    case Hand.right: return;
+    case Hand.left:
+      return;
+    case Hand.right:
+      return;
   }
   // Should throw if the implicit `default` branch is taken.
-}
\ No newline at end of file
+}
diff --git a/tests/language/nnbd/flow_analysis/never_runtime_check_test.dart b/tests/language/nnbd/flow_analysis/never_runtime_check_test.dart
index c50d3a4..d3f2d71 100644
--- a/tests/language/nnbd/flow_analysis/never_runtime_check_test.dart
+++ b/tests/language/nnbd/flow_analysis/never_runtime_check_test.dart
@@ -49,26 +49,50 @@
   });
 
   Expect.throws(() {
+    isPromoteToNever_noIf(null);
+  });
+
+  Expect.throws(() {
     isNotPromoteToNever(null);
   });
 
   Expect.throws(() {
+    isNotPromoteToNever_noIf(null);
+  });
+
+  Expect.throws(() {
     equalNullPromoteToNever(() => null);
   });
 
   Expect.throws(() {
+    equalNullPromoteToNever_noIf(() => null);
+  });
+
+  Expect.throws(() {
     notEqualNullPromoteToNever(() => null);
   });
 
   Expect.throws(() {
+    notEqualNullPromoteToNever_noIf(() => null);
+  });
+
+  Expect.throws(() {
     nullEqualPromoteToNever(() => null);
   });
 
   Expect.throws(() {
+    nullEqualPromoteToNever_noIf(() => null);
+  });
+
+  Expect.throws(() {
     nullNotEqualPromoteToNever(() => null);
   });
 
   Expect.throws(() {
+    nullNotEqualPromoteToNever_noIf(() => null);
+  });
+
+  Expect.throws(() {
     unnecessaryIfNull(() => null, () => throw "should not reach");
   }, (error) => error != "should not reach");
 
@@ -81,19 +105,64 @@
     ifNullAssignStatic(() => throw "should not reach");
   }, (error) => error != "should not reach");
 
+  C.staticField = null;
+  Expect.throws(() {
+    ifNullAssignStaticGetter_nullableSetter(() => throw "should not reach");
+  }, (error) => error != "should not reach");
+
   Expect.throws(() {
     ifNullAssignField(C(null), () => throw "should not reach");
   }, (error) => error != "should not reach");
 
   Expect.throws(() {
+    ifNullAssignGetter_nullableSetter(C(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    ifNullAssignGetter_implicitExtension(
+        E(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    ifNullAssignGetter_explicitExtension(
+        E(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
     ifNullAssignIndex(<int>[null], () => throw "should not reach");
   }, (error) => error != "should not reach");
 
   Expect.throws(() {
+    ifNullAssignIndex_nullAware(<int>[null], () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    ifNullAssignIndex_nullableSetter(C(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    ifNullAssignIndex_implicitExtension(
+        E(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    ifNullAssignIndex_explicitExtension(
+        E(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
     ifNullAssignSuper(D(null), () => throw "should not reach");
   }, (error) => error != "should not reach");
 
   Expect.throws(() {
+    ifNullAssignSuper_nullableSetter(D(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    ifNullAssignSuperIndex(D(null), () => throw "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
     ifNullAssignNullAwareField(C(null), () => throw "should not reach");
   }, (error) => error != "should not reach");
 
@@ -110,6 +179,66 @@
   }, (error) => error != "should not reach");
 
   Expect.throws(() {
+    unnecessaryNullAwareAccess_methodOnObject(() => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_cascaded_methodOnObject(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_methodOnExtension(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_cascaded_methodOnExtension(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_methodOnExtension_explicit(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_getter(() => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_cascaded(() => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_cascaded_getter(() => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_getterOnObject(() => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_cascaded_getterOnObject(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_getterOnExtension(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_cascaded_getterOnExtension(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
+    unnecessaryNullAwareAccess_getterOnExtension_explicit(
+        () => null, "should not reach");
+  }, (error) => error != "should not reach");
+
+  Expect.throws(() {
     getterReturnsNever(AImpl());
   });
 
diff --git a/tests/language/regress/regress65278_test.dart b/tests/language/regress/regress65278_test.dart
new file mode 100644
index 0000000..9edf22c
--- /dev/null
+++ b/tests/language/regress/regress65278_test.dart
@@ -0,0 +1,30 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+void main() {
+  ContentTabsWidget();
+}
+
+class StatefulWidget {}
+
+class State<T> {}
+
+class WidgetsBindingObserver {}
+
+class IBase {}
+
+class ContentTabsWidget extends BaseStatefulWidget<ContentTabsState, dynamic> {}
+
+class ContentTabsState<W extends ContentTabsWidget>
+    extends BaseState<W, dynamic> {}
+
+class BaseStatefulWidget<ST extends SuperState, T>
+    extends SuperStatefulWidget<ST, T, IBase> {}
+
+class BaseState<W extends StatefulWidget, T> extends SuperState<W, T, IBase> {}
+
+class SuperStatefulWidget<S extends SuperState, T, B> extends StatefulWidget {}
+
+class SuperState<W extends StatefulWidget, T, B> extends State<W>
+    with WidgetsBindingObserver {}
diff --git a/tests/language_2/vm/regress_flutter_55345_const_test.dart b/tests/language_2/mixin/regress_flutter_55345_const_test.dart
similarity index 94%
rename from tests/language_2/vm/regress_flutter_55345_const_test.dart
rename to tests/language_2/mixin/regress_flutter_55345_const_test.dart
index 9b548ff..9c9551d 100644
--- a/tests/language_2/vm/regress_flutter_55345_const_test.dart
+++ b/tests/language_2/mixin/regress_flutter_55345_const_test.dart
@@ -34,4 +34,5 @@
     },
     'abc'
   ]);
+  // No compile time or runtime errors.
 }
diff --git a/tests/language_2/vm/regress_flutter_55345_test.dart b/tests/language_2/mixin/regress_flutter_55345_test.dart
similarity index 95%
rename from tests/language_2/vm/regress_flutter_55345_test.dart
rename to tests/language_2/mixin/regress_flutter_55345_test.dart
index f5ee00a..0cb0441 100644
--- a/tests/language_2/vm/regress_flutter_55345_test.dart
+++ b/tests/language_2/mixin/regress_flutter_55345_test.dart
@@ -41,4 +41,5 @@
   var x3 = foo(x2);
   var x4 = bar(x3);
   x4(x3);
+  // No compile time or runtime errors.
 }
diff --git a/tests/language_2/regress/regress65278_test.dart b/tests/language_2/regress/regress65278_test.dart
new file mode 100644
index 0000000..9edf22c
--- /dev/null
+++ b/tests/language_2/regress/regress65278_test.dart
@@ -0,0 +1,30 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+void main() {
+  ContentTabsWidget();
+}
+
+class StatefulWidget {}
+
+class State<T> {}
+
+class WidgetsBindingObserver {}
+
+class IBase {}
+
+class ContentTabsWidget extends BaseStatefulWidget<ContentTabsState, dynamic> {}
+
+class ContentTabsState<W extends ContentTabsWidget>
+    extends BaseState<W, dynamic> {}
+
+class BaseStatefulWidget<ST extends SuperState, T>
+    extends SuperStatefulWidget<ST, T, IBase> {}
+
+class BaseState<W extends StatefulWidget, T> extends SuperState<W, T, IBase> {}
+
+class SuperStatefulWidget<S extends SuperState, T, B> extends StatefulWidget {}
+
+class SuperState<W extends StatefulWidget, T, B> extends State<W>
+    with WidgetsBindingObserver {}
diff --git a/tools/VERSION b/tools/VERSION
index f2e2efb..775d3f3 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 10
 PATCH 0
-PRERELEASE 124
+PRERELEASE 125
 PRERELEASE_PATCH 0
\ No newline at end of file