Infer parameter types on overrides

lib/src/checker/resolver.dart

 // Copyright (c) 2015, 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.
 
 /// Encapsulates how to invoke the analyzer resolver and overrides how it
 /// computes types on expressions to use our restricted set of types.
 library dev_compiler.src.checker.resolver;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/src/generated/ast.dart';
@@ skipping 150 matching lines @@
       }
 
       if (_options.inferFromOverrides) {
         // Infer field types from overrides first, otherwise from initializers.
         var pending = new Set<VariableDeclaration>();
         cls.members
             .where(_isInstanceField)
             .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)
             .expand((f) => f.fields.variables));
       }
     }
     classes.forEach(visit);
   }
 
   void _reanalyzeVar(Map<Source, RestrictedResolverVisitor> visitors,
@@ skipping 39 matching lines @@
       }
 
       // Use type from the override.
       var newType = type.returnType;
       varElement.type = newType;
       varElement.getter.returnType = newType;
       if (!varElement.isFinal) varElement.setter.parameters[0].type = newType;
     }
   }
 
-  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 DefaultFormalParameter) parameter = parameter.parameter;
+      if (parameter is SimpleFormalParameter && parameter.type == null) {
+        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) {
     for (var variable in variables) {
       var declaration = variable.parent as VariableDeclarationList;
       // Only infer on variables that don't have any declared type.
       if (declaration.type != null) continue;
       if (_options.onlyInferConstsAndFinalFields &&
           !declaration.isFinal &&
           !declaration.isConst) {
@@ skipping 460 matching lines @@
     }
   }
 
   // Review note: no longer need to override visitFunctionExpression, this is
   // handled by the analyzer internally.
   // TODO(vsm): in visitbinaryExpression: check computeStaticReturnType result?
   // TODO(vsm): in visitFunctionDeclaration: Should we ever use the expression
   // type in a (...) => expr or just the written type?
 
 }