fixes #24507, allow known functions to be treated as strict arrows

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 538 matching lines @@
     test('dynamic', () {
       checkFile('''
 
       class A {}
 
       typedef dynamic Top(dynamic x);     // Top of the lattice
       typedef dynamic Left(A x);          // Left branch
       typedef A Right(dynamic x);         // Right branch
       typedef A Bottom(A x);              // Bottom of the lattice
 
+      void main() {
+        Top top;
+        Left left;
+        Right right;
+        Bottom bot;
+        {
+          Top f;
+          f = top;
+          f = left;
+          f = right;
+          f = bot;
+        }
+        {
+          Left f;
+          f = /*warning:DOWN_CAST_COMPOSITE*/top;
+          f = left;
+          f = /*warning:DOWN_CAST_COMPOSITE*/right;
+          f = bot;
+        }
+        {
+          Right f;
+          f = /*warning:DOWN_CAST_COMPOSITE*/top;
+          f = /*warning:DOWN_CAST_COMPOSITE*/left;
+          f = right;
+          f = bot;
+        }
+        {
+          Bottom f;
+          f = /*warning:DOWN_CAST_COMPOSITE*/top;
+          f = /*warning:DOWN_CAST_COMPOSITE*/left;
+          f = /*warning:DOWN_CAST_COMPOSITE*/right;
+          f = bot;
+        }
+      }
+   ''');
+    });
+
+    test('dynamic - known functions', () {
+      checkFile('''
+
+      class A {}

[Leaf, 2016/02/16 20:30:43]

A little pedantic, but I think it's worth getting the terminology right here
just to make it clear what's going on.  In this test, you have a lattice induced
by the function type operator over Bottom <: A <: Top, so you get a nine point
lattice rather than a four point lattice.  So some of the top/bottom names below
aren't right, and the left right doesn't make sense.  We can only express 6 of
the 9 points, because we can't write down Bot -> Bot, A -> Bot, or Top -> Bot. 
The remaining six point lattice looks like:

           Bot -> Top
          /        \
      A -> Top    Bot -> A
       /     \      /
 Top -> Top   A -> A
         \      /
         Top -> A


You can name these points as paths through the lattice (Top, Left, LeftLeft,
Right, RightLeft, Bot), or just using their constituent types (BotTop, ATop,
TopTop, TopA, BotA, AA).  

You could fold the previous test into this, since the lattice tested above is a
sub-lattice of this lattice (it's the upper right diamond).

[Jennifer Messerly, 2016/02/17 20:13:23]

Done!

* used that picture in a comment. Thanks :)
* went with the "constituent types" naming, as it makes it easier to look at one
line in isolation and know what the answer should be.
* added all 6 types we can be assigning to.
* kept "known functions" as a separate test. Tried merging them, but it was a
little confusing because some of the messages are warnings and some are errors,
which has nothing to do with the type lattice itself, only the source of the
type.

+
+      typedef dynamic Top(dynamic x);     // Top of the lattice
+      typedef dynamic Left(A x);          // Left branch
+      typedef A Right(dynamic x);         // Right branch
+      typedef A Bottom(A x);              // Bottom of the lattice

[Leaf, 2016/02/16 20:30:43]

This is not the bottom type in this lattice.

[Jennifer Messerly, 2016/02/17 20:13:23]

Fixed. See above.

+
       dynamic left(A x) => x;
       A bot(A x) => x;

[Leaf, 2016/02/16 20:30:43]

This is not the bottom type in this lattice.

[Jennifer Messerly, 2016/02/17 20:13:23]

Fixed. See above.

       dynamic top(dynamic x) => x;

[Leaf, 2016/02/16 20:30:43]

This is not the top type in this lattice.

[Jennifer Messerly, 2016/02/17 20:13:23]

Fixed. See above.

       A right(dynamic x) => /*info:DYNAMIC_CAST*/x;

[Leaf, 2016/02/16 20:30:43]

This is the bottom type in this lattice.

[Jennifer Messerly, 2016/02/17 20:13:23]

Fixed. See above.

 
       void main() {
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Left f;
-          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = top;
           f = left;
-          f = /*severe:STATIC_TYPE_ERROR*/right;
+          f = right;
           f = bot;
         }
         {
           Right f;
           f = /*severe:STATIC_TYPE_ERROR*/top;
           f = /*severe:STATIC_TYPE_ERROR*/left;
           f = right;
           f = bot;
         }
         {
           Bottom f;
           f = /*severe:STATIC_TYPE_ERROR*/top;
           f = /*severe:STATIC_TYPE_ERROR*/left;
-          f = /*severe:STATIC_TYPE_ERROR*/right;
+          f = right;
           f = bot;
         }
       }
    ''');
     });
 
     test('function literal variance', () {
       checkFile('''
 
       class A {}
@@ skipping 2193 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()); }
     ''');
     });
   });
 }