Lint to warn about incorrect types in overrides in a mixed mode null safety setting

[nshahan]

This request is motivated by a breakage I found in google3, and the potential for many more as null safety migrations continue.

Would it be possible to create a lint to trigger when:

1. An API is defined in a null safe library.
2. The API is implemented in a null safe library.
3. The API definition and implementation are only related through a library that is not yet null safe.

In this example a method signature is defined in a null safe mixin and returns int. The implementation is in a null safe library and returns int?. There is no direct relation between the definition and the implementation so there are no errors. They are brought together by another class that has not yet been migrated to null safety, so still no errors even though we know that the implementation is invalid for the method signature defined by the mixin.

file1.dart (not migrated to null safety)

class C extends B with M {}

file2.dart (migrated to null safety)

class B {
  int? fn() => null;
}

file3.dart (migrated to null safety)

mixin M {
  int fn();
}

[bwilkerson]

I'm not actually certain that we can detect this because of the need to drop information in the not-migrated library.

@scheglov Do we have a way to perform that check today?

[scheglov]

We still know everything about every class or mixin. So, this is a matter to asking for this data. It probably does not make sense to do for all classes, and for all packages, but the linter to do it. Something like this (InheritanceManager is not API, but linter already uses it).

  solo_test_XXX() async {
    newFile('$testPackageLibPath/a.dart', r'''
class B {
  int? fn() => null;
}

mixin M {
  int fn();
}
''');

    await resolveTestCode('''
// @dart = 2.6
import 'a.dart';

class C extends B with M {}
''');

    var C = findElement.classOrMixin('C');

    final C_superElements = [
      C.supertype?.element2,
      ...C.mixins.map((mixin) => mixin.element2),
    ].whereNotNull().toList();
    print('C_superElements: $C_superElements');

    final C_implemented = manager.getInterface(C).implemented;
    for (final entry in C_implemented.entries) {
      if (entry.value.library.isNonNullableByDefault) {
        for (final superElement in C_superElements) {
          final superExecutable = manager.getMember2(superElement, entry.key);
          print('[${entry.key}][$superElement][$superExecutable]');
        }
      }
    }
  }

Produces:

C_superElements: [class B, mixin M on Object]
[==][class B][bool ==(Object other)]
[==][mixin M on Object][bool ==(Object other)]
[toString][class B][String toString()]
[toString][mixin M on Object][String toString()]
[noSuchMethod][class B][dynamic noSuchMethod(Invocation invocation)]
[noSuchMethod][mixin M on Object][dynamic noSuchMethod(Invocation invocation)]
[hashCode][class B][int get hashCode]
[hashCode][mixin M on Object][int get hashCode]
[runtimeType][class B][Type get runtimeType]
[runtimeType][mixin M on Object][Type get runtimeType]
[fn][class B][int? fn()]
[fn][mixin M on Object][int fn()]

The key is that

[srawlins]

Everything is now null safe.