Implement the spec's notion of LUB for function types.

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';
 
 import 'strong_test_helper.dart';
 
 void main() {
   testChecker('ternary operator', {
     '/main.dart': '''
         abstract class Comparable<T> {
           int compareTo(T other);
           static int compare(Comparable a, Comparable b) => a.compareTo(b);
         }
         typedef int Comparator<T>(T a, T b);
 
         typedef bool _Predicate<T>(T value);
 
         class SplayTreeMap<K, V> {
           Comparator<K> _comparator;
           _Predicate _validKey;
 
-          // Initializing _comparator needs a cast, since K may not always be
-          // Comparable.
-          // Initializing _validKey shouldn't need a cast.  Currently
-          // it requires inference to work because of dartbug.com/23381
+          // TODO(rnystrom): Initializing _comparator should have a cast, since
+          // K may not always be Comparable. It doesn't currently get one
+          // because we're using the spec's LUB on function types, which isn't
+          // sound.
           SplayTreeMap([int compare(K key1, K key2),
                         bool isValidKey(potentialKey)]) {
-            : _comparator = /*warning:DOWN_CAST_COMPOSITE*/(compare == null)
-                           ? Comparable.compare : compare,
-              _validKey = /*warning:DOWN_CAST_COMPOSITE*/(isValidKey != null)
-                         ? isValidKey : ((v) => true);
-             _Predicate<Object> _v = /*warning:DOWN_CAST_COMPOSITE*/(isValidKey != null)
-                                    ? isValidKey : (/*info:INFERRED_TYPE_CLOSURE*/(v) => true);
-        // TODO(leafp): Fix unimplemented LUB in analyzer
-        _v = /*warning:DOWN_CAST_COMPOSITE*/(isValidKey != null)
-             ? _v : (/*info:INFERRED_TYPE_CLOSURE*/(v) => true);
+            : _comparator = (compare == null) ? Comparable.compare : compare,
+              _validKey = (isValidKey != null) ? isValidKey : ((v) => true);
+             _Predicate<Object> v = /*warning:DOWN_CAST_COMPOSITE*/(isValidKey != null)
+                                    ? isValidKey : (/*info:INFERRED_TYPE_CLOSURE*/(_) => true);
+
+            v = (isValidKey != null)
+                 ? v : (/*info:INFERRED_TYPE_CLOSURE*/(_) => true);
           }
         }
         void main() {
           Object obj = 42;
           dynamic dyn = 42;
           int i = 42;
 
           // Check the boolean conversion of the condition.
           print((/*severe:STATIC_TYPE_ERROR*/i) ? false : true);
           print((/*info:DOWN_CAST_IMPLICIT*/obj) ? false : true);
@@ skipping 2508 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* new Iterable<int>(); }
         Iterable<int> baz5() sync* { yield* (/*info:INFERRED_TYPE_ALLOCATION*/new Iterable()); }
     '''
     });
   });
 }