Fix commentaries breaking parentheses balancing

Author: shippingfandom

riddle.py

@@ -325,15 +325,21 @@ def _visit_reassign(self, node):
 
     def _visit_glosure_anon(self, node):
         self._indent += 1
+        body_indent = self._indent
         params_str, body_str = self._make_function_body(node.children[0], node.children[1])
         self._indent -= 1
-        return f"(glosure ({params_str}) (begin\n{body_str}))" if body_str else f"(glosure ({params_str}) (begin))"
+        if body_str:
+            return f"(glosure ({params_str}) (begin\n{body_str}\n{INDENT * body_indent}))"
+        return f"(glosure ({params_str}) (begin))"
 
     def _visit_lambda_anon(self, node):
         self._indent += 1
+        body_indent = self._indent
         params_str, body_str = self._make_function_body(node.children[0], node.children[1])
         self._indent -= 1
-        return f"(lambda ({params_str}) (begin\n{body_str}))" if body_str else f"(lambda ({params_str}) (begin))"
+        if body_str:
+            return f"(lambda ({params_str}) (begin\n{body_str}\n{INDENT * body_indent}))"
+        return f"(lambda ({params_str}) (begin))"
 
     def _visit_return_stmt(self, node):
         return self._visit(node.children[0])
@@ -359,7 +365,7 @@ def _make_function_body(self, param_node, block_node):
         body_str = "\n".join(body_lines)
         return params_str, body_str
 
-    def _make_method(self, keyword, dotted_name, params_str, body_str):
+    def _make_method(self, keyword, dotted_name, params_str, body_str, body_indent=0):
         parts = dotted_name.split(".")
         method_name = parts[-1]
         obj_parts = parts[:-1]
@@ -371,7 +377,10 @@ def _make_method(self, keyword, dotted_name, params_str, body_str):
                 target = f"(at {target} '{part}')"
             set_target = target
         func_name = f"__{method_name}"
-        func_body = f"(begin\n{body_str})" if body_str else "(begin)"
+        if body_str:
+            func_body = f"(begin\n{body_str}\n{INDENT * body_indent})"
+        else:
+            func_body = "(begin)"
         func_def = f"({keyword} {func_name} ({params_str}) {func_body})"
         set_line = f"(set {set_target} '{method_name}' {func_name})"
         idt = INDENT * self._indent
@@ -384,11 +393,15 @@ def _visit_function_def(self, node):
         param_node = node.children[1]
         block_node = node.children[2]
         self._indent += 1
+        body_indent = self._indent
         params_str, body_str = self._make_function_body(param_node, block_node)
         self._indent -= 1
         if "." in name:
-            return self._make_method("defunction", name, params_str, body_str)
-        func_body = f"(begin\n{body_str})" if body_str else "(begin)"
+            return self._make_method("defunction", name, params_str, body_str, body_indent)
+        if body_str:
+            func_body = f"(begin\n{body_str}\n{INDENT * body_indent})"
+        else:
+            func_body = "(begin)"
         return f"(defunction {name} ({params_str}) {func_body})"
 
     def _visit_defun_def(self, node):
@@ -398,11 +411,15 @@ def _visit_defun_def(self, node):
         param_node = node.children[1]
         block_node = node.children[2]
         self._indent += 1
+        body_indent = self._indent
         params_str, body_str = self._make_function_body(param_node, block_node)
         self._indent -= 1
         if "." in name:
-            return self._make_method("defun", name, params_str, body_str)
-        func_body = f"(begin\n{body_str})" if body_str else "(begin)"
+            return self._make_method("defun", name, params_str, body_str, body_indent)
+        if body_str:
+            func_body = f"(begin\n{body_str}\n{INDENT * body_indent})"
+        else:
+            func_body = "(begin)"
         return f"(defun {name} ({params_str}) {func_body})"
 
     def _visit_param_list(self, node):
@@ -423,8 +440,9 @@ def _visit_for_stmt(self, node):
         cond_str = self._visit(cond)
         inc_str = self._visit(inc)
         self._indent += 1
+        body_indent = self._indent
         body_str = self._visit(body)
-        result = f"(for {init_str} {cond_str} {inc_str} (begin\n{INDENT * self._indent}{body_str}))"
+        result = f"(for {init_str} {cond_str} {inc_str} (begin\n{INDENT * body_indent}{body_str}\n{INDENT * body_indent}))"
         self._indent -= 1
         return result
 
@@ -433,25 +451,28 @@ def _visit_foreach_stmt(self, node):
         vl = node.children[1].value
         expr_str = self._visit(node.children[2])
         self._indent += 1
+        body_indent = self._indent
         body_str = self._visit(node.children[3])
-        result = f"(foreach {idx} {vl} {expr_str} (begin\n{INDENT * self._indent}{body_str}))"
+        result = f"(foreach {idx} {vl} {expr_str} (begin\n{INDENT * body_indent}{body_str}\n{INDENT * body_indent}))"
         self._indent -= 1
         return result
 
     def _visit_while_stmt(self, node):
         cond = self._visit(node.children[0])
         self._indent += 1
+        body_indent = self._indent
         body = self._visit(node.children[1])
-        result = f"(while {cond} (begin\n{INDENT * self._indent}{body}))"
+        result = f"(while {cond} (begin\n{INDENT * body_indent}{body}\n{INDENT * body_indent}))"
         self._indent -= 1
         return result
 
     def _visit_if_stmt(self, node):
         children = node.children
         cond = self._visit(children[0])
         self._indent += 1
+        then_indent = self._indent
         then_block = self._visit(children[1])
-        then_result = f"(if {cond} (begin\n{INDENT * self._indent}{then_block})"
+        then_result = f"(if {cond} (begin\n{INDENT * then_indent}{then_block}\n{INDENT * then_indent})"
         self._indent -= 1
 
         if len(children) == 2:
@@ -460,8 +481,9 @@ def _visit_if_stmt(self, node):
         remaining = children[2:]
         if len(remaining) % 2 == 1:
             self._indent += 1
+            else_indent = self._indent
             last_block = self._visit(remaining[-1])
-            rest = f"(begin\n{INDENT * self._indent}{last_block})"
+            rest = f"(begin\n{INDENT * else_indent}{last_block}\n{INDENT * else_indent})"
             self._indent -= 1
             pairs = remaining[:-1]
         else:
@@ -471,8 +493,9 @@ def _visit_if_stmt(self, node):
         for i in range(len(pairs) - 2, -1, -2):
             else_cond = self._visit(pairs[i])
             self._indent += 1
+            else_indent = self._indent
             else_block = self._visit(pairs[i + 1])
-            else_part = f"(if {else_cond} (begin\n{INDENT * self._indent}{else_block})"
+            else_part = f"(if {else_cond} (begin\n{INDENT * else_indent}{else_block}\n{INDENT * else_indent})"
             self._indent -= 1
             if rest:
                 rest = f"{else_part}\n{INDENT * self._indent}{rest})"

tests/commentaries.riddle

@@ -0,0 +1,6 @@
+defun Test() {
+    // Some comment
+}
+for i = 0; i < 10; ++i {
+    // Some comment
+}

tests/correct/anonymous.gls

@@ -1,8 +1,10 @@
 ;; Host anonymous function
 ((at somelist 'apply') (glosure (a1 a2) (begin
     (defaultvalue a2 0)
-    (print a1))))
+    (print a1)
+    )))
 ;; Glosure anonymous function
 ((at somelist 'apply') (lambda (a1 a2) (begin
     (defaultvalue a2 0)
-    (print a1))))
+    (print a1)
+    )))

tests/correct/branching.gls

@@ -1,17 +1,24 @@
 ;; One branch
 (if true (begin
-    (print true)))
+    (print true)
+    ))
 ;; Two branches
 (if true (begin
-    (print true))
+    (print true)
+    )
 (begin
-    (print false)))
+    (print false)
+    ))
 ;; Multiple branches
 (if true (begin
-    (print true))
+    (print true)
+    )
 (if false (begin
-    (print false))
+    (print false)
+    )
 (if true (begin
-    (print true))
+    (print true)
+    )
 (begin
-    (print false)))))
+    (print false)
+    ))))

tests/correct/commentaries.gls

@@ -0,0 +1,6 @@
+(defun Test () (begin
+    ;; Some comment
+    ))
+(for (def i 0) (< i 10) (++ i) (begin
+    ;; Some comment
+    ))

tests/correct/functions.gls

@@ -1,9 +1,11 @@
 ;; Host function with zero arguments
 (defunction HostFZero () (begin
-    (print 'Host function with zero arguments')))
+    (print 'Host function with zero arguments')
+    ))
 ;; Glosure function with zero arguments
 (defun GlosureFZero () (begin
-    (print 'Glosure function with zero arguments')))
+    (print 'Glosure function with zero arguments')
+    ))
 ;; Host function reference
 (print (array 'HostFZero reference' HostFZero))
 ;; Glosure function referenece
@@ -14,22 +16,26 @@
 (GlosureFZero)
 ;; Host function with one argument
 (defunction HostFOne (a) (begin
-    (print (array 'Host function with one argument' a))))
+    (print (array 'Host function with one argument' a))
+    ))
 ;; Glosure function with one argument
 (defun GlosureFOne (a) (begin
-    (print (array 'Glosure function with one argument' a))))
+    (print (array 'Glosure function with one argument' a))
+    ))
 ;; Host function call
 (HostFOne 1337)
 ;; Glosure function call
 (GlosureFOne 1337)
 ;; Host function with one default argument
 (defunction HostFOneDefault (a) (begin
     (defaultvalue a 0)
-    (print (array 'Host function with one default argument' a))))
+    (print (array 'Host function with one default argument' a))
+    ))
 ;; Glosure function with one default argument
 (defun GlosureFOneDefault (a) (begin
     (defaultvalue a 0)
-    (print (array 'Glosure function with one default argument' a))))
+    (print (array 'Glosure function with one default argument' a))
+    ))
 ;; Host function call
 (HostFOneDefault)
 ;; Glosure function call
@@ -50,12 +56,14 @@
 ;; Namespace builtin function
 (defunction __Host (a b) (begin
     (defaultvalue b 1)
-    (+ a b)))
+    (+ a b)
+    ))
 (set (at ns 'functions') 'Host' __Host)
 ;; Namespace Glosure function
 (defunction __Glosure (a b) (begin
     (defaultvalue b 1)
-    (+ a b)))
+    (+ a b)
+    ))
 (set (at ns 'functions') 'Glosure' __Glosure)
 ;; Namespace builtin function call
 ((at (at ns 'functions') 'Host') 1 2)

tests/correct/glob_include.gls

@@ -7,6 +7,7 @@
 (isa a b)
 (gl-break-silence 'Hiiii!')
 (if empty? (begin
+    
     ))
 (effectful! 'Effects!')
 (! condition?)

tests/correct/include_main.gls

@@ -1,6 +1,8 @@
 (defun greet (name) (begin
-    (print name)))
+    (print name)
+    ))
 (defun add (a b) (begin
-    (+ a b)))
+    (+ a b)
+    ))
 (greet 'world')
 (add 1 2)

tests/correct/indent.gls

@@ -2,10 +2,19 @@
     (foreach index value collection (begin
         (if condition (begin
             (if condition (begin
-                body)
+                body
+                )
             (begin
                 (defun name (params) (begin
                     (defunction name (params) (begin
                         (lambda (params) (begin
                             (glosure (params) (begin
-                                body))))))))))))))))
+                                body
+                                ))
+                            ))
+                        ))
+                    ))
+                ))
+            ))
+        ))
+    ))