Rewire DDC to use the analyzer task model

test/checker/inferred_type_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.
 
 /// Tests for type inference.
 library dev_compiler.test.inferred_type_test;
 
 import 'package:test/test.dart';
 
 import '../testing.dart';
@@ skipping 132 matching lines @@
         y = /*severe:StaticTypeError*/"hi";
         A.x = "hi";
         A.y = /*severe:StaticTypeError*/"hi";
         new A().x2 = "hi";
         new A().y2 = /*severe:StaticTypeError*/"hi";
       }
     '''
   });
 
   testChecker(
-      'do not infer from variables if flag is off',
-      {
-        '/main.dart': '''
-          var x = 2;
-          var y = x;
-
-          test1() {
-            x = /*severe:StaticTypeError*/"hi";
-            y = "hi";
-          }
-    '''
-      },
-      inferTransitively: false);
-
-  testChecker(
-      'do not infer from variables if flag is off 2',
-      {
-        '/main.dart': '''
-          class A {
-            static var x = 2;
-            static var y = A.x;
-          }
-
-          test1() {
-            A.x = /*severe:StaticTypeError*/"hi";
-            A.y = "hi";
-          }
-    '''
-      },
-      inferTransitively: false);
-
-  testChecker(
-      'do not infer from variables in non-cycle imports if flag is off',
-      {
-        '/a.dart': '''
-          var x = 2;
-      ''',
-        '/main.dart': '''
-          import 'a.dart';
-          var y = x;
-
-          test1() {
-            x = /*severe:StaticTypeError*/"hi";
-            y = "hi";
-          }
-    '''
-      },
-      inferTransitively: false);
-
-  testChecker(
-      'do not infer from variables in non-cycle imports if flag is off 2',
-      {
-        '/a.dart': '''
-          class A { static var x = 2; }
-      ''',
-        '/main.dart': '''
-          import 'a.dart';
-          class B { static var y = A.x; }
-
-          test1() {
-            A.x = /*severe:StaticTypeError*/"hi";
-            B.y = "hi";
-          }
-    '''
-      },
-      inferTransitively: false);
-
-  testChecker(
       'infer from variables in non-cycle imports with flag',
       {
         '/a.dart': '''
           var x = 2;
       ''',
         '/main.dart': '''
           import 'a.dart';
           var y = x;
 
           test1() {
@@ skipping 16 matching lines @@
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
             B.y = /*severe:StaticTypeError*/"hi";
           }
     '''
       },
       inferTransitively: true);
 
   testChecker(
-      'do not infer from variables in cycle libs when flag is off',
-      {
-        '/a.dart': '''
-          import 'main.dart';
-          var x = 2; // ok to infer
-      ''',
-        '/main.dart': '''
-          import 'a.dart';
-          var y = x; // not ok to infer yet
-
-          test1() {
-            int t = 3;
-            t = x;
-            t = /*info:DynamicCast*/y;
-          }
-    '''
-      },
-      inferTransitively: false);
-
-  testChecker(
-      'do not infer from variables in cycle libs when flag is off 2',
-      {
-        '/a.dart': '''
-          import 'main.dart';
-          class A { static var x = 2; }
-      ''',
-        '/main.dart': '''
-          import 'a.dart';
-          class B { static var y = A.x; }
-
-          test1() {
-            int t = 3;
-            t = A.x;
-            t = /*info:DynamicCast*/B.y;
-          }
-    '''
-      },
-      inferTransitively: false);
-
-  testChecker(
       'infer from variables in cycle libs when flag is on',
       {
         '/a.dart': '''
           import 'main.dart';
           var x = 2; // ok to infer
       ''',
         '/main.dart': '''
           import 'a.dart';
           var y = x; // now ok :)
 
@@ skipping 20 matching lines @@
           test1() {
             int t = 3;
             t = A.x;
             t = B.y;
           }
     '''
       },
       inferTransitively: true);
 
   testChecker(
-      'do not infer from static and instance fields when flag is off',
-      {
-        '/a.dart': '''
-          import 'b.dart';
-          class A {
-            static final a1 = B.b1;
-            final a2 = new B().b2;
-          }
-      ''',
-        '/b.dart': '''
-          class B {
-            static final b1 = 1;
-            final b2 = 1;
-          }
-      ''',
-        '/main.dart': '''
-          import "a.dart";
-
-          test1() {
-            int x = 0;
-            // inference in A disabled (flag is off)
-            x = /*info:DynamicCast*/A.a1;
-            x = /*info:DynamicCast*/new A().a2;
-          }
-    '''
-      },
-      inferTransitively: false);
-
-  testChecker(
       'can infer also from static and instance fields (flag on)',
       {
         '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
       ''',
         '/b.dart': '''
@@ skipping 143 matching lines @@
           h = /*severe:StaticTypeError*/false;
           h = new B();
           i = false;
           j = new B();
           j = /*severe:StaticTypeError*/false;
           j = /*severe:StaticTypeError*/[];
         }
     '''
   });
 
-  testChecker(
-      'do not infer if complex expressions read possibly inferred field',
-      {
-        '/a.dart': '''
-        class A {
-          var x = 3;
-        }
-      ''',
-        '/main.dart': '''
-        import 'a.dart';
-        class B {
-          var y = 3;
-        }
-        final t1 = new A();
-        final t2 = new A().x;
-        final t3 = new B();
-        final t4 = new B().y;
-
-        test1() {
-          int i = 0;
-          A a;
-          B b;
-          a = t1;
-          i = /*info:DynamicCast*/t2;
-          b = t3;
-          i = /*info:DynamicCast*/t4;
-          i = new B().y; // B.y was inferred though
-        }
-    '''
-      },
-      inferTransitively: false);
-
   // but flags can enable this behavior.
   testChecker(
       'infer if complex expressions read possibly inferred field',
       {
         '/a.dart': '''
         class A {
           var x = 3;
         }
       ''',
         '/main.dart': '''
@@ skipping 151 matching lines @@
         print(d1.c.b.a.x);
 
         D d2 = new D();
         print(d2.c.b.a.x);
       }
     '''
   });
 
   group('infer type on overridden fields', () {
     testChecker(
-        '1',
-        {
-          '/main.dart': '''
-        class A {
-          int x = 2;
-        }
-
-        class B extends A {
-          /*severe:InvalidMethodOverride*/get x => 3;
-        }
-
-        foo() {
-          String y = /*info:DynamicCast*/new B().x;
-          int z = /*info:DynamicCast*/new B().x;
-        }
-    '''
-        },
-        inferFromOverrides: false);
-
-    testChecker(
         '2',
         {
           '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B extends A {
           get x => 3;
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
         },
         inferFromOverrides: true);
 
     testChecker(
-        '3',
-        {
-          '/main.dart': '''
-        class A {
-          int x = 2;
-        }
-
-        class B implements A {
-          /*severe:InvalidMethodOverride*/get x => 3;
-        }
-
-        foo() {
-          String y = /*info:DynamicCast*/new B().x;
-          int z = /*info:DynamicCast*/new B().x;
-        }
-    '''
-        },
-        inferFromOverrides: false);
-
-    testChecker(
         '4',
         {
           '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B implements A {
           get x => 3;
         }
@@ skipping 24 matching lines @@
           foo() {
             String y = /*info:DynamicCast*/new B().x;
             int z = /*info:DynamicCast*/new B().x;
           }
       '''
           },
           inferFromOverrides: infer);
     }
 
     testChecker(
-        '2',
-        {
-          '/main.dart': '''
-        class A<T> {
-          T x;
-        }
-
-        class B implements A<int> {
-          /*severe:InvalidMethodOverride*/get x => 3;
-        }
-
-        foo() {
-          String y = /*info:DynamicCast*/new B().x;
-          int z = /*info:DynamicCast*/new B().x;
-        }
-    '''
-        },
-        inferFromOverrides: false);
-
-    testChecker(
         '3',
         {
           '/main.dart': '''
         class A<T> {
           T x;
           T w;
         }
 
         class B implements A<int> {
           get x => 3;
@@ skipping 88 matching lines @@
 
   // Note: this is a regression test for a non-deterministic behavior we used to
   // have with inference in library cycles. If you see this test flake out,
   // change `test` to `skip_test` and reopen bug #48.
   testChecker(
       'infer types on generic instantiations in library cycle',
       {
         '/a.dart': '''
           import 'main.dart';
         abstract class I<E> {
-          A<E> m(a, String f(v, T e));
+          A<E> m(a, String f(v, int e));
         }
       ''',
         '/main.dart': '''
           import 'a.dart';
 
         abstract class A<E> implements I<E> {
           const A();
 
           E value;
         }
 
         abstract class M {
           int y;
         }
 
         class B<E> extends A<E> implements M {
           const B();
           int get y => 0;
 
-          m(a, f(v, T e)) {}
+          m(a, f(v, int e)) {}
         }
 
         foo () {
           int y = /*severe:StaticTypeError*/new B<String>().m(null, null).value;
           String z = new B<String>().m(null, null).value;
         }
     '''
       },
       inferFromOverrides: true);
 
@@ skipping 34 matching lines @@
 
         class A {
           final I1 a;
         }
 
         class B {
           final I2 a;
         }
 
         class C1 extends A implements B {
-          /*severe:InvalidMethodOverride*/get a => null;
+          /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/get a => null;
         }
 
-        // Here we infer from B, which is more precise.
+        // Still ambiguous
         class C2 extends B implements A {
-          get a => null;
+          /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/get a => null;
         }
     '''
       },
       inferFromOverrides: true);
 
   testChecker(
       'conflicts can happen 2',
       {
         '/main.dart': '''
         class I1 {
@@ skipping 14 matching lines @@
 
         class B {
           final I2 a;
         }
 
         class C1 extends A implements B {
           I3 get a => null;
         }
 
         class C2 extends A implements B {
-          /*severe:InvalidMethodOverride*/get a => null;
+          /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/get a => null;
         }
     '''
       },
       inferFromOverrides: true);
 
   testChecker(
       'infer from RHS only if it wont conflict with overridden fields',
       {
         '/main.dart': '''
         class A {
@@ skipping 552 matching lines @@
         main() {
           Iterable<Future<int>> list = <int>[1, 2, 3].map(make);
           Future<List<int>> results = Future.wait(list);
           Future<String> results2 = results.then((List<int> list) 
             => list.fold('', (String x, int y) => x + y.toString()));
         }
     '''
     });
   });
 }