fix #26512, correct handling of fuzzy arrows in strong mode LUB

pkg/analyzer/test/generated/type_system_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.
 
 // Tests related to the [TypeSystem] class.
 
 library analyzer.test.generated.type_system_test;
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 146 matching lines @@
     FunctionType expected = _functionType([], optional: [objectType, numType]);
     _checkLeastUpperBound(type1, type2, expected);
   }
 
   void test_functionsLubRequiredParams() {
     FunctionType type1 = _functionType([stringType, intType, intType]);
     FunctionType type2 = _functionType([intType, doubleType, numType]);
     FunctionType expected = _functionType([objectType, numType, numType]);
     _checkLeastUpperBound(type1, type2, expected);
   }
-
   void test_nestedNestedFunctionsLubInnermostParamTypes() {
     FunctionType type1 = _functionType([
       _functionType([
         _functionType([stringType, intType, intType])
       ])
     ]);
     FunctionType type2 = _functionType([
       _functionType([
         _functionType([intType, doubleType, numType])
       ])
@@ skipping 957 matching lines @@
   }
 
   void test_functionsDifferentRequiredArityBecomeOptional() {
     FunctionType type1 = _functionType([intType]);
     FunctionType type2 = _functionType([intType, intType, intType]);
     FunctionType expected =
         _functionType([intType], optional: [intType, intType]);
     _checkGreatestLowerBound(type1, type2, expected);
   }
 
+  void test_functionsFuzzyArrows() {
+    FunctionType type1 = _functionType([dynamicType]);
+    FunctionType type2 = _functionType([intType]);
+    FunctionType expected = _functionType([intType]);
+    _checkGreatestLowerBound(type1, type2, expected);
+  }
+
   void test_functionsGlbReturnType() {
     FunctionType type1 = _functionType([], returns: intType);
     FunctionType type2 = _functionType([], returns: numType);
     FunctionType expected = _functionType([], returns: intType);
     _checkGreatestLowerBound(type1, type2, expected);
   }
 
   void test_functionsLubNamedParams() {
     FunctionType type1 =
         _functionType([], named: {'a': stringType, 'b': intType});
@@ skipping 149 matching lines @@
  * In particular, function parameters are compared using LUB in spec mode, but
  * GLB in strong mode.
  */
 @reflectiveTest
 class StrongLeastUpperBoundTest extends LeastUpperBoundTestBase {
   void setUp() {
     typeSystem = new StrongTypeSystemImpl();
     super.setUp();
   }
 
+  void test_functionsFuzzyArrows() {
+    FunctionType type1 = _functionType([dynamicType]);
+    FunctionType type2 = _functionType([intType]);
+    FunctionType expected = _functionType([dynamicType]);
+    _checkLeastUpperBound(type1, type2, expected);
+  }
+
   void test_functionsGlbNamedParams() {
     FunctionType type1 =
         _functionType([], named: {'a': stringType, 'b': intType});
     FunctionType type2 = _functionType([], named: {'a': intType, 'b': numType});
     FunctionType expected =
         _functionType([], named: {'a': bottomType, 'b': intType});
     _checkLeastUpperBound(type1, type2, expected);
   }
 
   void test_functionsGlbPositionalParams() {
@@ skipping 465 matching lines @@
     if (types != null) {
       f.typeParameters =
           new List<TypeParameterElement>.from(types.map((t) => t.element));
     }
     return f.type = new FunctionTypeImpl(f);
   }
 
   static TypeParameterType variable(String name, {DartType bound}) =>
       ElementFactory.typeParameterWithType(name, bound).type;
 }