fix #25794, infer parameter type from default value

[email protected]

Review URL: https://codereview.chromium.org/2092873002 .

Author: John Messerly

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

@@ -4840,7 +4840,7 @@ class InferenceContext {
    * 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;
     }
@@ -5635,6 +5635,11 @@ class ResolverVisitor extends ScopedVisitor {
    */
   bool resolveOnlyCommentInFunctionBody = false;
 
+  /**
+   * True if we're analyzing in strong mode.
+   */
+  bool _strongMode;
+
   /**
    * Body of the function currently being analyzed, if any.
    */
@@ -5666,6 +5671,7 @@ class ResolverVisitor extends ScopedVisitor {
     this.typeSystem = definingLibrary.context.typeSystem;
     bool strongModeHints = false;
     AnalysisOptions options = definingLibrary.context.analysisOptions;
+    _strongMode = options.strongMode;
     if (options is AnalysisOptionsImpl) {
       strongModeHints = options.strongModeHints;
     }
@@ -6356,13 +6362,24 @@ class ResolverVisitor extends ScopedVisitor {
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
-    InferenceContext.setType(node.defaultValue, node.parameter.element?.type);
-    super.visitDefaultFormalParameter(node);
     ParameterElement element = node.element;
+    InferenceContext.setType(node.defaultValue, element.type);
+    super.visitDefaultFormalParameter(node);
     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(

pkg/analyzer/lib/src/summary/summarize_elements.dart

@@ -902,10 +902,14 @@ class _CompilationUnitSerializer {
     DartType type = parameter.type;
     if (parameter.hasImplicitType) {
       Element contextParent = context.enclosingElement;
+      // Strong mode infers parameters in two cases:
+      // - instance members (i.e. not constructors or static members),
+      // - parameters with default values, except initializing formals
+      //   (the type comes from the field).
       if (!parameter.isInitializingFormal &&
           contextParent is ExecutableElement &&
-          !contextParent.isStatic &&
-          contextParent is! ConstructorElement) {
+          (!contextParent.isStatic && contextParent is! ConstructorElement ||
+              parameter.parameterKind != ParameterKind.REQUIRED)) {
         b.inferredTypeSlot = storeInferredType(type, context);
       }
     } else {

pkg/analyzer/test/src/summary/resynthesize_ast_test.dart

@@ -508,6 +508,12 @@ var b = a.m();
     super.test_inferCorrectlyOnMultipleVariablesDeclaredTogether();
   }
 
+  @override
+  @failingTest
+  void test_inferDefaultFormalParameter() {
+    super.test_inferDefaultFormalParameter();
+  }
+
   @override
   @failingTest
   void test_inferenceInCyclesIsDeterministic() {

pkg/analyzer/test/src/summary/resynthesize_test.dart

@@ -4107,9 +4107,7 @@ void f<T, U>() {
     checkLibrary('class C { bool operator<=(C other) => false; }');
   }
 
-  test_parameterTypeNotInferred_constructor() {
-    // Strong mode doesn't do type inference on constructor parameters, so it's
-    // ok that we don't store inferred type info for them in summaries.
+  test_parameterType_inferred_constructor() {
     checkLibrary('''
 class C {
   C.positional([x = 1]);
@@ -4118,21 +4116,7 @@ class C {
 ''');
   }
 
-  test_parameterTypeNotInferred_initializingFormal() {
-    // Strong mode doesn't do type inference on initializing formals, so it's
-    // ok that we don't store inferred type info for them in summaries.
-    checkLibrary('''
-class C {
-  var x;
-  C.positional([this.x = 1]);
-  C.named({this.x: 1});
-}
-''');
-  }
-
-  test_parameterTypeNotInferred_staticMethod() {
-    // Strong mode doesn't do type inference on parameters of static methods,
-    // so it's ok that we don't store inferred type info for them in summaries.
+  test_parameterType_inferred_staticMethod() {
     checkLibrary('''
 class C {
   static void positional([x = 1]) {}
@@ -4141,16 +4125,25 @@ class C {
 ''');
   }
 
-  test_parameterTypeNotInferred_topLevelFunction() {
-    // Strong mode doesn't do type inference on parameters of top level
-    // functions, so it's ok that we don't store inferred type info for them in
-    // summaries.
+  test_parameterType_inferred_topLevelFunction() {
     checkLibrary('''
 void positional([x = 1]) {}
 void named({x: 1}) {}
 ''');
   }
 
+  test_parameterTypeNotInferred_initializingFormal() {
+    // Strong mode doesn't do type inference on initializing formals, so it's
+    // ok that we don't store inferred type info for them in summaries.
+    checkLibrary('''
+class C {
+  var x;
+  C.positional([this.x = 1]);
+  C.named({this.x: 1});
+}
+''');
+  }
+
   test_parts() {
     addSource('/a.dart', 'part of my.lib;');
     addSource('/b.dart', 'part of my.lib;');

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

@@ -723,7 +723,7 @@ class Foo {
 }
 void f([List<int> l = /*info:INFERRED_TYPE_LITERAL*/const [1]]) {}
 // We do this inference in an early task but don't preserve the infos.
-Function2<List<int>, String> g = /*pass should be info:INFERRED_TYPE_CLOSURE*/([llll = /*info:INFERRED_TYPE_LITERAL*/const [1]]) => "hello";
+Function2<List<int>, String> g = /*pass should be info:INFERRED_TYPE_CLOSURE*/([/*info:INFERRED_TYPE*/llll = /*info:INFERRED_TYPE_LITERAL*/const [1]]) => "hello";
 ''');
   }
 
@@ -1913,6 +1913,33 @@ foo() {
 ''');
   }
 
+  void test_inferDefaultFormalParameter() {
+    var unit = checkFile('''
+f([/*info:INFERRED_TYPE*/x = 42]) {}
+g({/*info:INFERRED_TYPE*/x: 'hi'}) {}
+''');
+    expect(unit.functions[0].parameters[0].type.toString(), 'int');
+    expect(unit.functions[1].parameters[0].type.toString(), 'String');
+  }
+
+  void test_inferDefaultFormalParameter_fieldFormal() {
+    checkFile('''
+class C {
+  int x;
+  var y;
+  C({this.x: /*error:INVALID_ASSIGNMENT*/0.0, this.y: 'hi'}) {
+    String z = /*info:DYNAMIC_CAST*/y;
+  }
+  C.c([this.x =/*error:INVALID_ASSIGNMENT*/0.0, this.y = 'hi']) {
+    String z = /*info:DYNAMIC_CAST*/y;
+  }
+  m() {
+    String z = /*info:DYNAMIC_CAST*/y;
+  }
+}
+''');
+  }
+
   void test_inferedType_usesSyntheticFunctionType() {
     var mainUnit = checkFile('''
 int f() => null;