Do not put a newline on empty `{}` for functions (#447)

The original intent of it was for `if then else` and `try catch` as they aren't likely to be empty, but it accidentally caught function bodys, which have many valid reasons to be empty. Let's special case those out.

src/printer.js

@@ -449,7 +449,7 @@ function genericPrintNoParens(path, options, print) {
       parts.push(path.call(print, "source"), ";");
 
       return concat(parts);
-    case "BlockStatement":
+    case "BlockStatement": {
       var naked = path.call(
         function(bodyPath) {
           return printStatementSequence(bodyPath, options, print);
@@ -460,6 +460,14 @@ function genericPrintNoParens(path, options, print) {
       const hasContent = getFirstString(naked);
       const hasDirectives = n.directives && n.directives.length > 0;
 
+      var parent = path.getParentNode();
+      if (!hasContent && !hasDirectives && !n.comments &&
+          (parent.type === "ArrowFunctionExpression" ||
+            parent.type === "FunctionExpression" ||
+            parent.type === "FunctionDeclaration")) {
+        return "{}";
+      }
+
       parts.push("{");
 
       // Babel 6
@@ -491,6 +499,7 @@ function genericPrintNoParens(path, options, print) {
       parts.push(hardline, "}");
 
       return concat(parts);
+    }
     case "ReturnStatement":
       parts.push("return");
 

tests/abnormal/__snapshots__/jsfmt.spec.js.snap

@@ -30,8 +30,7 @@ function foo() {
     bar(x);
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function bar(x: number) {
+function bar(x: number) {}
-}
 function foo() {
   var x = null;
   if (x == null) return;

tests/annot/__snapshots__/jsfmt.spec.js.snap

@@ -174,8 +174,7 @@ exports[`test issue-530.js 1`] = `
 
 module.exports = foo;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function foo(...args: any) {
+function foo(...args: any) {}
-}
 
 module.exports = foo;
 "

tests/arith/__snapshots__/jsfmt.spec.js.snap

@@ -93,11 +93,9 @@ let tests = [
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @providesModule Arith */
 
-function num(x: number) {
+function num(x: number) {}
-}
 
-function str(x: string) {
+function str(x: string) {}
-}
 
 function foo() {
   var x = 0;
@@ -291,8 +289,7 @@ y *= 2; // error
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
 
-function num(x: number) {
+function num(x: number) {}
-}
 
 num(null * 1);
 num(1 * null);

tests/arraylib/__snapshots__/jsfmt.spec.js.snap

@@ -58,8 +58,7 @@ function from_test() {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
-function foo(x: string) {
+function foo(x: string) {}
-}
 
 var a = [ 0 ];
 var b = a.map(function(x) {

tests/arrays/__snapshots__/jsfmt.spec.js.snap

@@ -41,8 +41,7 @@ module.exports = \"arrays\";
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @providesModule Arrays */
 
-function foo(x: string) {
+function foo(x: string) {}
-}
 
 var a = [];
 a[0] = 1;

tests/arrows/__snapshots__/jsfmt.spec.js.snap

@@ -35,20 +35,13 @@ export default (() => {})();
 new (() => {});
 if ((() => {}) ? 1 : 0) {}
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-(a => {
+(a => {}).length;
-}).length;
+typeof (() => {});
-typeof (() => {
+export default (() => {})();
-});
+(() => {})()\`\`;
-export default (() => {
+(() => {})\`\`;
-})();
+new (() => {})();
-(() => {
+if ((() => {}) ? 1 : 0) {
-})()\`\`;
-(() => {
-})\`\`;
-new (() => {
-})();
-if ((() => {
-  }) ? 1 : 0) {
 }
 "
 `;
@@ -87,8 +80,7 @@ exports[`test long-call-no-args.js 1`] = `
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 veryLongCall(
   VERY_VERY_VERY_VERY_VERY_VERY_VERY_VERY_VERY_VERY_LONG_CONSTANT,
-  () => {
+  () => {}
-  }
 );
 "
 `;

tests/async/__snapshots__/jsfmt.spec.js.snap

@@ -171,42 +171,24 @@ console.log(x.async);
 var async = 3;
 var y = { async };
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-async function f() {
+async function f() {}
-}
+async function ft<T>(a: T) {}
-async function ft<T>(a: T) {
-}
 
 class C {
-  async m() {
+  async m() {}
-  }
+  async mt<T>(a: T) {}
-  async mt<T>(a: T) {
+  static async m(a) {}
-  }
+  static async mt<T>(a: T) {}
-  static async m(a) {
-  }
-  static async mt<T>(a: T) {
-  }
 }
 
-var e = async function() {
+var e = async function() {};
-};
+var et = async function<T>(a: T) {};
-var et = async function<T>(a: T) {
-};
 
-var n = new (async function() {
+var n = new (async function() {})();
-})();
 
-var o = {
+var o = { async m() {} };
-  async m() {
+var ot = { async m<T>(a: T) {} };
-  }
+var oz = { async async() {} };
-};
-var ot = {
-  async m<T>(a: T) {
-  }
-};
-var oz = {
-  async async() {
-  }
-};
 
 var x = { async: 5 };
 console.log(x.async);
@@ -254,8 +236,7 @@ async function foo2(): Promise<string> {
 }
 
 async function foo3(): Promise<string> {
-  function bar() {
+  function bar() {}
-  }
   return bar();
 }
 "

tests/binding/__snapshots__/jsfmt.spec.js.snap

@@ -411,18 +411,14 @@ function var_var() {
 
 // function x *
 function function_toplevel() {
-  function a() {
+  function a() {}
-  }
+  function a() {}
-  function a() {
-  }
 }
 
 function function_block() {
   {
-    function a() {
+    function a() {}
-    }
+    function a() {}
-    function a() {
-    }
   }
 }
 
@@ -446,8 +442,7 @@ function type_shadow_nested_scope() {
 }
 
 // fn params name clash
-function fn_params_name_clash(x, x /* error: x already bound */) {
+function fn_params_name_clash(x, x /* error: x already bound */) {}
-}
 function fn_params_clash_fn_binding(x, y) {
   let x = 0;
   // error: x already bound

tests/bom/__snapshots__/jsfmt.spec.js.snap

@@ -235,15 +235,13 @@ const o: MutationObserver = new MutationObserver(callback);
 // correct
 new MutationObserver((arr: Array<MutationRecord>) => true);
 // correct
-new MutationObserver(() => {
+new MutationObserver(() => {});
-});
 // correct
 new MutationObserver();
 // incorrect
 new MutationObserver(42);
 // incorrect
-new MutationObserver((n: number) => {
+new MutationObserver((n: number) => {});
-});
 
 // incorrect
 // observe

tests/bounded_poly/__snapshots__/jsfmt.spec.js.snap

@@ -4,8 +4,7 @@ foo(0, \"\");
 
 function bar<X:number, Y:X>(x:X, y:Y): number { return y*0; }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function foo<X, Y: X>(x: X, y: Y): void {
+function foo<X, Y: X>(x: X, y: Y): void {}
-}
 foo(0, \"\");
 
 function bar<X: number, Y: X>(x: X, y: Y): number {

tests/builtins/__snapshots__/jsfmt.spec.js.snap

@@ -64,8 +64,7 @@ class Foo<T> {
   map<U>(callbackfn: () => U): Foo<U> {
     return new Foo();
   }
-  set(x: T): void {
+  set(x: T): void {}
-  }
   get(): T {
     return this.x;
   }

tests/call_properties/__snapshots__/jsfmt.spec.js.snap

@@ -106,15 +106,13 @@ var d: { (): string } = function(x: number): string {
 };
 
 // ...but subtyping rules still apply
-var e: { (x: any): void } = function() {
+var e: { (x: any): void } = function() {};
-};
 // arity
 var f: { (): mixed } = function(): string {
   return \"hi\";
 };
 // return type
-var g: { (x: string): void } = function(x: mixed) {
+var g: { (x: string): void } = function(x: mixed) {};
-};
 
 // param type
 // A function can be an object
@@ -264,16 +262,13 @@ f.myProp = 123;
 var c : { myProp: number } = f;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // Expecting properties that don\'t exist should be an error
-var a: { someProp: number } = function() {
+var a: { someProp: number } = function() {};
-};
 
 // Expecting properties that do exist should be fine
-var b: { apply: Function } = function() {
+var b: { apply: Function } = function() {};
-};
 
 // Expecting properties in the functions statics should be fine
-var f = function() {
+var f = function() {};
-};
 f.myProp = 123;
 var c: { myProp: number } = f;
 "
@@ -316,8 +311,7 @@ var c: { (x: string): string } = x => x.toFixed();
 var d: { (): string } = x => \"hi\";
 
 // ...but subtyping rules still apply
-var e: { (x: any): void } = () => {
+var e: { (x: any): void } = () => {};
-};
 // arity
 var f: { (): mixed } = () => \"hi\";
 // return type

tests/callable/__snapshots__/jsfmt.spec.js.snap

@@ -44,8 +44,7 @@ callable(0); // error, number ~> string
 callable.call(null, 0); // error, number ~> string
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 var x = Boolean(4);
-function foo(fn: (value: any) => boolean) {
+function foo(fn: (value: any) => boolean) {}
-}
 foo(Boolean);
 
 var dict: { [k: string]: any } = {};

tests/class_extends/__snapshots__/jsfmt.spec.js.snap

@@ -58,8 +58,7 @@ function* f() {
 x = class extends (++b) {}
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // \"ArrowFunctionExpression\"
-class a extends (() => {
+class a extends (() => {}) {}
-}) {}
 
 // \"AssignmentExpression\"
 class a extends (b = c) {}
@@ -82,8 +81,7 @@ class a extends class {} {}
 class a extends (b ? c : d) {}
 
 // \"FunctionExpression\"
-class a extends function() {
+class a extends function() {} {}
-} {}
 
 // \"LogicalExpression\"
 class a extends (b || c) {}

tests/class_statics/__snapshots__/jsfmt.spec.js.snap

@@ -64,20 +64,16 @@ module.exports = {
 class A {
   static x: number;
   static y: string;
-  static foo(x: number) {
+  static foo(x: number) {}
-  }
+  static bar(y: string) {}
-  static bar(y: string) {
-  }
 }
-A.qux = function(x: string) {
+A.qux = function(x: string) {};
-};
 
 // error?
 class B extends A {
   static x: string;
   // error?
-  static foo(x: string) {
+  static foo(x: string) {}
-  }
   // error?
   static main() {
     B.x = 0;
@@ -103,8 +99,7 @@ class B extends A {
 
 class C<X> {
   static x: X;
-  static bar(x: X) {
+  static bar(x: X) {}
-  }
   static create(): C<*> {
     return new this();
   }

tests/class_subtyping/__snapshots__/jsfmt.spec.js.snap

@@ -69,8 +69,7 @@ class C<X> {
   x: X;
 }
 
-function foo<X>(c: C<X>, x: X) {
+function foo<X>(c: C<X>, x: X) {}
-}
 
 type O = { f: number };
 

tests/class_type/__snapshots__/jsfmt.spec.js.snap

@@ -17,8 +17,7 @@ function foo(x: Class<A>): A {
 }
 
 class B {
-  constructor(_: any) {
+  constructor(_: any) {}
-  }
 }
 function bar(x: Class<B>): B {
   return new x(); // error (too few args)

tests/classes/__snapshots__/jsfmt.spec.js.snap

@@ -6,8 +6,7 @@ exports[`test A.js 1`] = `
 module.exports = A;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class A {
-  foo(x: number): void {
+  foo(x: number): void {}
-  }
 }
 
 module.exports = A;
@@ -51,8 +50,7 @@ module.exports = C;
 var B = require(\"./B\");
 
 class C extends B {
-  foo(x: string): void {
+  foo(x: string): void {}
-  }
 }
 
 let c = new C();

tests/closure/__snapshots__/jsfmt.spec.js.snap

@@ -85,15 +85,13 @@ function local_meth() {
  * @flow
  */
 
-function takes_string(_: string) {
+function takes_string(_: string) {}
-}
 
 // global write from function
 //
 var global_x = \"hello\";
 
-function global_f() {
+function global_f() {}
-}
 function global_g() {
   global_x = 42;
 }
@@ -114,8 +112,7 @@ global_x = 42;
 function local_func() {
   var local_x = \"hello\";
 
-  function local_f() {
+  function local_f() {}
-  }
   function local_g() {
     local_x = 42;
   }
@@ -136,8 +133,7 @@ function local_func() {
 var global_y = \"hello\";
 
 var global_o = {
-  f: function() {
+  f: function() {},
-  },
   g: function() {
     global_y = 42;
   }
@@ -160,8 +156,7 @@ function local_meth() {
   var local_y = \"hello\";
 
   var local_o = {
-    f: function() {
+    f: function() {},
-    },
     g: function() {
       local_y = 42;
     }
@@ -268,8 +263,7 @@ call_me();
  */
 
 // global, anybody can call it at any time
-var call_me: () => void = () => {
+var call_me: () => void = () => {};
-};
 
 function g(x: ?number) {
   const const_x = x;

tests/comments/__snapshots__/jsfmt.spec.js.snap

@@ -113,8 +113,7 @@ function f(
   someReallyLongArgument: WithSomeLongType,
   // Trailing comment should stay after
   someReallyLongArgument2: WithSomeLongType
-) {
+) {}
-}
 
 // Comments should either stay at the end of the line or always before, but
 // not one before and one after.
@@ -314,8 +313,7 @@ function f(
   someReallyLongArgument: WithSomeLongType,
   // Trailing comment should stay after
   someReallyLongArgument2: WithSomeLongType
-) {
+) {}
-}
 
 // Comments should either stay at the end of the line or always before, but
 // not one before and one after.

tests/commonjs/__snapshots__/jsfmt.spec.js.snap

@@ -4,8 +4,7 @@ function f(x:string) { }
 
 module.exports = f;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function f(x: string) {
+function f(x: string) {}
-}
 
 module.exports = f;
 "

tests/computed_props/__snapshots__/jsfmt.spec.js.snap

@@ -4,8 +4,7 @@ exports[`test classes.js 1`] = `
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class c {
-  [\"i\"]() {
+  [\"i\"]() {}
-  }
 }
 "
 `;

tests/constructor/__snapshots__/jsfmt.spec.js.snap

@@ -10,13 +10,11 @@ class D {
 module.exports = C;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class C {
-  constructor() {
+  constructor() {}
-  }
 }
 
 class D {
-  constructor(): number {
+  constructor(): number {}
-  }
 }
 
 module.exports = C;

tests/destructuring/__snapshots__/jsfmt.spec.js.snap

@@ -218,17 +218,13 @@ var {
 (p: void);
 
 // error: string ~> void
-function obj_prop_err({ x: { y } } = null) {
+function obj_prop_err({ x: { y } } = null) {}
-}
 // error: property \`x\` cannot be accessed on null
-function obj_rest_err({ ...o } = 0) {
+function obj_rest_err({ ...o } = 0) {}
-}
 // error: expected object instead of number
-function arr_elem_err([ x ] = null) {
+function arr_elem_err([ x ] = null) {}
-}
 // error: element 0 cannot be accessed on null
-function arr_rest_err([ ...a ] = null) {
+function arr_rest_err([ ...a ] = null) {}
-}
 
 // error: expected array instead of null
 function gen<T>(x: T, { p = x }: { p: T }): T {
@@ -242,19 +238,14 @@ obj_prop_var(({}: { p?: { q?: null } }));
 
 // ok
 // union-like upper bounds preserved through destructuring
-function obj_prop_opt({ p }: { p?: string } = { p: 0 }) {
+function obj_prop_opt({ p }: { p?: string } = { p: 0 }) {}
-}
+function obj_prop_maybe({ p }: { p: ?string } = { p: 0 }) {}
-function obj_prop_maybe({ p }: { p: ?string } = { p: 0 }) {
+function obj_prop_union({ p }: { p: number | string } = { p: true }) {}
-}
-function obj_prop_union({ p }: { p: number | string } = { p: true }) {
-}
 
 // TODO: union-of-objects upper bounds preserved through destructuring
-function obj_prop_union2({ p }: { p: number } | { p: string } = { p: true }) {
+function obj_prop_union2({ p }: { p: number } | { p: string } = { p: true }) {}
-}
 
-function default_expr_scope({ a, b = a }) {
+function default_expr_scope({ a, b = a }) {}
-}
 "
 `;
 
@@ -360,11 +351,9 @@ bar({ x: \"\", y: 0 });
 var spread = { y: \"\" };
 var extend: { x: number, y: string, z: boolean } = { x: 0, ...spread };
 
-function qux(_: { a: number }) {
+function qux(_: { a: number }) {}
-}
 qux({ a: \"\" });
-function corge({ b }: { b: string }) {
+function corge({ b }: { b: string }) {}
-}
 corge({ b: 0 });
 
 var { n }: { n: number } = { n: \"\" };
@@ -484,35 +473,27 @@ function arr_rest_pattern<X>([ _, ...a ] : ArrRest<X>) { // a: [X]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 
-function obj_pattern<X>({ prop }: { prop: X }) {
+function obj_pattern<X>({ prop }: { prop: X }) {}
-}
 // prop: X
 type Prop<X> = { prop: X };
-function obj_pattern2<X>({ prop }: Prop<X>) {
+function obj_pattern2<X>({ prop }: Prop<X>) {}
-}
 
 // prop: X
-function arr_pattern<X>([ elem ]: X[]) {
+function arr_pattern<X>([ elem ]: X[]) {}
-}
 // elem: X
 type Elem<X> = X[];
-function arr_pattern2<X>([ elem ]: Elem<X>) {
+function arr_pattern2<X>([ elem ]: Elem<X>) {}
-}
 
 // elem: X
-function tup_pattern<X>([ proj ]: [X]) {
+function tup_pattern<X>([ proj ]: [X]) {}
-}
 // proj: X
 type Proj<X> = [X];
-function tup_pattern2<X>([ proj ]: Proj<X>) {
+function tup_pattern2<X>([ proj ]: Proj<X>) {}
-}
 
 // proj: X
-function rest_antipattern<T>(...t: T) {
+function rest_antipattern<T>(...t: T) {}
-}
 // nonsense
-function rest_pattern<X>(...r: X[]) {
+function rest_pattern<X>(...r: X[]) {}
-}
 
 // r: X[]
 function obj_rest_pattern<X>({ _, ...o }: { _: any, x: X }) {

tests/dom/__snapshots__/jsfmt.spec.js.snap

@@ -301,8 +301,7 @@ let tests = [
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 
-let listener: EventListener = function(event: Event): void {
+let listener: EventListener = function(event: Event): void {};
-};
 
 let tests = [
   // attachEvent
@@ -424,26 +423,16 @@ let tests = [
   function() {
     document.registerElement(\"custom-element\", {
       prototype: Object.create(HTMLElement.prototype, {
-        createdCallback: {
+        createdCallback: { value: function createdCallback() {} },
-          value: function createdCallback() {
+        attachedCallback: { value: function attachedCallback() {} },
-          }
+        detachedCallback: { value: function detachedCallback() {} },
-        },
-        attachedCallback: {
-          value: function attachedCallback() {
-          }
-        },
-        detachedCallback: {
-          value: function detachedCallback() {
-          }
-        },
         attributeChangedCallback: {
           value: function attributeChangedCallback(
             attributeLocalName,
             oldAttributeValue,
             newAttributeValue,
             attributeNamespace
-          ) {
+          ) {}
-          }
         }
       })
     });
@@ -452,19 +441,15 @@ let tests = [
   function() {
     document.registerElement(\"custom-element\", {
       prototype: Object.assign(Object.create(HTMLElement.prototype), {
-        createdCallback() {
+        createdCallback() {},
-        },
+        attachedCallback() {},
-        attachedCallback() {
+        detachedCallback() {},
-        },
-        detachedCallback() {
-        },
         attributeChangedCallback(
           attributeLocalName,
           oldAttributeValue,
           newAttributeValue,
           attributeNamespace
-        ) {
+        ) {}
-        }
       })
     });
   },
@@ -479,8 +464,7 @@ let tests = [
           newVal: string,
           // Error: This might be null
           namespace: string
-        ) {
+        ) {}
-        }
       }
     });
   }

tests/dump-types/__snapshots__/jsfmt.spec.js.snap

@@ -7,8 +7,7 @@ module.exports = num;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 var num = 42;
-function bar() {
+function bar() {}
-}
 bar();
 module.exports = num;
 "
@@ -39,8 +38,7 @@ const idxResult = idx(obj, obj => obj.a.b.c.d);
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 var num = require(\"./import\");
-function foo(x) {
+function foo(x) {}
-}
 foo(0);
 var a: string = num;
 

tests/duplicate_methods/__snapshots__/jsfmt.spec.js.snap

@@ -36,10 +36,8 @@ class C5 {
 new C5().m = new C5().m - 42;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class C1 {
-  m() {
+  m() {}
-  }
+  m() {}
-  m() {
-  }
 }
 
 new C1().m();
@@ -48,17 +46,14 @@ class C2 {
   get m() {
     return 42;
   }
-  m() {
+  m() {}
-  }
 }
 
 new C2().m();
 
 class C3 {
-  set m(x) {
+  set m(x) {}
-  }
+  m() {}
-  m() {
-  }
 }
 
 new C3().m();
@@ -67,20 +62,17 @@ class C4 {
   get m() {
     return 42;
   }
-  set m(x: number) {
+  set m(x: number) {}
-  }
 }
 
 new C4().m = new C4().m - 42;
 
 class C5 {
-  m() {
+  m() {}
-  }
   get m() {
     return 42;
   }
-  set m(x: number) {
+  set m(x: number) {}
-  }
 }
 
 new C5().m = new C5().m - 42;

tests/es6modules/__snapshots__/jsfmt.spec.js.snap

@@ -1350,8 +1350,7 @@ import {
 exports[`test export_default_arrow_expression.js 1`] = `
 "export default () => {};
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-export default () => {
+export default () => {};
-};
 "
 `;
 
@@ -1379,32 +1378,28 @@ export default (class foobar {});
 exports[`test export_default_function_declaration.js 1`] = `
 "export default function() {}
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-export default function() {
+export default function() {}
-}
 "
 `;
 
 exports[`test export_default_function_declaration_named.js 1`] = `
 "export default function f(){}
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-export default function f() {
+export default function f() {}
-}
 "
 `;
 
 exports[`test export_default_function_expression.js 1`] = `
 "export default (function() {});
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-export default (function() {
+export default (function() {});
-});
 "
 `;
 
 exports[`test export_default_function_expression_named.js 1`] = `
 "export default (function f(){})
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-export default (function f() {
+export default (function f() {});
-});
 "
 `;
 

tests/facebookisms/__snapshots__/jsfmt.spec.js.snap

@@ -79,8 +79,7 @@ let tests = [
   },
   // passed as a function
   function(copyProperties: Object$Assign) {
-    function x(cb: Function) {
+    function x(cb: Function) {}
-    }
     x(copyProperties);
   }
 ];
@@ -206,8 +205,7 @@ let tests = [
   },
   // passed as a function
   function(mergeInto: $Facebookism$MergeInto) {
-    function x(cb: Function) {
+    function x(cb: Function) {}
-    }
     x(mergeInto);
   }
 ];

tests/fetch/__snapshots__/jsfmt.spec.js.snap

@@ -122,8 +122,7 @@ for (let v of e.entries()) {
   const [ i, j ]: [string, string] = v; // correct
 }
 
-e.getAll(\"content-type\").forEach((v: string) => {
+e.getAll(\"content-type\").forEach((v: string) => {}); // correct
-}); // correct
 "
 `;
 
@@ -412,7 +411,6 @@ for (let v of e.entries()) {
   const [ i, j ]: [string, string] = v; // correct
 }
 
-e.getAll(\"key1\").forEach((v: string) => {
+e.getAll(\"key1\").forEach((v: string) => {}); // correct
-}); // correct
 "
 `;

tests/function/__snapshots__/jsfmt.spec.js.snap

@@ -317,8 +317,7 @@ function bad(x: Function, y: Object): void {
 
 let tests = [
   function(y: () => void, z: Function) {
-    function x() {
+    function x() {}
-    }
     (x.length: void);
     // error, it\'s a number
     (y.length: void);
@@ -333,8 +332,7 @@ let tests = [
     (z.name: void); // error, it\'s a string
   },
   function(y: () => void, z: Function) {
-    function x() {
+    function x() {}
-    }
     x.length = \"foo\";
     // error, it\'s a number
     y.length = \"foo\";
@@ -373,23 +371,14 @@ new (function() {});
 (function() {});
 a = function f() {} || b;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-(function() {
+(function() {}).length;
-}).length;
+typeof (function() {});
-typeof (function() {
+export default (function() {})();
-});
+(function() {})()\`\`;
-export default (function() {
+(function() {})\`\`;
-})();
+new (function() {})();
-(function() {
+(function() {});
-})()\`\`;
+a = function f() {} || b;
-(function() {
-})\`\`;
-new (function() {
-})();
-(function() {
-});
-a = function f() {
-} ||
-  b;
 "
 `;
 

tests/get-def2/__snapshots__/jsfmt.spec.js.snap

@@ -81,8 +81,7 @@ class D extends C {
 // @flow
 
 class C {
-  override() {
+  override() {}
-  }
 }
 
 class D extends C {
@@ -92,8 +91,7 @@ class D extends C {
   bar() {
     this.override;
   }
-  override() {
+  override() {}
-  }
 }
 "
 `;

tests/getters_and_setters_enabled/__snapshots__/jsfmt.spec.js.snap

@@ -79,19 +79,16 @@ class Foo {
   get propWithMatchingGetterAndSetter(): number {
     return 4;
   }
-  set propWithMatchingGetterAndSetter(x: number) {
+  set propWithMatchingGetterAndSetter(x: number) {}
-  }
 
   // The getter and setter need not have the same type - no error
   get propWithSubtypingGetterAndSetter(): ?number {
     return 4;
   }
-  set propWithSubtypingGetterAndSetter(x: number) {
+  set propWithSubtypingGetterAndSetter(x: number) {}
-  }
 
   // The getter and setter need not have the same type - no error
-  set propWithSubtypingGetterAndSetterReordered(x: number) {
+  set propWithSubtypingGetterAndSetterReordered(x: number) {}
-  }
   get propWithSubtypingGetterAndSetterReordered(): ?number {
     return 4;
   }
@@ -99,8 +96,7 @@ class Foo {
   get propWithMismatchingGetterAndSetter(): number {
     return 4;
   }
-  set propWithMismatchingGetterAndSetter(x: string) {
+  set propWithMismatchingGetterAndSetter(x: string) {}
-  }
 
   // doesn\'t match getter (OK)
   propOverriddenWithGetter: number;
@@ -109,8 +105,7 @@ class Foo {
   }
 
   propOverriddenWithSetter: number;
-  set propOverriddenWithSetter(x: string) {
+  set propOverriddenWithSetter(x: string) {}
-  }
 }
 
 var foo = new Foo();
@@ -231,17 +226,14 @@ var obj = {
   get propWithMatchingGetterAndSetter(): number {
     return 4;
   },
-  set propWithMatchingGetterAndSetter(x: number) {
+  set propWithMatchingGetterAndSetter(x: number) {},
-  },
   // The getter and setter need not have the same type
   get propWithSubtypingGetterAndSetter(): ?number {
     return 4;
   },
   // OK
-  set propWithSubtypingGetterAndSetter(x: number) {
+  set propWithSubtypingGetterAndSetter(x: number) {},
-  },
+  set propWithSubtypingGetterAndSetterReordered(x: number) {},
-  set propWithSubtypingGetterAndSetterReordered(x: number) {
-  },
   // OK
   get propWithSubtypingGetterAndSetterReordered(): ?number {
     return 4;
@@ -249,10 +241,8 @@ var obj = {
   get exampleOfOrderOfGetterAndSetter(): A {
     return new A();
   },
-  set exampleOfOrderOfGetterAndSetter(x: B) {
+  set exampleOfOrderOfGetterAndSetter(x: B) {},
-  },
+  set exampleOfOrderOfGetterAndSetterReordered(x: B) {},
-  set exampleOfOrderOfGetterAndSetterReordered(x: B) {
-  },
   get exampleOfOrderOfGetterAndSetterReordered(): A {
     return new A();
   }
@@ -430,8 +420,7 @@ class Base {
 
 (class extends Base {
   // error: setter incompatible with read/write property
-  set x(value: B): void {
+  set x(value: B): void {}
-  }
 });
 
 (class extends Base {
@@ -439,14 +428,12 @@ class Base {
   get x(): C {
     return c;
   }
-  set x(value: A): void {
+  set x(value: A): void {}
-  }
 });
 
 (class extends Base {
   // error: setter incompatible with read-only property
-  set pos(value: B): void {
+  set pos(value: B): void {}
-  }
 });
 
 (class extends Base {
@@ -465,8 +452,7 @@ class Base {
 
 (class extends Base {
   // ok: setter contravariant with write-only property
-  set neg(value: A): void {
+  set neg(value: A): void {}
-  }
 });
 
 (class extends Base {

tests/init/__snapshots__/jsfmt.spec.js.snap

@@ -53,48 +53,42 @@ function _for_of(arr: Array<number>) {
 
 function _if(b: () => boolean) {
   if (b()) {
-    var f = function() {
+    var f = function() {};
-    };
   }
   f(); // error, possibly undefined
 }
 
 function _while(b: () => boolean) {
   while (b()) {
-    var f = function() {
+    var f = function() {};
-    };
   }
   f(); // error, possibly undefined
 }
 
 function _do_while(b: () => boolean) {
   do {
-    var f = function() {
+    var f = function() {};
-    };
   } while (b());
   f(); // ok
 }
 
 function _for(n: number) {
   for (var i = 0; i < n; i++) {
-    var f = function() {
+    var f = function() {};
-    };
   }
   f(); // error, possibly undefined
 }
 
 function _for_in(obj: Object) {
   for (var p in obj) {
-    var f = function() {
+    var f = function() {};
-    };
   }
   f(); // error, possibly undefined
 }
 
 function _for_of(arr: Array<number>) {
   for (var x of arr) {
-    var f = function() {
+    var f = function() {};
-    };
   }
   f(); // error, possibly undefined
 }

tests/interface/__snapshots__/jsfmt.spec.js.snap

@@ -190,13 +190,11 @@ declare class C {
 new C().bar((x: string) => { }); // error, number ~/~> string
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 interface I { foo(x: number): void }
-(function foo(x: number) {
+(function foo(x: number) {}: I);
-}: I);
 
 // error, property \`foo\` not found function
 declare class C { bar(i: I): void, bar(f: (x: number) => void): void }
 
-new C().bar((x: string) => {
+new C().bar((x: string) => {}); // error, number ~/~> string
-}); // error, number ~/~> string
 "
 `;

tests/iter/__snapshots__/jsfmt.spec.js.snap

@@ -38,8 +38,7 @@ for (var y in this) {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 var a = [ true, false ];
-function foo(x) {
+function foo(x) {}
-}
 
 for (var i = 0; i < 3; i++) {
   foo(a[i]);

tests/literal/__snapshots__/jsfmt.spec.js.snap

@@ -37,14 +37,12 @@ var red:string = tuple[indices.red]; // error: tuple[0] is a number
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 var APIKeys = require(\"./enum\");
 // object that maps \"AGE\" to \"age\", \"NAME\" to \"name\"
-function foo(x: $Keys<typeof APIKeys>) {
+function foo(x: $Keys<typeof APIKeys>) {}
-}
 foo(\"AGE\");
 foo(\"LOCATION\");
 
 // error
-function bar(x: $Keys<{ age: number }>) {
+function bar(x: $Keys<{ age: number }>) {}
-}
 bar(APIKeys.AGE);
 // not an error: APIKeys.AGE = \"age\"
 bar(APIKeys.NAME);

tests/locals/__snapshots__/jsfmt.spec.js.snap

@@ -159,8 +159,7 @@ var x: string = 0;
 var x: number = 1;
 
 //declare var T: $Type<number | Array<T>>;
-function foo(p: boolean) {
+function foo(p: boolean) {}
-}
 
 function sorry(really: boolean) {
   if (really) {

tests/method_properties/__snapshots__/jsfmt.spec.js.snap

@@ -36,12 +36,9 @@ function f(x) {
 f(foo);
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class C {
-  C() {
+  C() {}
-  }
+  foo() {}
-  foo() {
+  static bar() {}
-  }
-  static bar() {
-  }
   qux() {
     this.constructor.x;
   }

tests/misc/__snapshots__/jsfmt.spec.js.snap

@@ -21,8 +21,7 @@ module.exports = {};
 var A = { x: true, ...{} };
 module.exports.cls = A;
 
-function f(x: boolean) {
+function f(x: boolean) {}
-}
 module.exports.fn = f;
 
 A.y = \"?\";
@@ -147,8 +146,7 @@ module.exports = {obj: o};
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @providesModule E */
 
-function h(x: number) {
+function h(x: number) {}
-}
 var proto = { fn: h };
 
 var o = Object.create(proto);

tests/modules/__snapshots__/jsfmt.spec.js.snap

@@ -41,8 +41,7 @@ module.exports = f;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
 
-function g(x: string) {
+function g(x: string) {}
-}
 
 //function f(x) { g(x); return x; }
 //function f(x:number) { g(x); return x; }

tests/more_annot/__snapshots__/jsfmt.spec.js.snap

@@ -42,8 +42,7 @@ var o2: Foo = new Foo();
 function Foo() {
   this.x = 0;
 }
-Foo.prototype.m = function() {
+Foo.prototype.m = function() {};
-};
 
 var o1: { x: number, m(): void } = new Foo();
 
@@ -58,8 +57,7 @@ class D extends C { }
 var d: { +m: () => void } = new D();
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class C {
-  m() {
+  m() {}
-  }
 }
 class D extends C {}
 

tests/more_classes/__snapshots__/jsfmt.spec.js.snap

@@ -121,8 +121,7 @@ class Qux {
     return this.w;
   }
 
-  fooqux(x: number) {
+  fooqux(x: number) {}
-  }
 }
 
 module.exports = Qux;

tests/more_path/__snapshots__/jsfmt.spec.js.snap

@@ -59,8 +59,7 @@ module.exports = true;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @providesModule Condition */
 
-function f(x: number) {
+function f(x: number) {}
-}
 function g() {
   return 42 || \"hello\";
 }
@@ -86,8 +85,7 @@ function bar() {
 }
 
 class C {
-  qux() {
+  qux() {}
-  }
 }
 
 function foo() {
@@ -140,8 +138,7 @@ module.exports = FlowSA;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @providesModule FlowSA */
 
-function check(x: string) {
+function check(x: string) {}
-}
 
 function FlowSA() {
   var x = 0;
@@ -198,18 +195,15 @@ module.exports = \"sigma\";
 /* @providesModule Sigma */
 
 class A {
-  a() {
+  a() {}
-  }
 }
 
 class B extends A {
-  b() {
+  b() {}
-  }
 }
 
 class C extends B {
-  c() {
+  c() {}
-  }
 }
 
 function bar(x: B) {
@@ -234,8 +228,7 @@ function foo(x: A) {
 }
 
 class D {
-  d() {
+  d() {}
-  }
 }
 
 function baz(x: D) {

tests/namespace/__snapshots__/jsfmt.spec.js.snap

@@ -31,8 +31,7 @@ module.exports = { foo: (\"\": number) };
 /*@flow*/
 // import type { T } from \'...\'
 type T = (x: number) => void;
-var f: T = function(x: string): void {
+var f: T = function(x: string): void {};
-};
 
 type Map<X, Y> = (x: X) => Y;
 

tests/node_tests/stream/__snapshots__/jsfmt.spec.js.snap

@@ -44,18 +44,14 @@ var data = \"foo\";
 
 ls.stdin.write(data);
 ls.stdin.write(data, \"utf-8\");
-ls.stdin.write(data, () => {
+ls.stdin.write(data, () => {});
-});
+ls.stdin.write(data, \"utf-8\", () => {});
-ls.stdin.write(data, \"utf-8\", () => {
-});
 
 ls.stdin.end();
 ls.stdin.end(data);
 ls.stdin.end(data, \"utf-8\");
-ls.stdin.end(data, () => {
+ls.stdin.end(data, () => {});
-});
+ls.stdin.end(data, \"utf-8\", () => {});
-ls.stdin.end(data, \"utf-8\", () => {
-});
 
 var ws = fs.createWriteStream(\"/dev/null\");
 ls.stdout.pipe(ws).end();

tests/nullable/__snapshots__/jsfmt.spec.js.snap

@@ -42,11 +42,9 @@ function bar(): ?string {
   return null;
 }
 
-function qux(x: string) {
+function qux(x: string) {}
-}
 
-function corge(x: number) {
+function corge(x: number) {}
-}
 
 var x = bar();
 // x: ?string
@@ -76,15 +74,12 @@ bar(\'hmm\');
 function fn(data: ?{}) {}
 fn({some: \'literal\'});
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function foo(x: ?string) {
+function foo(x: ?string) {}
-}
+function bar(x: ?number) {}
-function bar(x: ?number) {
-}
 foo(\"hmm\");
 bar(\"hmm\");
 
-function fn(data: ?{}) {
+function fn(data: ?{}) {}
-}
 fn({ some: \"literal\" });
 "
 `;

tests/object_api/__snapshots__/jsfmt.spec.js.snap

@@ -4,10 +4,7 @@ exports[`test a.js 1`] = `
 module.exports = { a() {} };~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
 
-module.exports = {
+module.exports = { a() {} };
-  a() {
-  }
-};
 "
 `;
 
@@ -22,14 +19,7 @@ module.exports = b;
 /* @flow */
 
 var a = require(\"./a\");
-var b = Object.assign(
+var b = Object.assign({ bar() {}, ...{} }, a);
-  {
-    bar() {
-    },
-    ...{}
-  },
-  a
-);
 b.a();
 // works here
 module.exports = b;
@@ -207,8 +197,7 @@ var any: Object = {};
 // error, Array<string>
 class Foo {
   prop: string;
-  foo() {
+  foo() {}
-  }
 }
 // constructor and foo not enumerable
 (Object.keys(new Foo()): Array<\"error\">);
@@ -216,8 +205,7 @@ class Foo {
 // error: prop ~> error
 class Bar extends Foo {
   bar_prop: string;
-  bar() {
+  bar() {}
-  }
 }
 // only own enumerable props
 (Object.keys(new Bar()): Array<\"error\">); // error: bar_prop ~> error
@@ -411,14 +399,10 @@ var k : Object = a.constructor;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
 
-function takesABool(x: boolean) {
+function takesABool(x: boolean) {}
-}
+function takesAString(x: string) {}
-function takesAString(x: string) {
+function takesANumber(x: number) {}
-}
+function takesAnObject(x: Object) {}
-function takesANumber(x: number) {
-}
-function takesAnObject(x: Object) {
-}
 
 class Foo {}
 
@@ -473,8 +457,7 @@ takesAString(y.toString());
 // ... on a primitive
 (123).toString();
 (123).toString;
-(123).toString = function() {
+(123).toString = function() {};
-};
 // error
 (123).toString(2);
 (123).toString(\"foo\");

tests/object_freeze/__snapshots__/jsfmt.spec.js.snap

@@ -39,8 +39,7 @@ bliffl.corge;
 // error
 bliffl.constructor = baz;
 // error
-bliffl.toString = function() {
+bliffl.toString = function() {};
-};
 
 // error
 baz.baz = 0;

tests/optional/__snapshots__/jsfmt.spec.js.snap

@@ -27,12 +27,10 @@ class C {
   x<T>(x: T = 0) {}
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function x<T>(x: T = 0) {
+function x<T>(x: T = 0) {}
-}
 
 class C {
-  x<T>(x: T = 0) {
+  x<T>(x: T = 0) {}
-  }
 }
 "
 `;
@@ -267,8 +265,7 @@ function testOptionalNullableProperty(obj: { x?: ?string }): string {
 }
 
 function testOptionalNullableFlowingToNullable(x?: ?string): ?string {
-  var f = function(y: ?string) {
+  var f = function(y: ?string) {};
-  };
   f(x);
 }
 "
@@ -298,8 +295,7 @@ function bar(x = \"bar\"): string {
 }
 bar(undefined); // ok
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function foo(x?: number) {
+function foo(x?: number) {}
-}
 foo(undefined);
 
 // ok

tests/optional_props/__snapshots__/jsfmt.spec.js.snap

@@ -24,8 +24,7 @@ y = o;
 o.foo = 0;
 
 // future widening is constrained
-function bar(config: { foo?: number }) {
+function bar(config: { foo?: number }) {}
-}
 bar({});
 bar({ foo: \"\" });
 "

tests/predicates-parsing/__snapshots__/jsfmt.spec.js.snap

@@ -24,8 +24,7 @@ function f6(x: mixed): %checks (x !== null) {  }
 
 // Error: no return statement
 
-function f6(x: mixed): %checks(x !== null) {
+function f6(x: mixed): %checks(x !== null) {}
-}
 "
 `;
 

tests/promises/__snapshots__/jsfmt.spec.js.snap

@@ -589,8 +589,7 @@ Promise
 // TODO: resolvedPromise<T> -> catch() -> then():T
 Promise
   .resolve(0)
-  .catch(function(err) {
+  .catch(function(err) {})
-  })
   .then(function(num) {
     var a: number = num;
 

tests/react/__snapshots__/jsfmt.spec.js.snap

@@ -197,18 +197,8 @@ var Example = React.createClass({
   propTypes: { func: React.PropTypes.func.isRequired }
 });
 
-var ok_void = (
+var ok_void = <Example func={() => {}} />;
-  <Example
+var ok_args = <Example func={x => {}} />;
-    func={() => {
-    }}
-  />
-);
-var ok_args = (
-  <Example
-    func={x => {
-    }}
-  />
-);
 var ok_retval = <Example func={() => 1} />;
 
 var fail_mistyped = <Example func={2} />;

tests/react_functional/__snapshots__/jsfmt.spec.js.snap

@@ -15,8 +15,7 @@ var Z = 0;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 import React from \"react\";
 
-function F(props: { foo: string }) {
+function F(props: { foo: string }) {}
-}
 <F />;
 /* error: missing \`foo\`*/
 <F foo={0} />;
@@ -25,8 +24,7 @@ function F(props: { foo: string }) {
 
 // ok
 // props subtyping is property-wise covariant
-function G(props: { foo: string | numner }) {
+function G(props: { foo: string | numner }) {}
-}
 <G foo=\"\" />;
 
 // ok

tests/recheck/__snapshots__/jsfmt.spec.js.snap

@@ -130,8 +130,7 @@ export function foo(props: { x: number }) { }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 
-export function foo(props: { x: number }) {
+export function foo(props: { x: number }) {}
-}
 "
 `;
 

tests/recheck/tmp2c/__snapshots__/jsfmt.spec.js.snap

@@ -5,7 +5,6 @@ export function foo(props: { y: number }) { }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 
-export function foo(props: { y: number }) {
+export function foo(props: { y: number }) {}
-}
 "
 `;

tests/refinements/__snapshots__/jsfmt.spec.js.snap

@@ -208,8 +208,7 @@ function testLiteralProperty(a: A) {
 
 type A = { \"b_c\": ?string };
 
-function stuff(str: string) {
+function stuff(str: string) {}
-}
 
 function testProperty(a: A) {
   if (a.b_c) {
@@ -601,8 +600,7 @@ function def_assign_setprop_nohavoc(obj: Obj, obj2: Obj2) {
 
 type Obj = { p: number | string };
 
-function f() {
+function f() {}
-}
 
 function def_assign_function_havoc(obj: Obj) {
   obj.p = 10;
@@ -799,8 +797,7 @@ function foo5() {
     o.p();
   }
   function _foo5() {
-    o.p = function() {
+    o.p = function() {};
-    };
   }
 }
 
@@ -958,10 +955,8 @@ function arr0(x: mixed) {
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
 
-function takesNumber(x: number) {
+function takesNumber(x: number) {}
-}
+function takesString(x: string) {}
-function takesString(x: string) {
-}
 
 function num(x: mixed) {
   if (typeof x === \"number\") {
@@ -1726,8 +1721,7 @@ function bar(b) {
   var z: string = x;
 }
 
-function maybe_throw() {
+function maybe_throw() {}
-}
 function qux() {
   var x = 0;
   try {

tests/replace/__snapshots__/jsfmt.spec.js.snap

@@ -7,8 +7,7 @@ foo(\"\");
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 var a = 0;
 
-function foo(x) {
+function foo(x) {}
-}
 
 foo(\"\");
 "

tests/require/__snapshots__/jsfmt.spec.js.snap

@@ -74,8 +74,7 @@ require(\"not a module name\");
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 
-function require() {
+function require() {}
-}
 require(\"not a module name\");
 "
 `;
@@ -132,10 +131,8 @@ require.call(null, \"DoesNotExist\");
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
 
-function takesANumber(num: number): void {
+function takesANumber(num: number): void {}
-}
+function takesAString(str: string): void {}
-function takesAString(str: string): void {
-}
 
 // @providesModule
 var A = require(\"A\");

tests/requireLazy/__snapshots__/jsfmt.spec.js.snap

@@ -86,8 +86,7 @@ var notB: Object = B;
 
 requireLazy();
 // Error: No args
-requireLazy([ nope ], function() {
+requireLazy([ nope ], function() {});
-});
 // Error: Non-stringliteral args
 requireLazy([ \"A\" ]); // Error: No calback expression
 "

tests/rest/__snapshots__/jsfmt.spec.js.snap

@@ -27,8 +27,7 @@ declare class C {
 function f(
   superSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperSuperLong,
   ...args
-) {
+) {}
-}
 
 declare class C {
   f(

tests/return/__snapshots__/jsfmt.spec.js.snap

@@ -37,8 +37,7 @@ module.exports = C;
 //module.exports = fn;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class C {
-  foo() {
+  foo() {}
-  }
   bar() {
     return;
   }

tests/return_new/__snapshots__/jsfmt.spec.js.snap

@@ -24,8 +24,7 @@ function Bar() {
 var bar: number = new Bar();
 
 // error (returns new object)
-function Qux() {
+function Qux() {}
-}
 var qux: number = new Qux();
 
 // error (returns new object)

tests/sealed/__snapshots__/jsfmt.spec.js.snap

@@ -41,8 +41,7 @@ var export_o: { x:any; } = o; // awkward type cast
 
 module.exports = export_o;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function Foo() {
+function Foo() {}
-}
 var o = new Foo();
 var x: number = o.x;
 

tests/shebang/__snapshots__/jsfmt.spec.js.snap

@@ -3,8 +3,7 @@ exports[`test shebang.js 1`] = `
 function a() {}
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #!/usr/bin/env node
-function a() {
+function a() {}
-}
 "
 `;
 
@@ -15,7 +14,6 @@ function a() {}
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 #!/usr/bin/env node
 
-function a() {
+function a() {}
-}
 "
 `;

tests/singleton/__snapshots__/jsfmt.spec.js.snap

@@ -127,8 +127,7 @@ bar(3);
 
 // error
 type ComparatorResult = -1 | 0 | 1;
-function sort(fn: (x: any, y: any) => ComparatorResult) {
+function sort(fn: (x: any, y: any) => ComparatorResult) {}
-}
 sort((x, y) => -1);
 "
 `;

tests/spread/__snapshots__/jsfmt.spec.js.snap

@@ -74,8 +74,7 @@ foo({foo: 42});
 function foo(o) {
   bar({ ...o });
 }
-function bar(_: { foo: number }) {
+function bar(_: { foo: number }) {}
-}
 foo({ foo: 42 });
 "
 `;
@@ -119,8 +118,7 @@ function test(...nums: Array<number>) {}
 test(0, ...[1, 2, 3]);
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
-function test(...nums: Array<number>) {
+function test(...nums: Array<number>) {}
-}
 
 test(0, ...[ 1, 2, 3 ]);
 "

tests/statics/__snapshots__/jsfmt.spec.js.snap

@@ -10,8 +10,7 @@ C.g(0);
 var x:number = C.x;
 C.x = 0;~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class C {
-  static f(x: number) {
+  static f(x: number) {}
-  }
   static x: string;
 }
 
@@ -32,8 +31,7 @@ C.g = function(x) { return x; };
 
 var x:string = new C().f();
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function C() {
+function C() {}
-}
 C.prototype.f = function() {
   return C.g(0);
 };

tests/strict/__snapshots__/jsfmt.spec.js.snap

@@ -15,8 +15,7 @@ class B extends A {
   foo(x: A): A {
     return x;
   }
-  bar(x) {
+  bar(x) {}
-  }
   qux<X, Y>(x: X, y: Y): X {
     return x;
   }

tests/super/__snapshots__/jsfmt.spec.js.snap

@@ -223,8 +223,7 @@ class I_ {
   constructor(leaked_this) {
     leaked_this.foo();
   }
-  foo() {
+  foo() {}
-  }
 }
 class I extends I_ {
   constructor() {
@@ -238,8 +237,7 @@ class J_ extends J__ {
     closure_leaking_this();
     super();
   }
-  foo() {
+  foo() {}
-  }
 }
 class J extends J_ {
   constructor() {
@@ -257,8 +255,7 @@ class K_ {
   constructor(closure_leaking_this) {
     this.closure_leaking_this = closure_leaking_this;
   }
-  foo() {
+  foo() {}
-  }
 }
 class K extends K_ {
   constructor() {
@@ -362,13 +359,11 @@ class B extends A {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 class A {
-  constructor(x: number) {
+  constructor(x: number) {}
-  }
   static staticMethod(x: string): string {
     return x;
   }
-  f(x: string) {
+  f(x: string) {}
-  }
 }
 
 class B extends A {

tests/suppress/__snapshots__/jsfmt.spec.js.snap

@@ -74,8 +74,7 @@ function runTest(y: number): void {
   );
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function takesAString(x: string): void {
+function takesAString(x: string): void {}
-}
 
 function runTest(y: number): void {
   takesAString(

tests/tabWith/__snapshots__/jsfmt.spec.js.snap

@@ -61,8 +61,7 @@ function a() {
   }
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-const c = () => {
+const c = () => {};
-};
 
 function a() {
   return function b() {
@@ -89,8 +88,7 @@ function a() {
   }
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-const c = () => {
+const c = () => {};
-};
 
 function a() {
     return function b() {

tests/template/__snapshots__/jsfmt.spec.js.snap

@@ -88,8 +88,7 @@ function* f() {
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // \"ArrowFunctionExpression\"
-(() => {
+(() => {})\`\`;
-})\`\`;
 
 // \"AssignmentExpression\"
 (b = c)\`\`;
@@ -112,8 +111,7 @@ b()\`\`;
 (b ? c : d)\`\`;
 
 // \"FunctionExpression\"
-(function() {
+(function() {})\`\`;
-})\`\`;
 
 // \"LogicalExpression\"
 (b || c)\`\`;

tests/this/__snapshots__/jsfmt.spec.js.snap

@@ -69,8 +69,7 @@ F.prototype.m = function() {
   this.y = 0;
 };
 
-function foo(p: string) {
+function foo(p: string) {}
-}
 
 var o1 = new F();
 // sets o1.x to 0
@@ -199,8 +198,7 @@ var j = g();
 
 // error, since return type of bar is C, not the type of \`this\`
 class E {
-  foo(x: number) {
+  foo(x: number) {}
-  }
 }
 class F extends E {
   foo() {

tests/this_type/__snapshots__/jsfmt.spec.js.snap

@@ -90,13 +90,11 @@ var d = new D();
 
 // sneaky
 class A {
-  foo<X: this>(that: X) {
+  foo<X: this>(that: X) {} // error: can\'t hide contravariance using a bound
-  } // error: can\'t hide contravariance using a bound
 }
 
 class B extends A {
-  foo<Y: this>(that: Y) {
+  foo<Y: this>(that: Y) {} // error (see above, catches hidden override)
-  } // error (see above, catches hidden override)
 }
 
 // covariance checks on this type in invariant positions
@@ -104,15 +102,13 @@ class Invariant {
   out_object(): { _: this } {
     return { _: this };
   }
-  in_object(_: { _: this }) {
+  in_object(_: { _: this }) {}
-  }
   inout_object: { _: this };
 
   out_array(): Array<this> {
     return [ this ];
   }
-  in_array(_: Array<this>) {
+  in_array(_: Array<this>) {}
-  }
   inout_array: Array<this>;
 }
 
@@ -122,16 +118,14 @@ class Misc {
   out_set(): Set<this> {
     return new Set().add(this);
   }
-  in_set(_: Set<this>) {
+  in_set(_: Set<this>) {}
-  }
   inout_set: Set<this>;
 
   // Promise<X> has covariant X
   async out_promise(): Promise<this> {
     return this;
   }
-  in_promise(_: Promise<this>) {
+  in_promise(_: Promise<this>) {}
-  }
   inout_promise: Promise<this>;
 
   // Generator<X,Y,Z> has covariant X, covariant Y, contravariant Z
@@ -139,8 +133,7 @@ class Misc {
     yield this;
     return this;
   }
-  in_generator(_: Generator<this, this, this>) {
+  in_generator(_: Generator<this, this, this>) {}
-  }
   inout_generator: Generator<this, this, this>;
 }
 "
@@ -529,10 +522,8 @@ class Base2 {
     return this.bar();
   }
 
-  corge(that: this) {
+  corge(that: this) {}
-  }
+  grault(that: Base2) {}
-  grault(that: Base2) {
-  }
 }
 
 class Inherit2 extends Base2 {}
@@ -552,12 +543,10 @@ class Override2 extends Base2 {
   }
   // error (cf. OK above)
   // see exploit below
-  corge(that: this) {
+  corge(that: this) {}
-  }
   // error
   // see exploit below
-  grault(that: this) {
+  grault(that: this) {} // error, too
-  } // error, too
 }
 
 class InheritOverride2 extends Override2 {}

tests/traces/__snapshots__/jsfmt.spec.js.snap

@@ -21,24 +21,21 @@ function double(n) { return n * 2 }
 f3(double);
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // arg/param type mismatch on arg 0
-function g0(y: string) {
+function g0(y: string) {}
-}
 function f0(x) {
   g0(x);
 }
 f0(0);
 
 // ...on arg n
-function g1(a: string, b: string) {
+function g1(a: string, b: string) {}
-}
 function f1(x, y) {
   g1(x, y);
 }
 f1(\"hey\", 0);
 
 // h/o call with function expr
-function g2(ylam: (s: string) => number) {
+function g2(ylam: (s: string) => number) {}
-}
 function f2(xlam) {
   g2(xlam);
 }
@@ -47,8 +44,7 @@ f2(function(x) {
 });
 
 // h/o call with function def
-function g3(ylam: (s: string) => number) {
+function g3(ylam: (s: string) => number) {}
-}
 function f3(xlam) {
   g3(xlam);
 }

tests/trailingComma/__snapshots__/jsfmt.spec.js.snap

@@ -11,8 +11,7 @@ a(
 
 a(\'value\', \'value2\', a(\'long-nested-value\', \'long-nested-value2\', \'long-nested-value3\'));
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-const a = (param1, param2, param3) => {
+const a = (param1, param2, param3) => {};
-};
 
 a(\"value\", \"value2\", \"value3\");
 
@@ -43,8 +42,7 @@ a(
 
 a(\'value\', \'value2\', a(\'long-nested-value\', \'long-nested-value2\', \'long-nested-value3\'));
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-const a = (param1, param2, param3) => {
+const a = (param1, param2, param3) => {};
-};
 
 a(\"value\", \"value2\", \"value3\");
 

tests/try/__snapshots__/jsfmt.spec.js.snap

@@ -196,8 +196,7 @@ function f(b) {
 
 // for illustrative purposes only - Flow considers a throw possible
 // anywhere within a block
-function might_throw() {
+function might_throw() {}
-}
 
 // local use of annotated var within try is ok
 function f() {

tests/tuples/__snapshots__/jsfmt.spec.js.snap

@@ -49,8 +49,7 @@ foo([ {} ]); // error, too few elements in array passed to a tuple
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 /* @flow */
 
-function foo(a: [Object, Object]) {
+function foo(a: [Object, Object]) {}
-}
 
 foo([ {} ]); // error, too few elements in array passed to a tuple
 "

tests/type-at-pos/__snapshots__/jsfmt.spec.js.snap

@@ -59,10 +59,7 @@ const y = {
 //   foo(): void {}
 // }
 
-const y = {
+const y = { bar(): void {} };
-  bar(): void {
-  }
-};
 "
 `;
 
@@ -135,8 +132,7 @@ module.exports = num;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 var num = 42;
-function bar() {
+function bar() {}
-}
 bar();
 module.exports = num;
 "
@@ -254,8 +250,7 @@ const w:MyNum = 42;
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // @flow
 var str = require(\"./import\");
-function foo() {
+function foo() {}
-}
 foo();
 str;
 

tests/type_param_scope/__snapshots__/jsfmt.spec.js.snap

@@ -15,8 +15,7 @@ class C<T> {
     this.b(a); // error: A ~> incompatible instance of T
   }
 
-  b(x: T) {
+  b(x: T) {}
-  }
 }
 "
 `;
@@ -37,8 +36,7 @@ f(0); // ok
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 function f<T>(a: T) {
   function g<U>(b: U, c: T = a) {
-    function h(d: U = b) {
+    function h(d: U = b) {}
-    }
     h();
     // ok
     h(b);

tests/undefined/__snapshots__/jsfmt.spec.js.snap

@@ -23,8 +23,7 @@ function doSomethingAsync(): Promise<void> {
 }
 
 // simpler repro to show that too few args are fine when expecting void
-function foo(x: void) {
+function foo(x: void) {}
-}
 foo();
 "
 `;
@@ -52,8 +51,7 @@ function bar() {
   if (x) x.bar();
 }
 
-function qux(x?: number, y: string = \"\", z) {
+function qux(x?: number, y: string = \"\", z) {}
-}
 "
 `;
 

tests/union/__snapshots__/jsfmt.spec.js.snap

@@ -110,27 +110,8 @@ myclass.myfun([\"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", function (ar) {}
 declare class Myclass { myfun(myarray: Array<Function | string>): any }
 declare var myclass: Myclass;
 
-myclass.myfun([
+myclass.myfun([ \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", function(ar) {} ]);
-  \"1\",
+myclass.myfun([ \"1\", \"2\", \"3\", \"4\", \"5\", \"6\", \"7\", function(ar) {} ]);
-  \"2\",
-  \"3\",
-  \"4\",
-  \"5\",
-  \"6\",
-  function(ar) {
-  }
-]);
-myclass.myfun([
-  \"1\",
-  \"2\",
-  \"3\",
-  \"4\",
-  \"5\",
-  \"6\",
-  \"7\",
-  function(ar) {
-  }
-]);
 "
 `;
 
@@ -343,8 +324,7 @@ type Foo<X: ?C> = Array<X>;
 // workaround
 var x: Array<C> = [];
 var y: Array<?C> = [];
-function foo<X>(x: Foo<X>) {
+function foo<X>(x: Foo<X>) {}
-}
 foo(x);
 foo(y);
 
@@ -356,8 +336,7 @@ type Bar = () => C | string;
 function f() {
   return \"\";
 }
-function bar(x: Bar) {
+function bar(x: Bar) {}
-}
 bar(f);
 "
 `;
@@ -431,8 +410,7 @@ function corge(b) {
     new F().foo(x);
 }
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-function bar(x: Document | string): void {
+function bar(x: Document | string): void {}
-}
 bar(0);
 
 class C {}
@@ -441,11 +419,9 @@ function CD(b) {
   var E = b ? C : D;
   var c: C = new E();
   // error, since E could be D, and D is not a subtype of C
-  function qux(e: E) {
+  function qux(e: E) {}
-  }
   // this annotation is an error: is it C, or is it D?
-  function qux2(e: C | D) {
+  function qux2(e: C | D) {}
-  }
   // OK
   qux2(new C());
 }

tests/union_new/__snapshots__/jsfmt.spec.js.snap

@@ -155,8 +155,7 @@ function node(content: ?Foobar | String | Array<String>) {
 /* @flow */
 import type { Foobar } from \"./issue-1455-helper\";
 
-function create(content: ?Foobar | String | Array<String>) {
+function create(content: ?Foobar | String | Array<String>) {}
-}
 
 function node(content: ?Foobar | String | Array<String>) {
   create(content);
@@ -490,8 +489,7 @@ type B4 = string;
 /////////////////////////////////////////////
 // similar example with class instance types
 /////////////////////////////////////////////
-function inst(a: A5 | A6) {
+function inst(a: A5 | A6) {}
-}
 
 class B5 {}
 class B6 {}
@@ -591,8 +589,7 @@ type B6 = string;
 // example with object types
 //////////////////////////////
 
-function obj(a: { x: number } | { x: string }) {
+function obj(a: { x: number } | { x: string }) {}
-}
 
 obj(({ x: \"\" }: A1));
 
@@ -603,8 +600,7 @@ type B1 = string;
 ///////////////////////////////////////
 // similar example with function types
 ///////////////////////////////////////
-function fun(a: (() => number) | (() => string)) {
+function fun(a: (() => number) | (() => string)) {}
-}
 
 fun((() => \"\": A2));
 
@@ -617,8 +613,7 @@ type B2 = string;
 /////////////////////////////////////////////////////
 class C<X> {}
 
-function inst(a: C<number> | C<string>) {
+function inst(a: C<number> | C<string>) {}
-}
 
 inst((new C(): A3));
 
@@ -629,12 +624,8 @@ type B3 = string;
 /////////////////////////////////////////////
 // similar example with generic type aliases
 /////////////////////////////////////////////
-function alias(a: T<number> | T<string>) {
+function alias(a: T<number> | T<string>) {}
-}
+alias({ x: (x: V<B4>) => {} });
-alias({
-  x: (x: V<B4>) => {
-  }
-});
 
 type T<X> = { x: U<X> };
 type U<X> = (x: V<X>) => void;
@@ -643,8 +634,7 @@ type V<X> = X;
 type B4 = string;
 
 // class statics
-function stat(a: { x: number } | { x: string }) {
+function stat(a: { x: number } | { x: string }) {}
-}
 
 class D {
   static x: B5;
@@ -655,8 +645,7 @@ stat(D);
 type B5 = string;
 
 // tuples
-function tup(a: [number, boolean] | [string, boolean]) {
+function tup(a: [number, boolean] | [string, boolean]) {}
-}
 
 tup(([ \"\", false ]: A6));
 
@@ -706,13 +695,9 @@ type B2 = string;
 // example with function types
 ///////////////////////////////
 
-function fun(a: ((x: number) => void) | ((x: string) => void)) {
+function fun(a: ((x: number) => void) | ((x: string) => void)) {}
-}
 
-fun(
+fun((x => {}: A1));
-  (x => {
-  }: A1)
-);
 
 type A1 = (x: B1) => void;
 
@@ -721,8 +706,7 @@ type B1 = string;
 ////////////////////////////
 // example with array types
 ////////////////////////////
-function arr(a: number[] | string[]) {
+function arr(a: number[] | string[]) {}
-}
 
 arr(([]: A2));
 
@@ -780,11 +764,9 @@ type B2 = string;
 // example with function types
 ///////////////////////////////
 
-function fun(a: ((x: number) => void) | ((x: string) => void)) {
+function fun(a: ((x: number) => void) | ((x: string) => void)) {}
-}
 
-const a1 = (x => {
+const a1 = (x => {}: A1);
-}: A1);
 fun(a1);
 
 function fun_call(x: string) {
@@ -798,8 +780,7 @@ type B1 = string;
 ////////////////////////////
 // example with array types
 ////////////////////////////
-function arr(a: number[] | string[]) {
+function arr(a: number[] | string[]) {}
-}
 
 const a2 = ([]: A2);
 arr(a2);
@@ -856,8 +837,7 @@ function arr_set(x: string, i: number) { a2[i] = x; }
 // example with function types
 ///////////////////////////////
 
-function fun(a: ((x: number) => number) | ((x: string) => string)) {
+function fun(a: ((x: number) => number) | ((x: string) => string)) {}
-}
 
 function a1(x) {
   return x;
@@ -871,8 +851,7 @@ function fun_call(x: string): string {
 /////////////////////////////
 // example with array types
 /////////////////////////////
-function arr(a: number[] | string[]) {
+function arr(a: number[] | string[]) {}
-}
 
 var a2 = [];
 arr(a2);
@@ -981,8 +960,7 @@ type PG<X> = { x: X, y?: PG<X> };
 // recursive types
 ////////////////////
 
-function rec(x: F1 | F2) {
+function rec(x: F1 | F2) {}
-}
 rec({ x: 0 });
 
 type F1 = G1;
@@ -995,8 +973,7 @@ type H2 = number;
 ///////////////////////////////
 // polymorphic recursive types
 ///////////////////////////////
-function polyrec(x: PF<number> | PF<string>) {
+function polyrec(x: PF<number> | PF<string>) {}
-}
 rec({ x: 0 });
 
 type PF<X> = PG<X>;
@@ -1039,8 +1016,7 @@ type H2_ = number;
 // nested union types
 //////////////////////
 
-function rec(x: F1 | F2) {
+function rec(x: F1 | F2) {}
-}
 rec({ x: 0 });
 
 type F1 = G1 | G1_;
@@ -1088,8 +1064,7 @@ function square(x? = 0) {
   return x * x;
 }
 
-function foo(f: ((_: ?number) => ?number) | (() => void)) {
+function foo(f: ((_: ?number) => ?number) | (() => void)) {}
-}
 foo((x): number => square(x));
 "
 `;
@@ -1177,8 +1152,7 @@ function id<X>(x: X): X {
 /////////////////////////
 // primitive annotations
 /////////////////////////
-function check_prim(_: number | string) {
+function check_prim(_: number | string) {}
-}
 
 // ok
 check_prim(\"\");
@@ -1191,8 +1165,7 @@ check_prim(id(\"\"));
 //////////////////////////////
 class C {}
 class D {}
-function check_inst(_: C | D) {
+function check_inst(_: C | D) {}
-}
 
 // ok
 check_inst(new D());
@@ -1203,8 +1176,7 @@ check_inst(id(new C()));
 ////////////////////////
 // function annotations
 ////////////////////////
-function check_fun(_: ((_: number) => number) | ((_: string) => string)) {
+function check_fun(_: ((_: number) => number) | ((_: string) => string)) {}
-}
 
 // help!
 check_fun(x => x);
@@ -1212,8 +1184,7 @@ check_fun(x => x);
 //////////////////////
 // object annotations
 //////////////////////
-function check_obj(_: { x: number } | { x: string }) {
+function check_obj(_: { x: number } | { x: string }) {}
-}
 
 // ok
 check_obj({ x: \"\" });
@@ -1224,8 +1195,7 @@ check_obj({ x: id(\"\") });
 /////////////////////
 // array annotations
 /////////////////////
-function check_arr(_: number[] | string[]) {
+function check_arr(_: number[] | string[]) {}
-}
 
 // ok
 check_arr([ \"\" ]);
@@ -1237,8 +1207,7 @@ check_arr([ id(\"\") ]);
 // generic class instance annotations
 //////////////////////////////////////
 class P<X> {}
-function check_poly_inst(_: P<number> | P<string>) {
+function check_poly_inst(_: P<number> | P<string>) {}
-}
 
 // help!
 check_poly_inst(new P());
@@ -1356,8 +1325,7 @@ function foo(c: C<number>) {
 
 declare class C<X> { get(): X }
 
-function union(o: { x: string } | { x: number }) {
+function union(o: { x: string } | { x: number }) {}
-}
 
 function foo(c: C<number>) {
   union({ x: c.get() });
@@ -1396,8 +1364,7 @@ bar(() => { });
 // functions as objects
 
 function foo<X>(target: EventTarget) {
-  target.addEventListener(\"click\", e => {
+  target.addEventListener(\"click\", e => {});
-  });
 }
 
 declare class EventTarget {
@@ -1412,11 +1379,9 @@ type EventHandler = (event: Event) => mixed;
 type KeyboardEventHandler = (event: KeyboardEvent) => mixed;
 
 // example where globals are not yet resolved
-function bar(x: (() => void) | { x: number }) {
+function bar(x: (() => void) | { x: number }) {}
-}
 
-bar(() => {
+bar(() => {});
-});
 "
 `;
 
@@ -1449,12 +1414,10 @@ type Foo = T | (() => boolean);
 
 type Bar = number | (() => string) | (() => boolean);
 
-function foo(x: Foo) {
+function foo(x: Foo) {}
-}
 foo(() => qux());
 
-function bar(x: Bar) {
+function bar(x: Bar) {}
-}
 bar(() => qux());
 
 var x = false;

tests/while/__snapshots__/jsfmt.spec.js.snap

@@ -82,8 +82,7 @@ class C {
     return new C();
   }
 }
-function blah() {
+function blah() {}
-}
 var node: ?C = new C();
 while (node) {
   var parent = node.m();