Parse Comments line by line

Author: stasm

spec/fluent.ebnf

@@ -3,12 +3,10 @@
 Resource            ::= (Entry | blank_block | junk_line)*
 Entry               ::= Message
                       | Term
-                      | (ResourceComment | GroupComment | Comment)
-Message             ::= Comment? Identifier blank_inline? "=" ((Pattern Attribute*) | (Attribute+))
-Term                ::= Comment? TermIdentifier blank_inline? "=" Value Attribute*
-Comment             ::= ("#" ("\u0020" /.*/)? line_end)+
-GroupComment        ::= ("##" ("\u0020" /.*/)? line_end)+
-ResourceComment     ::= ("###" ("\u0020" /.*/)? line_end)+
+                      | CommentLine
+Message             ::= Identifier blank_inline? "=" ((Pattern Attribute*) | (Attribute+))
+Term                ::= TermIdentifier blank_inline? "=" Value Attribute*
+CommentLine         ::= ("###" | "##" | "#") ("\u0020" /.*/)? line_end
 
 /* Adjacent junk_lines should be joined into FTL.Junk during the AST
    construction. */

syntax/abstract.mjs

@@ -10,6 +10,19 @@ import {always, never} from "../lib/combinators.mjs";
 
 export function list_into(Type) {
     switch (Type) {
+        case FTL.BaseComment:
+            return ([sigil, content = ""]) => {
+                switch (sigil) {
+                    case "#":
+                        return always(new FTL.Comment(content));
+                    case "##":
+                        return always(new FTL.GroupComment(content));
+                    case "###":
+                        return always(new FTL.ResourceComment(content));
+                    default:
+                        return never(`Unknown comment sigil: ${sigil}`);
+                }
+            };
         case FTL.CallExpression:
             return ([callee, args]) => {
                 let positional_args = [];
@@ -32,9 +45,6 @@ export function list_into(Type) {
                 let named_args = Array.from(named_map.values());
                 return always(new Type(callee, positional_args, named_args));
             };
-        case FTL.Message:
-            return ([comment, ...args]) =>
-                always(new Type(...args, comment));
         case FTL.Pattern:
             return elements =>
                 always(new FTL.Pattern(
@@ -46,7 +56,12 @@ export function list_into(Type) {
             return entries =>
                 always(new FTL.Resource(
                     entries
-                        .reduce(join_adjacent(FTL.Junk), [])
+                        .reduce(join_adjacent(
+                            FTL.Junk,
+                            FTL.Comment,
+                            FTL.GroupComment,
+                            FTL.ResourceComment), [])
+                        .reduce(attach_comments, [])
                         .filter(remove_blank_lines)));
         case FTL.SelectExpression:
             return ([selector, variants]) => {
@@ -68,9 +83,6 @@ export function list_into(Type) {
                 }
                 return always(new Type(selector, variants));
             };
-        case FTL.Term:
-            return ([comment, ...args]) =>
-                always(new Type(...args, comment));
         case FTL.VariantList:
             return ([variants]) =>
                 always(new Type(variants));
@@ -82,21 +94,6 @@ export function list_into(Type) {
 
 export function into(Type) {
     switch (Type) {
-        case FTL.Comment:
-        case FTL.GroupComment:
-        case FTL.ResourceComment:
-            return content => {
-                if (!content.endsWith("\n")) {
-                    // The comment ended with the EOF; don't trim it.
-                    return always(new Type(content));
-                }
-                if (content.endsWith("\r\n")) {
-                    // Trim the CRLF from the end of the comment.
-                    return always(new Type(content.slice(0, -2)));
-                }
-                // Trim the LF from the end of the comment.
-                return always(new Type(content.slice(0, -1)));
-            };
         case FTL.Placeable:
             return expression => {
                 let invalid_expression_found =
@@ -121,15 +118,16 @@ export function into(Type) {
     }
 }
 
-function join_adjacent(Type) {
+function join_adjacent(...types) {
     return function(acc, cur) {
         let prev = acc[acc.length - 1];
-        if (prev instanceof Type && cur instanceof Type) {
-            join_of_type(Type, prev, cur);
-            return acc;
-        } else {
-            return acc.concat(cur);
+        for (let Type of types) {
+            if (prev instanceof Type && cur instanceof Type) {
+                join_of_type(Type, prev, cur);
+                return acc;
+            }
         }
+        return acc.concat(cur);
     };
 }
 
@@ -139,12 +137,30 @@ function join_of_type(Type, ...elements) {
         case FTL.TextElement:
             return elements.reduce((a, b) =>
                 (a.value += b.value, a));
+        case FTL.Comment:
+        case FTL.GroupComment:
+        case FTL.ResourceComment:
+            return elements.reduce((a, b) =>
+                (a.content += `\n${b.content}`, a));
         case FTL.Junk:
             return elements.reduce((a, b) =>
                 (a.content += b.content, a));
     }
 }
 
+function attach_comments(acc, cur) {
+    let prev = acc[acc.length - 1];
+    if (prev instanceof FTL.Comment
+        && (cur instanceof FTL.Message
+            || cur instanceof FTL.Term)) {
+        cur.comment = prev;
+        acc[acc.length - 1] = cur;
+        return acc;
+    } else {
+        return acc.concat(cur);
+    }
+}
+
 function trim_text_at_extremes(element, index, array) {
     if (element instanceof FTL.TextElement) {
         if (index === 0) {

syntax/grammar.mjs

@@ -24,14 +24,10 @@ let Entry = defer(() =>
     either(
         Message,
         Term,
-        either(
-            ResourceComment,
-            GroupComment,
-            Comment)));
+        CommentLine));
 
 let Message = defer(() =>
     sequence(
-        maybe(Comment).abstract,
         Identifier.abstract,
         maybe(blank_inline),
         string("="),
@@ -48,7 +44,6 @@ let Message = defer(() =>
 
 let Term = defer(() =>
     sequence(
-        maybe(Comment).abstract,
         TermIdentifier.abstract,
         maybe(blank_inline),
         string("="),
@@ -57,47 +52,20 @@ let Term = defer(() =>
     .map(keep_abstract)
     .chain(list_into(FTL.Term)));
 
-let Comment = defer(() =>
-    repeat1(
-        sequence(
-            string("#"),
-            maybe(
-                sequence(
-                    string(" "),
-                    regex(/.*/).abstract)),
-            line_end.abstract))
-    .map(flatten(2))
-    .map(keep_abstract)
-    .map(join)
-    .chain(into(FTL.Comment)));
-
-let GroupComment = defer(() =>
-    repeat1(
-        sequence(
-            string("##"),
-            maybe(
-                sequence(
-                    string(" "),
-                    regex(/.*/).abstract)),
-            line_end.abstract))
-    .map(flatten(2))
-    .map(keep_abstract)
-    .map(join)
-    .chain(into(FTL.GroupComment)));
-
-let ResourceComment = defer(() =>
-    repeat1(
-        sequence(
+let CommentLine = defer(() =>
+    sequence(
+        either(
             string("###"),
-            maybe(
-                sequence(
-                    string(" "),
-                    regex(/.*/).abstract)),
-            line_end.abstract))
-    .map(flatten(2))
+            string("##"),
+            string("#")).abstract,
+        maybe(
+            sequence(
+                string(" "),
+                regex(/.*/).abstract)),
+        line_end)
+    .map(flatten(1))
     .map(keep_abstract)
-    .map(join)
-    .chain(into(FTL.ResourceComment)));
+    .chain(list_into(FTL.BaseComment)));
 
 /* ----------------------------------------------------------------- */
 /* Adjacent junk_lines should be joined into FTL.Junk during the AST