Minor type inference fixes.

pkg/front_end/lib/src/fasta/type_inference/type_inferrer.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.md file.
 
 import 'package:front_end/src/base/instrumentation.dart';
 import 'package:front_end/src/fasta/kernel/kernel_shadow_ast.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_engine.dart';
 import 'package:front_end/src/fasta/type_inference/type_inference_listener.dart';
 import 'package:front_end/src/fasta/type_inference/type_promotion.dart';
 import 'package:front_end/src/fasta/type_inference/type_schema.dart';
@@ skipping 335 matching lines @@
 
     // Attempt to match `K` as a function type compatible with the closure (that
     // is, one having n type parameters and a compatible set of formal
     // parameters).  If there is a successful match, let `<S0, ..., Sn>` be the
     // set of matched type parameters and `(Q0, ..., Qm)` be the set of matched
     // formal parameter types, and let `N` be the return type.
     Substitution substitution;
     List<DartType> formalTypesFromContext =
         new List<DartType>.filled(formals.length, null);
     DartType returnContext;
-    if (typeContext is FunctionType) {
+    if (strongMode && typeContext is FunctionType) {
       for (int i = 0; i < formals.length; i++) {
         if (i < function.positionalParameters.length) {
           formalTypesFromContext[i] =
               _getPositionalParameterType(typeContext, i);
         } else {
           formalTypesFromContext[i] =
               _getNamedParameterType(typeContext, formals[i].name);
         }
       }
       returnContext = typeContext.returnType;
@@ skipping 18 matching lines @@
       substitution = Substitution.empty;
     }
 
     // Define `Ri` as follows: if `Pi` is not `_`, let `Ri` be `Pi`.
     // Otherwise, if `Qi` is not `_`, let `Ri` be the greatest closure of
     // `Qi[T/S]` with respect to `?`.  Otherwise, let `Ri` be `dynamic`.
     for (int i = 0; i < formals.length; i++) {
       KernelVariableDeclaration formal = formals[i];
       if (KernelVariableDeclaration.isImplicitlyTyped(formal)) {
         if (formalTypesFromContext[i] != null) {
-          formal.type = greatestClosure(coreTypes,
+          var inferredType = greatestClosure(coreTypes,
               substitution.substituteType(formalTypesFromContext[i]));
+          instrumentation?.record(Uri.parse(uri), formal.fileOffset, 'type',
+              new InstrumentationValueForType(inferredType));
+          formal.type = inferredType;
         }
       }
     }
 
     // Let `N’` be `N[T/S]`, adjusted accordingly if the closure is declared
     // with `async`, `async*`, or `sync*`.
     if (returnContext != null) {
       returnContext = substitution.substituteType(returnContext);
     }
     if (isGenerator) {
@@ skipping 480 matching lines @@
   /// statement returning the given [type].
   void updateInferredReturnType(TypeInferrerImpl inferrer, DartType type) {
     if (_inferredReturnType == null) {
       _inferredReturnType = type;
     } else {
       _inferredReturnType = inferrer.typeSchemaEnvironment
           .getLeastUpperBound(_inferredReturnType, type);
     }
   }
 }