Transitive inference using SCC

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 144 matching lines @@
         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)', () {
+  test('do not infer from variables if flag is off', () {
     testChecker({
       '/main.dart': '''
           var x = 2;
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = "hi";
           }
     '''
-    });
+    }, inferTransitively: false);
 
     testChecker({
       '/main.dart': '''
           class A {
             static var x = 2;
             static var y = A.x;
           }
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
             A.y = "hi";
           }
     '''
-    });
+    }, inferTransitively: false);
   });
 
-  test('not ok to infer from variables in non-cycle libs', () {
+  test('do not infer from variables in non-cycle imports if flag is off', () {
     testChecker({
       '/a.dart': '''
           var x = 2;
       ''',
       '/main.dart': '''
           import 'a.dart';
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = "hi";
           }
     '''
-    });
+    }, inferTransitively: false);
 
     testChecker({
       '/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);
   });
 
-  test('ok to infer from variables in non-cycle libs with flag', () {
+  test('infer from variables in non-cycle imports with flag', () {
     testChecker({
       '/a.dart': '''
           var x = 2;
       ''',
       '/main.dart': '''
           import 'a.dart';
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
@@ skipping 11 matching lines @@
           class B { static var y = A.x; }
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
             B.y = /*severe:StaticTypeError*/"hi";
           }
     '''
     }, inferTransitively: true);
   });
 
-  test('do not infer from variables in cycle libs', () {
+  test('do not infer from variables in cycle libs when flag is off', () {
     testChecker({
       '/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:DownCast*/y;
           }
     '''
+    }, inferTransitively: false);
+
+    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 = A.x;
+            t = /*info:DownCast*/B.y;
+          }
+    '''
+    }, inferTransitively: false);
+  });
+
+  test('infer from variables in cycle libs when flag is on', () {
+    testChecker({
+      '/a.dart': '''
+          import 'main.dart';
+          var x = 2; // ok to infer
+      ''',
+      '/main.dart': '''
+          import 'a.dart';
+          var y = x; // now ok :)
+
+          test1() {
+            int t = 3;
+            t = x;
+            t = y;
+          }
+    '''
     }, inferTransitively: 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 = A.x;
-            t = /*info:DownCast*/A.y;
+            t = B.y;
           }
     '''
     }, inferTransitively: true);
   });
 
-  test('do not infer from static and instance fields', () {
+  test('do not infer from static and instance fields when flag is off', () {
     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;
           }
       ''',
       '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             // inference in A disabled (flag is off)
             x = /*info:DownCast*/A.a1;
             x = /*info:DownCast*/new A().a2;
           }
     '''
-    });
+    }, inferTransitively: false);
   });
 
   test('can infer also from static and instance fields (flag on)', () {
     testChecker({
       '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
@@ skipping 10 matching lines @@
           test1() {
             int x = 0;
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
     }, inferTransitively: true);
   });
 
-  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;
-          }
-    '''
-    }, inferTransitively: 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': '''
@@ skipping 47 matching lines @@
           test1() {
             int x = 0;
             // inference in A works, it's not in a cycle
             x = A.a1;
             x = new A().a2;
 
             // 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 = D.d2;
             x = new C().c2;
             x = new D().d3;
             x = /*info:DownCast*/new D().d4;
 
 
             // Similarly if the library contains parts.
             x = E.e1;
-            x = /*info:DownCast*/E.e2;
+            x = 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;
           }
     '''
     }, inferTransitively: true);
   });
@@ skipping 67 matching lines @@
           int i = 0;
           A a;
           B b;
           a = t1;
           i = /*info:DownCast*/t2;
           b = t3;
           i = /*info:DownCast*/t4;
           i = new B().y; // B.y was inferred though
         }
     '''
-    });
+    }, inferTransitively: false);
 
     // but flags can enable this behavior.
     testChecker({
       '/a.dart': '''
         class A {
           var x = 3;
         }
       ''',
       '/main.dart': '''
         import 'a.dart';
@@ skipping 502 matching lines @@
           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);
   });
+
+  test('infer consts transitively', () {
+    testChecker({
+      '/b.dart': '''
+        const b1 = 2;
+      ''',
+      '/a.dart': '''
+        import 'main.dart';
+        import 'b.dart';
+        const a1 = m2;
+        const a2 = b1;
+      ''',
+      '/main.dart': '''
+        import 'a.dart';
+        const m1 = a1;
+        const m2 = a2;
+
+        foo() {
+          int i;
+          i = m1;
+        }
+    '''
+    }, inferFromOverrides: true, inferTransitively: true);
+  });
+
+  test('infer statics transitively', () {
+    testChecker({
+      '/b.dart': '''
+        final b1 = 2;
+      ''',
+      '/a.dart': '''
+        import 'main.dart';
+        import 'b.dart';
+        final a1 = m2;
+        class A {
+          static final a2 = b1;
+        }
+      ''',
+      '/main.dart': '''
+        import 'a.dart';
+        final m1 = a1;
+        final m2 = A.a2;
+
+        foo() {
+          int i;
+          i = m1;
+        }
+    '''
+    }, inferFromOverrides: true, inferTransitively: true);
+
+    testChecker({
+      '/main.dart': '''
+        const x1 = 1;
+        final x2 = 1;
+        final y1 = x1;
+        final y2 = x2;
+
+        foo() {
+          int i;
+          i = y1;
+          i = y2;
+        }
+    '''
+    }, inferFromOverrides: true, inferTransitively: true);
+
+    testChecker({
+      '/a.dart': '''
+        const a1 = 3;
+        const a2 = 4;
+        class A {
+          a3;
+        }
+      ''',
+      '/main.dart': '''
+        import 'a.dart' show a1, A;
+        import 'a.dart' as p show a2, A;
+        const t1 = 1;
+        const t2 = t1;
+        const t3 = a1;
+        const t4 = p.a2;
+        const t5 = A.a3;
+        const t6 = p.A.a3;
+
+        foo() {
+          int i;
+          i = t1;
+          i = t2;
+          i = t3;
+          i = t4;
+        }
+    '''
+    }, inferFromOverrides: true, inferTransitively: true);
+  });
+
+  test('infer statics with method invocations', () {
+    testChecker({
+      '/a.dart': '''
+        m3(String a, String b, [a1,a2]) {}
+      ''',
+      '/main.dart': '''
+        import 'a.dart';
+        class T {
+          static final T foo = m1(m2(m3('', '')));
+          static T m1(String m) { return null; }
+          static String m2(e) { return ''; }
+        }
+
+
+    '''
+    }, inferFromOverrides: true, inferTransitively: true);
+  });
 }