Turn on infer-from-overrides by default, rename inferStaticFromOtherStatics to

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 218 matching lines @@
       ''',
       '/main.dart': '''
           import 'a.dart';
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = /*severe:StaticTypeError*/"hi";
           }
     '''
-    }, inferStaticsFromIdentifiers: true);
+    }, inferTransitively: true);
 
     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 = /*severe:StaticTypeError*/"hi";
           }
     '''
-    }, inferStaticsFromIdentifiers: true);
+    }, inferTransitively: true);
   });
 
   test('do not infer from variables in cycle libs', () {
     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;
           }
     '''
-    }, inferStaticsFromIdentifiers: true);
+    }, 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;
           }
     '''
-    }, inferStaticsFromIdentifiers: true);
+    }, inferTransitively: true);
   });
 
   test('do not infer from static and instance fields', () {
     testChecker({
       '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
@@ skipping 35 matching lines @@
       '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
-    }, inferStaticsFromIdentifiers: true);
+    }, 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;
           }
     '''
-    }, inferStaticsFromIdentifiers: true);
+    }, 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;
           }
@@ skipping 66 matching lines @@
             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);
+    }, inferTransitively: 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
@@ skipping 88 matching lines @@
           int i = 0;
           A a;
           B b;
           a = t1;
           i = t2;
           b = t3;
           i = /*info:DownCast*/t4;
           i = new B().y; // B.y was inferred though
         }
     '''
-    }, inferStaticsFromIdentifiers: true);
+    }, inferTransitively: true);
   });
 
   test('infer types on loop indices', () {
     // foreach loop
     testChecker({
       '/main.dart': '''
       class Foo {
         int bar = 42;
       }
 
@@ skipping 473 matching lines @@
 
           i = /*info:DownCast*/new B().x;
           i = new B().y;
           i = /*severe:StaticTypeError*/new B().z;
           i = new B().w;
         }
     '''
     }, inferFromOverrides: true);
   });
 }