Refactor fuzzy arrow hints.

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.
 
 library analyzer.test.src.task.strong.checker_test;
 
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'strong_test_helper.dart';
 
@@ skipping 471 matching lines @@
 void main() {
   var a = new A();
   bar(a);
   (/*info:DYNAMIC_INVOKE*/bar1(a));
   var b = bar;
   (/*info:DYNAMIC_INVOKE*/b(a));
   var f1 = foo;
   f1("hello");
   dynamic f2 = foo;
   (/*info:DYNAMIC_INVOKE*/f2("hello"));
-  DynFun f3 = foo;
+  DynFun f3 = /*info:USES_DYNAMIC_AS_BOTTOM*/foo;
   (/*info:DYNAMIC_INVOKE*/f3("hello"));
   (/*info:DYNAMIC_INVOKE*/f3(42));
   StrFun f4 = foo;
   f4("hello");
   a.baz1("hello");
   var b1 = a.baz1;
   (/*info:DYNAMIC_INVOKE*/b1("hello"));
   A.baz2("hello");
   var b2 = A.baz2;
   (/*info:DYNAMIC_INVOKE*/b2("hello"));
@@ skipping 163 matching lines @@
     x = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
     x = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f./*error:UNDEFINED_METHOD*/col(3.0);
     y = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
     y = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f./*error:UNDEFINED_METHOD*/col(3.0);
     /*info:DYNAMIC_INVOKE*/f(3.0);
     // Through type propagation, we know f is actually a B, hence the
     // hint.
     /*info:DYNAMIC_INVOKE*/f./*error:UNDEFINED_METHOD*/col(3);
   }
   {
-    A f = new B();
+    A f = /*info:USES_DYNAMIC_AS_BOTTOM*/new B();
     int x;
     double y;
     x = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
     y = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
     /*info:DYNAMIC_INVOKE*/f(3.0);
   }
   {
     dynamic g = new B();
     /*info:DYNAMIC_INVOKE*/g.call(32.0);
     /*info:DYNAMIC_INVOKE*/g.col(42.0);
     /*info:DYNAMIC_INVOKE*/g.foo(42.0);
     /*info:DYNAMIC_INVOKE*/g.x;
-    A f = new B();
+    A f = /*info:USES_DYNAMIC_AS_BOTTOM*/new B();
     /*info:DYNAMIC_INVOKE*/f./*error:UNDEFINED_METHOD*/col(42.0);
     /*info:DYNAMIC_INVOKE*/f./*error:UNDEFINED_METHOD*/foo(42.0);
     /*info:DYNAMIC_INVOKE*/f./*error:UNDEFINED_GETTER*/x;
   }
 }
 ''');
   }
 
   test_factoryConstructorDowncast() async {
     await checkFile(r'''
@@ skipping 355 matching lines @@
     f = bot;
   }
 }
 ''');
   }
 
   test_functionTypingAndSubtyping_dynamic() async {
     await checkFile('''
 class A {}
 
-typedef dynamic Top(dynamic x);     // Top of the lattice
+typedef dynamic Top(Null x);     // Top of the lattice
 typedef dynamic Left(A x);          // Left branch
-typedef A Right(dynamic x);         // Right branch
+typedef A Right(Null 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;
@@ skipping 38 matching lines @@
     //         \      /
     //         Top -> A
     //
     // Note that downcasts of known functions are promoted to
     // static type errors, since they cannot succeed.
     // This makes some of what look like downcasts turn into
     // type errors below.
     await checkFile('''
 class A {}
 
-typedef dynamic BotTop(dynamic x);
+typedef dynamic BotTop(Null x);
 typedef dynamic ATop(A x);
-typedef A BotA(dynamic x);
+typedef A BotA(Null x);
 typedef A AA(A x);
 typedef A TopA(Object x);
 typedef dynamic TopTop(Object x);
 
 dynamic aTop(A x) => x;
 A aa(A x) => x;
 dynamic topTop(dynamic x) => x;
 A topA(dynamic x) => /*info:DYNAMIC_CAST*/x;
 void apply<T>(T f0, T f1, T f2,
                   T f3, T f4, T f5) {}
@@ skipping 1945 matching lines @@
   }
 
   test_leastUpperBounds_fuzzyArrows() async {
     await checkFile(r'''
 typedef String TakesA<T>(T item);
 
 void main() {
   TakesA<int> f;
   TakesA<dynamic> g;
   TakesA<String> h;
-  g = h;
+  g = /*info:USES_DYNAMIC_AS_BOTTOM*/h;
   f = /*info:DOWN_CAST_COMPOSITE*/f ?? g;
 }
 ''');
   }
 
   test_loadLibrary() async {
     addFile('''library lib1;''', name: '/lib1.dart');
     await checkFile(r'''
 import 'lib1.dart' deferred as lib1;
 import 'dart:async' show Future;
@@ skipping 1353 matching lines @@
 class CheckerTest_Driver extends CheckerTest {
   @override
   bool get enableNewAnalysisDriver => true;
 
   @failingTest
   @override
   test_covariantOverride_fields() async {
     await super.test_covariantOverride_fields();
   }
 }