Format all multitests

tests/language/covariant_test.dart

 // Copyright (c) 2017, 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.
 
 // Test that `covariant` can be parsed (and ignored) by
 // dart2js and the VM.
 // This test only checks for non-strong mode behavior.
 //
 // Generally, `covariant` should be ignored, when it is used in the right
 // places.
@@ skipping 17 matching lines @@
 // Would be considered a minor (acceptable) bug, if it was accepted here too.
 void set x2(
     covariant //# 02: compile-time error
     int val) {}
 
 // Same as above, but with `covariant` in different positions.
 // The `covariant` is just wrong there.
 
 int
 covariant // //# 03: compile-time error
-x3;
+    x3;
 
 int
 covariant // //# 04: compile-time error
-get x4 => 499;
+    get x4 => 499;
 
 void set x5(
     int
     covariant //# 05: compile-time error
     val) {}
 
-
 // Same without types.
 
 // Since `covariant` is a built-in identifier, it is not allowed here.
 covariant x6; // //# 06: compile-time error
 
 covariant covariant; // //# 06b: compile-time error
 
 // Getters may never have `covariant`.
 covariant // //# 07: compile-time error
 get x7 => 499;
@@ skipping 12 matching lines @@
 int f10() => 499;
 
 // Covariant won't work as a return type.
 covariant // //# 11: compile-time error
 f11() => 499;
 
 // Covariant should not work on top-level methods.
 // It's a minor (acceptable) bug to not error out here.
 int f12(
     covariant //# 12: compile-time error
-    int x) => 499;
+        int x) =>
+    499;
 
 // `Covariant` must be in front of the types.
 int f13(
-    int
+        int
     covariant //# 13: compile-time error
-    x) => 499;
+        x) =>
+    499;
 
 // Covariant should not work on top-level methods.
 // It's a minor (acceptable) bug to not error out here.
 int f14(
     covariant //# 14: compile-time error
-    final
-    x) => 499;
+        final x) =>
+    499;
 
 // `Covariant` must be in front of modifiers.
 int f15(
-    final
+        final
     covariant //# 15: compile-time error
-    x) => 499;
+        x) =>
+    499;
 
 // Covariant should not work on top-level methods.
 // It's a minor (acceptable) bug to not error out here.
 int f16(
     covariant //# 16: compile-time error
-    final
-    int
-    x) => 499;
+        final int x) =>
+    499;
 
 // `Covariant` must be in front of modifiers.
 int f17(
-    final
+        final
     covariant //# 17: compile-time error
-    int
-    x) => 499;
+        int x) =>
+    499;
 
 // On its own, `covariant` is just a parameter name.
 int f18(covariant) => covariant;
 
 covariant; // //# 19: compile-time error
 
 // All of the above as statics in a class.
 class A {
   // Static fields may not have a covariant.
   // Would be considered a minor (acceptable) bug, if it was accepted here too.
   static
   covariant // //# 20: compile-time error
-  int x20;
+      int x20;
 
   static covariant int covariant // //# 20b: compile-time error
 
   static int covariant; // //# 20c: ok
 
   // Getters may never have `covariant`.
   static
   covariant // //# 21: compile-time error
-  int get x21 => 499;
+      int get x21 => 499;
 
   // Getters may never have `covariant`.
   covariant // //# 21b: compile-time error
-  static
-  int get x21b => 499;
+  static int get x21b => 499;
 
   // Static setters may not have a covariant.
   // Would be considered a minor (acceptable) bug, if it was accepted here too.
   static void set x22(
       covariant //# 22: compile-time error
       int val) {}
 
   // Same as above, but with `covariant` in different positions.
   // The `covariant` is just wrong there.
 
   static int
   covariant // //# 23: compile-time error
-  x23;
+      x23;
 
   static int
   covariant // //# 24: compile-time error
-  get x24 => 499;
+      get x24 => 499;
 
   static void set x25(
-    int
+      int
     covariant //# 25: compile-time error
-    val) {}
+      val) {}
 
   // Since `covariant` is a built-in identifier, it is not allowed here.
   static covariant x26; //# 26: compile-time error
   static covariant covariant; //# 26b: compile-time error
 
   // Getters may never have `covariant`.
   static
   covariant // //# 27: compile-time error
-  get x27 => 499;
+      get x27 => 499;
 
   covariant // //# 27b: compile-time error
-  static
-  get x27b => 499;
+  static get x27b => 499;
 
   // Static setters may not have a covariant.
   // Would be considered a minor (acceptable) bug, if it was accepted here too.
   static void set x28(
       covariant //# 28: compile-time error
       val) {}
 
   // If there is no type, then `covariant` is simply the parameter name:
   static void set x29(covariant) {}
 
   // Covariant won't work on return types.
   static
   covariant // //# 30: compile-time error
-  int f30() => 499;
+      int f30() => 499;
 
   covariant // //# 30b: compile-time error
-  static
-  int f30b() => 499;
+  static int f30b() => 499;
 
   // Covariant won't work as a return type.
   static
   covariant // //# 31: compile-time error
-  f31() => 499;
+      f31() => 499;
 
   covariant // //# 31b: compile-time error
-  static
-  f31b() => 499;
+  static f31b() => 499;
 
   // Covariant should not work on static methods.
   // It's a minor (acceptable) bug to not error out here.
   static int f32(
       covariant //# 32: compile-time error
-      int x) => 499;
+          int x) =>
+      499;
 
   // `Covariant` must be in front of the types.
   static int f33(
-      int
+          int
       covariant //# 33: compile-time error
-      x) => 499;
+          x) =>
+      499;
 
   // Covariant should not work on top-level methods.
   // It's a minor (acceptable) bug to not error out here.
   static int f34(
       covariant //# 34: compile-time error
-      final
-      x) => 499;
+          final x) =>
+      499;
 
   // `Covariant` must be in front of modifiers.
   static int f35(
-      final
+          final
       covariant //# 35: compile-time error
-      x) => 499;
+          x) =>
+      499;
 
   // Covariant should not work on top-level methods.
   // It's a minor (acceptable) bug to not error out here.
   static int f36(
       covariant //# 36: compile-time error
-      final
-      int
-      x) => 499;
+          final int x) =>
+      499;
 
   // `Covariant` must be in front of modifiers.
   static int f37(
-      final
+          final
       covariant //# 37: compile-time error
-      int
-      x) => 499;
+          int x) =>
+      499;
 
   // `Covariant` on its own is just a parameter name.
   static int f38(covariant) => covariant;
 
   static covariant; // //# 39: compile-time error
 
 }
 
 // All of the above as instance members in a class.
 class B {
   covariant // //# 40: ok
   int x40;
 
   covariant int covariant; // //# 40b: ok
 
   int covariant; //           //# 40c: ok
 
   // Getters may never have `covariant`.
   covariant // //# 41: compile-time error
   int get x41 => 499;
 
   void set x42(
       covariant // //# 42: ok
       int val) {}
 
   // `covariant` in the wrong position.
   int
   covariant // //# 43: compile-time error
-  x43;
+      x43;
 
   // `covariant` in the wrong position.
   int
   covariant // //# 44: compile-time error
-  get x44 => 499;
+      get x44 => 499;
 
   void set x45(
-    int
+      int
     covariant //# 45: compile-time error
-    val) {}
+      val) {}
 
   // Since `covariant` is a built-in identifier, it is not allowed here.
   covariant x46; //# 46: compile-time error
   covariant covariant; //# 46b: compile-time error
 
   // Getters may never have `covariant`.
   covariant // //# 47: compile-time error
   get x47 => 499;
 
   void set x48(
       covariant // //# 48: ok
       val) {}
 
   // If there is no type, then `covariant` is simply the parameter name:
   void set x49(covariant) {}
 
   // Covariant won't work on return types.
   covariant // //# 50: compile-time error
   int f50() => 499;
 
   // Covariant won't work as a return type.
   covariant // //# 51: compile-time error
   f51() => 499;
 
   int f52(
       covariant // //# 52: ok
-      int x) => 499;
+          int x) =>
+      499;
 
   // `Covariant` must be in front of the types.
   int f53(
-      int
+          int
       covariant //# 53: compile-time error
-      x) => 499;
+          x) =>
+      499;
 
   int f54(
       covariant // //# 54: ok
-      final x) => 499;
+          final x) =>
+      499;
 
   // `Covariant` must be in front of modifiers.
   int f55(
-      final
+          final
       covariant //# 55: compile-time error
-      x) => 499;
+          x) =>
+      499;
 
   int f56(
       covariant // //# 56: ok
-      final int x) => 499;
+          final int x) =>
+      499;
 
   // `Covariant` must be in front of modifiers.
   int f57(
-      final
+          final
       covariant //# 57: compile-time error
-      int
-      x) => 499;
+          int x) =>
+      499;
 
   // `Covariant` on its own is just a parameter name.
   int f58(covariant) => covariant;
 
   covariant; // //# 59: compile-time error
 }
 
 void use(x) {}
 
 main() {
@@ skipping 65 matching lines @@
   use(b.f50());
   use(b.f51());
   use(b.f52(2));
   use(b.f53(2));
   use(b.f54(3));
   use(b.f55(3));
   use(b.f56(3));
   use(b.f57(3));
   Expect.equals(12345, b.f58(12345));
   use(B.covariant); // //# 59: continued
-}
+}