Handle type-inference on fields, consts, and inferable overrides

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:unittest/unittest.dart';
 
 import 'package:dev_compiler/src/testing.dart';
@@ skipping 119 matching lines @@
         c = /*severe:StaticTypeError*/"hi";
         c = 4;
       }
 
       int y = 0; // field def after use
       final z = 42; // should infer `int`
     '''
     });
   });
 
+  test('do not infer field type when initializer is null', () {
+    testChecker({
+      '/main.dart': '''
+      var x = null;
+      var y = 3;
+      class A {
+        static var x = null;
+        static var y = 3;
+
+        var x2 = null;
+        var y2 = 3;
+      }
+
+      test() {
+        x = "hi";
+        y = /*severe:StaticTypeError*/"hi";
+        A.x = "hi";
+        A.y = /*severe:StaticTypeError*/"hi";
+        new A().x2 = "hi";
+        new A().y2 = /*severe:StaticTypeError*/"hi";
+      }
+    '''
+    });
+  });
+
   test('do not infer from variables in same lib (order independence)', () {
     testChecker({
       '/main.dart': '''
           var x = 2;
-          var y = x;
-
-          test1() {
-            x = /*severe:StaticTypeError*/"hi";
-            y = "hi";
-          }
-    '''
-    });
-
-    testChecker({
-      '/main.dart': '''
-          class A {
-            static var x = 2;
-            static var y = A.x;
-          }
-
-          test1() {
-            A.x = /*severe:StaticTypeError*/"hi";
-            A.y = "hi";
-          }
-    '''
-    });
-
-    // Allowed with special flag. Note, while the flag is generally not stable,
-    // we can use it in this test because it is stable within a library (order
-    // matches program order).
-    testChecker({
-      '/main.dart': '''
-          var x = 2;
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
-            y = /*severe:StaticTypeError*/"hi";
+            y = "hi";
           }
     '''
-    }, inferInNonStableOrder: true);
+    });
 
     testChecker({
       '/main.dart': '''
           class A {
             static var x = 2;
             static var y = A.x;
           }
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
-            A.y = /*severe:StaticTypeError*/"hi";
+            A.y = "hi";
           }
     '''
-    }, inferInNonStableOrder: true);
+    });
   });
 
   test('not ok to infer from variables in non-cycle libs', () {
     testChecker({
       '/a.dart': '''
           var x = 2;
       ''',
       '/main.dart': '''
           import 'a.dart';
           var y = x;
@@ skipping 50 matching lines @@
             B.y = /*severe:StaticTypeError*/"hi";
           }
     '''
     }, inferStaticsFromIdentifiers: true);
   });
 
   test('do not infer from variables in cycle libs', () {
     testChecker({
       '/a.dart': '''
           import 'main.dart';
-          var x = 2;
+          var x = 2; // ok to infer
       ''',
       '/main.dart': '''
           import 'a.dart';
-          var y = x;
+          var y = x; // not ok to infer yet
 
           test1() {
             int t = 3;
-            t = /*info:DownCast*/x;
+            t = x;
             t = /*info:DownCast*/y;
           }
     '''
     }, inferStaticsFromIdentifiers: true);
 
     testChecker({
       '/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 = /*info:DownCast*/A.x;
+            t = A.x;
             t = /*info:DownCast*/A.y;
           }
     '''
     }, inferStaticsFromIdentifiers: true);
   });
 
   test('do not infer from static and instance fields', () {
     testChecker({
       '/a.dart': '''
           import 'b.dart';
@@ skipping 42 matching lines @@
           test1() {
             int x = 0;
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
     }, inferStaticsFromIdentifiers: true);
   });
 
-  test('don\'t infer on cycles', () {
+  test('inference uses declared types', () {
+    testChecker({
+      '/main.dart': '''
+          int w = 0;
+          var x = 0;
+
+          var y = w; // y can be inferred because w is typed int.
+          var z = x; // z cannot, because x would be inferred.
+
+          test1() {
+            int a;
+            a = w;
+            a = x;
+            a = y;
+            a = /*info:DownCast*/z;
+          }
+    '''
+    }, inferStaticsFromIdentifiers: true);
+  });
+
+  test('inference in cycles is deterministic', () {
     testChecker({
       '/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;
           }
       ''',
       '/c.dart': '''
           import "main.dart"; // creates a cycle
 
           class C {
             static final c1 = 1;
             final c2 = 1;
           }
       ''',
       '/e.dart': '''
-          part "e2.dart";
+          import 'a.dart';
+          part 'e2.dart';
 
           class E {
             static final e1 = 1;
-            final e2 = 1;
+            static final e2 = F.f1;
+            static final e3 = A.a1;
+            final e4 = 1;
+            final e5 = new F().f2;
+            final e6 = new A().a2;
           }
       ''',
       '/f.dart': '''
-          part "f2.dart";
+          part 'f2.dart';
       ''',
       '/e2.dart': '''
           class F {
             static final f1 = 1;
             final f2 = 1;
           }
       ''',
       '/main.dart': '''
           import "a.dart";
           import "c.dart";
           import "e.dart";
 
           class D {
             static final d1 = A.a1 + 1;
             static final d2 = C.c1 + 1;
             final d3 = new A().a2;
             final d4 = new C().c2;
           }
 
           test1() {
             int x = 0;
             // inference in A works, it's not in a cycle
             x = A.a1;
             x = new A().a2;
 
-            // inference here or in c.dart is disabled because of the cycle
-            x = /*info:DownCast*/C.c1;
-            x = /*info:DownCast*/D.d1;
+            // Within a cycle we allow inference when the RHS is well known, but
+            // not when it depends on other fields within the cycle
+            x = C.c1;
+            x = D.d1;
             x = /*info:DownCast*/D.d2;
-            x = /*info:DownCast*/new C().c2;
-            x = /*info:DownCast*/new D().d3;
+            x = new C().c2;
+            x = new D().d3;
             x = /*info:DownCast*/new D().d4;
 
 
-            // inference in e.dart and f.dart is disabled because they contains
-            // parts
-            x = /*info:DownCast*/E.e1;
-            x = /*info:DownCast*/new E().e2;
-            x = /*info:DownCast*/F.f1;
-            x = /*info:DownCast*/new F().f2;
+            // Similarly if the library contains parts.
+            x = E.e1;
+            x = /*info:DownCast*/E.e2;
+            x = E.e3;
+            x = new E().e4;
+            x = /*info:DownCast*/new E().e5;
+            x = new E().e6;
+            x = F.f1;
+            x = new F().f2;
           }
     '''
     }, inferStaticsFromIdentifiers: true);
   });
 
   test('infer from complex expressions if the outer-most value is precise', () {
     testChecker({
       '/main.dart': '''
         class A { int x; B operator+(other) {} }
         class B extends A { B(ignore); }
         var a = new A();
         // Note: it doesn't matter that some of these refer to 'x'.
         var b = new B(x);       // allocations
         var c1 = [x];           // list literals
         var c2 = const [];
         var d = {'a': 'b'};     // map literals
         var e = new A()..x = 3; // cascades
         var f = 2 + 3;          // binary expressions are OK if the left operand
                                 // is from a library in a different strongest
                                 // conected component.
         var g = -3;
         var h = new A() + 3;
         var i = - new A();
+        var j = null as B;
 
         test1() {
           a = /*severe:StaticTypeError*/"hi";
           a = new B(3);
           b = /*severe:StaticTypeError*/"hi";
           b = new B(3);
           c1 = [];
           c1 = /*severe:StaticTypeError*/{};
           c2 = [];
           c2 = /*severe:StaticTypeError*/{};
           d = {};
           d = /*severe:StaticTypeError*/3;
           e = new A();
           e = /*severe:StaticTypeError*/{};
           f = 3;
           f = /*severe:StaticTypeError*/false;
           g = 1;
           g = /*severe:StaticTypeError*/false;
           h = /*severe:StaticTypeError*/false;
           h = new B();
           i = false;
+          j = new B();
+          j = /*severe:StaticTypeError*/false;
+          j = /*severe:StaticTypeError*/[];
         }
     '''
     });
   });
 
   test('do not infer if complex expressions read possibly inferred field', () {
     testChecker({
       '/a.dart': '''
         class A {
           var x = 3;
@@ skipping 327 matching lines @@
         }
 
         foo () {
           int y = /*severe:StaticTypeError*/new B().m(null, null);
           String z = new B().m(null, null);
         }
     '''
     }, inferFromOverrides: true);
   });
 
-  // TODO(sigmund): enable this test, it's currently flaky (see issue #48).
-  skip_test('infer types on generic instantiations in library cycle', () {
+  test('infer type regardless of declaration order or cycles', () {
+    testChecker({
+      '/b.dart': '''
+        import 'main.dart';
+
+        class B extends A { }
+      ''',
+      '/main.dart': '''
+        import 'b.dart';
+        class C extends B {
+          get x;
+        }
+        class A {
+          int get x;
+        }
+        foo () {
+          int y = new C().x;
+          String y = /*severe:StaticTypeError*/new C().x;
+        }
+    '''
+    }, inferFromOverrides: true);
+  });
+
+  // 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.
+  test('infer types on generic instantiations in library cycle', () {
     testChecker({
       '/a.dart': '''
           import 'main.dart';
         abstract class I<E> {
           A<E> m(a, String f(v, T e));
         }
       ''',
       '/main.dart': '''
           import 'a.dart';
 
@@ skipping 97 matching lines @@
         class C1 extends A implements B {
           I3 get a => null;
         }
 
         class C2 extends A implements B {
           /*severe:InvalidMethodOverride*/get a => null;
         }
     '''
     }, inferFromOverrides: true);
   });
+
+  test('infer from RHS only if there are no overridden fields', () {
+    testChecker({
+      '/main.dart': '''
+        class A {
+          var x;
+        }
+
+        class B extends A {
+          var x = 2;
+        }
+
+        foo() {
+          String y = /*info:DownCast*/new B().x;
+          int z = /*info:DownCast*/new B().x;
+        }
+    '''
+    }, inferFromOverrides: true);
+  });
+
+  test('infer correctly on multiple variables declared together', () {
+    testChecker({
+      '/main.dart': '''
+        class A {
+          var x, y = 2, z = "hi";
+        }
+
+        class B extends A {
+          var x = 2, y = 3, z, w = 2;
+        }
+
+        foo() {
+          String s;
+          int i;
+
+          s = /*info:DownCast*/new B().x;
+          s = /*severe:StaticTypeError*/new B().y;
+          s = new B().z;
+          s = /*severe:StaticTypeError*/new B().w;
+
+          i = /*info:DownCast*/new B().x;
+          i = new B().y;
+          i = /*severe:StaticTypeError*/new B().z;
+          i = new B().w;
+        }
+    '''
+    }, inferFromOverrides: true);
+  });
 }