Use GLB for function parameters when doing LUB in strong mode.

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 10 matching lines @@
           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;
 
-          // 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.
+          // The warning on assigning to _comparator is legitimate. Since K has
+          // no bound, all we know is that it's object. _comparator's function
+          // type is effectively:              (Object, Object) -> int
+          // We are assigning it a fn of type: (Comparable, Comparable) -> int
+          // There's no telling if that will work. For example, consider:
+          //
+          //     new SplayTreeMap<Uri>();
+          //
+          // This would end up calling .compareTo() on a Uri, which doesn't
+          // define that since it doesn't implement Comparable.
           SplayTreeMap([int compare(K key1, K key2),
                         bool isValidKey(potentialKey)])
-            : _comparator = (compare == null) ? Comparable.compare : compare,
+            : _comparator = /*warning:FIELD_INITIALIZER_NOT_ASSIGNABLE*/(compare == null) ? Comparable.compare : compare,
               _validKey = (isValidKey != null) ? isValidKey : ((v) => true) {
-            _Predicate<Object> v = /*warning:DOWN_CAST_COMPOSITE*/(isValidKey != null)

[Leaf, 2016/03/22 00:02:20]

\o/

-                                    ? isValidKey : (/*info:INFERRED_TYPE_CLOSURE*/(_) => true);
+            _Predicate<Object> v = (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;
 
@@ skipping 2855 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(); }
     ''');
     });
   });
 }