fix #25794, infer parameter type from default value

pkg/analyzer/lib/src/generated/resolver.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 4817 matching lines @@
   void pushReturnContext(BlockFunctionBody node) {
     DartType returnType = getType(node);
     _returnStack.add(returnType);
     _inferredReturn.add(BottomTypeImpl.instance);
   }
 
   /**
    * Place an info node into the error stream indicating that a
    * [type] has been inferred as the type of [node].
    */
-  void recordInference(Expression node, DartType type) {
+  void recordInference(AstNode node, DartType type) {
     if (!_inferenceHints) {
       return;
     }
 
     ErrorCode error;
     if (node is Literal) {
       error = StrongModeCode.INFERRED_TYPE_LITERAL;
     } else if (node is InstanceCreationExpression) {
       error = StrongModeCode.INFERRED_TYPE_ALLOCATION;
     } else if (node is FunctionExpression) {
@@ skipping 775 matching lines @@
    * A comment before a function should be resolved in the context of the
    * function. But when we incrementally resolve a comment, we don't want to
    * resolve the whole function.
    *
    * So, this flag is set to `true`, when just context of the function should
    * be built and the comment resolved.
    */
   bool resolveOnlyCommentInFunctionBody = false;
 
   /**
+   * True if we're analyzing in strong mode.
+   */
+  bool _strongMode;
+
+  /**
    * Body of the function currently being analyzed, if any.
    */
   FunctionBody _currentFunctionBody;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in an AST node.
    *
    * The [definingLibrary] is the element for the library containing the node
    * being visited. The [source] is the source representing the compilation unit
    * containing the node being visited. The [typeProvider] is the object used to
@@ skipping 10 matching lines @@
    */
   ResolverVisitor(LibraryElement definingLibrary, Source source,
       TypeProvider typeProvider, AnalysisErrorListener errorListener,
       {Scope nameScope})
       : super(definingLibrary, source, typeProvider, errorListener,
             nameScope: nameScope) {
     this.elementResolver = new ElementResolver(this);
     this.typeSystem = definingLibrary.context.typeSystem;
     bool strongModeHints = false;
     AnalysisOptions options = definingLibrary.context.analysisOptions;
+    _strongMode = options.strongMode;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
     }
     this.inferenceContext = new InferenceContext._(
         errorReporter, typeProvider, typeSystem, strongModeHints);
     this.typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   /**
    * Return the element representing the function containing the current node, or `null` if
@@ skipping 670 matching lines @@
     // We do not visit the label because it needs to be visited in the context
     // of the statement.
     //
     node.accept(elementResolver);
     node.accept(typeAnalyzer);
     return null;
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
-    InferenceContext.setType(node.defaultValue, node.parameter.element?.type);
+    ParameterElement element = node.element;
+    InferenceContext.setType(node.defaultValue, element.type);
     super.visitDefaultFormalParameter(node);
-    ParameterElement element = node.element;
     if (element.initializer != null && node.defaultValue != null) {
       (element.initializer as FunctionElementImpl).returnType =
           node.defaultValue.staticType;
     }
+    if (_strongMode &&
+        node.defaultValue != null &&
+        element.hasImplicitType &&
+        element is! FieldFormalParameterElement) {
+
+      DartType type = node.defaultValue.staticType;
+      if (!type.isBottom && !type.isDynamic) {
+        (element as ParameterElementImpl).type = type;
+        inferenceContext.recordInference(node, type);
+      }
+    }
     // Clone the ASTs for default formal parameters, so that we can use them
     // during constant evaluation.
     if (!LibraryElementImpl.hasResolutionCapability(
         definingLibrary, LibraryResolutionCapability.constantExpressions)) {
       (element as ConstVariableElement).constantInitializer =
           new ConstantAstCloner().cloneNode(node.defaultValue);
     }
     return null;
   }
 
@@ skipping 4647 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }