anchor.diff:  main() {
     defineReflectiveSuite(() {
       defineReflectiveTests(ConflictingGenericInterfacesTest);
  -    defineReflectiveTests(ConflictingGenericInterfacesWithNullSafetyTest);
     });
   }
   
   @reflectiveTest
   class ConflictingGenericInterfacesTest extends PubPackageResolutionTest
  -    with WithoutNullSafetyMixin {
  +    with WithNonFunctionTypeAliasesMixin {
     test_class_extends_implements() async {
       await assertErrorsInCode('''
   class I<T> {}
  
positive.code:     ]);
    }
  
    test_class_extends_with() async {
      await assertErrorsInCode('''
  class I<T> {}
  class A implements I<int> {}
  class B implements I<String> {}
  class C extends A with B {}
  ''', [
        error(CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES, 75, 27),
      ]);
    }
  
    test_classTypeAlias_extends_with() async {
      await assertErrorsInCode('''
  class I<T> {}
  class A implements I<int> {}
  mixin M implements I<String> {}
  class C = A with M;
  ''', [
        error(CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES, 75, 19),
      ]);
    }
  
    test_mixin_on_implements() async {
      await assertErrorsInCode('''
  class I<T> {}
  class A implements I<int> {}
  class B implements I<String> {}
  mixin M on A implements B {}
  ''', [
        error(CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES, 75, 28),
      ]);
    }
  
    test_noConflict() async {
      await assertNoErrorsInCode('''
  class I<T> {}
  class A implements I<int> {}
  class B implements I<int> {}
  class C extends A implements B {}
  ''');
    }
  }
  
  @reflectiveTest
  class ConflictingGenericInterfacesWithNullSafetyTest
      extends ConflictingGenericInterfacesTest with WithNullSafetyMixin {
    test_class_extends_implements_never() async {
      await assertNoErrorsInCode('''
  class I<T> {}
  
negative.code: 
  class C extends B implements A<int> {}
  ''');
    }
  
    test_class_extends_with() async {
      await assertErrorsInCode('''
  class I<T> {}
  class A implements I<int> {}
  class B implements I<String> {}
  class C extends A with B {}
  ''', [
        error(CompileTimeErrorCode.CONFLICTING_GENERIC_INTERFACES, 75, 27),
      ]);
    }
  
    test_class_mixed_viaLegacy() async {
  