Reformat untouched files.

tests/compiler/dart2js/async_await_js_transform_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.
 
 import "package:expect/expect.dart";
 import "package:compiler/src/js/js.dart";
 import "package:compiler/src/js/rewrite_async.dart";
 import "package:compiler/src/js_backend/js_backend.dart" show StringBackedName;
 
 void testTransform(String source, String expected, AsyncRewriterBase rewriter) {
@@ skipping 76 matching lines @@
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""")
 
       /// 01: ok
       ;
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
 function(a) async {
   print(this.x); // Ensure `this` is translated in the helper function.
   await foo();
-}""",
-      """
+}""", """
 function(a) {
   var __goto = 0, __completer = NewCompleter(), __self = this;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
           print(__self.x);
           __goto = 2;
           return awaitHelper(foo(), body);
         case 2:
           // returning from await.
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
   function(b) async {
     try {
       __outer: while (true) { // Overlapping label name.
         try {
           inner: while (true) {
             break __outer; // Break from untranslated loop to translated target.
             break; // break to untranslated target.
           }
           while (true) {
             return; // Return via finallies.
           }
           var __helper = await foo(); // Overlapping variable name.
         } finally {
           foo();
           continue; // Continue from finally with pending finally.
           return 2; // Return from finally with pending finally.
         }
       }
     } finally {
       return 3; // Return from finally with no pending finally.
     }
     return 4;
-  }""",
-      """
+  }""", """
 function(b) {
   var __goto = 0, __completer = NewCompleter(), __returnValue, __handler = 2, __currentError, __next = [], __helper;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1) {
       __currentError = __result;
       __goto = __handler;
     }
     while (true)
       __outer1:
         switch (__goto) {
@@ skipping 80 matching lines @@
             // return
             return returnHelper(__returnValue, __completer);
           case 2:
             // rethrow
             return rethrowHelper(__currentError, __completer);
         }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
 function(c) async {
   var a, b, c, d, e, f;
   a = b++; // post- and preincrements.
   b = --b;
   c = (await foo()).a++;
   d = ++(await foo()).a;
   e = foo1()[await foo2()]--;
   f = --foo1()[await foo2()];
-}""",
-      """
+}""", """
 function(c) {
   var __goto = 0, __completer = NewCompleter(), a, b, c, d, e, f, __temp1;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
           a = b++;
@@ skipping 20 matching lines @@
         case 5:
           // returning from await.
           f = --__temp1[__result];
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
   function(d2) async {
     var a, b, c, d, e, f, g, h; // empty initializer
     a = foo1() || await foo2(); // short circuiting operators
     b = await foo1() || foo2();
     c = await foo1() || foo3(await foo2());
     d = foo1() || foo2();
     e = foo1() && await foo2();
     f = await foo1() && foo2();
     g = await foo1() && await foo2();
     h = foo1() && foo2();
-  }""",
-      """
+  }""", """
 function(d2) {
   var __goto = 0, __completer = NewCompleter(), a, b, c, d, e, f, g, h, __temp1;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
           __temp1 = foo1();
@@ skipping 96 matching lines @@
           // join
           g = __result;
           h = foo1() && foo2();
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
 function(x, y) async {
   while (true) {
     switch(y) { // Switch with no awaits in case key expressions
       case 0:
       case 1: 
         await foo();
         continue; // Continue the loop, not the switch
       case 1: // Duplicate case
         await foo();
         break; // Break the switch
       case 2:
         foo(); // No default
     }
   }
-}""",
-      """
+}""", """
 function(x, y) {
   var __goto = 0, __completer = NewCompleter();
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
         case 2:
@@ skipping 53 matching lines @@
           break;
         case 3:
           // after while
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
   function(f) async {
     do {
       var a = await foo();
       if (a) // If with no awaits in body
         break;
       else
         continue;
     } while (await foo());
   }
-  """,
-      """
+  """, """
 function(f) {
   var __goto = 0, __completer = NewCompleter(), a;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
         case 2:
@@ skipping 25 matching lines @@
           }
         case 4:
           // after do
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
 function(g) async {
   for (var i = 0; i < await foo1(); i += await foo2()) {
     if (foo(i))
       continue;
     else
       break;
     if (!foo(i)) { // If with no else and await in body.
       await foo();
       return;
     }
     print(await(foo(i)));
   } 
 }
-""",
-      """
+""", """
 function(g) {
   var __goto = 0, __completer = NewCompleter(), __returnValue, i, __temp1;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
           i = 0;
@@ skipping 50 matching lines @@
         case 5:
           // after for
         case 1:
           // return
           return returnHelper(__returnValue, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
   function(a, h) async {
     var x = {"a": foo1(), "b": await foo2(), "c": foo3()};
     x["a"] = 2; // Different assignments
     (await foo()).a = 3;
     x[await foo()] = 4;
     x[(await foo1()).a = await foo2()] = 5;
     (await foo1())[await foo2()] = await foo3(6);
   }
-  """,
-      """
+  """, """
 function(a, h) {
   var __goto = 0, __completer = NewCompleter(), x, __temp1, __temp2;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
           __temp1 = foo1();
@@ skipping 40 matching lines @@
         case 9:
           // returning from await.
           __temp1[__temp2] = __result;
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
 function(c, i) async {
   try {
     var x = c ? await foo() : foo(); // conditional
     var y = {};
   } catch (error) {
     try {
       x = c ? await fooError(error) : fooError(error);
     } catch (error) { // nested error handler with overlapping name
       y.x = foo(error);
     } finally {
       foo(x);
     }
   }
 }
-""",
-      """
+""", """
 function(c, i) {
   var __goto = 0, __completer = NewCompleter(), __handler = 1, __currentError, __next = [], x, y, __error, __error1;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1) {
       __currentError = __result;
       __goto = __handler;
     }
     while (true)
       switch (__goto) {
         case 0:
@@ skipping 81 matching lines @@
           // implicit return
           return returnHelper(null, __completer);
         case 1:
           // rethrow
           return rethrowHelper(__currentError, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
   function(x, y, j) async {
     print(await(foo(x))); // calls
     (await print)(foo(x));
     print(foo(await x));
     await (print(foo(await x)));
     print(foo(x, await y, z));
   }
-  """,
-      """
+  """, """
 function(x, y, j) {
   var __goto = 0, __completer = NewCompleter(), __temp1, __temp2, __temp3;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
           __temp1 = print;
@@ skipping 32 matching lines @@
         case 7:
           // returning from await.
           __temp1(__temp2(__temp3, __result, z));
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
 function(x, y, k) async {
   while (await(foo())) {
     lab: { // labelled statement
       switch(y) {
       case 0:
         foo();
       case 0: // Duplicate case
         print(await foo1(x));
         return y;
       case await bar(): // await in case
         print(await foobar(x));
         return y;
       case x:
         if (a) {
           throw new Error();
         } else {
           continue;
         }
       default: // default case
         break lab; // break to label
       }
       foo();
     }
   }
-}""",
-      """
+}""", """
 function(x, y, k) {
   var __goto = 0, __completer = NewCompleter(), __returnValue, __temp1;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
         case 3:
@@ skipping 89 matching lines @@
         case 4:
           // after while
         case 1:
           // return
           return returnHelper(__returnValue, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
   function(l) async {
     switch(await l) {
       case 1:
         print(1);
         break;
       case 2:
         print(1);
         // Fallthrough
       default:
         print(2);
         break;
     }
-  }""",
-      """
+  }""", """
 function(l) {
   var __goto = 0, __completer = NewCompleter();
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1)
       return rethrowHelper(__result, __completer);
     while (true)
       switch (__goto) {
         case 0:
           // Function start
           __goto = 2;
@@ skipping 10 matching lines @@
               print(2);
               break;
           }
           // implicit return
           return returnHelper(null, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testAsyncTransform(
-      """
+  testAsyncTransform("""
   function(m) async {
     var exception = 1;
     try {
       await 42;
       throw 42;
     } catch (exception) {
       exception = await 10;
       exception += await 10;
       exception++;
       exception--;
       ++exception;
       --exception;
       exception += 10;
     }
     print(exception);
-  }""",
-      """
+  }""", """
 function(m) {
   var __goto = 0, __completer = NewCompleter(), __handler = 1, __currentError, __next = [], exception, __exception;
   var body = _wrapJsFunctionForAsync(function(__errorCode, __result) {
     if (__errorCode === 1) {
       __currentError = __result;
       __goto = __handler;
     }
     while (true)
       switch (__goto) {
         case 0:
@@ skipping 42 matching lines @@
           // implicit return
           return returnHelper(null, __completer);
         case 1:
           // rethrow
           return rethrowHelper(__currentError, __completer);
       }
   });
   return startHelper(body, __completer);
 }""");
 
-  testSyncStarTransform(
-      """
+  testSyncStarTransform("""
 function(a) sync* {
   // Ensure that return of a value is treated as first evaluating the value, and
   // then returning.
   return foo();
-}""",
-      """
+}""", """
 function(__a) {
   return NewIterable(function() {
     var a = __a;
     var __goto = 0, __handler = 2, __currentError;
     return function body(__errorCode, __result) {
       if (__errorCode === 1) {
         __currentError = __result;
         __goto = __handler;
       }
       while (true)
         switch (__goto) {
           case 0:
             // Function start
             foo();
             // goto return
             __goto = 1;
             break;
           case 1:
             // return
             return endOfIteration();
           case 2:
             // rethrow
             return uncaughtError(__currentError);
         }
     };
   });
 }""");
 }