remove "infer from overrides" option which is now obsolete

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 541 matching lines @@
         var d1 = new D();
         print(d1.c.b.a.x);
 
         D d2 = new D();
         print(d2.c.b.a.x);
       }
     '''
   });
 
   group('infer type on overridden fields', () {
-    testChecker(
-        '2',
-        {
-          '/main.dart': '''
+    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(
-        '4',
-        {
-          '/main.dart': '''
+    testChecker('4', {
+      '/main.dart': '''
         class A {
           int x = 2;
         }
 
         class B implements A {
           get x => 3;
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
-        },
-        inferFromOverrides: true);
+    });
   });
 
   group('infer types on generic instantiations', () {
-    for (bool infer in [true, false]) {
-      testChecker(
-          'infer: $infer',
-          {
-            '/main.dart': '''
-          class A<T> {
-            T x;
-          }
+    testChecker('infer', {
+      '/main.dart': '''
+        class A<T> {
+          T x;
+        }
 
-          class B implements A<int> {
-            /*severe:InvalidMethodOverride*/dynamic get x => 3;
-          }
+        class B implements A<int> {
+          /*severe:InvalidMethodOverride*/dynamic get x => 3;
+        }
 
-          foo() {
-            String y = /*info:DynamicCast*/new B().x;
-            int z = /*info:DynamicCast*/new B().x;
-          }
-      '''
-          },
-          inferFromOverrides: infer);
-    }
+        foo() {
+          String y = /*info:DynamicCast*/new B().x;
+          int z = /*info:DynamicCast*/new B().x;
+        }
+    '''
+    });
 
-    testChecker(
-        '3',
-        {
-          '/main.dart': '''
+    testChecker('3', {
+      '/main.dart': '''
         class A<T> {
           T x;
           T w;
         }
 
         class B implements A<int> {
           get x => 3;
           get w => /*severe:StaticTypeError*/"hello";
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
-        },
-        inferFromOverrides: true);
+    });
 
-    testChecker(
-        '4',
-        {
-          '/main.dart': '''
+    testChecker('4', {
+      '/main.dart': '''
         class A<T> {
           T x;
         }
 
         class B<E> extends A<E> {
           E y;
           get x => y;
         }
 
         foo() {
           int y = /*severe:StaticTypeError*/new B<String>().x;
           String z = new B<String>().x;
         }
     '''
-        },
-        inferFromOverrides: true);
+    });
 
-    testChecker(
-        '5',
-        {
-          '/main.dart': '''
+    testChecker('5', {
+      '/main.dart': '''
         abstract class I<E> {
           String m(a, String f(v, T e));
         }
 
         abstract class A<E> implements I<E> {
           const A();
           String m(a, String f(v, T e));
         }
 
         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)) {}
         }
 
         foo () {
           int y = /*severe:StaticTypeError*/new B().m(null, null);
           String z = new B().m(null, null);
         }
     '''
-        },
-        inferFromOverrides: true);
+    });
   });
 
-  testChecker(
-      'infer type regardless of declaration order or cycles',
-      {
-        '/b.dart': '''
+  testChecker('infer type regardless of declaration order or cycles', {
+    '/b.dart': '''
         import 'main.dart';
 
         class B extends A { }
       ''',
-        '/main.dart': '''
+    '/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.
-  testChecker(
-      'infer types on generic instantiations in library cycle',
-      {
-        '/a.dart': '''
+  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, int e));
         }
       ''',
-        '/main.dart': '''
+    '/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, 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);
+  });
 
   group('do not infer overridden fields that explicitly say dynamic', () {
-    for (bool infer in [true, false]) {
-      testChecker(
-          'infer: $infer',
-          {
-            '/main.dart': '''
+    testChecker('infer', {
+      '/main.dart': '''
           class A {
             int x = 2;
           }
 
           class B implements A {
             /*severe:InvalidMethodOverride*/dynamic get x => 3;
           }
 
           foo() {
             String y = /*info:DynamicCast*/new B().x;
             int z = /*info:DynamicCast*/new B().x;
           }
       '''
-          },
-          inferFromOverrides: infer);
-    }
+    });
   });
 
-  testChecker(
-      'conflicts can happen',
-      {
-        '/main.dart': '''
+  testChecker('conflicts can happen', {
+    '/main.dart': '''
         class I1 {
           int x;
         }
         class I2 extends I1 {
           int y;
         }
 
         class A {
           final I1 a;
         }
 
         class B {
           final I2 a;
         }
 
         class C1 extends A implements B {
           /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/get a => null;
         }
 
         // Still ambiguous
         class C2 extends B implements A {
           /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/get a => null;
         }
     '''
-      },
-      inferFromOverrides: true);
+  });
 
-  testChecker(
-      'conflicts can happen 2',
-      {
-        '/main.dart': '''
+  testChecker('conflicts can happen 2', {
+    '/main.dart': '''
         class I1 {
           int x;
         }
         class I2 {
           int y;
         }
 
         class I3 implements I1, I2 {
           int x;
           int y;
         }
 
         class A {
           final I1 a;
         }
 
         class B {
           final I2 a;
         }
 
         class C1 extends A implements B {
           I3 get a => null;
         }
 
         class C2 extends A implements B {
           /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/get a => null;
         }
     '''
-      },
-      inferFromOverrides: true);
+  });
 
   testChecker(
-      'infer from RHS only if it wont conflict with overridden fields',
-      {
-        '/main.dart': '''
+      'infer from RHS only if it wont conflict with overridden fields', {
+    '/main.dart': '''
         class A {
           var x;
         }
 
         class B extends A {
           var x = 2;
         }
 
         foo() {
           String y = /*info:DynamicCast*/new B().x;
           int z = /*info:DynamicCast*/new B().x;
         }
     '''
-      },
-      inferFromOverrides: true);
+  });
 
   testChecker(
-      'infer from RHS only if it wont conflict with overridden fields 2',
-      {
-        '/main.dart': '''
+      'infer from RHS only if it wont conflict with overridden fields 2', {
+    '/main.dart': '''
         class A {
           final x;
         }
 
         class B extends A {
           final x = 2;
         }
 
         foo() {
           String y = /*severe:StaticTypeError*/new B().x;
           int z = new B().x;
         }
     '''
-      },
-      inferFromOverrides: true);
+  });
 
-  testChecker(
-      'infer correctly on multiple variables declared together',
-      {
-        '/main.dart': '''
+  testChecker('infer correctly on multiple variables declared together', {
+    '/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:DynamicCast*/new B().x;
           s = /*severe:StaticTypeError*/new B().y;
           s = new B().z;
           s = /*severe:StaticTypeError*/new B().w;
 
           i = /*info:DynamicCast*/new B().x;
           i = new B().y;
           i = /*severe:StaticTypeError*/new B().z;
           i = new B().w;
         }
     '''
-      },
-      inferFromOverrides: true);
+  });
 
   testChecker(
       'infer consts transitively',
       {
         '/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);
 
   testChecker(
       'infer statics transitively',
       {
         '/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(
       'infer statics transitively 2',
       {
         '/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(
       'infer statics transitively 3',
       {
         '/a.dart': '''
         const a1 = 3;
         const a2 = 4;
         class A {
           a3;
@@ skipping 11 matching lines @@
 
         foo() {
           int i;
           i = t1;
           i = t2;
           i = t3;
           i = t4;
         }
     '''
       },
-      inferFromOverrides: true,
       inferTransitively: true);
 
   testChecker(
       'infer statics with method invocations',
       {
         '/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);
 
   testChecker(
       'downwards inference: miscellaneous',
       {
         '/main.dart': '''
       typedef (T x);
       class A<T> {
         Function2<T> x;
         A(this.x);
@@ skipping 354 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()));
         }
     '''
     });
   });
 }