Fix weird identlhs formatting

Author: FedericoPonzi

src/main/java/me/fponzi/tlaplusformatter/constructs/impl/IdentLHSConstruct.java

@@ -47,7 +47,7 @@ public Doc buildDoc(TreeNode node, ConstructContext context, int indentSize) {
 
         Doc content = elementDocs.get(0);
         for (int i = 1; i < elementDocs.size(); i++) {
-            content = content.append(Doc.text(",")).appendLineOrSpace(elementDocs.get(i));
+            content = content.append(Doc.text(",")).appendSpace(elementDocs.get(i));
         }
 
         return

src/test/resources/outputs/AllConstructs.tla

@@ -29,11 +29,9 @@ vars == << x, y, z, f, r, s, q >>
 (****************************************************************)
 Zero == 0
 
-Add(a,
-b) == a + b
+Add(a, b) == a + b
 
-Equal(a,
-b) == a = b
+Equal(a, b) == a = b
 
 RECURSIVE Fact(_)
 Fact(n) == IF n = 0 THEN 1 ELSE n * Fact(n - 1)
@@ -42,15 +40,11 @@ MapPlusOne(U) == LET plus1(t) == t + 1 IN {plus1(t): t \in U}
 
 IdFun(U) == [u \in U |-> u]
 
-Bump(f_,
-k) == [f_ EXCEPT ![k] = @ + 1]
+Bump(f_, k) == [f_ EXCEPT ![k] = @ + 1]
 
-Rec(a,
-b) == [ a |-> a, b |-> b ]
+Rec(a, b) == [ a |-> a, b |-> b ]
 
-Tuple3(a,
-b,
-c) == << a, b, c >>
+Tuple3(a, b, c) == << a, b, c >>
 
 Power(U) == SUBSET U
 
@@ -60,9 +54,7 @@ CaseExample(u) == CASE u \in Nat -> u + 1
                   [] u \in Int \ Nat -> - u
                   [] OTHER-> 0
 
-IfElseExample(b,
-e1,
-e2) == IF b THEN e1 ELSE e2
+IfElseExample(b, e1, e2) == IF b THEN e1 ELSE e2
 
 ChooseAnyFrom(U) == CHOOSE u \in U: TRUE
 
@@ -72,8 +64,7 @@ Dom(f_) == DOMAIN f_
 
 Range(f_) == {f_[i]: i \in DOMAIN f_}
 
-ConstFun(U,
-v) == [U -> { v }]
+ConstFun(U, v) == [U -> { v }]
 
 SeqStuff(U) ==
   LET s0 == <<>> \o << 1 >> \o << 2, 3 >>

src/test/resources/outputs/Stones.tla

@@ -59,8 +59,7 @@ ASSUME W \in Nat /\ N \in 1 .. W
 (* definition.                                                             *)
 (***************************************************************************)
 RECURSIVE Partitions(_,_)
-Partitions(seq,
-wt) ==
+Partitions(seq, wt) ==
   IF Len(seq) = N
   THEN { seq }
   ELSE LET r == N - Len(seq)
@@ -75,8 +74,7 @@ wt) ==
 (* For convenience, we define Weighs(seq, wt) to be true if the elements   *)
 (* of the sequence seq sum to wt.                                          *)
 (***************************************************************************)
-Weighs(seq,
-wt) ==
+Weighs(seq, wt) ==
   \E coef \in [1 .. N -> - 1 .. 1]:
     SeqSum([i \in 1 .. N |-> coef[i] * seq[i]]) = wt
 

src/test/resources/outputs/TowerOfHanoi.tla

@@ -59,36 +59,30 @@ IsEmptyTower(tower) == tower = 0
 (***************************************************************************)
 (* TRUE iff the disk is located on the given tower                         *)
 (***************************************************************************)
-IsOnTower(tower,
-disk) == /\ tower & disk = disk
+IsOnTower(tower, disk) == /\ tower & disk = disk
 
 (***************************************************************************)
 (* TRUE iff disk is the smallest disk on tower                             *)
 (***************************************************************************)
-IsSmallestDisk(tower,
-disk) == /\ IsOnTower(tower, disk)
-         /\ tower & ( disk - 1 ) = 0
+IsSmallestDisk(tower, disk) == /\ IsOnTower(tower, disk)
+                               /\ tower & ( disk - 1 ) = 0
 \* All less significant bits are 0
 (***************************************************************************)
 (* TRUE iff disk can be moved off of tower                                 *)
 (***************************************************************************)
-CanMoveOff(tower,
-disk) == /\ IsOnTower(tower, disk)
-         /\ IsSmallestDisk(tower, disk)
+CanMoveOff(tower, disk) == /\ IsOnTower(tower, disk)
+                           /\ IsSmallestDisk(tower, disk)
 
 (***************************************************************************)
 (* TRUE iff disk can be moved to the tower                                 *)
 (***************************************************************************)
-CanMoveTo(tower,
-disk) == \/ tower & ( disk - 1 ) = 0
-         \/ IsEmptyTower(tower)
+CanMoveTo(tower, disk) == \/ tower & ( disk - 1 ) = 0
+                          \/ IsEmptyTower(tower)
 
 (***************************************************************************)
 (*                                                                         *)
 (***************************************************************************)
-Move(from,
-to,
-disk) ==
+Move(from, to, disk) ==
   /\ CanMoveOff(towers[from], disk)
   /\ CanMoveTo(towers[to], disk)
   /\ towers' =