Fix logic error causing all unnamed parameters have index 0.

In the definition of `_computeExplicitlyTypedParameterSet`, I
accidentally nested the declaration of `unnamedParameterIndex` inside
the `for` loop, defeating the increment and causing all parameters to
be considered to have index 0.

I've included a test case that would have caught the mistake.

Bug: dart-lang/language#731
Change-Id: I0cd0e1e5b481313150e495d370af2477253d6637
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/242741
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Reviewed-by: Samuel Rawlins <[email protected]>

Author: stereotype441

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

@@ -23,8 +23,8 @@ Set<Object> _computeExplicitlyTypedParameterSet(
   List<FormalParameter> parameters =
       functionExpression.parameters?.parameters ?? const [];
   Set<Object> result = {};
+  int unnamedParameterIndex = 0;
   for (var formalParameter in parameters) {
-    int unnamedParameterIndex = 0;
     var key = formalParameter.isNamed
         ? formalParameter.identifier?.name ?? ''
         : unnamedParameterIndex++;

pkg/analyzer/test/src/dart/resolution/type_inference/inference_update_1_test.dart

@@ -110,6 +110,30 @@ test() {
         _isEnabled ? 'List<int>' : 'List<dynamic>');
   }
 
+  test_horizontal_inference_necessary_due_to_wrong_explicit_parameter_type() async {
+    // In this example, horizontal type inference is needed because although the
+    // type of `y` is explicit, it's actually `x` that would have needed to be
+    // explicit.
+    await assertErrorsInCode('''
+test(List<int> list) {
+  var a = list.fold(0, (x, int y) => x + y);
+}
+''', [
+      error(HintCode.UNUSED_LOCAL_VARIABLE, 29, 1),
+      if (!_isEnabled)
+        error(
+            CompileTimeErrorCode
+                .UNCHECKED_OPERATOR_INVOCATION_OF_NULLABLE_VALUE,
+            62,
+            1),
+    ]);
+    assertType(findElement.localVar('a').type, _isEnabled ? 'int' : 'dynamic');
+    assertType(findElement.parameter('x').type, _isEnabled ? 'int' : 'Object?');
+    assertType(findElement.parameter('y').type, 'int');
+    expect(findNode.binary('+ y').staticElement?.enclosingElement.name,
+        _isEnabled ? 'num' : null);
+  }
+
   test_horizontal_inference_propagate_to_earlier_closure() async {
     await assertErrorsInCode('''
 U f<T, U>(U Function(T) g, T Function() h) => throw '';

tests/language/inference_update_1/horizontal_inference_enabled_test.dart

@@ -84,6 +84,15 @@ testDependencyCycle(Map<T, U> Function<T, U>(T Function(U), U Function(T)) f) {
       .expectStaticType<Exactly<Map<List<Object?>, Set<Object?>>>>();
 }
 
+testNecessaryDueToWrongExplicitParameterType(List<int> list) {
+  var a = list.fold(
+      0,
+      (x, int y) =>
+          (x..expectStaticType<Exactly<int>>()) +
+          (y..expectStaticType<Exactly<int>>()));
+  a.expectStaticType<Exactly<int>>();
+}
+
 testPropagateFromContravariantReturnType(
     U Function<T, U>(void Function(T) Function(), U Function(T)) f) {
   f(() => (int i) {}, (x) => [x]..expectStaticType<Exactly<List<int>>>())