Add FunctionReference

spec/CHANGELOG.md

@@ -91,6 +91,16 @@
     Junk represents a literal slice of unparsed content and shouldn't have
     its line endings normalized to LF.
 
+  - Add the `FunctionReference` production. (#210)
+
+    Function references in `CallExpressions` are now stored as
+    `FunctionReference` AST nodes, with an `id` field which is an
+    `Identifier`.
+
+    The `Function` production and its corresponding AST node have been
+    removed. The logic validating that function names are all upper-case has
+    been moved to `abstract.mjs`.
+
 ## 0.7.0 (October 15, 2018)
 
   - Relax the indentation requirement. (#87)

spec/fluent.ebnf

@@ -64,7 +64,8 @@ NumberLiteral       ::= "-"? digit+ ("." digit+)?
 MessageReference    ::= Identifier
 TermReference       ::= "-" Identifier
 VariableReference   ::= "$" Identifier
-CallExpression      ::= Function blank? "(" blank? argument_list blank? ")"
+FunctionReference   ::= Identifier
+CallExpression      ::= FunctionReference blank? "(" blank? argument_list blank? ")"
 argument_list       ::= (Argument blank? "," blank?)* Argument?
 Argument            ::= NamedArgument
                       | InlineExpression
@@ -79,9 +80,8 @@ Variant             ::= line_end blank? VariantKey blank_inline? Value
 DefaultVariant      ::= line_end blank? "*" VariantKey blank_inline? Value
 VariantKey          ::= "[" blank? (NumberLiteral | Identifier) blank? "]"
 
-/* Identifiers */
+/* Identifier */
 Identifier          ::= [a-zA-Z] [a-zA-Z0-9_-]*
-Function            ::= [A-Z] [A-Z_?-]*
 
 /* Content Characters
  *

syntax/abstract.mjs

@@ -72,7 +72,7 @@ export function list_into(Type) {
                     || (selector instanceof FTL.AttributeExpression
                         && selector.ref instanceof FTL.MessageReference);
                 if (invalid_selector_found) {
-                    return never("Invalid selector type: ${selector.type}.");
+                    return never(`Invalid selector type: ${selector.type}.`);
                 }
                 let invalid_variants_found = variants.some(
                     variant => variant.value instanceof FTL.VariantList);
@@ -94,14 +94,24 @@ export function list_into(Type) {
 
 export function into(Type) {
     switch (Type) {
+        case FTL.FunctionReference:
+            const VALID_FUNCTION_NAME = /^[A-Z][A-Z0-9_?-]*$/;
+            return identifier => {
+                if (!VALID_FUNCTION_NAME.test(identifier.name)) {
+                    return never(
+                        `Invalid function name: ${identifier.name}. ` +
+                        "Function names must be upper-case.");
+                }
+                return always(new Type(identifier));
+            };
         case FTL.Placeable:
             return expression => {
                 let invalid_expression_found =
                     expression instanceof FTL.AttributeExpression
                     && expression.ref instanceof FTL.TermReference;
                 if (invalid_expression_found) {
                     return never(
-                        "Invalid expression type: ${expression.type}.");
+                        `Invalid expression type: ${expression.type}.`);
                 }
                 return always(new Type(expression));
             };

syntax/ast.mjs

@@ -121,6 +121,14 @@ export class VariableReference extends Expression {
     }
 }
 
+export class FunctionReference extends Expression {
+    constructor(id) {
+        super();
+        this.type = "FunctionReference";
+        this.id = id;
+    }
+}
+
 export class SelectExpression extends Expression {
     constructor(selector, variants) {
         super();
@@ -222,13 +230,6 @@ export class ResourceComment extends BaseComment {
     }
 }
 
-export class Function extends Identifier {
-    constructor(name) {
-        super(name);
-        this.type = "Function";
-    }
-}
-
 export class Junk extends SyntaxNode {
     constructor(content) {
         super();

syntax/grammar.mjs

@@ -238,9 +238,12 @@ let VariableReference = defer(() =>
     .map(element_at(1))
     .chain(into(FTL.VariableReference)));
 
+let FunctionReference = defer(() =>
+    Identifier.chain(into(FTL.FunctionReference)));
+
 let CallExpression = defer(() =>
     sequence(
-        Function.abstract,
+        FunctionReference.abstract,
         maybe(blank),
         string("("),
         maybe(blank),
@@ -350,8 +353,8 @@ let VariantKey = defer(() =>
         string("]"))
     .map(element_at(2)));
 
-/* ----------- */
-/* Identifiers */
+/* ---------- */
+/* Identifier */
 
 let Identifier =
     sequence(
@@ -362,15 +365,6 @@ let Identifier =
     .map(join)
     .chain(into(FTL.Identifier));
 
-let Function =
-    sequence(
-        charset("A-Z"),
-        repeat(
-            charset("A-Z_?-")))
-    .map(flatten(1))
-    .map(join)
-    .chain(into(FTL.Function));
-
 /* -------------------------------------------------------------------------- */
 /* Content Characters
  *

test/fixtures/call_expressions.ftl

@@ -1,3 +1,19 @@
+## Callees
+
+function-callee = {FUNCTION()}
+
+# ERROR Equivalent to a MessageReference callee.
+mixed-case-callee = {Function()}
+
+# ERROR MessageReference is not a valid callee.
+message-callee = {message()}
+# ERROR TermReference is not a valid callee.
+term-callee = {-term()}
+# ERROR VariableReference is not a valid callee.
+variable-callee = {$variable()}
+
+## Arguments
+
 positional-args = {FUN(1, "a", msg)}
 named-args = {FUN(x: 1, y: "Y")}
 dense-named-args = {FUN(x:1, y:"Y")}