Handle fuzzy optional parameters correctly.

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

 // Copyright (c) 2015, 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.
 
 // TODO(jmesserly): this file needs to be refactored, it's a port from
 // package:dev_compiler's tests
 /// General type checking tests
 library analyzer.test.src.task.strong.checker_test;
 
 import 'package:unittest/unittest.dart';
@@ skipping 719 matching lines @@
           f = /*warning:DOWN_CAST_COMPOSITE*/right;
           f = bot;
         }
       }
    ''');
     });
 
     test('dynamic functions - closures are not fuzzy', () {
       // Regression test for
       // https://github.com/dart-lang/sdk/issues/26118
+      // https://github.com/dart-lang/sdk/issues/26156
       checkFile('''
+        void takesF(void f(int x)) {}
+
+        typedef void TakesInt(int x);
+
+        void update(_) {}
+        void updateOpt([_]) {}
+        void updateOptNum([num x]) {}
+
+        class A {
+          TakesInt f;
+          A(TakesInt g) {
+            f = update;
+            f = updateOpt;
+            f = updateOptNum;
+          }
+          TakesInt g(bool a, bool b) {
+            if (a) {
+              return update;
+            } else if (b) {
+              return updateOpt;
+            } else {
+              return updateOptNum;
+            }
+          }
+        }
+
+        void test0() {
+          takesF(update);
+          takesF(updateOpt);
+          takesF(updateOptNum);
+          TakesInt f;
+          f = update;
+          f = updateOpt;
+          f = updateOptNum;
+          new A(update);
+          new A(updateOpt);
+          new A(updateOptNum);
+        }
+
         void test1() {
           void takesF(f(int x)) => null;
           takesF((dynamic y) => 3);
         }
 
         void test2() {
           int x;
           int f/*<T>*/(/*=T*/ t, callback(/*=T*/ x)) { return 3; }
           f(x, (y) => 3);
         }
@@ skipping 2424 matching lines @@
 
         baz1() sync* { yield* /*info:DYNAMIC_CAST*/x; }
         Iterable baz2() sync* { yield* /*info:DYNAMIC_CAST*/x; }
         Iterable<int> baz3() sync* { yield* /*warning:DOWN_CAST_COMPOSITE*/x; }
         Iterable<int> baz4() sync* { yield* bar3(); }
         Iterable<int> baz5() sync* { yield* /*info:INFERRED_TYPE_ALLOCATION*/new List(); }
     ''');
     });
   });
 }