experiment: rascal formatter based on Box and layoutDiff

src/org/rascalmpl/library/lang/box/syntax/Box.rsc

@@ -23,7 +23,6 @@ module lang::box::\syntax::Box
 * `L` produces A literal word. This word may only contain printable characters and no spaces; this is a required property that the formatting algorithm depends on for correctness.
 * `U` splices its contents in the surrounding box, for automatic flattening of overly nested structures in syntax trees.
 * `G` is an additional group-by feature that reduces tot the above core features
-* `SL` is a convenience box for separated syntax lists based on `G`
 * `NULL()` is the group that will dissappear from its context, useful for skipping content. It is based on the `U` box.
 }
 @benefits{
@@ -81,4 +80,13 @@ algorithm starts counting boxes and widths.
 * Do not use `NULL` for empty Row cells, unless you do want your cells aligned to the left and filled up to the right with empty H boxes.
 * NULL will be formatted as `H([])` if it's the outermost Box.
 }
-Box NULL() = U([]);
+Box NULL() = U([]);
+
+@synopsis{Convenience box for adding separators to an existing box list}
+@description{
+Each element is wrapped by the `op` operator together with the next separator.
+The resulting list is wrapped by a G box, of which the elements will be spliced
+into their context. 
+}
+Box SL(list[Box] boxes, Box sep, Box(list[Box]) op = H, int hs=1, int vs=0, int is=4)
+  = G([b, sep | b <- boxes][..-1], op=op, hs=hs, vs=vs, is=is);

src/org/rascalmpl/library/lang/box/util/Box2Text.rsc

@@ -125,7 +125,7 @@ data Options = options(
     int wrapAfter = 70
 );
 
-@synopsis{Quickly splice in any nested U boxes}
+@synopsis{Quickly splice in any nested U boxes, and empty H, V, HV, I or HOV boxes}
 list[Box] u(list[Box] boxes) {
     return [*((U(list[Box] nested) := b) ? u(nested) : [b]) | b <- boxes, !isDegenerate(b)];
 }

src/org/rascalmpl/library/lang/box/util/Tree2Box.rsc

@@ -189,7 +189,7 @@ default Box toBox(t:appl(Production p, list[Tree] args), FO opts = fo()) {
         // We remove all layout node positions to make the number of children predictable
         // Comments can be recovered by `layoutDiff`. By not recursing into layout
         // positions `toBox` becomes more than twice as fast.
-        case <prod(layouts(_), _, _), list[Tree] content>:
+        case <prod(layouts(_), _, _), list[Tree] _>:
             return NULL();
 
         // if we are given a comment node, then we can format it here for use by layoutDiff

src/org/rascalmpl/library/lang/rascal/format/Grammar.rsc

@@ -10,6 +10,10 @@
 @contributor{Arnold Lankamp - [email protected]}
 @synopsis{Convert the Rascal internal grammar representation format (Grammar) to 
   a syntax definition in Rascal source code.}
+@pitfalls{
+This function does not use advanced formatting feature because it is a part of
+components early in Rascal's bootstrapping and standard library construction cycle.
+}
 module lang::rascal::format::Grammar
 
 import ParseTree;

src/org/rascalmpl/library/lang/rascal/format/Rascal.rsc

@@ -0,0 +1,170 @@
+@license{
+Copyright (c) 2022, NWO-I Centrum Wiskunde & Informatica (CWI) 
+All rights reserved. 
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+}
+@synopsis{Composes a default formatter for Rascal modules}
+@description{
+This module composes and describes a "standard" formatting style for Rascal.
+There could be other styles of course. Other styles can be build by 
+writing different `toBox` rules.
+}
+@bootstrapParser
+module lang::rascal::format::Rascal
+
+// by extending these modules we compose a `toBox` function
+// which handles all relevant constructs of Rascal
+extend lang::box::util::Tree2Box;
+extend lang::rascal::\syntax::Rascal;
+
+import ParseTree;
+import analysis::diff::edits::ExecuteTextEdits;
+import analysis::diff::edits::HiFiLayoutDiff;
+import analysis::diff::edits::TextEdits;
+import lang::box::\syntax::Box;
+import lang::box::util::Box2Text;
+import String;
+
+@synopsis{Format an entire Rascal file, in-place.}
+void formatRascalFile(loc \module) {
+    start[Module] tree = parse(#start[Module], \module);
+    edits = formatRascalModule(tree);
+    executeFileSystemChanges(changed(\module, edits));
+}
+
+@synopsis{Format a Rascal module string}
+str formatRascalString(str \module) 
+    = executeTextEdits(\module, formatRascalModule(parse(#start[Module], \module, |unknown:///|)));
+
+@synopsis{Top-level work-horse for formatting Rascal modules}
+@benefits{
+* retains source code comments 
+* uses Box for adaptive nested formatting
+}
+list[TextEdit] formatRascalModule(start[Module] \module) 
+    = layoutDiff(\module, parse(#start[Module], format(toBox(\module)), \module@\loc.top));
+
+
+/* Modules */
+
+Box toBox(Toplevel* toplevels) = V([toBox(t) | t <- toplevels], vs=2);
+
+Box toBox((Module) `<Tags tags> module <QualifiedName name> <Import* imports> <Body body>`)
+    = V([
+        toBox(tags),
+        H([L("module"), toBox(name)]),
+        toBox(imports),
+        toBox(body)
+    ], vs=1);
+
+Box toBox(Import* imports) = V([toBox(i) | i <- imports]);
+
+Box toBox((Import) `import <ImportedModule m> ;`)
+    = H([L("import"), H([toBox(m), L(";")], hs=0)]);
+
+Box toBox((Visibility) ``) = NULL();
+
+/* Declarations */
+
+Box toBox(FunctionModifier* modifiers) = H([toBox(b) | b <- modifiers]);
+
+Box toBox((Signature) `<FunctionModifiers modifiers> <Type typ>  <Name name> <Parameters parameters> throws <{Type ","}+ exs>`)
+    = HOV([
+        H([toBox(modifiers), toBox(typ), H([toBox(name), toBox(parameters)], hs=0)]), 
+        H([L("throws"), HV([toBox(e) | e <- exs])])], hs=1);
+
+Box toBox((Signature) `<FunctionModifiers modifiers> <Type typ>  <Name name> <Parameters parameters>`)
+    = H([toBox(modifiers), toBox(typ), H([toBox(name), toBox(parameters)], hs=0)]);
+
+Box toBox((FunctionDeclaration) `<Tags tags> <Visibility vis> <Signature sig> ;`)
+    = V([
+        toBox(tags),
+        H([toBox(vis), toBox(sig), L(";")])
+    ]);
+
+Box toBox((FunctionDeclaration) `<Tags tags> <Visibility vis> <Signature sig> = <Expression exp>;`)
+    = V([
+        toBox(tags),
+        H([toBox(vis), toBox(sig)]),
+        I([H([L("="), H([toBox(exp), L(";")], hs=0)])])
+    ]);
+
+Box toBox((FunctionDeclaration) `<Tags tags> <Visibility vis> <Signature sig> = <Expression exp> when <{Expression ","}+ conds>;`)
+    = V([
+        toBox(tags),
+        H([toBox(vis), toBox(sig)]),
+        I([H([L("="), toBox(exp)])]),
+        I([L("when"), V([toBox(c) | c <- conds])])
+    ]);
+
+Box toBox((FunctionDeclaration) `<Tags tags> <Visibility vis> <Signature sig> { <Statement* stats> }`)
+    = V([
+        toBox(tags),
+        H([toBox(vis), toBox(sig), L("{")]),
+        I([toBox(stats)]),
+        L("}")
+    ]);
+
+Box toBox(Tag* tags) = V([toBox(t) | Tag t <- tags]);
+
+Box toBox((Tag) `@synopsis <TagString c>`) 
+    = H([
+        L("@"), L("synopsis"), L("{"),
+        H([L("<l>") | l <- split("\n", "<c>"[1..-1])]),
+        L("}")]
+    , hs=0);
+
+Box toBox((Tag) `@<Name n> <TagString c>`) 
+    = HOV([
+        H([L("@"), L("<n>")], hs=0),
+        toBox(c)]
+    , hs=0)
+    when "<n>" != "synopsis";
+
+Box toBox((Parameters) `( <Formals formals> <KeywordFormals keywordFormals>)`)
+    = H([L("("), H([toBox(formals), toBox(keywordFormals)]), L(")")], hs=0);
+
+Box toBox((Parameters) `( <Formals formals> ... <KeywordFormals keywordFormals>)`)
+    = H([L("("), H([H([toBox(formals), L("...")], hs=0), toBox(keywordFormals)]), L(")")], hs=0);
+
+/* Statements */
+
+Box toBox(Statement* stmts) 
+    = V([toBox(s) | s <- stmts]);
+
+Box toBox((Statement) `return <Expression e>;`)
+    = HV([L("return"), I([H([toBox(e), L(";")], hs=0)])]);
+
+/* Expressions */
+
+Box toBox((Expression) `<Expression condition> ? <Expression thenExp> : <Expression elseExp>`)
+    =  HOV([
+        toBox(condition),
+        I([H([L("?"), toBox(thenExp)])]),
+        I([H([L(":"), toBox(elseExp)])])
+    ]);
+
+// call without kwargs
+Box toBox((Expression) `<Expression caller>(<{Expression ","}* arguments>)`)
+    = H([toBox(caller), L("("), toBox(arguments), L(")")], hs=0);
+
+// call with kwargs
+Box toBox((Expression) `<Expression caller>(<{Expression ","}* arguments>, <{KeywordArgument[Expression] ","}+ kwargs>)`)
+    = H([toBox(caller), L("("), toBox(arguments), H([L(","), toBox(kwargs)], hs=1), L(")")], hs=0);
+
+// call with kwargs no-comma
+Box toBox((Expression) `<Expression caller>(<{Expression ","}* arguments> <{KeywordArgument[Expression] ","}+ kwargs>)`)
+    = H([toBox(caller), L("("), V([toBox(arguments),toBox(kwargs)]), L(")")], hs=0);
+
+Box toBox({KeywordArgument[Expression] ","}+ args) 
+    = SL([toBox(a) | a <- args], L(","), hs=0);
+
+// this should not be necessary
+// Box HV([H([])]) = U([]);