Infer parameter types on overrides

lib/src/checker/resolver.dart

Index: lib/src/checker/resolver.dart
diff --git a/lib/src/checker/resolver.dart b/lib/src/checker/resolver.dart
index b4954453288a42725160dd232a8e7a4d27e01c5c..a6c3287e2a29351add002453dcb0905171791d1b 100644
--- a/lib/src/checker/resolver.dart
+++ b/lib/src/checker/resolver.dart
@@ -168,10 +168,10 @@ class LibraryResolverWithInference extends LibraryResolver {
             .forEach((f) => _inferFieldTypeFromOverride(f, pending));
         if (pending.isNotEmpty) _inferVariableFromInitializer(pending);
 
-        // Infer return-types from overrides
+        // Infer return-types and param-types from overrides
         cls.members
             .where((m) => m is MethodDeclaration && !m.isStatic)
-            .forEach(_inferMethodReturnTypeFromOverride);
+            .forEach(_inferMethodTypesFromOverride);
       } else {
         _inferVariableFromInitializer(cls.members
             .where(_isInstanceField)
@@ -231,18 +231,37 @@ class LibraryResolverWithInference extends LibraryResolver {
     }
   }
 
-  void _inferMethodReturnTypeFromOverride(MethodDeclaration method) {
+  void _inferMethodTypesFromOverride(MethodDeclaration method) {
     var methodElement = method.element;
-    if ((methodElement is MethodElement ||
-            methodElement is PropertyAccessorElement) &&
-        methodElement.returnType.isDynamic &&
-        method.returnType == null) {
-      var enclosingElement = methodElement.enclosingElement as ClassElement;
-      var type = searchTypeFor(enclosingElement.type, methodElement);
-      if (type != null && !type.returnType.isDynamic) {
+    if (methodElement is! MethodElement &&
+        methodElement is! PropertyAccessorElement) return;
+
+    var enclosingElement = methodElement.enclosingElement as ClassElement;
+    FunctionType type = null;
+
+    // Infer the return type if omitted
+    if (methodElement.returnType.isDynamic && method.returnType == null) {
+      type = searchTypeFor(enclosingElement.type, methodElement);
+      if (type == null) return;
+      if (!type.returnType.isDynamic) {
         methodElement.returnType = type.returnType;
       }
     }
+
+    // Infer parameter types if omitted
+    if (method.parameters == null) return;
+    var parameters = method.parameters.parameters;
+    var length = parameters.length;
+    for (int i = 0; i < length; ++i) {
+      var parameter = parameters[i];
+      if (parameter is SimpleFormalParameter && parameter.type == null) {

[Leaf, 2015/08/25 17:03:50]

Maybe a TODO to handle default parameters and function typed parameters?

[vsm, 2015/08/25 17:44:55]

Added line to handle default params.  We would not infer if function typed (the
override would have an explicit function type), so I think that's properly
handled anyway.

[Leaf, 2015/08/25 19:21:44]

It's a corner case, but you could argue that something like the following is the
equivalent for a function typed formal:

class A {
  int f(int g(int x)) {...}
}

class B extends A {
  int f(g(x)) {...}
}

Maybe not worth worrying about though.  And I guess you could argue that if they
really want inference they should write it as:

class B extends A {
  int f(g) {...}
}

+        type = type ?? searchTypeFor(enclosingElement.type, methodElement);
+        if (type == null) return;
+        if (type.parameters.length > i && !type.parameters[i].type.isDynamic) {
+          parameter.element.type = type.parameters[i].type;
+        }
+      }
+    }
   }
 
   void _inferVariableFromInitializer(Iterable<VariableDeclaration> variables) {