feat(compiler)!: Changed comma to and in recursive types and bindings (#1827)

feat(compiler)!: Changed comma to `and` in mutually rec types

Author: alex-snezhko

compiler/src/formatting/format.re

@@ -4198,119 +4198,145 @@ and print_value_bind =
     | Mutable => Doc.text("mut ")
     };
 
-  let formatted_items =
+  let value_bindings =
     switch (vbs) {
-    | [] => []
+    | [] => Doc.nil
     | [first, ...rem] =>
-      let get_loc = (vb: Parsetree.value_binding) => vb.pvb_loc;
-      let print_item = (~comments, vb: Parsetree.value_binding) => {
-        let after_let_comments =
-          Comment_utils.get_comments_enclosed_and_before_location(
-            ~loc1=get_loc(vb),
-            ~loc2=vb.pvb_pat.ppat_loc,
-            comments,
-          );
+      let leading_comments =
+        Comment_utils.get_comments_before_location(
+          ~location=first.pvb_loc,
+          comments,
+        );
+      let leading_comments_docs =
+        switch (leading_comments) {
+        | [] => Doc.nil
+        | _ =>
+          Doc.group(
+            Doc.concat([
+              Comment_utils.new_comments_to_docs(leading_comments),
+              Doc.ifBreaks(Doc.nil, Doc.space),
+            ]),
+          )
+        };
 
-        let after_let_comments_docs =
-          switch (after_let_comments) {
-          | [] => Doc.nil
-          | _ =>
-            Comment_utils.inbetween_comments_to_docs(
-              ~offset=false,
-              after_let_comments,
-            )
-          };
+      let previous_bind: ref(option(Parsetree.value_binding)) = ref(None);
+      let docs =
+        Doc.join(
+          ~sep=Doc.concat([Doc.hardLine]),
+          List.mapi(
+            (i, vb: Parsetree.value_binding) => {
+              let leading_comments =
+                switch (previous_bind^) {
+                | None => []
+                | Some(prev) =>
+                  Comment_utils.get_comments_between_locations(
+                    ~loc1=prev.pvb_loc,
+                    ~loc2=vb.pvb_loc,
+                    comments,
+                  )
+                };
 
-        let expr_comments =
-          Comment_utils.get_comments_inside_location(
-            ~location=vb.pvb_expr.pexp_loc,
-            comments,
-          );
-        let printed =
-          print_expression(
-            ~expression_parent=GenericExpression,
-            ~original_source,
-            ~comments=expr_comments,
-            vb.pvb_expr,
-          );
+              let leading_comment_docs =
+                switch (leading_comments) {
+                | [] => Doc.nil
+                | _ =>
+                  Doc.group(
+                    Doc.concat([
+                      Comment_utils.new_comments_to_docs(leading_comments),
+                      Doc.ifBreaks(Doc.nil, Doc.space),
+                    ]),
+                  )
+                };
 
-        let expression =
-          switch (vb.pvb_expr.pexp_desc) {
-          | PExpIf(_) =>
-            if (Doc.willBreak(printed)) {
-              Doc.concat([Doc.space, printed]);
-            } else {
-              Doc.indent(Doc.concat([Doc.line, printed]));
-            }
-          | _ => Doc.concat([Doc.space, printed])
-          };
+              let after_let_comments =
+                Comment_utils.get_comments_enclosed_and_before_location(
+                  ~loc1=vb.pvb_loc,
+                  ~loc2=vb.pvb_pat.ppat_loc,
+                  comments,
+                );
 
-        let pattern_comments =
-          Comment_utils.get_comments_enclosed_and_before_location(
-            ~loc1=vb.pvb_loc,
-            ~loc2=vb.pvb_expr.pexp_loc,
-            comments,
-          );
+              let after_let_comments_docs =
+                switch (after_let_comments) {
+                | [] => Doc.nil
+                | _ =>
+                  Comment_utils.inbetween_comments_to_docs(
+                    ~offset=false,
+                    after_let_comments,
+                  )
+                };
 
-        Doc.concat([
-          Doc.group(
-            print_pattern(
-              ~original_source,
-              ~comments=pattern_comments,
-              ~next_loc=vb.pvb_loc,
-              vb.pvb_pat,
-            ),
+              let expr_comments =
+                Comment_utils.get_comments_inside_location(
+                  ~location=vb.pvb_expr.pexp_loc,
+                  comments,
+                );
+              let printed =
+                print_expression(
+                  ~expression_parent=GenericExpression,
+                  ~original_source,
+                  ~comments=expr_comments,
+                  vb.pvb_expr,
+                );
+
+              let expression =
+                switch (vb.pvb_expr.pexp_desc) {
+                | PExpIf(_) =>
+                  if (Doc.willBreak(printed)) {
+                    Doc.concat([Doc.space, printed]);
+                  } else {
+                    Doc.indent(Doc.concat([Doc.line, printed]));
+                  }
+                | _ => Doc.concat([Doc.space, printed])
+                };
+
+              let pattern_comments =
+                Comment_utils.get_comments_enclosed_and_before_location(
+                  ~loc1=vb.pvb_loc,
+                  ~loc2=vb.pvb_expr.pexp_loc,
+                  comments,
+                );
+
+              previous_bind := Some(vb);
+
+              Doc.concat([
+                leading_comment_docs,
+                if (i != 0) {
+                  Doc.text("and ");
+                } else {
+                  Doc.nil;
+                },
+                Doc.group(
+                  print_pattern(
+                    ~original_source,
+                    ~comments=pattern_comments,
+                    ~next_loc=vb.pvb_loc,
+                    vb.pvb_pat,
+                  ),
+                ),
+                after_let_comments_docs,
+                switch (after_let_comments) {
+                | [] => Doc.space
+                | _ => Doc.nil
+                },
+                Doc.equal,
+                expression,
+              ]);
+            },
+            vbs,
           ),
-          after_let_comments_docs,
-          switch (after_let_comments) {
-          | [] => Doc.space
-          | _ => Doc.nil
-          },
-          Doc.equal,
-          expression,
-        ]);
-      };
+        );
 
-      item_iterator(
-        ~get_loc,
-        ~print_item,
-        ~comments,
-        ~iterated_item=IteratedValueBindings,
-        vbs,
-      );
+      Doc.concat([leading_comments_docs, docs]);
     };
 
-  let value_bindings =
-    List.mapi(
-      (index, doc) => {
-        let item =
-          if (index > 0) {
-            Doc.concat([Doc.line, doc]);
-          } else {
-            doc;
-          };
-        let vb = List.nth(vbs, index);
-        switch (vb.pvb_expr.pexp_desc) {
-        | PExpLambda(fn, _) => item
-        | _ =>
-          if (index > 0) {
-            Doc.indent(item);
-          } else {
-            item;
-          }
-        };
-      },
-      formatted_items,
-    );
-
   Doc.group(
     Doc.concat([
       exported,
       Doc.text("let"),
       Doc.space,
       recursive,
       mutble,
-      Doc.concat(value_bindings),
+      value_bindings,
     ]),
   );
 };
@@ -4768,9 +4794,9 @@ let data_print =
     ) => {
   let previous_data: ref(option(Parsetree.data_declaration)) = ref(None);
   Doc.join(
-    ~sep=Doc.concat([Doc.comma, Doc.hardLine]),
-    List.map(
-      data => {
+    ~sep=Doc.concat([Doc.hardLine]),
+    List.mapi(
+      (i, data) => {
         let (expt, decl: Parsetree.data_declaration) = data;
 
         let leading_comments =
@@ -4797,6 +4823,11 @@ let data_print =
 
         Doc.concat([
           leading_comment_docs,
+          if (i != 0) {
+            Doc.text("and ");
+          } else {
+            Doc.nil;
+          },
           switch ((expt: Asttypes.provide_flag)) {
           | NotProvided => Doc.nil
           | Provided => Doc.text("provide ")

compiler/src/parsing/lexer.re

@@ -337,6 +337,7 @@ let rec token = lexbuf => {
   | "," => positioned(COMMA)
   | ";" => positioned(SEMI)
   | "as" => positioned(AS)
+  | "and" => positioned(AND)
   | "(" => positioned(LPAREN)
   | ")" => positioned(RPAREN)
   | "{" => positioned(LBRACE)

compiler/src/parsing/parser.messages

@@ -790,34 +790,26 @@ program: MODULE UIDENT EOL ENUM UIDENT LBRACE UIDENT LPAREN WHILE
 
 Expected one or more types to complete the variant definition.
 
-program: MODULE UIDENT EOL ENUM UIDENT LBRACE UIDENT RBRACE COMMA EOL WHILE
+program: MODULE UIDENT EOL TYPE UIDENT EQUAL UIDENT AND YIELD
 ##
-## Ends in an error in state: 986.
+## Ends in an error in state: 860.
 ##
-## separated_nonempty_list(comma,data_declaration_stmt) -> data_declaration_stmt comma . separated_nonempty_list(comma,data_declaration_stmt) [ SEMI EOL EOF ]
+## separated_nonempty_list(AND,data_declaration_stmt) -> data_declaration_stmt AND . separated_nonempty_list(AND,data_declaration_stmt) [ SEMI RBRACE EOL EOF ]
 ##
 ## The known suffix of the stack is as follows:
-## data_declaration_stmt comma
+## data_declaration_stmt AND
 ##
-## WARNING: This example involves spurious reductions.
-## This implies that, although the LR(1) items shown above provide an
-## accurate view of the past (what has been recognized so far), they
-## may provide an INCOMPLETE view of the future (what was expected next).
-## In state 3, spurious reduction of production nonempty_list(eol) -> EOL
-## In state 5, spurious reduction of production eols -> nonempty_list(eol)
-## In state 96, spurious reduction of production comma -> COMMA eols
+program: MODULE UIDENT EOL TYPE UIDENT EQUAL UIDENT AND PROVIDE YIELD
 ##
-program: MODULE UIDENT EOL ENUM UIDENT LBRACE UIDENT RBRACE COMMA PROVIDE WHILE
+## Ends in an error in state: 861.
 ##
-## Ends in an error in state: 987.
-##
-## data_declaration_stmt -> PROVIDE . data_declaration [ SEMI EOL EOF COMMA ]
+## data_declaration_stmt -> PROVIDE . data_declaration [ SEMI RBRACE EOL EOF AND ]
 ##
 ## The known suffix of the stack is as follows:
 ## PROVIDE
 ##
 
-Mutually recursive type declarations are separated by commas, but cannot be mixed with other kinds of expressions.
+Mutually recursive type declarations are separated by `and`, but cannot be mixed with other kinds of expressions.
 
 program: MODULE UIDENT EOL ENUM UIDENT LBRACE UIDENT WHILE
 ##
@@ -861,7 +853,7 @@ program: MODULE UIDENT EOL ENUM UIDENT LBRACE UIDENT RBRACE WHILE
 ## data_declaration_stmt
 ##
 
-Expected a comma followed by more mutually-recursive type declarations or a newline character to complete the current one.
+Expected `and` followed by more mutually-recursive type declarations or a newline character to complete the current one.
 
 program: MODULE UIDENT EOL ENUM UIDENT LCARET LIDENT RCARET INFIX_80
 ##
@@ -4449,22 +4441,14 @@ program: MODULE UIDENT EOL LET UIDENT LPAREN WHILE
 
 Expected a comma-separated list of patterns.
 
-program: MODULE UIDENT EOL LET WASMI64 EQUAL WASMI64 COMMA EOL WHILE
+program: MODULE UIDENT EOL LET NUMBER_INT EQUAL UIDENT AND YIELD
 ##
-## Ends in an error in state: 433.
+## Ends in an error in state: 423.
 ##
-## lseparated_nonempty_list_inner(comma,value_bind) -> lseparated_nonempty_list_inner(comma,value_bind) comma . value_bind [ SEMI RBRACE EOL EOF COMMA ]
+## lseparated_nonempty_list_inner(AND,value_bind) -> lseparated_nonempty_list_inner(AND,value_bind) AND . value_bind [ SEMI RBRACE EOL EOF AND ]
 ##
 ## The known suffix of the stack is as follows:
-## lseparated_nonempty_list_inner(comma,value_bind) comma
-##
-## WARNING: This example involves spurious reductions.
-## This implies that, although the LR(1) items shown above provide an
-## accurate view of the past (what has been recognized so far), they
-## may provide an INCOMPLETE view of the future (what was expected next).
-## In state 3, spurious reduction of production nonempty_list(eol) -> EOL
-## In state 5, spurious reduction of production eols -> nonempty_list(eol)
-## In state 96, spurious reduction of production comma -> COMMA eols
+## lseparated_nonempty_list_inner(AND,value_bind) AND
 ##
 
 Expected a binding, e.g. `foo = 5`.

compiler/src/parsing/parser.mly

@@ -38,6 +38,7 @@ module Grain_parsing = struct end
 %token <string> INFIX_ASSIGNMENT_10
 
 %token ENUM RECORD TYPE MODULE INCLUDE USE PROVIDE ABSTRACT FOREIGN WASM PRIMITIVE
+%token AND
 %token EXCEPT FROM STAR
 %token SLASH DASH PIPE
 %token EOL EOF
@@ -327,7 +328,7 @@ value_bind:
   | pattern equal expr { ValueBinding.mk ~loc:(to_loc $loc) $1 $3 }
 
 value_binds:
-  | lseparated_nonempty_list(comma, value_bind) { $1 }
+  | lseparated_nonempty_list(AND, value_bind) { $1 }
 
 as_prefix(X):
   | AS opt_eols X {$3}
@@ -362,7 +363,7 @@ data_declaration_stmt:
   | data_declaration { (NotProvided, $1) }
 
 data_declaration_stmts:
-  | separated_nonempty_list(comma, data_declaration_stmt) { $1 }
+  | separated_nonempty_list(AND, data_declaration_stmt) { $1 }
 
 provide_item:
   | TYPE aliasable(uid) { PProvideType { name=fst $2; alias = snd $2; loc=to_loc $loc} }

compiler/src/parsing/wrapped_lexer.re

@@ -316,7 +316,7 @@ let token = state => {
 };
 
 let token = state => {
-  // if-else and or-patterns hack
+  // if-else, or-patterns, and `and` hack
   let (tok, _, _) as triple = token(state);
   if (tok == EOL) {
     let fst = ((a, _, _)) => a;
@@ -328,6 +328,7 @@ let token = state => {
     };
 
     switch (fst(next_triple^)) {
+    | AND
     | ELSE
     | PIPE => next_triple^
     | _ =>