Allow empty let and loop forms (#382)

Author: chrisrink10

src/basilisp/lang/compiler/parser.py

@@ -497,6 +497,21 @@ def _clean_meta(meta: Optional[lmap.Map]) -> Optional[lmap.Map]:
         return None if len(new_meta) == 0 else new_meta
 
 
+def _body_ast(
+    ctx: ParserContext, form: Union[llist.List, ISeq]
+) -> Tuple[Iterable[Node], Node]:
+    """Parse the form into a body of statement nodes and a single return
+    expression node.
+
+    If the body is empty, return a constant node containing nil."""
+    body = list(map(partial(_parse_ast, ctx), form))
+    if body:
+        *stmts, ret = body
+    else:
+        stmts, ret = [], _const_node(ctx, None)
+    return stmts, ret
+
+
 def _with_meta(gen_node):
     """Wraps the node generated by gen_node in a :with-meta AST node if the
     original form has meta.
@@ -764,13 +779,7 @@ def __deftype_classmethod(
 
         params = args[1:]
         has_vargs, param_nodes = __deftype_method_param_bindings(ctx, params)
-
-        body = list(map(partial(_parse_ast, ctx), runtime.nthrest(form, 2)))
-        if body:
-            *stmts, ret = body
-        else:
-            stmts, ret = [], _const_node(ctx, None)
-
+        stmts, ret = _body_ast(ctx, runtime.nthrest(form, 2))
         method = ClassMethod(
             form=form,
             name=method_name,
@@ -824,12 +833,7 @@ def __deftype_method(
 
         loop_id = genname(method_name)
         with ctx.new_recur_point(loop_id, param_nodes):
-            body = list(map(partial(_parse_ast, ctx), runtime.nthrest(form, 2)))
-            if body:
-                *stmts, ret = body
-            else:
-                stmts, ret = [], _const_node(ctx, None)
-
+            stmts, ret = _body_ast(ctx, runtime.nthrest(form, 2))
             method = Method(
                 form=form,
                 name=method_name,
@@ -889,12 +893,7 @@ def __deftype_property(
 
         assert not has_vargs, "deftype* properties may not have arguments"
 
-        body = list(map(partial(_parse_ast, ctx), runtime.nthrest(form, 2)))
-        if body:
-            *stmts, ret = body
-        else:
-            stmts, ret = [], _const_node(ctx, None)
-
+        stmts, ret = _body_ast(ctx, runtime.nthrest(form, 2))
         prop = PropertyMethod(
             form=form,
             name=method_name,
@@ -924,13 +923,7 @@ def __deftype_staticmethod(
     """Emit a node for a :staticmethod member of a deftype* form."""
     with ctx.hide_parent_symbol_table(), ctx.new_symbol_table(method_name):
         has_vargs, param_nodes = __deftype_method_param_bindings(ctx, args)
-
-        body = list(map(partial(_parse_ast, ctx), runtime.nthrest(form, 2)))
-        if body:
-            *stmts, ret = body
-        else:
-            stmts, ret = [], _const_node(ctx, None)
-
+        stmts, ret = _body_ast(ctx, runtime.nthrest(form, 2))
         method = StaticMethod(
             form=form,
             name=method_name,
@@ -1287,12 +1280,7 @@ def __fn_method_ast(  # pylint: disable=too-many-branches,too-many-locals
 
         fn_loop_id = genname("fn_arity" if fnname is None else fnname.name)
         with ctx.new_recur_point(fn_loop_id, param_nodes):
-            body = list(map(partial(_parse_ast, ctx), form.rest))
-            if body:
-                *stmts, ret = body
-            else:
-                stmts, ret = [], _const_node(ctx, None)
-
+            stmts, ret = _body_ast(ctx, form.rest)
             method = FnMethod(
                 form=form,
                 loop_id=fn_loop_id,
@@ -1654,18 +1642,14 @@ def _let_ast(ctx: ParserContext, form: ISeq) -> Let:
     assert form.first == SpecialForm.LET
     nelems = count(form)
 
-    if nelems < 3:
+    if nelems < 2:
         raise ParserException(
-            "let forms must have bindings and at least one body form", form=form
+            "let forms must have bindings vector and 0 or more body forms", form=form
         )
 
     bindings = runtime.nth(form, 1)
     if not isinstance(bindings, vec.Vector):
         raise ParserException("let bindings must be a vector", form=bindings)
-    elif len(bindings) == 0:
-        raise ParserException(
-            "let form must have at least one pair of bindings", form=bindings
-        )
     elif len(bindings) % 2 != 0:
         raise ParserException(
             "let bindings must appear in name-value pairs", form=bindings
@@ -1689,13 +1673,13 @@ def _let_ast(ctx: ParserContext, form: ISeq) -> Let:
             ctx.put_new_symbol(name, binding)
 
         let_body = runtime.nthrest(form, 2)
-        *statements, ret = map(partial(_parse_ast, ctx), let_body)
+        stmts, ret = _body_ast(ctx, let_body)
         return Let(
             form=form,
             bindings=vec.vector(binding_nodes),
             body=Do(
                 form=let_body,
-                statements=vec.vector(statements),
+                statements=vec.vector(stmts),
                 ret=ret,
                 is_body=True,
                 env=ctx.get_node_env(),
@@ -1708,9 +1692,9 @@ def _loop_ast(ctx: ParserContext, form: ISeq) -> Loop:
     assert form.first == SpecialForm.LOOP
     nelems = count(form)
 
-    if nelems < 3:
+    if nelems < 2:
         raise ParserException(
-            "loop forms must have bindings and at least one body form", form=form
+            "loop forms must have bindings vector and 0 or more body forms", form=form
         )
 
     bindings = runtime.nth(form, 1)
@@ -1740,13 +1724,13 @@ def _loop_ast(ctx: ParserContext, form: ISeq) -> Loop:
 
         with ctx.new_recur_point(loop_id, binding_nodes):
             loop_body = runtime.nthrest(form, 2)
-            *statements, ret = map(partial(_parse_ast, ctx), loop_body)
+            stmts, ret = _body_ast(ctx, loop_body)
             loop_node = Loop(
                 form=form,
                 bindings=vec.vector(binding_nodes),
                 body=Do(
                     form=loop_body,
-                    statements=vec.vector(statements),
+                    statements=vec.vector(stmts),
                     ret=ret,
                     is_body=True,
                     env=ctx.get_node_env(),

tests/basilisp/compiler_test.py

@@ -1951,10 +1951,14 @@ def test_let_num_elems(self, ns: runtime.Namespace):
         with pytest.raises(compiler.CompilerException):
             lcompile("(let*)")
 
-        with pytest.raises(compiler.CompilerException):
-            lcompile("(let* [a :kw])")
+    def test_let_may_have_empty_bindings(self, ns: runtime.Namespace):
+        assert None is lcompile("(let* [])")
+        assert kw.keyword("kw") == lcompile("(let* [] :kw)")
 
     def test_let_bindings_must_be_vector(self, ns: runtime.Namespace):
+        with pytest.raises(compiler.CompilerException):
+            lcompile("(let* () :kw)")
+
         with pytest.raises(compiler.CompilerException):
             lcompile("(let* (a kw) a)")
 
@@ -1976,9 +1980,9 @@ def test_let_name_does_not_resolve(self, ns: runtime.Namespace):
         with pytest.raises(compiler.CompilerException):
             lcompile("(let* [a 'sym] c)")
 
-    def test_let_must_have_bindings(self, ns: runtime.Namespace):
-        with pytest.raises(compiler.CompilerException):
-            lcompile('(let* [] "string")')
+    def test_let_may_have_empty_body(self, ns: runtime.Namespace):
+        assert None is lcompile("(let* [])")
+        assert None is lcompile("(let* [a :kw])")
 
     def test_let(self, ns: runtime.Namespace):
         assert lcompile("(let* [a 1] a)") == 1
@@ -2118,8 +2122,9 @@ def test_loop_num_elems(self, ns: runtime.Namespace):
         with pytest.raises(compiler.CompilerException):
             lcompile("(loop*)")
 
-        with pytest.raises(compiler.CompilerException):
-            lcompile("(loop* [a :kw])")
+    def test_loop_may_have_empty_bindings(self, ns: runtime.Namespace):
+        assert None is lcompile("(loop* [])")
+        assert kw.keyword("kw") == lcompile("(loop* [] :kw)")
 
     def test_loop_bindings_must_be_vector(self, ns: runtime.Namespace):
         with pytest.raises(compiler.CompilerException):
@@ -2146,6 +2151,10 @@ def test_let_name_does_not_resolve(self, ns: runtime.Namespace):
         with pytest.raises(compiler.CompilerException):
             lcompile("(loop* [a 'sym] c)")
 
+    def test_loop_may_have_empty_body(self, ns: runtime.Namespace):
+        assert None is lcompile("(loop* [])")
+        assert None is lcompile("(loop* [a :kw])")
+
     def test_loop_without_recur(self, ns: runtime.Namespace):
         assert 1 == lcompile("(loop* [a 1] a)")
         assert kw.keyword("keyword") == lcompile('(loop* [a :keyword b "string"] a)')