Add Parameterized Terms

Author: stasm

spec/fluent.ebnf

@@ -64,7 +64,10 @@ NumberLiteral       ::= "-"? digit+ ("." digit+)?
 MessageReference    ::= Identifier
 TermReference       ::= "-" Identifier
 VariableReference   ::= "$" Identifier
-CallExpression      ::= Function blank? "(" blank? argument_list blank? ")"
+FunctionReference   ::= Identifier
+CallExpression      ::= Callee blank? "(" blank? argument_list blank? ")"
+Callee              ::= FunctionReference
+                      | TermReference
 argument_list       ::= (Argument blank? "," blank?)* Argument?
 Argument            ::= NamedArgument
                       | InlineExpression
@@ -79,9 +82,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
  *

spec/valid.md

@@ -54,5 +54,6 @@ Invalid Select Expressions:
 
     SelectExpression.selector > MessageReference
     SelectExpression.selector > TermReference
+    SelectExpression.selector > CallExpression.callee > TermReference
     SelectExpression.selector > VariantExpression
     SelectExpression.selector > AttributeExpression.ref > MessageReference

syntax/abstract.mjs

@@ -68,11 +68,13 @@ export function list_into(Type) {
                 let invalid_selector_found =
                     selector instanceof FTL.MessageReference
                     || selector instanceof FTL.TermReference
+                    || (selector instanceof FTL.CallExpression
+                        && selector.callee instanceof FTL.TermReference)
                     || selector instanceof FTL.VariantExpression
                     || (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 +96,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

@@ -239,9 +239,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,
+        Callee.abstract,
         maybe(blank),
         string("("),
         maybe(blank),
@@ -251,6 +254,11 @@ let CallExpression = defer(() =>
     .map(keep_abstract)
     .chain(list_into(FTL.CallExpression)));
 
+let Callee =
+    either(
+        FunctionReference,
+        TermReference);
+
 let argument_list = defer(() =>
     sequence(
         repeat(
@@ -352,7 +360,7 @@ let VariantKey = defer(() =>
     .map(element_at(2)));
 
 /* ----------- */
-/* Identifiers */
+/* Identifier */
 
 let Identifier =
     sequence(
@@ -363,15 +371,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,15 @@
+## Callees
+
+function-callee = {FUNCTION()}
+term-callee = {-term()}
+
+# ERROR MessageReference is not a valid callee.
+message-callee = {message()}
+# 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")}