Add Parameterized Terms

spec/CHANGELOG.md

@@ -58,6 +58,59 @@
             on the second line of its value.
     ```
 
+  - Introduce parameterized `Terms`. (#176)
+
+    References to `Terms` can now receive parameters which will be used by
+    the runtime as values of variables referenced from within the `Term`.
+    This allows `Terms` to use regular `Patterns` as values, rather than
+    `VariantLists`:
+
+    ```properties
+    # A Term with a VariantList as a value.
+    -thing = {
+       *[definite] the thing
+       *[indefinite] a thing
+    }
+
+    this = This is { -term[indefinite] }.
+    ```
+
+    ```properties
+    # A parametrized Term with a Pattern as a value.
+    -thing = { $article ->
+       *[definite] the thing
+       *[indefinite] a thing
+    }
+
+    this = This is { -thing(article: "indefinite") }.
+    ```
+
+    Since `Patterns` can be nested, this feature allows more complex
+    hierarchies of term values:
+
+    ```properties
+    # A parametrized Term with nested Patterns.
+    -thing = { $article ->
+       *[definite] { $first-letter ->
+           *[lower] the thing
+            [upper] The thing
+        }
+        [indefinite] { $first-letter ->
+           *[lower] a thing
+            [upper] A thing
+        }
+    }
+
+    this = This is { -term(first-letter: "lower", article: "indefinite") }.
+    ```
+
+    Parameters must be named; positional parameters are ignored. If a
+    parameter is omitted then the regular default variant logic applies. The
+    above example could thus be written as `{-term(article: "indefinite")}`
+    and the `lower` variant would be used because it is marked as the default
+    one. If no parameters are specified, the paranthesis can be omitted:
+    `{-term()}` and `{-term}` are functionally the same.
+
   - Support astral Unicode characters. (#174)
 
     Unicode characters from outside of the Basic Multilingual Plane can now

spec/fluent.ebnf

@@ -65,7 +65,9 @@ MessageReference    ::= Identifier
 TermReference       ::= "-" Identifier
 VariableReference   ::= "$" Identifier
 FunctionReference   ::= Identifier
-CallExpression      ::= FunctionReference blank? "(" blank? argument_list blank? ")"
+CallExpression      ::= Callee blank? "(" blank? argument_list blank? ")"
+Callee              ::= FunctionReference
+                      | TermReference
 argument_list       ::= (Argument blank? "," blank?)* Argument?
 Argument            ::= NamedArgument
                       | InlineExpression

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,6 +68,8 @@ 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);

syntax/grammar.mjs

@@ -243,7 +243,7 @@ let FunctionReference = defer(() =>
 
 let CallExpression = defer(() =>
     sequence(
-        FunctionReference.abstract,
+        Callee.abstract,
         maybe(blank),
         string("("),
         maybe(blank),
@@ -253,6 +253,11 @@ let CallExpression = defer(() =>
     .map(keep_abstract)
     .chain(list_into(FTL.CallExpression)));
 
+let Callee =
+    either(
+        FunctionReference,
+        TermReference);
+
 let argument_list = defer(() =>
     sequence(
         repeat(

test/fixtures/call_expressions.ftl

@@ -1,14 +1,13 @@
 ## Callees
 
 function-callee = {FUNCTION()}
+term-callee = {-term()}
 
 # 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()}
 

test/fixtures/call_expressions.json

@@ -34,6 +34,35 @@
             "attributes": [],
             "comment": null
         },
+        {
+            "type": "Message",
+            "id": {
+                "type": "Identifier",
+                "name": "term-callee"
+            },
+            "value": {
+                "type": "Pattern",
+                "elements": [
+                    {
+                        "type": "Placeable",
+                        "expression": {
+                            "type": "CallExpression",
+                            "callee": {
+                                "type": "TermReference",
+                                "id": {
+                                    "type": "Identifier",
+                                    "name": "term"
+                                }
+                            },
+                            "positional": [],
+                            "named": []
+                        }
+                    }
+                ]
+            },
+            "attributes": [],
+            "comment": null
+        },
         {
             "type": "Comment",
             "content": "ERROR Equivalent to a MessageReference callee."
@@ -52,15 +81,6 @@
             "annotations": [],
             "content": "message-callee = {message()}\n"
         },
-        {
-            "type": "Comment",
-            "content": "ERROR TermReference is not a valid callee."
-        },
-        {
-            "type": "Junk",
-            "annotations": [],
-            "content": "term-callee = {-term()}\n"
-        },
         {
             "type": "Comment",
             "content": "ERROR VariableReference is not a valid callee."

test/fixtures/select_expressions.ftl

@@ -4,17 +4,29 @@ new-messages =
        *[other] {""}Other
     }
 
-valid-selector =
+valid-selector-term-attribute =
     { -term.case ->
        *[key] value
     }
 
 # ERROR
-invalid-selector =
+invalid-selector-term-value =
+    { -term ->
+       *[key] value
+    }
+
+# ERROR
+invalid-selector-term-variant =
     { -term[case] ->
        *[key] value
     }
 
+# ERROR
+invalid-selector-term-call =
+    { -term(case: "nominative") ->
+       *[key] value
+    }
+
 empty-variant =
     { 1 ->
        *[one] {""}

test/fixtures/select_expressions.json

@@ -81,7 +81,7 @@
             "type": "Message",
             "id": {
                 "type": "Identifier",
-                "name": "valid-selector"
+                "name": "valid-selector-term-attribute"
             },
             "value": {
                 "type": "Pattern",
@@ -137,7 +137,25 @@
         {
             "type": "Junk",
             "annotations": [],
-            "content": "invalid-selector =\n    { -term[case] ->\n       *[key] value\n    }\n"
+            "content": "invalid-selector-term-value =\n    { -term ->\n       *[key] value\n    }\n"
+        },
+        {
+            "type": "Comment",
+            "content": "ERROR"
+        },
+        {
+            "type": "Junk",
+            "annotations": [],
+            "content": "invalid-selector-term-variant =\n    { -term[case] ->\n       *[key] value\n    }\n"
+        },
+        {
+            "type": "Comment",
+            "content": "ERROR"
+        },
+        {
+            "type": "Junk",
+            "annotations": [],
+            "content": "invalid-selector-term-call =\n    { -term(case: \"nominative\") ->\n       *[key] value\n    }\n"
         },
         {
             "type": "Message",

test/fixtures/term_parameters.ftl

@@ -0,0 +1,8 @@
+-term = { $arg ->
+   *[key] Value
+}
+
+key01 = { -term }
+key02 = { -term() }
+key03 = { -term(arg: 1) }
+key04 = { -term("positional", narg1: 1, narg2: 2) }