Preserve function body braces and distinguish open vs. X.()

formatTest/typeCheckedTests/expected_output/attributes.re

@@ -120,7 +120,11 @@ let x = [@attrEverything] (true && false);
 /**
  * How attribute parsings respond to other syntactic constructs.
  */
-let add = a => [@onRet] a;
+let add = a =>
+  [@onRet]
+  {
+    a;
+  };
 
 let add = a => [@onRet] a;
 
@@ -382,8 +386,18 @@ type classAttributesOnKeys = {
   .
   [@bs.set] key1: string,
   /* The follow two are the same */
-  [@bs.get null] key2: [@onType2] Js.t(int),
-  [@bs.get null] key3: [@onType2] Js.t(int),
+  [@bs.get
+    {
+      null;
+    }
+  ]
+  key2: [@onType2] Js.t(int),
+  [@bs.get
+    {
+      null;
+    }
+  ]
+  key3: [@onType2] Js.t(int),
   key4: Js.t([@justOnInt] int),
 };
 
@@ -533,7 +547,13 @@ let res =
 
 let res =
   switch (x) {
-  | _ => [@attr] String.(Array.(concat))
+  | _ =>
+    [@attr]
+    {
+      open String;
+      open Array;
+      concat;
+    }
   };
 
 /* GADT */
@@ -602,10 +622,6 @@ type tttttt = {
   mutable x: int,
 };
 
-let tmp =
-  /** On if statement */
-  (if (true) {true} else {false});
-
 type foo =
   option(
     [@foo

formatTest/typeCheckedTests/expected_output/braces.re

@@ -0,0 +1,181 @@
+let preserveThis = "preserveThis";
+
+let x = a => {
+  preserveThis;
+};
+
+let x = a => {
+  /* Even with comment */
+  preserveThis;
+};
+
+let res = {
+  /**
+   * doc comment.
+   */
+  (if (true) {()} else {()});
+  ();
+};
+
+let x = a => {
+  /* It would be okay for this comment to get formatted into
+   * the braces but ideally it wouldn't. */
+  preserveThis;
+};
+
+type recordType = {
+  recordTypeFieldOne: int,
+  recordTypeFieldTwo: string,
+};
+
+let x =
+  {
+    recordTypeFieldOne: 0,
+    recordTypeFieldTwo: "two",
+  }.recordTypeFieldOne;
+
+/**
+ * Use a pointless wrapping.
+ */
+let x =
+  {
+    {
+      recordTypeFieldOne: 0,
+      recordTypeFieldTwo: "two",
+    };
+  }.recordTypeFieldOne;
+
+let createRecord = () => {
+  recordTypeFieldOne: 0,
+  recordTypeFieldTwo: "two",
+};
+
+let x =
+  {
+    createRecord();
+  }.recordTypeFieldOne;
+
+let y = [@attr] 3;
+
+/* The attribute on the explicit braces should also be preserved */
+let y =
+  [@attr]
+  {
+    3;
+  };
+
+let myFun = (. a, b, c) => a + b + c;
+
+let result = {
+  myFun(. 0, 1, 2);
+};
+
+let result =
+  [@attr]
+  {
+    myFun(. 0, 1, 2);
+  };
+
+let tmp =
+  /** On if statement */
+  {
+    if (true) {true} else {false};
+  };
+
+let tmp = {
+  let tmp = false;
+  /** On if statement */
+  (if (tmp) {true} else {false});
+};
+
+let tmp = {
+  let tmp = false;
+  /** On if statement */
+  (if (tmp) {"true"} else {"false"});
+  "but the if statement wasn't the last";
+};
+
+module Callbacks = {
+  let runThisCallback = (s, next) => {
+    s ++ next("!");
+    ();
+  };
+};
+
+let result =
+  Callbacks.runThisCallback("hi", s =>
+    s ++ "concatThis!"
+  );
+
+let result =
+  Callbacks.runThisCallback("hi", s => {
+    s ++ "!";
+  });
+
+Callbacks.runThisCallback("hi", s =>
+  s ++ "concatThis!"
+);
+
+Callbacks.runThisCallback("hi", s => {
+  s ++ "concatThis!";
+});
+
+Callbacks.runThisCallback("hi", s => {
+  let s = s ++ s;
+  s ++ "concatThis!";
+});
+
+let test = {
+  open Callbacks;
+  ();
+  34;
+};
+
+/* Even though these braces aren't needed we will preserve them because they
+ * were requested */
+let test = {
+  open Callbacks;
+  open String;
+  34;
+};
+
+/* You can have unecessary braces around inline opens even */
+let test = {
+  Callbacks.(String.(34));
+};
+
+/* Even though these braces aren't needed we will preserve them because they
+ * were requested */
+let test = {
+  open Callbacks;
+  String.("hello" ++ "!");
+};
+
+let test = {
+  open Callbacks;
+  [@attr] String.("hello" ++ "!");
+};
+
+/* Doesn't currently parse.
+     let test = {
+       [@attr1]
+       open Callbacks;
+       String.("hello" ++ "!");
+     };
+   */
+let test = {
+  Callbacks.(
+    {
+      let f = 0;
+      f;
+    }
+  );
+};
+
+let test =
+  Callbacks.(
+    {
+      let f = 0;
+      f;
+    }
+  );

formatTest/typeCheckedTests/expected_output/jsx.re

@@ -101,29 +101,32 @@ module Namespace = {
 };
 
 module Optional1 = {
-  let createElement = (~required, ~children, ()) =>
+  let createElement = (~required, ~children, ()) => {
     switch (required) {
     | Some(a) => {displayName: a}
     | None => {displayName: "nope"}
     };
+  };
 };
 
 module Optional2 = {
   let createElement =
-      (~optional=?, ~children, ()) =>
+      (~optional=?, ~children, ()) => {
     switch (optional) {
     | Some(a) => {displayName: a}
     | None => {displayName: "nope"}
     };
+  };
 };
 
 module DefaultArg = {
   let createElement =
-      (~default=Some("foo"), ~children, ()) =>
+      (~default=Some("foo"), ~children, ()) => {
     switch (default) {
     | Some(a) => {displayName: a}
     | None => {displayName: "nope"}
     };
+  };
 };
 
 module LotsOfArguments = {
@@ -174,8 +177,9 @@ let notReallyJSX = (~foo, ~bar, children) => {
   displayName: "test",
 };
 
-let fakeRender = (el: component) =>
+let fakeRender = (el: component) => {
   el.displayName;
+};
 
 /* end of setup */
 let (/><) = (a, b) => a + b;
@@ -465,7 +469,7 @@ let div = (~children) => 1;
 
 [@JSX] ((() => div)())(~children=[]);
 
-let myFun = () =>
+let myFun = () => {
   <>
     <Namespace.Foo
       intended=true
@@ -486,10 +490,13 @@ let myFun = () =>
       <Foo />
     </Namespace.Foo>
   </>;
+};
 
-let myFun = () => <> </>;
+let myFun = () => {
+  <> </>;
+};
 
-let myFun = () =>
+let myFun = () => {
   <>
     <Namespace.Foo
       intended=true
@@ -510,6 +517,7 @@ let myFun = () =>
       <Foo />
     </Namespace.Foo>
   </>;
+};
 
 /**
  * Children should wrap without forcing attributes to.

formatTest/typeCheckedTests/expected_output/oo.re

@@ -13,12 +13,18 @@ class virtual stack ('a) (init) = {
       Some(hd);
     | [] => None
     };
-  pub push = hd => v = [hd, ...v];
-  initializer (
-    print_string("initializing object")
-  );
-  pub explicitOverrideTest = a => a + 1;
-  pri explicitOverrideTest2 = a => a + 1;
+  pub push = hd => {
+    v = [hd, ...v];
+  };
+  initializer {
+    print_string("initializing object");
+  };
+  pub explicitOverrideTest = a => {
+    a + 1;
+  };
+  pri explicitOverrideTest2 = a => {
+    a + 1;
+  };
 };
 
 let tmp = {
@@ -49,10 +55,12 @@ class virtual stackWithAttributes ('a) (init) = {
       Some(hd);
     | [] => None
     };
-  pub push = hd => v = [hd, ...v];
-  initializer (
-    print_string("initializing object")
-  );
+  pub push = hd => {
+    v = [hd, ...v];
+  };
+  initializer {
+    print_string("initializing object");
+  };
 };
 
 class extendedStack ('a) (init) = {
@@ -66,9 +74,15 @@ class extendedStackAcknowledgeOverride
       (init) = {
   inherit (class stack('a))(init);
   val dummy = ();
-  pub implementMe = i => i + 1;
-  pub! explicitOverrideTest = a => a + 2;
-  pri! explicitOverrideTest2 = a => a + 2;
+  pub implementMe = i => {
+    i + 1;
+  };
+  pub! explicitOverrideTest = a => {
+    a + 2;
+  };
+  pri! explicitOverrideTest2 = a => {
+    a + 2;
+  };
 };
 
 let inst = (new extendedStack)([1, 2]);
@@ -134,8 +148,12 @@ let anonClosedObject: {
   x: int,
   y: int,
 } = {
-  pub x = 0;
-  pub y = 0
+  pub x = {
+    0;
+  };
+  pub y = {
+    0;
+  }
 };
 
 let onlyHasX = {pub x = 0};