Reformat untouched files.

tests/compiler/dart2js/type_checker_test.dart

 // Copyright (c) 2011, 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.
 
 import 'dart:async';
 
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
 
 import 'package:compiler/src/elements/resolution_types.dart';
@@ skipping 161 matching lines @@
   static String staticString;
   static int staticInt;
 }
 """;
   compiler.parseScript(script);
   LibraryElement mainApp = compiler.mainApp;
   ClassElement foo = mainApp.find("Class");
   foo.ensureResolved(compiler.resolution);
   FunctionElement method = foo.lookupLocalMember('forIn');
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (var e in <String>[]) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (String e in <String>[]) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       for (int e in <String>[]) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (int e in []) {} 
   }""");
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (var e in new HasUntypedIterator()) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (String e in new HasUntypedIterator()) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (int e in new HasUntypedIterator()) {} 
   }""");
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (var e in new HasIntIterator()) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       for (String e in new HasIntIterator()) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (int e in new HasIntIterator()) {} 
   }""");
 
   analyzeIn(
       compiler,
       method,
       """{ 
       for (var e in new HasNoIterator()) {} 
   }""",
       warnings: MessageKind.UNDEFINED_GETTER);
   analyzeIn(
       compiler,
       method,
       """{ 
       for (String e in new HasNoIterator()) {} 
   }""",
       warnings: MessageKind.UNDEFINED_GETTER);
   analyzeIn(
       compiler,
       method,
       """{ 
       for (int e in new HasNoIterator()) {} 
   }""",
       warnings: MessageKind.UNDEFINED_GETTER);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (var e in new HasCustomIntIterator()) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       for (String e in new HasCustomIntIterator()) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (int e in new HasCustomIntIterator()) {} 
   }""");
 
   analyzeIn(
       compiler,
       method,
       """{ 
       for (var e in new HasCustomNoCurrentIterator()) {} 
   }""",
       hints: MessageKind.UNDEFINED_GETTER);
   analyzeIn(
       compiler,
       method,
       """{ 
       for (String e in new HasCustomNoCurrentIterator()) {} 
   }""",
       hints: MessageKind.UNDEFINED_GETTER);
   analyzeIn(
       compiler,
       method,
       """{ 
       for (int e in new HasCustomNoCurrentIterator()) {} 
   }""",
       hints: MessageKind.UNDEFINED_GETTER);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       var localDyn; 
       for (localDyn in <String>[]) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       String localString; 
       for (localString in <String>[]) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       int localInt; 
       for (localInt in <String>[]) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (topLevelDyn in <String>[]) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (topLevelString in <String>[]) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       for (topLevelInt in <String>[]) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (instanceDyn in <String>[]) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (instanceString in <String>[]) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       for (instanceInt in <String>[]) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (staticDyn in <String>[]) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       for (staticString in <String>[]) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       for (staticInt in <String>[]) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 }
@@ skipping 18 matching lines @@
   static String staticString;
   static int staticInt;
 }
 """;
   compiler.parseScript(script);
   LibraryElement mainApp = compiler.mainApp;
   ClassElement foo = mainApp.find("Class");
   foo.ensureResolved(compiler.resolution);
   FunctionElement method = foo.lookupLocalMember('forIn');
 
-  analyzeIn(
-      compiler,
-      method,
-      """{
+  analyzeIn(compiler, method, """{
       var stream;
       await for (var e in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       var stream;
       await for (String e in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       var stream;
       await for (int e in stream) {} 
   }""");
 
   analyzeIn(
       compiler,
       method,
       """{ 
       await for (var e in []) {} 
   }""",
       hints: MessageKind.NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (var e in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (String e in stream) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       Stream<String> stream;
       await for (int e in stream) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       CustomStream<String> stream;
       await for (var e in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       CustomStream<String> stream;
       await for (String e in stream) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       CustomStream<String> stream;
       await for (int e in stream) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       StringStream stream;
       await for (var e in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       StringStream stream;
       await for (String e in stream) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       StringStream stream;
       await for (int e in stream) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       var localDyn; 
       await for (localDyn in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       String localString; 
       await for (localString in stream) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       Stream<String> stream;
       int localInt; 
       await for (localInt in stream) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (topLevelDyn in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (topLevelString in stream) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       Stream<String> stream;
       await for (topLevelInt in stream) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (instanceDyn in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (instanceString in stream) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       Stream<String> stream;
       await for (instanceInt in stream) {} 
   }""",
       hints: MessageKind.FORIN_NOT_ASSIGNABLE);
 
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (staticDyn in stream) {} 
   }""");
-  analyzeIn(
-      compiler,
-      method,
-      """{ 
+  analyzeIn(compiler, method, """{ 
       Stream<String> stream;
       await for (staticString in stream) {} 
   }""");
   analyzeIn(
       compiler,
       method,
       """{ 
       Stream<String> stream;
       await for (staticInt in stream) {} 
   }""",
@@ skipping 90 matching lines @@
 default: break;
 }""");
 
   check("""
 switch (Enum.A) {
 case Enum.A: break;
 case Enum.B: break;
 case Enum.C: break;
 }""");
 
-  check(
-      """
+  check("""
 switch (Enum.A) {
 case Enum.B: break;
 case Enum.C: break;
-}""",
-      warnings: MessageKind.MISSING_ENUM_CASES);
+}""", warnings: MessageKind.MISSING_ENUM_CASES);
 
-  check(
-      """
+  check("""
 switch (Enum.A) {
 case Enum.A: break;
 case Enum.C: break;
-}""",
-      warnings: MessageKind.MISSING_ENUM_CASES);
+}""", warnings: MessageKind.MISSING_ENUM_CASES);
 
-  check(
-      """
+  check("""
 switch (Enum.A) {
 case Enum.A: break;
 case Enum.B: break;
-}""",
-      warnings: MessageKind.MISSING_ENUM_CASES);
+}""", warnings: MessageKind.MISSING_ENUM_CASES);
 
-  check(
-      """
+  check("""
 switch (Enum.A) {
 case Enum.A: break;
-}""",
-      warnings: MessageKind.MISSING_ENUM_CASES);
+}""", warnings: MessageKind.MISSING_ENUM_CASES);
 
-  check(
-      """
+  check("""
 switch (Enum.A) {
 case Enum.B: break;
-}""",
-      warnings: MessageKind.MISSING_ENUM_CASES);
+}""", warnings: MessageKind.MISSING_ENUM_CASES);
 
-  check(
-      """
+  check("""
 switch (Enum.A) {
 case Enum.C: break;
-}""",
-      warnings: MessageKind.MISSING_ENUM_CASES);
+}""", warnings: MessageKind.MISSING_ENUM_CASES);
 
-  check(
-      """
+  check("""
 switch (Enum.A) {
-}""",
-      warnings: MessageKind.MISSING_ENUM_CASES);
+}""", warnings: MessageKind.MISSING_ENUM_CASES);
 }
 
 testOperators(MockCompiler compiler) {
   check(String code, {warnings}) {
     analyze(compiler, code, warnings: warnings);
   }
 
   // TODO(karlklose): add the DartC tests for operators when we can parse
   // classes with operators.
   for (final op in ['+', '-', '*', '/', '%', '~/', '|', '&']) {
@@ skipping 883 matching lines @@
   Future check(String code, [expectedWarnings]) {
     return analyzeTopLevel(code, expectedWarnings);
   }
 
   return Future.wait([
     check("""int i = 0;"""),
     check("""int i = '';""", NOT_ASSIGNABLE),
     check("""class Class {
                int i = 0;
              }"""),
-    check(
-        """class Class {
+    check("""class Class {
                int i = '';
-             }""",
-        NOT_ASSIGNABLE),
+             }""", NOT_ASSIGNABLE),
   ]);
 }
 
 void testTypeVariableExpressions(MockCompiler compiler) {
   String script = """class Foo<T> {
                        void method() {}
                      }""";
   compiler.parseScript(script);
   LibraryElement mainApp = compiler.mainApp;
   ClassElement foo = mainApp.find("Foo");
@@ skipping 191 matching lines @@
     check(r'''class Class {
                 int a;
                 Class(this.a);
               }
               '''),
     check(r'''class Class {
                 var a;
                 Class(int this.a);
               }
               '''),
-    check(
-        r'''class Class {
+    check(r'''class Class {
                 String a;
                 Class(int this.a);
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
     check(r'''class Class {
                 var a;
                 Class(int a) : this.a = a;
               }
               '''),
-    check(
-        r'''class Class {
+    check(r'''class Class {
                 String a;
                 Class(int a) : this.a = a;
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
 
     // Check this-calls.
     check(r'''class Class {
                 var a;
                 Class(this.a);
                 Class.named(int a) : this(a);
               }
               '''),
-    check(
-        r'''class Class {
+    check(r'''class Class {
                 String a;
                 Class(this.a);
                 Class.named(int a) : this(a);
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
     check(r'''class Class {
                 String a;
                 Class(var a) : this.a = a;
                 Class.named(int a) : this(a);
               }
               '''),
-    check(
-        r'''class Class {
+    check(r'''class Class {
                 String a;
                 Class(String a) : this.a = a;
                 Class.named(int a) : this(a);
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
 
     // Check super-calls.
     check(r'''class Super {
                 var a;
                 Super(this.a);
               }
               class Class extends Super {
                 Class.named(int a) : super(a);
               }
               '''),
-    check(
-        r'''class Super {
+    check(r'''class Super {
                 String a;
                 Super(this.a);
               }
               class Class extends Super {
                 Class.named(int a) : super(a);
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
     check(r'''class Super {
                 String a;
                 Super(var a) : this.a = a;
               }
               class Class extends Super {
                 Class.named(int a) : super(a);
               }
               '''),
-    check(
-        r'''class Super {
+    check(r'''class Super {
                 String a;
                 Super(String a) : this.a = a;
               }
               class Class extends Super {
                 Class.named(int a) : super(a);
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
 
     // Check super-calls involving generics.
     check(r'''class Super<T> {
                 var a;
                 Super(this.a);
               }
               class Class extends Super<String> {
                 Class.named(int a) : super(a);
               }
               '''),
-    check(
-        r'''class Super<T> {
+    check(r'''class Super<T> {
                 T a;
                 Super(this.a);
               }
               class Class extends Super<String> {
                 Class.named(int a) : super(a);
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
     check(r'''class Super<T> {
                 T a;
                 Super(var a) : this.a = a;
               }
               class Class extends Super<String> {
                 Class.named(int a) : super(a);
               }
               '''),
-    check(
-        r'''class Super<T> {
+    check(r'''class Super<T> {
                 T a;
                 Super(T a) : this.a = a;
               }
               class Class extends Super<String> {
                 Class.named(int a) : super(a);
               }
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
 
     // Check instance creations.
     check(r'''class Class {
                 var a;
                 Class(this.a);
               }
               method(int a) => new Class(a);
               '''),
-    check(
-        r'''class Class {
+    check(r'''class Class {
                 String a;
                 Class(this.a);
               }
               method(int a) => new Class(a);
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
     check(r'''class Class {
                 String a;
                 Class(var a) : this.a = a;
               }
               method(int a) => new Class(a);
               '''),
-    check(
-        r'''class Class {
+    check(r'''class Class {
                 String a;
                 Class(String a) : this.a = a;
               }
               method(int a) => new Class(a);
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
 
     // Check instance creations involving generics.
     check(r'''class Class<T> {
                 var a;
                 Class(this.a);
               }
               method(int a) => new Class<String>(a);
               '''),
-    check(
-        r'''class Class<T> {
+    check(r'''class Class<T> {
                 T a;
                 Class(this.a);
               }
               method(int a) => new Class<String>(a);
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
     check(r'''class Class<T> {
                 T a;
                 Class(var a) : this.a = a;
               }
               method(int a) => new Class<String>(a);
               '''),
-    check(
-        r'''class Class<T> {
+    check(r'''class Class<T> {
                 T a;
                 Class(String a) : this.a = a;
               }
               method(int a) => new Class<String>(a);
-              ''',
-        NOT_ASSIGNABLE),
+              ''', NOT_ASSIGNABLE),
   ]);
 }
 
 void testGetterSetterInvocation(MockCompiler compiler) {
   compiler.parseScript(r'''int get variable => 0;
                            void set variable(String s) {}
 
                            class Class {
                              int get instanceField => 0;
                              void set instanceField(String s) {}
@@ skipping 106 matching lines @@
                            class G<V> extends F<V, V> {
                              V g;
                            }
                            ''');
 
   check(String text, {warnings, hints, infos}) {
     analyze(compiler, '{ $text }',
         warnings: warnings, hints: hints, infos: infos);
   }
 
-  check(
-      r'''
+  check(r'''
             A a = new B();
             if (a is C) {
               var x = a.c;
             }''',
       warnings: [MessageKind.UNDEFINED_GETTER],
       hints: [MessageKind.NOT_MORE_SPECIFIC_SUBTYPE],
       infos: []);
 
-  check(
-      r'''
+  check(r'''
             A a = new B();
             if (a is C) {
               var x = '${a.c}${a.c}';
             }''',
       warnings: [MessageKind.UNDEFINED_GETTER, MessageKind.UNDEFINED_GETTER],
       hints: [MessageKind.NOT_MORE_SPECIFIC_SUBTYPE],
       infos: []);
 
-  check(
-      r'''
+  check(r'''
             A a = new B();
             if (a is C) {
               var x = '${a.d}${a.d}'; // Type promotion wouldn't help.
             }''',
       warnings: [MessageKind.UNDEFINED_GETTER, MessageKind.UNDEFINED_GETTER],
       hints: [],
       infos: []);
 
-  check(
-      '''
+  check('''
            D<int> d = new E();
            if (d is E) { // Suggest E<int>.
              var x = d.e;
-           }''',
-      warnings: [
-        MessageKind.UNDEFINED_GETTER
-      ],
-      hints: [
-        checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
-            {'shownTypeSuggestion': 'E<int>'})
-      ],
-      infos: []);
+           }''', warnings: [
+    MessageKind.UNDEFINED_GETTER
+  ], hints: [
+    checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
+        {'shownTypeSuggestion': 'E<int>'})
+  ], infos: []);
 
-  check(
-      '''
+  check('''
            D<int> d = new F();
            if (d is F) { // Suggest F<int, dynamic>.
              var x = d.f;
-           }''',
-      warnings: [
-        MessageKind.UNDEFINED_GETTER
-      ],
-      hints: [
-        checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
-            {'shownTypeSuggestion': 'F<int, dynamic>'})
-      ],
-      infos: []);
+           }''', warnings: [
+    MessageKind.UNDEFINED_GETTER
+  ], hints: [
+    checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
+        {'shownTypeSuggestion': 'F<int, dynamic>'})
+  ], infos: []);
 
-  check(
-      '''
+  check('''
            D<int> d = new G();
            if (d is G) { // Suggest G<int>.
              var x = d.f;
-           }''',
-      warnings: [
-        MessageKind.UNDEFINED_GETTER
-      ],
-      hints: [
-        checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
-            {'shownTypeSuggestion': 'G<int>'})
-      ],
-      infos: []);
+           }''', warnings: [
+    MessageKind.UNDEFINED_GETTER
+  ], hints: [
+    checkMessage(MessageKind.NOT_MORE_SPECIFIC_SUGGESTION,
+        {'shownTypeSuggestion': 'G<int>'})
+  ], infos: []);
 
-  check(
-      '''
+  check('''
            F<double, int> f = new G();
            if (f is G) { // Cannot suggest a more specific type.
              var x = f.g;
            }''',
       warnings: [MessageKind.UNDEFINED_GETTER],
       hints: [MessageKind.NOT_MORE_SPECIFIC],
       infos: []);
 
-  check(
-      '''
+  check('''
            D<int> d = new E();
            if (d is E) {
              var x = d.f; // Type promotion wouldn't help.
            }''',
-      warnings: [MessageKind.UNDEFINED_GETTER],
-      hints: [],
-      infos: []);
+      warnings: [MessageKind.UNDEFINED_GETTER], hints: [], infos: []);
 
-  check(
-      '''
+  check('''
            A a = new B();
            if (a is B) {
              a = null;
              var x = a.b;
            }''',
       warnings: [MessageKind.UNDEFINED_GETTER],
       hints: [MessageKind.POTENTIAL_MUTATION],
       infos: [MessageKind.POTENTIAL_MUTATION_HERE]);
 
-  check(
-      '''
+  check('''
            A a = new B();
            if (a is B) {
              a = null;
              var x = a.c; // Type promotion wouldn't help.
            }''',
-      warnings: [MessageKind.UNDEFINED_GETTER],
-      hints: [],
-      infos: []);
+      warnings: [MessageKind.UNDEFINED_GETTER], hints: [], infos: []);
 
-  check(
-      '''
+  check('''
            A a = new B();
            local() { a = new A(); }
            if (a is B) {
              var x = a.b;
            }''',
       warnings: [MessageKind.UNDEFINED_GETTER],
       hints: [MessageKind.POTENTIAL_MUTATION_IN_CLOSURE],
       infos: [MessageKind.POTENTIAL_MUTATION_IN_CLOSURE_HERE]);
 
-  check(
-      '''
+  check('''
            A a = new B();
            local() { a = new A(); }
            if (a is B) {
              var x = a.c; // Type promotion wouldn't help.
            }''',
-      warnings: [MessageKind.UNDEFINED_GETTER],
-      hints: [],
-      infos: []);
+      warnings: [MessageKind.UNDEFINED_GETTER], hints: [], infos: []);
 
-  check(
-      '''
+  check('''
            A a = new B();
            if (a is B) {
              var x = () => a;
              var y = a.b;
            }
-           a = new A();''',
-      warnings: [
-        MessageKind.UNDEFINED_GETTER
-      ],
-      hints: [
-        MessageKind.ACCESSED_IN_CLOSURE
-      ],
-      infos: [
-        MessageKind.ACCESSED_IN_CLOSURE_HERE,
-        MessageKind.POTENTIAL_MUTATION_HERE
-      ]);
+           a = new A();''', warnings: [
+    MessageKind.UNDEFINED_GETTER
+  ], hints: [
+    MessageKind.ACCESSED_IN_CLOSURE
+  ], infos: [
+    MessageKind.ACCESSED_IN_CLOSURE_HERE,
+    MessageKind.POTENTIAL_MUTATION_HERE
+  ]);
 
-  check(
-      '''
+  check('''
            A a = new B();
            if (a is B) {
              var x = () => a;
              var y = a.c; // Type promotion wouldn't help.
            }
            a = new A();''',
-      warnings: [MessageKind.UNDEFINED_GETTER],
-      hints: [],
-      infos: []);
+      warnings: [MessageKind.UNDEFINED_GETTER], hints: [], infos: []);
 }
 
 void testCascade(MockCompiler compiler) {
   compiler.parseScript(r'''typedef A AFunc();
                            typedef Function FuncFunc();
                            class A {
                              A a;
                              B b;
                              C c;
                              AFunc afunc() => null;
@@ skipping 416 matching lines @@
   TreeElements elements = compiler.resolveNodeStatement(node, element);
   TypeCheckerVisitor checker =
       new TypeCheckerVisitor(compiler, elements, compiler.resolution.types);
   DiagnosticCollector collector = compiler.diagnosticCollector;
   collector.clear();
   checker.analyze(node, mustHaveType: false);
   generateOutput(compiler, text);
   compareWarningKinds(text, warnings, collector.warnings);
   compareWarningKinds(text, hints, collector.hints);
 }