remove most of the StrongOptions

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 107 matching lines @@
         x = "hi";
         y = /*severe:StaticTypeError*/"hi";
         A.x = "hi";
         A.y = /*severe:StaticTypeError*/"hi";
         new A().x2 = "hi";
         new A().y2 = /*severe:StaticTypeError*/"hi";
       }
     '''
   });
 
-  testChecker(
-      'infer from variables in non-cycle imports with flag',
-      {
-        '/a.dart': '''
+  testChecker('infer from variables in non-cycle imports with flag', {
+    '/a.dart': '''
           var x = 2;
       ''',
-        '/main.dart': '''
+    '/main.dart': '''
           import 'a.dart';
           var y = x;
 
           test1() {
             x = /*severe:StaticTypeError*/"hi";
             y = /*severe:StaticTypeError*/"hi";
           }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'infer from variables in non-cycle imports with flag 2',
-      {
-        '/a.dart': '''
+  testChecker('infer from variables in non-cycle imports with flag 2', {
+    '/a.dart': '''
           class A { static var x = 2; }
       ''',
-        '/main.dart': '''
+    '/main.dart': '''
           import 'a.dart';
           class B { static var y = A.x; }
 
           test1() {
             A.x = /*severe:StaticTypeError*/"hi";
             B.y = /*severe:StaticTypeError*/"hi";
           }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'infer from variables in cycle libs when flag is on',
-      {
-        '/a.dart': '''
+  testChecker('infer from variables in cycle libs when flag is on', {
+    '/a.dart': '''
           import 'main.dart';
           var x = 2; // ok to infer
       ''',
-        '/main.dart': '''
+    '/main.dart': '''
           import 'a.dart';
           var y = x; // now ok :)
 
           test1() {
             int t = 3;
             t = x;
             t = y;
           }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'infer from variables in cycle libs when flag is on 2',
-      {
-        '/a.dart': '''
+  testChecker('infer from variables in cycle libs when flag is on 2', {
+    '/a.dart': '''
           import 'main.dart';
           class A { static var x = 2; }
       ''',
-        '/main.dart': '''
+    '/main.dart': '''
           import 'a.dart';
           class B { static var y = A.x; }
 
           test1() {
             int t = 3;
             t = A.x;
             t = B.y;
           }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'can infer also from static and instance fields (flag on)',
-      {
-        '/a.dart': '''
+  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': '''
+    '/b.dart': '''
           class B {
             static final b1 = 1;
             final b2 = 1;
           }
       ''',
-        '/main.dart': '''
+    '/main.dart': '''
           import "a.dart";
 
           test1() {
             int x = 0;
             // inference in A now works.
             x = A.a1;
             x = new A().a2;
           }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'inference in cycles is deterministic',
-      {
-        '/a.dart': '''
+  testChecker('inference in cycles is deterministic', {
+    '/a.dart': '''
           import 'b.dart';
           class A {
             static final a1 = B.b1;
             final a2 = new B().b2;
           }
       ''',
-        '/b.dart': '''
+    '/b.dart': '''
           class B {
             static final b1 = 1;
             final b2 = 1;
           }
       ''',
-        '/c.dart': '''
+    '/c.dart': '''
           import "main.dart"; // creates a cycle
 
           class C {
             static final c1 = 1;
             final c2 = 1;
           }
       ''',
-        '/e.dart': '''
+    '/e.dart': '''
           import 'a.dart';
           part 'e2.dart';
 
           class E {
             static final e1 = 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': '''
+    '/f.dart': '''
           part 'f2.dart';
       ''',
-        '/e2.dart': '''
+    '/e2.dart': '''
           class F {
             static final f1 = 1;
             final f2 = 1;
           }
       ''',
-        '/main.dart': '''
+    '/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;
           }
@@ skipping 18 matching lines @@
             x = E.e1;
             x = E.e2;
             x = E.e3;
             x = new E().e4;
             x = /*info:DynamicCast*/new E().e5;
             x = new E().e6;
             x = F.f1;
             x = new F().f2;
           }
     '''
-      },
-      inferTransitively: true);
+  });
 
   testChecker(
       'infer from complex expressions if the outer-most value is precise', {
     '/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
@@ skipping 29 matching lines @@
           h = new B();
           i = false;
           j = new B();
           j = /*severe:StaticTypeError*/false;
           j = /*severe:StaticTypeError*/[];
         }
     '''
   });
 
   // but flags can enable this behavior.
-  testChecker(
-      'infer if complex expressions read possibly inferred field',
-      {
-        '/a.dart': '''
+  testChecker('infer if complex expressions read possibly inferred field', {
+    '/a.dart': '''
         class A {
           var x = 3;
         }
       ''',
-        '/main.dart': '''
+    '/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 = t2;
           b = t3;
           i = /*info:DynamicCast*/t4;
           i = new B().y; // B.y was inferred though
         }
     '''
-      },
-      inferTransitively: true);
+  });
 
   group('infer types on loop indices', () {
     testChecker('foreach loop', {
       '/main.dart': '''
       class Foo {
         int bar = 42;
       }
 
       test() {
         var list = <Foo>[];
@@ skipping 438 matching lines @@
           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;
         }
     '''
   });
 
-  testChecker(
-      'infer consts transitively',
-      {
-        '/b.dart': '''
+  testChecker('infer consts transitively', {
+    '/b.dart': '''
         const b1 = 2;
       ''',
-        '/a.dart': '''
+    '/a.dart': '''
         import 'main.dart';
         import 'b.dart';
         const a1 = m2;
         const a2 = b1;
       ''',
-        '/main.dart': '''
+    '/main.dart': '''
         import 'a.dart';
         const m1 = a1;
         const m2 = a2;
 
         foo() {
           int i;
           i = m1;
         }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'infer statics transitively',
-      {
-        '/b.dart': '''
+  testChecker('infer statics transitively', {
+    '/b.dart': '''
         final b1 = 2;
       ''',
-        '/a.dart': '''
+    '/a.dart': '''
         import 'main.dart';
         import 'b.dart';
         final a1 = m2;
         class A {
           static final a2 = b1;
         }
       ''',
-        '/main.dart': '''
+    '/main.dart': '''
         import 'a.dart';
         final m1 = a1;
         final m2 = A.a2;
 
         foo() {
           int i;
           i = m1;
         }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'infer statics transitively 2',
-      {
-        '/main.dart': '''
+  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;
         }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'infer statics transitively 3',
-      {
-        '/a.dart': '''
+  testChecker('infer statics transitively 3', {
+    '/a.dart': '''
         const a1 = 3;
         const a2 = 4;
         class A {
           a3;
         }
       ''',
-        '/main.dart': '''
+    '/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;
         }
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'infer statics with method invocations',
-      {
-        '/a.dart': '''
+  testChecker('infer statics with method invocations', {
+    '/a.dart': '''
         m3(String a, String b, [a1,a2]) {}
       ''',
-        '/main.dart': '''
+    '/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 ''; }
         }
 
 
     '''
-      },
-      inferTransitively: true);
+  });
 
-  testChecker(
-      'downwards inference: miscellaneous',
-      {
-        '/main.dart': '''
+  testChecker('downwards inference: miscellaneous', {
+    '/main.dart': '''
       typedef (T x);
       class A<T> {
         Function2<T> x;
         A(this.x);
       }
       void main() {
           {  // Variables, nested literals
             var x = "hello";
             var y = 3;
             void f(List<Map<int, String>> l) {};
             f(/*info:InferredTypeLiteral*/[{y: x}]);
           }
           {
             int f(int x) {};
             A<int> a = /*info:InferredTypeAllocation*/new A(f);
           }
       }
       '''
-      },
-      inferDownwards: true);
+  });
 
   group('downwards inference on instance creations', () {
-    String mk(String info) => '''
+    String info = 'info:InferredTypeAllocation';
+    String code = '''
       class A<S, T> {
         S x;
         T y;
         A(this.x, this.y);
         A.named(this.x, this.y);
       }
 
       class B<S, T> extends A<T, S> {
         B(S y, T x) : super(x, y);
         B.named(S y, T x) : super.named(x, y);
@@ skipping 73 matching lines @@
         { // Check named and optional arguments
           A<int, String> a0 = /*$info*/new F(3, "hello", a: [3], b: ["hello"]);
           A<int, String> a1 = /*severe:StaticTypeError*/new F(3, "hello", a: ["hello"], b:[3]);
           A<int, String> a2 = /*$info*/new F.named(3, "hello", 3, "hello");
           A<int, String> a3 = /*$info*/new F.named(3, "hello");
           A<int, String> a4 = /*severe:StaticTypeError*/new F.named(3, "hello", "hello", 3);
           A<int, String> a5 = /*severe:StaticTypeError*/new F.named(3, "hello", "hello");
         }
       }
         ''';
-    testChecker(
-        'infer downwards', {'/main.dart': mk("info:InferredTypeAllocation")},
-        inferDownwards: true);
-    testChecker(
-        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
-        inferDownwards: false);
+    testChecker('infer downwards', {'/main.dart': code});
   });
 
   group('downwards inference on list literals', () {
-    String mk(String info) => '''
+    String info = "info:InferredTypeLiteral";
+    String code = '''
       void foo([List<String> list1 = /*$info*/const [],
                 List<String> list2 = /*severe:StaticTypeError*/const [42]]) {
       }
 
       void main() {
         {
           List<int> l0 = /*$info*/[];
           List<int> l1 = /*$info*/[3];
           List<int> l2 = /*severe:StaticTypeError*/["hello"];
           List<int> l3 = /*severe:StaticTypeError*/["hello", 3];
@@ skipping 17 matching lines @@
           Iterable<int> i3 = /*severe:StaticTypeError*/["hello", 3];
         }
         {
           const List<int> c0 = /*$info*/const [];
           const List<int> c1 = /*$info*/const [3];
           const List<int> c2 = /*severe:StaticTypeError*/const ["hello"];
           const List<int> c3 = /*severe:StaticTypeError*/const ["hello", 3];
         }
       }
       ''';
-    testChecker(
-        'infer downwards', {'/main.dart': mk("info:InferredTypeLiteral")},
-        inferDownwards: true);
-    testChecker(
-        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
-        inferDownwards: false);
+    testChecker('infer downwards', {'/main.dart': code});
   });
 
   group('downwards inference on function arguments', () {
-    String mk(String info) => '''
+    String info = "info:InferredTypeLiteral";
+    String code = '''
       void f0(List<int> a) {};
       void f1({List<int> a}) {};
       void f2(Iterable<int> a) {};
       void f3(Iterable<Iterable<int>> a) {};
       void f4({Iterable<Iterable<int>> a}) {};
       void main() {
         f0(/*$info*/[]);
         f0(/*$info*/[3]);
         f0(/*severe:StaticTypeError*/["hello"]);
         f0(/*severe:StaticTypeError*/["hello", 3]);
@@ skipping 12 matching lines @@
         f3(/*$info*/[[3]]);
         f3(/*severe:StaticTypeError*/[["hello"]]);
         f3(/*severe:StaticTypeError*/[["hello"], [3]]);
 
         f4(a: /*$info*/[]);
         f4(a: /*$info*/[[3]]);
         f4(a: /*severe:StaticTypeError*/[["hello"]]);
         f4(a: /*severe:StaticTypeError*/[["hello"], [3]]);
       }
       ''';
-    testChecker(
-        'infer downwards', {'/main.dart': mk("info:InferredTypeLiteral")},
-        inferDownwards: true);
-    testChecker(
-        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
-        inferDownwards: false);
+    testChecker('infer downwards', {'/main.dart': code});
   });
 
   group('downwards inference on map literals', () {
-    String mk(String info) => '''
+    String info = "info:InferredTypeLiteral";
+    String code = '''
       void foo([Map<int, String> m1 = /*$info*/const {1: "hello"},
                 Map<int, String> m1 = /*severe:StaticTypeError*/const {"hello": "world"}]) {
       }
       void main() {
         {
           Map<int, String> l0 = /*$info*/{};
           Map<int, String> l1 = /*$info*/{3: "hello"};
           Map<int, String> l2 = /*severe:StaticTypeError*/{"hello": "hello"};
           Map<int, String> l3 = /*severe:StaticTypeError*/{3: 3};
           Map<int, String> l4 = /*severe:StaticTypeError*/{3:"hello", "hello": 3};
@@ skipping 26 matching lines @@
         }
         {
           const Map<int, String> l0 = /*$info*/const {};
           const Map<int, String> l1 = /*$info*/const {3: "hello"};
           const Map<int, String> l2 = /*severe:StaticTypeError*/const {"hello": "hello"};
           const Map<int, String> l3 = /*severe:StaticTypeError*/const {3: 3};
           const Map<int, String> l4 = /*severe:StaticTypeError*/const {3:"hello", "hello": 3};
         }
       }
       ''';
-    testChecker(
-        'infer downwards', {'/main.dart': mk("info:InferredTypeLiteral")},
-        inferDownwards: true);
-    testChecker(
-        'no infer downwards', {'/main.dart': mk("severe:StaticTypeError")},
-        inferDownwards: false);
+    testChecker('infer downwards', {'/main.dart': code});
   });
 
-  testChecker(
-      'downwards inference on function expressions',
-      {
-        '/main.dart': '''
+  testChecker('downwards inference on function expressions', {
+    '/main.dart': '''
       typedef T Function2<S, T>(S x);
 
       void main () {
         {
           Function2<int, String> l0 = (int x) => null;
           Function2<int, String> l1 = (int x) => "hello";
           Function2<int, String> l2 = /*severe:StaticTypeError*/(String x) => "hello";
           Function2<int, String> l3 = /*severe:StaticTypeError*/(int x) => 3;
           Function2<int, String> l4 = /*warning:UninferredClosure should be severe:StaticTypeError*/(int x) {return 3};
         }
@@ skipping 12 matching lines @@
         }
         {
           Function2<int, int> l0 = /*info:InferredTypeClosure*/(x) => x;
           Function2<int, int> l1 = /*info:InferredTypeClosure*/(x) => /*info:DynamicInvoke should be pass*/x+1;
           Function2<int, String> l2 = /*info:InferredTypeClosure should be severe:StaticTypeError*/(x) => x;
           Function2<int, String> l3 = /*info:InferredTypeClosure should be severe:StaticTypeError*/(x) => /*info:DynamicInvoke should be pass*/x.substring(3);
           Function2<String, String> l4 = /*info:InferredTypeClosure*/(x) => /*info:DynamicInvoke should be pass*/x.substring(3);
         }
       }
       '''
-      },
-      inferDownwards: true);
+  });
 
   testChecker('inferred initializing formal checks default value', {
     '/main.dart': '''
       class Foo {
         var x = 1;
         Foo([this.x = /*severe:StaticTypeError*/"1"]);
       }'''
   });
 
   group('quasi-generics', () {
@@ skipping 41 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()));
         }
     '''
     });
   });
 }