Infer the return types of local functions where appropriate.

pkg/analyzer/test/src/task/strong/front_end_inference_test.dart

 // Copyright (c) 2017, 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.
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 351 matching lines @@
   }
 
   @override
   visitDeclaredIdentifier(DeclaredIdentifier node) {
     super.visitDeclaredIdentifier(node);
     if (node.type == null) {
       _recordType(node.identifier.offset, node.element.type);
     }
   }
 
+  @override
+  visitFunctionDeclaration(FunctionDeclaration node) {
+    super.visitFunctionDeclaration(node);
+    if (node.element is LocalElement &&
+        node.element.enclosingElement is! CompilationUnitElement) {
+      if (node.returnType == null) {
+        _instrumentation.record(
+            uri,
+            node.name.offset,
+            'returnType',
+            new _InstrumentationValueForType(
+                node.element.returnType, elementNamer));
+      }
+      var parameters = node.functionExpression.parameters;
+      for (var parameter in parameters.parameters) {
+        // Note: it's tempting to check `parameter.type == null`, but that
+        // doesn't work because of function-typed formal parameter syntax.
+        if (parameter.element.hasImplicitType) {
+          _recordType(parameter.identifier.offset, parameter.element.type);
+        }
+      }
+    }
+  }
+
   visitFunctionExpression(FunctionExpression node) {
     super.visitFunctionExpression(node);
     if (node.parent is! FunctionDeclaration) {
       DartType type = node.staticType;
       if (type is FunctionType) {
         _instrumentation.record(uri, node.parameters.offset, 'returnType',
             new _InstrumentationValueForType(type.returnType, elementNamer));
         List<FormalParameter> parameters = node.parameters.parameters;
         for (int i = 0; i < parameters.length; i++) {
           FormalParameter parameter = parameters[i];
@@ skipping 201 matching lines @@
 
   /// Based on DDC code generator's `_recoverTypeArguments`
   Iterable<DartType> _recoverTypeArguments(FunctionType g, FunctionType f) {
     assert(identical(g.element, f.element));
     assert(g.typeFormals.isNotEmpty && f.typeFormals.isEmpty);
     assert(g.typeFormals.length + g.typeArguments.length ==
         f.typeArguments.length);
     return f.typeArguments.skip(g.typeArguments.length);
   }
 }