fixes #25793, make strong checker tests sane

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 15 matching lines @@
 
         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.
           SplayTreeMap([int compare(K key1, K key2),
-                        bool isValidKey(potentialKey)]) {
+                        bool isValidKey(potentialKey)])
             : _comparator = (compare == null) ? Comparable.compare : compare,
-              _validKey = (isValidKey != null) ? isValidKey : ((v) => true);
-             _Predicate<Object> v = /*warning:DOWN_CAST_COMPOSITE*/(isValidKey != null)
+              _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);
           print((/*info:DYNAMIC_CAST*/dyn) ? false : true);
         }
       ''');
   });
 
   test('if/for/do/while statements use boolean conversion', () {
     checkFile('''
       main() {
-        dynamic d = 42;
+        dynamic dyn = 42;
         Object obj = 42;
         int i = 42;
         bool b = false;
 
         if (b) {}
         if (/*info:DYNAMIC_CAST*/dyn) {}
         if (/*info:DOWN_CAST_IMPLICIT*/obj) {}
         if (/*severe:STATIC_TYPE_ERROR*/i) {}
 
         while (b) {}
@@ skipping 53 matching lines @@
           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);
+          (/*info:DYNAMIC_INVOKE*/g./*info:UNDEFINED_GETTER*/x);
           A f = new B();
           f.call(32.0);
           (/*info:DYNAMIC_INVOKE*/f.col(42.0));
           (/*info:DYNAMIC_INVOKE*/f.foo(42.0));
-          (/*info:DYNAMIC_INVOKE*/f.x);
+          (/*info:DYNAMIC_INVOKE*/f./*warning:UNDEFINED_GETTER*/x);
         }
       }
     ''');
   });
 
   test('conversion and dynamic invoke', () {
     addFile(
         '''
       dynamic toString = (int x) => x + 42;
       dynamic hashCode = "hello";
@@ skipping 44 matching lines @@
         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"));
 
         dynamic a1 = new B();
-        (/*info:DYNAMIC_INVOKE*/a1.x);
+        (/*info:DYNAMIC_INVOKE*/a1./*info:UNDEFINED_GETTER*/x);
         a1.toString();
         (/*info:DYNAMIC_INVOKE*/a1.toString(42));
         var toStringClosure = a1.toString;
         (/*info:DYNAMIC_INVOKE*/a1.toStringClosure());
         (/*info:DYNAMIC_INVOKE*/a1.toStringClosure(42));
         (/*info:DYNAMIC_INVOKE*/a1.toStringClosure("hello"));
         a1.hashCode;
 
         dynamic toString = () => null;
         (/*info:DYNAMIC_INVOKE*/toString());
@@ skipping 39 matching lines @@
       void main() {
          A a = new A.c2(/*info:DOWN_CAST_IMPLICIT*/z, /*severe:STATIC_TYPE_ERROR*/z);
          var b = new B.c2(/*severe:STATIC_TYPE_ERROR*/"hello", /*info:DOWN_CAST_IMPLICIT*/obj);
       }
    ''');
   });
 
   test('Unbound variable', () {
     checkFile('''
       void main() {
-         dynamic y = /*pass should be severe:STATIC_TYPE_ERROR*/unboundVariable;
+         dynamic y = /*warning:UNDEFINED_IDENTIFIER should be error*/unboundVariable;
       }
    ''');
   });
 
   test('Unbound type name', () {
     checkFile('''
       void main() {
-         /*pass should be severe:STATIC_TYPE_ERROR*/AToB y;
+         /*warning:UNDEFINED_CLASS should be error*/AToB y;
       }
    ''');
   });
 
   // Regression test for https://github.com/dart-lang/sdk/issues/25069
   test('Void subtyping', () {
     checkFile('''
       typedef int Foo();
       void foo() {}
       void main () {
@@ skipping 718 matching lines @@
          r = /*severe:STATIC_TYPE_ERROR*/nn;
          r = /*severe:STATIC_TYPE_ERROR*/nnn;
 
          o = /*warning:DOWN_CAST_COMPOSITE*/r;
          o = o;
          o = /*severe:STATIC_TYPE_ERROR*/n;
          o = /*severe:STATIC_TYPE_ERROR*/rr;
          o = /*severe:STATIC_TYPE_ERROR*/ro;
          o = /*severe:STATIC_TYPE_ERROR*/rn;
          o = oo;
-         o = /*severe:STATIC_TYPE_ERROR*/nn
+         o = /*severe:STATIC_TYPE_ERROR*/nn;
          o = /*severe:STATIC_TYPE_ERROR*/nnn;
 
          n = /*severe:STATIC_TYPE_ERROR*/r;
          n = /*severe:STATIC_TYPE_ERROR*/o;
          n = n;
          n = /*severe:STATIC_TYPE_ERROR*/rr;
          n = /*severe:STATIC_TYPE_ERROR*/ro;
          n = /*severe:STATIC_TYPE_ERROR*/rn;
          n = /*severe:STATIC_TYPE_ERROR*/oo;
          n = nn;
@@ skipping 355 matching lines @@
           class B extends A {
             B() : super(/*severe:STATIC_TYPE_ERROR*/3);
           }
        ''');
   });
 
   test('factory constructor downcast', () {
     checkFile(r'''
         class Animal {
           Animal();
-          factory Animal.cat() => return new Cat();
+          factory Animal.cat() => new Cat();
         }
 
         class Cat extends Animal {}
 
         void main() {
           Cat c = /*info:ASSIGNMENT_CAST*/new Animal.cat();
           c = /*severe:STATIC_TYPE_ERROR*/new Animal();
         }''');
   });
 
@@ skipping 249 matching lines @@
           }
       ''');
   });
 
   test('generic function wrong number of arguments', () {
     checkFile(r'''
           /*=T*/ foo/*<T>*/(/*=T*/ x, /*=T*/ y) => x;
           /*=T*/ bar/*<T>*/({/*=T*/ x, /*=T*/ y}) => x;
 
           main() {
-            // resolving thses shouldn't crash.
-            foo(1, 2, 3);
-            String x = foo('1', '2', '3');
-            foo(1);
-            String x = foo('1');
-            x = /*severe:STATIC_TYPE_ERROR*/foo(1, 2, 3);
-            x = /*severe:STATIC_TYPE_ERROR*/foo(1);
+            String x;
+            // resolving these shouldn't crash.
+            foo/*warning:EXTRA_POSITIONAL_ARGUMENTS*/(1, 2, 3);
+            x = foo/*warning:EXTRA_POSITIONAL_ARGUMENTS*/('1', '2', '3');
+            foo/*warning:NOT_ENOUGH_REQUIRED_ARGUMENTS*/(1);
+            x = foo/*warning:NOT_ENOUGH_REQUIRED_ARGUMENTS*/('1');
+            x = /*severe:STATIC_TYPE_ERROR*/foo/*warning:EXTRA_POSITIONAL_ARGUMENTS*/(1, 2, 3);
+            x = /*severe:STATIC_TYPE_ERROR*/foo/*warning:NOT_ENOUGH_REQUIRED_ARGUMENTS*/(1);
 
             // named arguments
-            bar(y: 1, x: 2, z: 3);
-            String x = bar(z: '1', x: '2', y: '3');
+            bar(y: 1, x: 2, /*warning:UNDEFINED_NAMED_PARAMETER*/z: 3);
+            x = bar(/*warning:UNDEFINED_NAMED_PARAMETER*/z: '1', x: '2', y: '3');
             bar(y: 1);
-            x = bar(x: '1', z: 42);
-            x = /*severe:STATIC_TYPE_ERROR*/bar(y: 1, x: 2, z: 3);
+            x = bar(x: '1', /*warning:UNDEFINED_NAMED_PARAMETER*/z: 42);
+            x = /*severe:STATIC_TYPE_ERROR*/bar(y: 1, x: 2, /*warning:UNDEFINED_NAMED_PARAMETER*/z: 3);
             x = /*severe:STATIC_TYPE_ERROR*/bar(x: 1);
           }
       ''');
   });
 
   test('type promotion from dynamic', () {
     checkFile(r'''
           f() {
             dynamic x;
             if (x is int) {
@@ skipping 18 matching lines @@
         A operator +(int x) {}
         A operator -(int x) {}
         A operator -() {}
       }
 
       foo() => new A();
 
       test() {
         A a = new A();
         var c = foo();
+        dynamic d;
 
         ~a;
         (/*info:DYNAMIC_INVOKE*/~d);
 
         !/*severe:STATIC_TYPE_ERROR*/a;
         !/*info:DYNAMIC_CAST*/d;
 
         -a;
         (/*info:DYNAMIC_INVOKE*/-d);
 
@@ skipping 161 matching lines @@
             a ^= b;
             a |= b;
             (/*info:DYNAMIC_INVOKE*/c += b);
 
             var d = new D();
             a[b] += d;
             a[/*info:DYNAMIC_CAST*/c] += d;
             a[/*severe:STATIC_TYPE_ERROR*/z] += d;
             a[b] += /*info:DYNAMIC_CAST*/c;
             a[b] += /*severe:STATIC_TYPE_ERROR*/z;
-            (/*info:DYNAMIC_INVOKE*/(/*info:DYNAMIC_INVOKE*/c[b]) += d);
+            /*info:DYNAMIC_INVOKE,info:DYNAMIC_INVOKE*/c[b] += d;
           }
        ''');
   });
 
   test('super call placement', () {
     checkFile('''
           class Base {
             var x;
             Base() : x = print('Base.1') { print('Base.2'); }
           }
@@ skipping 38 matching lines @@
               int j = i + 1;
             }
           }
         ''');
   });
 
   test('loadLibrary', () {
     addFile('''library lib1;''', name: '/lib1.dart');
     checkFile(r'''
         import 'lib1.dart' deferred as lib1;
+        import 'dart:async' show Future;
         main() {
           Future f = lib1.loadLibrary();
         }''');
   });
 
   group('invalid overrides', () {
     test('child override', () {
       checkFile('''
             class A {}
             class B {}
 
             class Base {
                 A f;
             }
 
             class T1 extends Base {
-              /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/B get f => null;
+              /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_FIELD_OVERRIDE*/B get f => null;
             }
 
             class T2 extends Base {
-              /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/set f(B b) => null;
+              /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_FIELD_OVERRIDE*/set f(B b) => null;
             }
 
             class T3 extends Base {
               /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/final B f;
             }
             class T4 extends Base {
               // two: one for the getter one for the setter.
               /*severe:INVALID_FIELD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/B f;
             }
 
@@ skipping 812 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()); }
     ''');
     });
   });
 }