Revert "fix #25794, infer parameter type from default value"

It caused a regression in cyclic_default_values_test in DDC.
Fixes #26785

This reverts commit d43f687.

[email protected]

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

Author: John Messerly

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

@@ -4857,7 +4857,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(AstNode node, DartType type) {
+  void recordInference(Expression node, DartType type) {
     if (!_inferenceHints) {
       return;
     }
@@ -5652,11 +5652,6 @@ 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.
    */
@@ -5688,7 +5683,6 @@ 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;
     }
@@ -6379,24 +6373,13 @@ class ResolverVisitor extends ScopedVisitor {
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
-    ParameterElement element = node.element;
-    InferenceContext.setType(node.defaultValue, element.type);
+    InferenceContext.setType(node.defaultValue, node.parameter.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(

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

@@ -902,14 +902,10 @@ 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 ||
-              parameter.parameterKind != ParameterKind.REQUIRED)) {
+          !contextParent.isStatic &&
+          contextParent is! ConstructorElement) {
         b.inferredTypeSlot = storeInferredType(type, context);
       }
     } else {

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

@@ -508,12 +508,6 @@ 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,7 +4107,9 @@ void f<T, U>() {
     checkLibrary('class C { bool operator<=(C other) => false; }');
   }
 
-  test_parameterType_inferred_constructor() {
+  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.
     checkLibrary('''
 class C {
   C.positional([x = 1]);
@@ -4116,31 +4118,36 @@ class C {
 ''');
   }
 
-  test_parameterType_inferred_staticMethod() {
+  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 {
-  static void positional([x = 1]) {}
-  static void named({x: 1}) {}
+  var x;
+  C.positional([this.x = 1]);
+  C.named({this.x: 1});
 }
 ''');
   }
 
-  test_parameterType_inferred_topLevelFunction() {
+  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.
     checkLibrary('''
-void positional([x = 1]) {}
-void named({x: 1}) {}
+class C {
+  static void positional([x = 1]) {}
+  static 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.
+  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.
     checkLibrary('''
-class C {
-  var x;
-  C.positional([this.x = 1]);
-  C.named({this.x: 1});
-}
+void positional([x = 1]) {}
+void named({x: 1}) {}
 ''');
   }
 

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

@@ -2037,12 +2037,16 @@ void f1(dynamic x) {}
 // default formal
 void df0([/*error:IMPLICIT_DYNAMIC_PARAMETER*/x = DYNAMIC_VALUE]) {}
 void df1([dynamic x = DYNAMIC_VALUE]) {}
-void df2([/*info:INFERRED_TYPE*/x = 42]) {}
+
+// https://github.com/dart-lang/sdk/issues/25794
+void df2([/*error:IMPLICIT_DYNAMIC_PARAMETER*/x = 42]) {}
 
 // default formal (named)
 void nf0({/*error:IMPLICIT_DYNAMIC_PARAMETER*/x: DYNAMIC_VALUE}) {}
 void nf1({dynamic x: DYNAMIC_VALUE}) {}
-void nf2({/*info:INFERRED_TYPE*/x: 42}) {}
+
+// https://github.com/dart-lang/sdk/issues/25794
+void nf2({/*error:IMPLICIT_DYNAMIC_PARAMETER*/x: 42}) {}
 
 // field formal
 class C {

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*/([/*info:INFERRED_TYPE*/llll = /*info:INFERRED_TYPE_LITERAL*/const [1]]) => "hello";
+Function2<List<int>, String> g = /*pass should be info:INFERRED_TYPE_CLOSURE*/([llll = /*info:INFERRED_TYPE_LITERAL*/const [1]]) => "hello";
 ''');
   }
 
@@ -1912,33 +1912,6 @@ 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;