Support some incomplete expressions

This adds support for some incomplete expressions, notably case & receive without
clauses or begin block without expressions.

Author: michalmuskala

src/erlfmt_format.erl

@@ -201,34 +201,31 @@ do_expr_to_algebra({macro_string, _Meta, Name}) ->
 do_expr_to_algebra({remote, _Meta, Left, Right}) ->
     concat(expr_to_algebra(Left), <<":">>, expr_to_algebra(Right));
 do_expr_to_algebra({block, Meta, Exprs}) ->
-    surround_block(<<"begin">>, block_to_algebra(Meta, Exprs), <<"end">>);
+    surround_block(<<"begin">>, Exprs, fun(X) -> block_to_algebra(Meta, X) end, <<"end">>);
 do_expr_to_algebra({'fun', _Meta, Expr}) ->
     fun_to_algebra(Expr);
 do_expr_to_algebra({args, Meta, Values}) ->
     container(Meta, Values, <<"(">>, <<")">>);
 do_expr_to_algebra({'case', _Meta, Expr, Clauses}) ->
     Prefix = surround(<<"case">>, <<" ">>, expr_to_algebra(Expr), <<" ">>, <<"of">>),
-    surround_block(Prefix, clauses_to_algebra(Clauses), <<"end">>);
+    surround_block(Prefix, Clauses, fun clauses_to_algebra/1, <<"end">>);
 do_expr_to_algebra({'maybe', _Meta, MaybeExpressions}) ->
-    surround_block(<<"maybe">>, maybe_expressions_to_algebra(MaybeExpressions), <<"end">>);
+    surround_block(<<"maybe">>, MaybeExpressions, fun maybe_expressions_to_algebra/1, <<"end">>);
 do_expr_to_algebra({'maybe', _Meta, MaybeExpressions, Else}) ->
     ElseD = expr_to_algebra(Else),
     surround_block(
-        <<"maybe">>, maybe_expressions_to_algebra(MaybeExpressions), line(ElseD, <<"end">>)
+        <<"maybe">>, MaybeExpressions, fun maybe_expressions_to_algebra/1, line(ElseD, <<"end">>)
     );
 do_expr_to_algebra({else_clause, _Meta, Clauses}) ->
     concat(
         force_breaks(),
         group(concat(<<"else">>, nest(concat(line(), clauses_to_algebra(Clauses)), ?INDENT)))
     );
 do_expr_to_algebra({'receive', _Meta, Clauses}) ->
-    surround_block(<<"receive">>, expr_to_algebra(Clauses), <<"end">>);
-do_expr_to_algebra({'receive', _Meta, empty, After}) ->
-    AfterD = expr_to_algebra(After),
-    concat(force_breaks(), (line(<<"receive">>, line(AfterD, <<"end">>))));
+    surround_block(<<"receive">>, Clauses, fun expr_to_algebra/1, <<"end">>);
 do_expr_to_algebra({'receive', _Meta, Clauses, After}) ->
     AfterD = expr_to_algebra(After),
-    surround_block(<<"receive">>, expr_to_algebra(Clauses), line(AfterD, <<"end">>));
+    surround_block(<<"receive">>, Clauses, fun expr_to_algebra/1, line(AfterD, <<"end">>));
 do_expr_to_algebra({after_clause, _Meta, Expr, Body}) ->
     receive_after_to_algebra(Expr, Body);
 do_expr_to_algebra({'try', _Meta, Exprs, OfClauses, CatchClauses, After}) ->
@@ -237,7 +234,7 @@ do_expr_to_algebra({'catch', _Meta, Exprs}) ->
     ExprsD = lists:map(fun expr_to_algebra/1, Exprs),
     fold_doc(fun(Doc, Acc) -> concat(Doc, <<":">>, Acc) end, ExprsD);
 do_expr_to_algebra({'if', _Meta, Clauses}) ->
-    surround_block(<<"if">>, clauses_to_algebra(Clauses), <<"end">>);
+    surround_block(<<"if">>, Clauses, fun clauses_to_algebra/1, <<"end">>);
 do_expr_to_algebra({spec, _Meta, Name, [SingleClause]}) ->
     single_clause_spec_to_algebra(Name, SingleClause);
 do_expr_to_algebra({spec, _Meta, Name, Clauses}) ->
@@ -261,13 +258,8 @@ do_expr_to_algebra({clauses, _Meta, Clauses}) ->
 do_expr_to_algebra({body, _Meta, Exprs}) ->
     block_to_algebra(Exprs);
 do_expr_to_algebra({sigil, _Meta, Prefix, Content, Suffix}) ->
-    concat(
-        concat(
-            concat(<<"~">>, do_expr_to_algebra(Prefix)),
-            do_expr_to_algebra(Content)
-        ),
-        do_expr_to_algebra(Suffix)
-    );
+    PrefixDoc = concat(<<"~">>, do_expr_to_algebra(Prefix)),
+    concat(concat(PrefixDoc, do_expr_to_algebra(Content)), do_expr_to_algebra(Suffix));
 do_expr_to_algebra({sigil_prefix, _Meta, ''}) ->
     <<"">>;
 do_expr_to_algebra({sigil_prefix, _Meta, SigilName}) ->
@@ -288,7 +280,10 @@ surround(Left, LeftSpace, Doc, RightSpace, Right) ->
         )
     ).
 
-surround_block(Left, Doc, Right) ->
+surround_block(Left, Empty, _Mapper, Right) when Empty =:= []; Empty =:= empty ->
+    line(Left, Right);
+surround_block(Left, Clauses, Mapper, Right) ->
+    Doc = Mapper(Clauses),
     concat(
         force_breaks(),
         group(line(concat(Left, nest(concat(line(), Doc), ?INDENT)), Right))
@@ -752,8 +747,7 @@ fun_to_algebra({clauses, _Anno, [Clause]}) ->
         _ -> group(break(space(<<"fun">>, ClauseD), <<"end">>))
     end;
 fun_to_algebra({clauses, _Anno, Clauses}) ->
-    ClausesD = clauses_to_algebra(Clauses),
-    surround_block(<<"fun">>, ClausesD, <<"end">>);
+    surround_block(<<"fun">>, Clauses, fun clauses_to_algebra/1, <<"end">>);
 fun_to_algebra(type) ->
     <<"fun()">>;
 fun_to_algebra({type, Meta, Args, Result}) ->

src/erlfmt_parse.yrl

@@ -30,7 +30,7 @@ map_comprehension
 binary_comprehension
 tuple
 record_expr record_name record_field_name record_tuple record_field record_fields
-map_expr map_tuple
+map_expr map_tuple begin_block
 if_expr if_clause if_clauses case_expr cr_clause cr_clauses receive_expr maybe_expr
 fun_expr fun_clause fun_clauses
 atom_or_var atom_or_var_or_macro integer_or_var_or_macro
@@ -250,7 +250,7 @@ expr_max -> map_comprehension : '$1'.
 expr_max -> binary_comprehension : '$1'.
 expr_max -> tuple : '$1'.
 expr_max -> '(' expr ')' : set_parens('$2').
-expr_max -> 'begin' exprs 'end' : {block,?range_anno('$1', '$3'),'$2'}.
+expr_max -> begin_block : '$1'.
 expr_max -> if_expr : '$1'.
 expr_max -> case_expr : '$1'.
 expr_max -> maybe_expr : '$1'.
@@ -406,7 +406,11 @@ record_field_name -> atom_or_var_or_macro : '$1'.
 function_call -> expr_max_remote argument_list :
     {call, ?range_anno('$1', '$2'), '$1', ?val('$2')}.
 
-if_expr -> 'if' if_clauses 'end' : {'if',?range_anno('$1', '$3'),'$2'}.
+begin_block -> 'begin' 'end' : {block, ?range_anno('$1', '$2'), []}.
+begin_block -> 'begin' exprs 'end' : {block, ?range_anno('$1', '$3'), '$2'}.
+
+if_expr -> 'if' 'end' : {'if', ?range_anno('$1', '$2'), []}.
+if_expr -> 'if' if_clauses 'end' : {'if', ?range_anno('$1', '$3'), '$2'}.
 
 if_clauses -> if_clause : ['$1'].
 if_clauses -> if_clause ';' : ['$1'].
@@ -415,15 +419,22 @@ if_clauses -> if_clause ';' if_clauses : ['$1' | '$3'].
 if_clause -> guard clause_body :
     {clause, ?range_anno('$1', '$2'), empty, '$1', ?val('$2')}.
 
+case_expr -> 'case' expr 'of' 'end' :
+    {'case', ?range_anno('$1', '$4'), '$2', []}.
 case_expr -> 'case' expr 'of' cr_clauses 'end' :
     {'case', ?range_anno('$1', '$5'), '$2', '$4'}.
 
 cr_clauses -> cr_clause : ['$1'].
 cr_clauses -> cr_clause ';' : ['$1'].
 cr_clauses -> cr_clause ';' cr_clauses : ['$1' | '$3'].
 
+maybe_expr -> 'maybe' 'end' :
+    {'maybe', ?range_anno('$1', '$2'), []}.
 maybe_expr -> 'maybe' exprs 'end' :
     {'maybe', ?range_anno('$1', '$3'), '$2'}.
+maybe_expr -> 'maybe' 'else' cr_clauses 'end' :
+    Else = {else_clause, ?range_anno('$2', '$4'), '$3'},
+    {'maybe', ?range_anno('$1', '$4'), [], Else}.
 maybe_expr -> 'maybe' exprs 'else' cr_clauses 'end' :
     Else = {else_clause, ?range_anno('$3', '$5'), '$4'},
     {'maybe', ?range_anno('$1', '$5'), '$2', Else}.
@@ -437,6 +448,8 @@ cr_clause -> expr clause_guard clause_body :
 cr_clause -> macro_call_expr :
     '$1'.
 
+receive_expr -> 'receive' 'end' :
+        {'receive', ?range_anno('$1', '$2'), empty}.
 receive_expr -> 'receive' cr_clauses 'end' :
         Clauses = {clauses, ?range_anno('$1', '$3'), '$2'},
         {'receive',?range_anno('$1', '$3'),Clauses}.
@@ -454,6 +467,9 @@ fun_expr -> 'fun' atom_or_var_or_macro '/' integer_or_var_or_macro :
 fun_expr -> 'fun' atom_or_var_or_macro ':' atom_or_var_or_macro '/' integer_or_var_or_macro :
     Anno = ?range_anno('$1', '$6'),
     {'fun',Anno,{function,Anno,'$2','$4','$6'}}.
+fun_expr -> 'fun' 'end' :
+    Anno = ?range_anno('$1', '$2'),
+    {'fun', Anno, {clauses, Anno, []}}.
 fun_expr -> 'fun' fun_clauses 'end' :
     Anno = ?range_anno('$1', '$3'),
     {'fun',Anno,{clauses,Anno,'$2'}}.
@@ -490,11 +506,11 @@ try_expr -> 'try' exprs try_catch :
     {'try', ?range_anno('$1', '$3'), Body, none, TryClauses, After}.
 
 try_catch -> 'catch' try_clauses 'end' :
-        {{clauses, ?range_anno('$1', '$3'), '$2'}, ?anno('$3'), '$1', []}.
+    {{clauses, ?range_anno('$1', '$3'), '$2'}, ?anno('$3'), '$1', []}.
 try_catch -> 'catch' try_clauses 'after' exprs 'end' :
-        {{clauses, ?range_anno('$1', '$3'), '$2'}, ?anno('$5'), '$1', '$4'}.
+    {{clauses, ?range_anno('$1', '$3'), '$2'}, ?anno('$5'), '$1', '$4'}.
 try_catch -> 'after' exprs 'end' :
-        {none, ?anno('$3'), '$1', '$2'}.
+    {none, ?anno('$3'), '$1', '$2'}.
 
 try_clauses -> try_clause : ['$1'].
 try_clauses -> try_clause ';' : ['$1'].

test/erlfmt_format_SUITE.erl

@@ -73,7 +73,9 @@
     update_edgecase/1,
     sigils/1,
     doc_attributes/1,
-    doc_macros/1
+    doc_macros/1,
+    incomplete/1,
+    maybe_incomplete/1
 ]).
 
 suite() ->
@@ -97,7 +99,7 @@ init_per_group(_GroupName, Config) ->
 end_per_group(_GroupName, _Config) ->
     ok.
 
-init_per_testcase(maybe_expression, Config) ->
+init_per_testcase(Maybe, Config) when Maybe =:= maybe_expression; Maybe =:= maybe_incomplete ->
     case has_feature(maybe_expr, Config) of
         true -> Config;
         false -> {skip, "Maybe feature not present in the runtime system"}
@@ -122,11 +124,13 @@ groups() ->
             fun_expression,
             case_expression,
             maybe_expression,
+            maybe_incomplete,
             receive_expression,
             try_expression,
             if_expression,
             macro,
-            doc_macros
+            doc_macros,
+            incomplete
         ]},
         {forms, [parallel], [
             function,
@@ -4422,3 +4426,37 @@ doc_macros(Config) when is_list(Config) ->
     ?assertSame("?MODULEDOC(\"Test\").\n?MODULEDOC(#{since => <<\"1.0.0\">>}).\n"),
     ?assertSame("?DOC(\"Test\").\n?DOC(#{since => <<\"1.0.0\">>}).\ntest() -> ok.\n"),
     ?assertSame("?DOC(\"Test\").\n?DOC(#{since => <<\"1.0.0\">>}).\n-type t() :: ok.\n").
+
+incomplete(Config) when is_list(Config) ->
+    ?assertSame(
+        "case X of\n"
+        "end.\n"
+    ),
+    ?assertSame(
+        "receive\n"
+        "end.\n"
+    ),
+    ?assertSame(
+        "if\n"
+        "end.\n"
+    ),
+    ?assertSame(
+        "fun\n"
+        "end.\n"
+    ),
+    ?assertSame(
+        "begin\n"
+        "end.\n"
+    ).
+
+maybe_incomplete(Config) when is_list(Config) ->
+    ?assertSame(
+        "maybe\n"
+        "end.\n"
+    ),
+    ?assertSame(
+        "maybe\n"
+        "else\n"
+        "    ok -> ok\n"
+        "end.\n"
+    ).