Bogus "[warning] Missing concrete implementation of 'RenderObject.applyPaintTransform'"

[Hixie]

If I apply the following patch to Flutter's repository (at aa80bd6), and then run the analyzer (flutter analyze --flutter-repo), then the code goes from having zero warnings to having lots of warnings to the effect of [warning] Missing concrete implementation of 'RenderObject.applyPaintTransform'.

$ git diff upstream/master --stat ; git diff upstream/master
 packages/flutter/lib/src/rendering/box.dart | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/packages/flutter/lib/src/rendering/box.dart b/packages/flutter/lib/src/rendering/box.dart
index 4c57d43..6f98b7c 100644
--- a/packages/flutter/lib/src/rendering/box.dart
+++ b/packages/flutter/lib/src/rendering/box.dart
@@ -624,7 +624,7 @@ abstract class RenderBox extends RenderObject {
   ///
   /// The RenderBox implementation takes care of adjusting the matrix for the
   /// position of the given child.
-  void applyPaintTransform(RenderObject child, Matrix4 transform) {
+  void applyPaintTransform(RenderBox child, Matrix4 transform) {
     assert(child.parent == this);
     BoxParentData childParentData = child.parentData;
     Point position = childParentData.position;

RenderBox is a subtype of RenderObject and the method is not abstract anywhere, it's concretely defined everywhere.

See: flutter/flutter#887
https://travis-ci.org/flutter/flutter/builds/96211427

[Hixie]

eukreign helped narrow this down. Here's a tiny test case that shows the same problem. You have to run dartanalyzer --strong on this:

abstract class A { void test(A arg) { } }
abstract class B extends A { void test(B arg) { } }
abstract class X implements A { }
class C extends B with X { }
void main() { }

Because B's test signature is different than A's, it gets an "Invalid override." strong-mode error. This seems to cause the analyzer to forget the implementation of test even exists, and then when it gets to C, it seems that it sees the "implements A" directive and looks for a test implementation and can't find one.

I guess then this is a request that when you get the "Invalid override." error, you still leave the implementation alone so that the "Missing concrete implementation" message doesn't also appear.

[eukreign]

This may not actually be a bug...

X is claiming to implement test(A arg) but the final subclass C implements test(B arg). These are not compatible because while test(A arg) can handle B instances the reverse is not true. test(B arg) only supports B and B's subclasses.

To illustrate the issue, here is some code to run through dartanalyzer:

class A { test(A arg) {} }
class B extends A { test(B arg) {} }
main() {
  new B().test(new A());
}

Which will produce:

Analyzing [foo.dart]...
[error] Invalid override. The type of B.test ((B) → dynamic) is not a subtype of A.test ((A) → dynamic). (foo.dart, line 2, col 21)
[error] Type check failed: new A() (A) is not of type B (foo.dart, line 4, col 16)
2 errors found.

So, while B is of type A, the reverse is not true, A cannot be passed to methods that are expecting B.

[Hixie]

If you change the argument types to be unrelated, you get the right set of warnings:

abstract class A { void test(int arg) { } }
abstract class B extends A { void test(String arg) { } }
abstract class X implements A { }
class C extends B with X { }
void main() { }

[error] Invalid override. The type of B.test ((String) → void) is not a subtype of A.test ((int) → void). (test.dart, line 2, col 30)
[warning] The parameter type 'String' is not assignable to 'int' as required by the method it is overriding from 'A' (test.dart, line 2, col 40)
[warning] 'test' is inherited by at least two interfaces inconsistently, from (String) → void, (int) → void (test.dart, line 4, col 7)

[jmesserly]

This still reproduces. Interestingly the error comes from existing Analyzer code in ErrorVerifier._checkForNonAbstractClassInheritsAbstractMember.

I think the problem is this line: if (_typeSystem.isSubtypeOf(foundConcreteFT, requiredMemberFT)) { ... that subtype check looks backwards. In classic Dart that makes almost no difference for function types, but in strong mode it's pretty important to get the direction of the check correct.

edit: may be wrong about that guess. I couldn't repro it without strong mode, by adding an optional parameter. Need to investigate further.

[jmesserly]

Ah so the issue is that abstract class B extends A { void test(B arg) { } } is not a legal override in strong mode:

[error] Invalid override. The type of B.test ((B) → void) is not a subtype of A.test ((A) → void). (test.dart, line 2, col 30)

that invalid override is the same reason that "C" does not satisfy the interface "A". Consider:

class A { void test(A arg) { } }
abstract class B extends A { void test(B arg) { } }
abstract class X implements A { }
class C extends B with X { }
main() {
  A a = new C();
  a.test(new A()); // boom! at runtime. A is not a B.
}

I'll dupe this with #24507 which is about covariant overrides (there's dart-archive/dev_compiler#289 too, possibly others).

[Hixie]

The bug here was really "I guess then this is a request that when you get the "Invalid override." error, you still leave the implementation alone so that the "Missing concrete implementation" message doesn't also appear."; that is, just a clarification rather than an error per se.