Preserve required coercion grouping and update formatted sources

Signed-off-by: Christoph Knittel <ck@cca.io>

Author: cknitt

CHANGELOG.md

@@ -62,7 +62,7 @@
 
 #### :nail_care: Polish
 
-- Omit unnecessary parentheses around coercions in call arguments, bindings, and collection elements while preserving expression grouping. https://github.com/rescript-lang/rescript/pull/8614
+- Omit unnecessary parentheses around coercions in call arguments, collection elements, and array indices while preserving expression grouping. https://github.com/rescript-lang/rescript/pull/8614
 - Print external declarations in signatures and type errors with their processed attributes instead of the `"#rescript-external"` placeholder, and print inline constants using `@inline` syntax. https://github.com/rescript-lang/rescript/pull/8581
 - Improve diagnostics for dynamic imports of local values and attempts to use `import` as a first-class value. https://github.com/rescript-lang/rescript/pull/8582
 - Allow inferred labeled functions to be called with labels in any order by removing legacy curried-arrow commutation locks. https://github.com/rescript-lang/rescript/pull/8547

compiler/syntax/src/res_parens.ml

@@ -16,13 +16,6 @@ let expr ?(allow_coercion = false) expr =
     | {pexp_desc = Pexp_constraint _ | Pexp_coerce _} -> Parenthesized
     | _ -> Nothing)
 
-(* A source annotation may precede :> directly, but nested coercions need
-   grouping. Preserve explicit braces through the normal expression rule. *)
-let coerce_expr_operand expression =
-  match (expr expression, expression.Parsetree.pexp_desc) with
-  | Parenthesized, Pexp_constraint _ -> Nothing
-  | kind, _ -> kind
-
 let expr_record_row_rhs ~optional e =
   let kind = expr e in
   match kind with

compiler/syntax/src/res_parens.mli

@@ -1,8 +1,8 @@
 type kind = Parenthesized | Braced of Location.t | Nothing
 
 (* Set [allow_coercion] to [true] only in grammar positions accepting a trailing
-   coercion without parentheses, such as call arguments and binding right-hand
-   sides. Arrow bodies require parentheses. *)
+   coercion without parentheses, such as call arguments and collection elements.
+   Bindings and arrow bodies require parentheses. *)
 val expr : ?allow_coercion:bool -> Parsetree.expression -> kind
 val structure_expr : Parsetree.expression -> kind
 
@@ -40,5 +40,3 @@ val arrow_return_typ_expr : Parsetree.core_type -> bool
 val pattern_record_row_rhs : Parsetree.pattern -> bool
 
 val expr_record_row_rhs : optional:bool -> Parsetree.expression -> kind
-
-val coerce_expr_operand : Parsetree.expression -> kind

compiler/syntax/src/res_printer.ml

@@ -2473,7 +2473,7 @@ and print_value_binding ~state ~rec_flag (vb : Parsetree.value_binding) cmt_tbl
     let opt_braces, expr = Parsetree_viewer.process_braces_attr vb.pvb_expr in
     let printed_expr =
       let doc = print_expression_with_comments ~state vb.pvb_expr cmt_tbl in
-      match Parens.expr ~allow_coercion:true vb.pvb_expr with
+      match Parens.expr vb.pvb_expr with
       | Parens.Parenthesized -> add_parens doc
       | Braced braces -> print_braces doc expr braces
       | Nothing -> doc
@@ -3844,7 +3844,7 @@ and print_expression ~state (e : Parsetree.expression) cmt_tbl =
       let doc_expr = print_expression_with_comments ~state expr cmt_tbl in
       let doc_typ = print_typ_expr ~state typ cmt_tbl in
       let doc_expr =
-        match Parens.coerce_expr_operand expr with
+        match Parens.expr expr with
         | Parens.Parenthesized -> add_parens doc_expr
         | Braced braces -> print_braces doc_expr expr braces
         | Nothing -> doc_expr

packages/dev-playground/src/CompilerApi.res

@@ -218,7 +218,7 @@ let applyConfig = (
   ~experimentalFeatures: array<PlaygroundConfig.experimentalFeature>,
 ) => {
   if hasFunction(instance, "setModuleSystem") {
-    instance->Instance.setModuleSystem((moduleSystem :> string))
+    instance->Instance.setModuleSystem(moduleSystem :> string)
   }
   if hasFunction(instance, "setWarnFlags") {
     instance->Instance.setWarnFlags(warnFlags === "" ? defaultConfig.warnFlags : warnFlags)

tests/syntax_tests/data/printer/expr/coerce.res

@@ -25,7 +25,7 @@ let foo = (~a=(3:int:>int), b) => 34
 
 let x = (/* c0 */ x /* c1 */ :> /* c2 */ int /* c3 */)
 
-// Delimited arguments and binding right-hand sides need no extra parentheses.
+// Delimited arguments need no extra parentheses.
 foo(v :> b)
 foo((v :> b))
 foo(~arg=(v :> b), ~optional=?(v :> b))
@@ -76,3 +76,15 @@ let piped = (value :> b)->foo
 let blockTail = {foo(); (value :> b)}
 let blockHead = {(value :> b); foo()}
 let dictSpread = dict{...(value :> dict<b>), "field": value}
+
+// A constrained operand needs parentheses when the coercion is a binding RHS.
+let constrainedOperand = (x: t) :> u
+let constrainedChain = ((x: t) :> u) :> v
+let constrainedBlock = {(x: t) :> u}
+call((x: t) :> u)
+
+// A following JSX element must not be read as coercion type arguments.
+let beforeJsx = () => {
+  let value = (x :> string)
+  <option value />
+}

tests/syntax_tests/data/printer/expr/expected/coerce.res.txt

@@ -1,31 +1,31 @@
-let z = x :> int
+let z = (x :> int)
 
-let z2 = x :> int
+let z2 = (x :> int)
 
 let foo = (x: int) => (x :> int)
 
 let foo2 = (x: int) => (x :> int)
 
-let bar = x => (x: t :> int)
+let bar = x => ((x: t) :> int)
 
-let bar2 = x => (x: t :> int)
+let bar2 = x => ((x: t) :> int)
 
-call(~x=y :> int, ~z=w: int :> int, ~a, ~b)
+call(~x=y :> int, ~z=(w: int) :> int, ~a, ~b)
 
 let foo = (~a=3: int, b) => 34
 
 let foo = (~a=3 :> int, b) => 34
 
-let foo = (~a=3: int :> int, b) => 34
+let foo = (~a=(3: int) :> int, b) => 34
 
 // THESE SHOULD NOT PARSE: no magic in the syntax
 // let x: int :> string = y
 // let x :> string = y
 // let x : int1 :> int2 = 3 :> int3
 
-let x = /* c0 */ x /* c1 */ :> /* c2 */ int /* c3 */
+let x = (/* c0 */ x /* c1 */ :> /* c2 */ int /* c3 */)
 
-// Delimited arguments and binding right-hand sides need no extra parentheses.
+// Delimited arguments need no extra parentheses.
 foo(v :> b)
 foo(v :> b)
 foo(~arg=v :> b, ~optional=?v :> b)
@@ -41,15 +41,15 @@ let variant = #Value(v :> b)
 // Preserve grouping when the surrounding expression needs it.
 let result = x => (x :> b)
 let callback = foo(x => (x :> b))
-let coercedFunction = x => x :> a => b
+let coercedFunction = (x => x :> a => b)
 let call = (f :> a => b)(v)
 let field = (v :> b).name
 let objectField = (v :> b)["name"]
 let equalLeft = (v :> b) == w
 let equalRight = v == (w :> b)
 let unary = !(v :> b)
 let awaited = await (v :> b)
-let nested = (v :> b) :> c
+let nested = ((v :> b) :> c)
 let record = {field: (v :> b)}
 let conditional = condition ? (v :> b) : (w :> b)
 let block = {v :> b}
@@ -59,14 +59,14 @@ let jsx = <Component value={v :> b}> {v :> b} </Component>
 // Comments must stay attached when parentheses disappear.
 foo(/* before */ v /* operand */ :> /* type */ b /* after */)
 foo(v :> b) // trailing line comment
-let attributed = @foo v :> b
-let coercionAttribute = @foo (v :> b)
+let attributed = (@foo v :> b)
+let coercionAttribute = (@foo (v :> b))
 let long = functionWithAVeryLongName(valueWithAVeryLongName :> typeWithAVeryLongName)
 
 let arrayIndex = values[index :> int]
 values[index :> int] = (value :> b)
 let recordSpread = {...value :> b, field: value}
-let bracedOperand = {value} :> b
+let bracedOperand = ({value} :> b)
 let blockSequence = {
   {
     foo()
@@ -86,3 +86,15 @@ let blockHead = {
   foo()
 }
 let dictSpread = dict{...value :> dict<b>, "field": value}
+
+// A constrained operand needs parentheses when the coercion is a binding RHS.
+let constrainedOperand = ((x: t) :> u)
+let constrainedChain = (((x: t) :> u) :> v)
+let constrainedBlock = {(x: t) :> u}
+call((x: t) :> u)
+
+// A following JSX element must not be read as coercion type arguments.
+let beforeJsx = () => {
+  let value = (x :> string)
+  <option value />
+}

tests/tests/src/Coercion.res

@@ -8,4 +8,4 @@ type r2 = {x: int}
 type t1 = array<r1>
 type t2 = array<r2>
 
-let foo = (x: t1) => {(x :> t2)}
+let foo = (x: t1) => {x :> t2}

tests/tests/src/VariantCoercion.res

@@ -124,7 +124,7 @@ module CoerceFromPolyvariantToVariant = {
 module CoerceVariantBinaryOp = {
   type flag = | @as(0) A | @as(2) B
 
-  let x = 0->Int.bitwiseOr((B :> int))
+  let x = 0->Int.bitwiseOr(B :> int)
 
   let v = B
   let f1 = () =>

tests/tests/src/poly_variant_test.res

@@ -82,7 +82,7 @@ describe(__MODULE__, () => {
   })
 
   test("emoji poly variant conversion", () => {
-    eq(__LOC__, "🚀", (#"🚀": t :> string))
-    eq(__LOC__, "🔥", (#"🔥": t :> string))
+    eq(__LOC__, "🚀", (#"🚀": t) :> string)
+    eq(__LOC__, "🔥", (#"🔥": t) :> string)
   })
 })