parse functionCall(args).field in TS (PolymerLabs#6097)

* parse functionCall(args).field in TS

* support (paxel expression) in in new entity fields and elsewhere

* lint

src/runtime/manifest-ast-types/manifest-ast-nodes.ts

@@ -903,7 +903,7 @@ export interface FieldExpressionNode extends BaseNode {
 
 export interface FunctionExpressionNode extends BaseNode {
   kind: 'paxel-function';
-  function: PaxelFunction;
+  function: string;
   arguments: PaxelExpressionNode[];
 }
 

src/runtime/manifest-parser.pegjs

@@ -1720,7 +1720,7 @@ ExpressionEntityFields
   }
 
 ExpressionEntityField
-  = fieldName:fieldName whiteSpace? ':' whiteSpace? expression:RefinementExpression {
+  = fieldName:fieldName whiteSpace? ':' whiteSpace? expression:PaxelExpressionWithRefinement {
     return toAstNode<AstNode.ExpressionEntityField>({
         kind: 'expression-entity-field',
         name: fieldName,
@@ -1837,9 +1837,40 @@ MultiplicativeExpression
     return leftExpr;
   }
 
+FunctionArguments
+  = arg: PaxelExpressionWithRefinement rest:(multiLineSpace? ',' multiLineSpace? PaxelExpressionWithRefinement)*
+  {
+    return [arg, ...rest.map(item => item[3])];
+  }
+
+FunctionCall
+  = fn: (fieldName '(' FunctionArguments? ')' / 'creationTimestamp')
+  {
+    const fnName = fn === 'creationTimestamp' ? fn : fn[0];
+    const args = typeof(fn) !== 'string' && fn[2] || [];
+
+    if (!isPaxelMode()) {
+      if (args.length > 0) {
+        error("Functions may have arguments only in paxel expressions.");
+      }
+      if (fnName !== 'now' && fnName !== 'creationTimestamp') {
+        error('Paxel function calls other to now() are permitted only in paxel expressions.');
+      }
+      return toAstNode<AstNode.BuiltInNode>({kind: 'built-in-node', value: fnName === 'now' ? 'now()' : fnName});
+    }
+    return toAstNode<AstNode.FunctionExpressionNode>({
+      kind: 'paxel-function',
+      function: fnName,
+      arguments: args
+    });
+  }
+
 PrimaryExpression
-  = '(' whiteSpace? expr:RefinementExpression whiteSpace? ')'
+  = '(' whiteSpace? expr:PaxelExpressionWithRefinement whiteSpace? ')'
   {
+    if (!isPaxelMode() && expr.kind.indexOf('paxel-') !== -1) {
+      error('Paxel expressions are not allowed in refinements.');
+    }
     return expr;
   }
   / op:(('not' whiteSpace) / ('-' whiteSpace?)) expr:PrimaryExpression
@@ -1853,17 +1884,18 @@ PrimaryExpression
   {
     return toAstNode<AstNode.BooleanNode>({kind: 'boolean-node', value: bool.toLowerCase() === 'true'});
   }
-  / fn: ('now()' / 'creationTimestamp')
-  {
-    return toAstNode<AstNode.BuiltInNode>({kind: 'built-in-node', value: fn});
-  }
-  / fn: fieldName nested:('.' fieldName)*
+  / fn: (FunctionCall / fieldName) nested:('.' fieldName)*
   {
+    const fieldNode = typeof(fn) === 'string' && toAstNode<AstNode.FieldNode>({kind: 'field-name-node', value: fn}) || fn;
     // nested is ignored, used only to allow Paxel expressions to parse as text
-    if (!isPaxelMode() && nested && nested.length > 0) {
-      error('Scope lookups are not permitted for refinements, only in paxel expressions.');
+    if (!isPaxelMode()) {
+      if (nested && nested.length > 0) {
+        error('Scope lookups are not permitted for refinements, only in paxel expressions.');
+      }
+      return fieldNode;
     } else {
-      return toAstNode<AstNode.FieldNode>({kind: 'field-name-node', value: fn});
+      // TODO: placeholder, doesn't actually construct the correct/full AST node
+      return toAstNode<AstNode.FieldExpressionNode>({kind: 'paxel-field', scopeExpression: null, field: fieldNode});
     }
   }
   / fn: '?'

src/runtime/tests/manifest-parser-test.ts

@@ -668,6 +668,24 @@ describe('manifest parser', () => {
           input: reads Something {value: Text } [ value.x / 2 ]
         `);
     }, `Scope lookups are not permitted`);
+    assert.throws(() => {
+      parse(`
+        particle Foo
+          input: reads Something {value: Text } [ now(x) > 0 ]
+        `);
+    }, `Functions may have arguments only in paxel expressions`);
+    assert.throws(() => {
+      parse(`
+        particle Foo
+          input: reads Something {value: Text } [ average() > 0 ]
+        `);
+    }, `Paxel function calls other to now() are permitted only in paxel expressions`);
+    assert.throws(() => {
+      parse(`
+        particle Foo
+          input: reads Something {value: Text } [ (from p in q select p) > 0 ]
+        `);
+    }, `Paxel expressions are not allowed in refinements`);
   });
   it('parses nested referenced inline schemas', () => {
     parse(`
@@ -875,6 +893,34 @@ describe('manifest parser', () => {
         bar: writes Bar {y: Number} = from p in foo.x select new Bar {y: p.num / 2}
       `);
     });
+    it('allows paxel expressions in new nested entity selection', () => {
+      parse(`
+      particle Converter
+        foo: reads Foo {x: Number}
+        bar: writes Bar {y: Number} = from p in foo.x select new Bar {y: (from p in foo.z select first(p))/2}
+      `);
+    });
+    it('allows paxel expressions in new entity selection', () => {
+      parse(`
+      particle Converter
+        foo: reads Foo {x: Number}
+        bar: writes Bar {y: Number} = from p in foo.x select new Bar {y: from p in foo.z select first(p)}
+      `);
+    });
+    it('allows function calls as qualifiers', () => {
+      parse(`
+      particle Converter
+        foo: reads Foo {x: Number}
+        bar: writes Bar {y: Number} = from p in foo.x select new Bar {y: first(foo).x}
+      `);
+    });
+    it('allows complex qualifiers in where condition', () => {
+      parse(`
+      particle Converter
+        foo: reads Foo {x: Number}
+        bar: writes Bar {y: Number} = from p in foo.x where first(foo).x < p.y select new Bar {y: foo.x}
+      `);
+    });
     it('fails expression without starting from', () => {
       assert.throws(() => parse(`
       particle Converter