Improve line breaking for nested groups (#56)

* Improve line breaking for nested groups

* Further improve group breaking logic

* 0.2.1

* Update mo-fmt version

* Deactivate compiler diff test

package.json

@@ -1,6 +1,6 @@
 {
     "name": "prettier-plugin-motoko",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "A code formatter for the Motoko smart contract language.",
     "main": "lib/environments/node.js",
     "browser": "lib/environments/web.js",

packages/mo-fmt/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mo-fmt",
-    "version": "0.2.0",
+    "version": "0.2.1",
     "description": "An easy-to-use Motoko formatter command.",
     "main": "src/cli.js",
     "bin": {
@@ -21,7 +21,7 @@
         "commander": "^9.4.0",
         "fast-glob": "^3.2.11",
         "prettier": "^2.7",
-        "prettier-plugin-motoko": "^0.2.0"
+        "prettier-plugin-motoko": "^0.2.1"
     },
     "devDependencies": {
         "@rollup/plugin-commonjs": "^22.0.2",

src/printers/motoko-tt-ast/print.ts

@@ -156,7 +156,39 @@ function printTokenTree(
         const leftMap = new Map<TokenTree, TokenTree>();
         const rightMap = new Map<TokenTree, TokenTree>();
 
-        let shouldBreak = false;
+        const shouldBreak = (
+            tt: TokenTree & { _shouldBreak?: boolean },
+        ): boolean => {
+            if ('_shouldBreak' in tt) {
+                // use incremental cache to reduce time complexity
+                return tt._shouldBreak;
+            }
+            if (tt.token_tree_type === 'Group') {
+                const [trees] = tt.data;
+                tt._shouldBreak =
+                    trees.some((tt) => shouldBreak(tt)) &&
+                    !trees.every((tt) => {
+                        // don't force break if all whitespace and/or nested groups
+                        const token = getToken(tt);
+                        return (
+                            !token || // group
+                            token.token_type === 'Line' ||
+                            token.token_type === 'MultiLine'
+                        );
+                    });
+            } else {
+                const token = getToken(tt);
+                if (token) {
+                    tt._shouldBreak =
+                        token.token_type === 'Line' ||
+                        token.token_type === 'MultiLine' ||
+                        token.token_type === 'LineComment';
+                }
+            }
+            return tt._shouldBreak;
+        };
+        let shouldBreakTree = shouldBreak(tree);
+
         const trees = originalTrees.filter((tt, i) => {
             const left = originalTrees[i - 1];
             if (left) {
@@ -166,10 +198,6 @@ function printTokenTree(
             if (right) {
                 rightMap.set(tt, right);
             }
-
-            if (getToken(tt)?.token_type === 'Line') {
-                shouldBreak = true;
-            }
             return !shouldSkipTokenTree(tt);
         });
 
@@ -184,10 +212,11 @@ function printTokenTree(
                 return true;
             }
             if (groupType === 'Square' || groupType === 'Paren') {
-                if (hasNestedGroup) {
-                    return false;
-                }
-                return results.length <= 1 && !shouldBreak;
+                // if (hasNestedGroup) {
+                //     return false;
+                // }
+                // return results.length <= 1 && !shouldBreakTree;
+                return !hasNestedGroup && !shouldBreakTree;
             }
             return false;
         };
@@ -320,7 +349,7 @@ function printTokenTree(
                       ]
                 : results,
             {
-                shouldBreak,
+                shouldBreak: shouldBreakTree,
             },
         );
         return shouldKeepSameLine() ? withoutLineBreaks(resultDoc) : resultDoc;
@@ -338,16 +367,15 @@ function printToken(token: Token): Doc {
         case 'Space':
             return space;
         case 'Line':
-            // return breakParent;
             return hardline;
         case 'MultiLine':
-            // return [breakParent, hardline];
-            // return [hardline, hardline];
             return [breakParent];
         case 'LineComment':
-            // return [token.data, hardline];
-            return token.data;
-        // return token.data;
+            // return token.data;
+            return ifBreak(
+                token.data,
+                `/* ${token.data.substring(2).trim()} */`,
+            );
         // return lineSuffix(token.data);
     }
     return getTokenText(token);

tests/motoko.test.ts

@@ -237,6 +237,14 @@ describe('Motoko formatter', () => {
         // );
     });
 
+    test('anonymous function line break', () => {
+        expect(format("(func() {\na\n})")).toStrictEqual("(\n  func() {\n    a;\n  },\n);\n");
+    });
+
+    test('line comment in single line', () => {
+        expect(format("a<(b,\n//c\n)>()")).toStrictEqual("a<(b, /* c */)>()\n");
+    });
+
     test('unclosed quotes in comments', () => {
         expect(format("// a'b\n '")).toStrictEqual("// a'b\n';\n");
         expect(format('// a"b\n "')).toStrictEqual('// a"b\n";\n');
@@ -268,11 +276,11 @@ describe('Motoko formatter', () => {
     //             )} <<<\n\n${formatted}\n\n`;
     //         }
     //         writeFileSync(
-    //             join(__dirname, `motoko/_CompilerTests_Before.${extension}`),
+    //             join(__dirname, `generated/_CompilerTests_Before.${extension}_`),
     //             preOutput,
     //         );
     //         writeFileSync(
-    //             join(__dirname, `motoko/_CompilerTests_Formatted.${extension}`),
+    //             join(__dirname, `generated/_CompilerTests_Formatted.${extension}_`),
     //             postOutput,
     //         );
     //     }