Revert "Format all multitests"

tests/language/built_in_identifier_test.dart

 // Copyright (c) 2012, 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.
 // Check that we can use pseudo keywords as names in function level code.
 
 import "package:expect/expect.dart";
 
+
 class PseudoKWTest {
   static testMain() {
+
     // This is a list of built-in identifiers from the Dart spec.
     // It sanity checks that these pseudo-keywords are legal identifiers.
 
     var abstract = 0; // //# 01: ok
     var as = 0;
     var dynamic = 0;
     var export = 0;
     var external = 0; // //# 01: ok
     var factory = 0;
     var get = 0;
     var implements = 0;
     var import = 0;
     var library = 0;
     var operator = 0;
     var part = 0;
     var set = 0;
     var static = 0; // //# 01: ok
     var typedef = 0;
 
     // "native" is a per-implementation extension that is not a part of the
     // Dart language.  While it is not an official built-in identifier, it
     // is useful to ensure that it remains a legal identifier.
     var native = 0;
 
+
     // The code below adds a few additional variants of usage without any
     // attempt at complete coverage.
     {
       void factory(set) {
         return; // //# 01: ok
       }
     }
 
-    get:
-    while (import > 0) {
+    get: while (import > 0) {
       break get;
     }
 
     return
         static + // //# 01: ok
         library * operator;
   }
 }
 
 typedef(x) => "typedef $x"; // //# 01: ok
 
 static(abstract) { // //# 01: ok
   return abstract == true; // //# 01: ok
 } // //# 01: ok
 
 class A {
   var typedef = 0;
   final operator = "smooth";
 
-  set(x) {
-    typedef = x;
-  }
-
+  set(x) { typedef = x; }
   get() => typedef - 5;
 
   static static() { // //# 01: ok
     return 1; // //# 01: ok
   } // //# 01: ok
   static check() {
     var o = new A();
     o.set(55);
     Expect.equals(50, o.get());
     static(); // //# 01: ok
@@ skipping 12 matching lines @@
   } // //# 01: ok
   int operator() {
     return 1;
   }
 }
 
 class C {
   static int operator = (5);
   static var get;
   static get set => 111;
-  static set set(set) {}
+  static set set(set) { }
 }
 
+
 main() {
   PseudoKWTest.testMain();
   A.check();
   new B().static(); // //# 01: ok
   Expect.equals(1, new B().operator());
   Expect.equals(1, A.static()); // //# 01: ok
   typedef("T"); // //# 01: ok
   Expect.equals("typedef T", typedef("T")); // //# 01: ok
   static("true"); // //# 01: ok
   Expect.equals(false, static("true")); // //# 01: ok
   Expect.equals(5, C.operator);
   Expect.equals(null, C.get);
   C.set = 0;
   Expect.equals(111, C.set);
 }