@sap/cds-compiler 5.7.2 → 5.8.0

package/lib/gen/Dictionary.json

@@ -132,6 +132,13 @@
         "Collection"
       ]
     },
+    "Analytics.LevelInformation": {
+      "Type": "Hierarchy.HierarchyType",
+      "AppliesTo": [
+        "EntityType"
+      ],
+      "$experimental": true
+    },
     "Authorization.SecuritySchemes": {
       "Type": "Collection(Authorization.SecurityScheme)",
       "AppliesTo": [
@@ -1121,6 +1128,13 @@
       ],
       "$experimental": true
     },
+    "Common.AddressViaNavigationPath": {
+      "Type": "Core.Tag",
+      "AppliesTo": [
+        "EntityContainer"
+      ],
+      "$experimental": true
+    },
     "Communication.Contact": {
       "Type": "Communication.ContactType",
       "AppliesTo": [
@@ -1519,7 +1533,7 @@
       "$experimental": true
     },
     "EntityRelationship.referencesWithConstantIds": {
-      "Type": "Collection(EntityRelationship.referencesWithConstantId)",
+      "Type": "Collection(EntityRelationship.referenceWithConstantId)",
       "AppliesTo": [
         "EntityType"
       ],
@@ -1575,8 +1589,7 @@
       ]
     },
     "HTML5.LinkTarget": {
-      "Type": "HTML5.LinkTargetType",
-      "$experimental": true
+      "Type": "HTML5.LinkTargetType"
     },
     "HTML5.RowSpanForDuplicateValues": {
       "Type": "Core.Tag",
@@ -1894,8 +1907,7 @@
         "Function",
         "ActionImport",
         "FunctionImport"
-      ],
-      "$experimental": true
+      ]
     },
     "UI.SelectionPresentationVariant": {
       "Type": "UI.SelectionPresentationVariantType",
@@ -2525,6 +2537,30 @@
         "AccumulativeMeasure": "Core.Tag"
       }
     },
+    "Analytics.MultiLevelExpandLevel": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "DimensionProperties": "Collection(Edm.String)",
+        "AdditionalProperties": "Collection(Edm.String)"
+      },
+      "$experimental": true
+    },
+    "Analytics.MultiLevelExpandSiblingOrder": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "Property": "Edm.String",
+        "Descending": "Edm.Boolean"
+      },
+      "$experimental": true
+    },
+    "Analytics.MultiLevelExpandEntry": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "Entry": "Collection(Edm.String)",
+        "Levels": "Edm.Int64"
+      },
+      "$experimental": true
+    },
     "Authorization.SecurityScheme": {
       "$kind": "ComplexType",
       "Properties": {
@@ -3964,16 +4000,26 @@
       },
       "$experimental": true
     },
+    "Hierarchy.HierarchyType": {
+      "$kind": "ComplexType",
+      "Properties": {
+        "LimitedDescendantCount": "Edm.Int64",
+        "DrillState": "Edm.String",
+        "DistanceFromRoot": "Edm.Int64"
+      },
+      "$experimental": true
+    },
     "Hierarchy.RecursiveHierarchyType": {
       "$kind": "ComplexType",
+      "BaseType": "Hierarchy.HierarchyType",
       "Properties": {
         "ExternalKey": "Edm.String",
         "NodeType": "Edm.String",
-        "ChildCount": "Edm.Int64",
-        "DescendantCount": "Edm.Int64",
         "LimitedDescendantCount": "Edm.Int64",
         "DrillState": "Edm.String",
         "DistanceFromRoot": "Edm.Int64",
+        "ChildCount": "Edm.Int64",
+        "DescendantCount": "Edm.Int64",
         "LimitedRank": "Edm.Int64",
         "SiblingRank": "Edm.Int64",
         "Matched": "Edm.Boolean",
@@ -3987,7 +4033,8 @@
         "ChangeNextSiblingAction": "Common.QualifiedName",
         "ChangeSiblingForRootsSupported": "Edm.Boolean",
         "CopyAction": "Common.QualifiedName"
-      }
+      },
+      "$experimental": true
     },
     "Hierarchy.TopLevelsExpandType": {
       "$kind": "ComplexType",

package/lib/json/from-csn.js

@@ -124,6 +124,7 @@ const { isAnnotationExpression } = require('../base/builtins');
 const { CompilerAssertion } = require('../base/error');
 const { Location } = require('../base/location');
 const { XsnSource } = require('../compiler/xsn-model');
+const { xprAsTree } = require('../parsers/XprTree');
 
 const $location = Symbol.for('cds.$location');
 
@@ -529,7 +530,7 @@ const schema = compileSchema( {
       'from', 'all', 'distinct', 'columns', 'excluding', // no 'mixin'
       'where', 'groupBy', 'having', 'orderBy', 'limit',
     ],
-    inKind: [ 'entity', 'event' ],
+    inKind: [ 'entity', 'event', 'type' ],
   },
   SELECT: {
     type: queryTerm,
@@ -664,7 +665,7 @@ const schema = compileSchema( {
         ],
         schema: {
           '=': {
-            type: renameTo( '$tokenTexts', string ),
+            type: renameTo( '$tokenTexts', stringOrBool ),
             xorGroups: null, // reset xorGroup; allow '=' for all :expr
           },
         },
@@ -698,7 +699,8 @@ const schema = compileSchema( {
     // 2. Inside "xpr"     => inside expressions
     // Because of (1) we have to set this property to false.
     inValue: false,
-    optional: typeProperties, // TODO: only in CDL-style cast, otherwise just length,…
+    optional: typeProperties,
+    // TODO v6: only in CDL-style cast, otherwise just length,…
     inKind: [ '$column' ],
   },
   default: {
@@ -762,6 +764,9 @@ const schema = compileSchema( {
   options: {                    // deprecated top-level property
     type: ignore,
   },
+  csnInteropEffective: {
+    type: ignore,               // by https://github.com/SAP/csn-interop-specification
+  },
   indexNo: {                    // CSN v0.1.0, but ignored without message
     ignore: true, type: ignore,
   },
@@ -787,6 +792,7 @@ const topLevelSpec = {
   optional: [
     'requires', 'definitions', 'vocabularies', 'extensions', 'i18n',
     'namespace', 'version', 'messages', 'meta', 'options', '@', '$location',
+    'csnInteropEffective',
   ],
   requires: false,              // empty object OK
   schema,
@@ -1316,6 +1322,14 @@ function string( val, spec ) {
   return ignore( val );
 }
 
+function stringOrBool( val, spec ) {
+  if (typeof val === 'string' && val || typeof val === 'boolean')
+    return val;
+  error( 'syntax-expecting-string', location(true),
+         { '#': spec.msgVariant || 'or-bool', prop: spec.msgProp } );
+  return ignore( val );
+}
+
 function stringVal( val, spec ) {
   if (typeof val === 'string' && val)
     //  XSN TODO: do not require literal
@@ -1440,12 +1454,12 @@ function annoValue( val, spec ) {
     }
     return retval;
   }
-  else if (typeof val['='] === 'string') {
+  else if (typeof val['='] === 'string' || val['='] === true) {
     // An object with `=` is an expression if and only if:
     //  - there is exactly one property ('=')
     //  - there is at least one other expression property (e.g. "xpr")
     const valKeys = Object.keys( val );
-    if (valKeys.length === 1) {
+    if (valKeys.length === 1 && typeof val['='] === 'string') {
       ++virtualLine;
       const r = refSplit( val['='], '=' ); // i.e. no extra `variant` stuff
       ++virtualLine;
@@ -1566,12 +1580,16 @@ function xpr( exprs, spec, xsn, csn ) {
              { prop: 'xpr', siblingprop: 'func', '#': 'suffix' });
     }
     xsn.suffix = exprArgs( exprs, spec );
+    if (exprs.length > 2)
+      xsn.suffix = xprAsTree( exprs, xsn.suffix, xsn.op.location ).args;
   }
   else {
     // setting $parens here would not always be correct; thus, keep distinction
     // between 'xpr' and 'ixpr' (”internal” `xpr` = without implicit parens)
     xsn.op = { val: 'xpr', location: location() };
     xsn.args = exprArgs( exprs, spec );
+    if (exprs.length > 2)
+      xsn.args = xprAsTree( exprs, xsn.args, xsn.op.location ).args;
   }
 }
 
@@ -1620,11 +1638,10 @@ function expr( e, spec ) {
   if (Array.isArray( e )) {
     if (e.length > 1) {         // struct-xpr
       const loc = location();
-      return {
-        op: { val: 'ixpr', location: loc },
-        args: exprArgs( e, spec ),
-        location: loc,
-      };
+      const xsn = exprArgs( e, spec );
+      return (e.length < 3)     // optimization
+        ? { op: { val: 'ixpr', location: loc }, args: xsn, location: loc }
+        : xprAsTree( e, xsn, loc );
     }
     else if (e.length === 1) { // CSN v.0.1.0 way for parentheses
       const loc = location();
@@ -1657,14 +1674,14 @@ function exprOrString( val, spec ) {
     : expr( val, spec );
 }
 
-// mark path argument of 'exits' predicate with $expected:'exists'
+// mark path argument of 'exists' predicate with $expected:'exists'
 function exprArgs( cond, spec ) {
   const rxsn = arrayOf( exprOrString )( cond, spec );
   // TODO: do that in definer.js, neither here nor in CDL parser
   if (Array.isArray( rxsn )) {
     for (let i = 0; i < rxsn.length - 1; i++) {
       // TODO: disallow param ref - write test
-      if (rxsn[i]?.val === 'exists' && rxsn[i].literal === 'token' && rxsn[i + 1].path)
+      if (cond[i] === 'exists' && rxsn[i + 1].path)
         rxsn[++i].$expected = 'exists';
     }
   }
@@ -1673,11 +1690,14 @@ function exprArgs( cond, spec ) {
 
 function condition( cond, spec ) {
   const loc = location();
-  return {
-    op: { val: 'xpr', location: loc },
-    args: exprArgs( cond, spec ),
-    location: loc,
-  };
+  const xsn = exprArgs( cond, spec );
+  // TODO sql-like backends: with the commented `return`, test3 generated sql
+  // files will not have the unnecessary `(…)` around `on` anymore → extra PR
+  const tree = (cond.length < 3) ? xsn : xprAsTree( cond, xsn, loc ).args;
+  return { op: { val: 'xpr', location: loc }, args: tree, location: loc };
+  // return (cond.length < 3)      // optimization
+  //   ? { op: { val: 'ixpr', location: loc }, args: xsn, location: loc }
+  //   : xprAsTree( cond, xsn, loc );
 }
 
 // Queries (std signature) ---------------------------------------------------

package/lib/json/to-csn.js

@@ -1147,6 +1147,8 @@ function value( node ) {
 }
 
 function enumValue( node ) {
+  if (node.val !== undefined)   // with `val` via CSN input (e.g. recompilation)
+    return extra( { '#': node.sym.id, val: node.val }, node );
   const r = extra( { '#': node.sym.id }, node );
   const sym = node.sym._artifact;
   // add calculated `val`, but not for chained symbols:
@@ -1276,6 +1278,8 @@ function exprInternal( node, xprParens ) {
 function flattenInternalXpr( array, op ) {
   if (!structXpr)
     return array.flat( Infinity );
+  // TODO: do not rely on 'nary' - this dosn't work with CSN input have an
+  // `xpr: [{val:1},'+',{val:2},'+',{val:3}]`.
   if (array.length < 5 || op !== 'nary')
     return array;
   // nary: [ ‹a›, '+', ‹b›, '+', ‹c› ] → [ [ ‹a›, '+', ‹b› ], '+', ‹c› ]

package/lib/language/genericAntlrParser.js

@@ -853,6 +853,10 @@ function valuePathAst( ref ) {
     const implicit = this.previousTokenAtLocation( location );
     if (implicit && implicit.isIdentifier)
       implicit.isIdentifier = 'func';
+
+    const filter = path[0].cardinality || path[0].where;
+    if (filter)
+      this.message( 'syntax-unexpected-filter', filter.location, {} );
     const op = { location, val: 'call' };
     return (args)
       ? {
@@ -881,6 +885,9 @@ function valuePathAst( ref ) {
       }, 'References after function calls can\'t be resolved. Use $(CODE) in function arguments');
       break;
     }
+    const filter = path[i].cardinality || path[i].where;
+    if (filter)
+      this.message( 'syntax-unexpected-filter', filter.location, {} );
   }
 
   const args = [];

package/lib/main.d.ts

@@ -172,7 +172,6 @@ declare namespace compiler {
     withLocations?: boolean|string
     /**
      * Use the new non-ANTLR based parser for compilation.
-     * Experimental flag!
      *
      * @since v5.2.0
      */
@@ -934,6 +933,11 @@ declare namespace compiler {
     /**
      * Renders the given CSN into a CDL source representation.
      *
+     * The CDL string representation may change between minor @sap/cds-compiler
+     * versions, but when compiled, will return the same CSN again.
+     * Hence, stylistic changes such as additional whitespace is not considered
+     * a breaking change.
+     *
      * @returns Object containing the rendered model.
      */
     function cdl(csn: CSN, options?: CdlOptions): CdlResult;

package/lib/model/cloneCsn.js

@@ -38,6 +38,7 @@ const internalCsnProps = {
   $default: shallowCopy, // used for HANA CSN migrations
   $notNull: shallowCopy, // used for HANA CSN migrations
   $sqlService: shallowCopy,
+  $dummyService: shallowCopy,
 };
 const internalEnumerableCsnProps = {
   __proto__: null,

package/lib/model/csnRefs.js

@@ -170,6 +170,7 @@
 //   any reference in the entity is inspected: with data for the query
 //   hierarchy, query number, table aliases and links from a column to its
 //   respective inferred element.
+// - TODO: some `name` property would also be useful (set with `initDefinition`)
 
 // Properties in cache:
 //

package/lib/model/csnUtils.js

@@ -1179,10 +1179,6 @@ function applyAnnotationsFromExtensions( csn, config ) {
   }
 }
 
-function isAspect( node ) {
-  return node && node.kind === 'aspect';
-}
-
 /**
  * Return true if the artifact has a valid, truthy persistence.exists/skip annotation
  *
@@ -1446,7 +1442,6 @@ module.exports = {
   normalizeTypeRef,
   copyAnnotations,
   copyAnnotationsAndDoc,
-  isAspect,
   hasValidSkipOrExists,
   getNamespace,
   getServiceNames,

package/lib/modelCompare/utils/filter.js

@@ -91,10 +91,10 @@ function getFilterObject( options, dialect, extensionCallback, migrationCallback
         if (migration.new.type === migration.old.type && migration.new.length < migration.old.length) {
           raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-length-change', id => message(id, loc, { '#': messageVariant, id: name }));
         }
-        else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale) {
+        else if (migration.new.type === migration.old.type && migration.new.scale < migration.old.scale || migration.new.precision - migration.old.precision < migration.new.scale - migration.old.scale) {
           raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-scale-change', id => message(id, loc, { '#': messageVariant, id: name }));
         }
-        else if (migration.new.type === migration.old.type && migration.new.precision !== migration.old.scale) {
+        else if (migration.new.type === migration.old.type && migration.new.precision < migration.old.precision) {
           raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-precision-change', id => message(id, loc, { '#': messageVariant, id: name }));
         }
         else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type)) {

package/lib/optionProcessor.js

@@ -580,6 +580,7 @@ optionProcessor.command('forEffective')
   .option('--resolve-projections <val>', { valid: ['true', 'false'] } )
   .option('--remap-odata-annotations <val>', { valid: ['true', 'false'] } )
   .option('--keep-localized <val>', { valid: ['true', 'false'] } )
+  .option('--effective-service-name <name>')
   .positionalArgument('<files...>')
   .help(`
   Usage: cdsc forEffective [options] <files...>
@@ -602,6 +603,7 @@ optionProcessor.command('forEffective')
        --keep-localized <val>            Keep '.localized' property in the CSN:
                                           true:           property is kept
                                           false:(default) property is deleted
+       --effective-service-name <name>   Filter the output CSN to only contain the given service
 `);
 
 optionProcessor.command('forSeal')

package/lib/parsers/AstBuildingParser.js

@@ -48,7 +48,7 @@ const PRECEDENCE_OF_IN_PREDICATE = 10;
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
-  leanConditions = { afterBrace: true, fail: true };
+  leanConditions = { afterBrace: true, atRightParen: true, fail: true };
 
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
@@ -171,7 +171,7 @@ class AstBuildingParser extends BaseParser {
     this.dynamic_.generic = spec ? spec[call.argPos] : specialFunctions[''][1];
   }
 
-  lGenericIntroOrExpr( tryGenericIntro = true ) {
+  lGenericIntroOrExpr( _mode, tryGenericIntro = true ) {
     const { keyword, type } = this.la();
     // TODO: use lower-case in specialFunctions
     const text = typeof keyword === 'string' ? keyword.toUpperCase() : type;
@@ -180,37 +180,44 @@ class AstBuildingParser extends BaseParser {
       if (this.dynamic_.generic?.IN === 'separator')
         this.prec_ = PRECEDENCE_OF_IN_PREDICATE; // only expressions if `in` is separator
       if (generic !== 'expr')
-        return (generic === 'intro') ? 'GenericIntro' : 'Id';
+        return (generic === 'intro') ? 'GenericIntro' : type;
+      // if both intro and expr: specialFunctions[fn][argPos][token] = 'expr'
       const next = this.tokens[this.tokenIdx + 1];
-      if (next.type !== ',' && next.type !== ')' &&
+      if (next && next.type !== ',' && next.type !== ')' &&
           this.dynamic_.generic[next.keyword?.toUpperCase?.()] !== 'separator')
         return 'GenericIntro';
     }
-    return (generic === 'expr') ? 'GenericExpr' : 'Id';
+    return (generic === 'expr') ? 'GenericExpr' : type;
   }
 
   lGenericExpr() {
-    return this.lGenericIntroOrExpr( false );
+    return this.lGenericIntroOrExpr( null, false );
   }
 
-  lGenericSeparator() {         // TODO: { keyword, type } as arg ?
+  lGenericSeparator() {
     const { keyword, type } = this.la();
     // TODO: use lower-case in specialFunctions
     const text = typeof keyword === 'string' ? keyword.toUpperCase() : type;
     const generic = this.dynamic_.generic?.[text];
-    return (generic === 'separator') ? 'GenericSeparator' : ',';
+    return (generic === 'separator') ? 'GenericSeparator' : type;
   }
 
   addTokenToSet_( set, tokenName, val, collectKeywordsOnly ) {
-    const realTokens = parserTokens[tokenName] && this.dynamic_.generic?.[parserTokens[tokenName]];
-    // TODO: avoid 2nd parserTokens dict use, use lower-case in specialFunctions
-    if (!realTokens) {
-      super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
-    }
-    else {
+    const token = parserTokens[tokenName];
+    // TODO: use lower-case in specialFunctions
+    const realTokens = token && this.dynamic_.generic?.[token];
+    if (realTokens) {
       for (const t of realTokens)
         super.addTokenToSet_( set, t.toLowerCase(), val, collectKeywordsOnly );
     }
+    else if (tokenName === 'DeleteStarFromSet') { // in rule `argumentsAndFilter`
+      // TODO: workaround for (`GenericExpr : Id_all | '*'`), see #13485.
+      // Works, since `DeleteStarFromSet` comes after `*` (length-sorted):
+      delete set['*'];
+    }
+    else {
+      super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
+    }
   }
 
   inSelectItem( _test, arg ) {  // only as action
@@ -334,7 +341,7 @@ class AstBuildingParser extends BaseParser {
   }
 
   /**
-   * Prepare element restrictions and check validility of final anno assignments.
+   * Prepare element restrictions and check validity of final anno assignments.
    *
    * Called as <prepare=…>:
    *
@@ -432,27 +439,49 @@ class AstBuildingParser extends BaseParser {
    * `;` between statements is optional only after a `}` (ex braces of structure
    * values for annotations and foreign key specifications).
    *
+   * Unfortunate exception: always optional after `entity … as projection on`.
+   *
    * Beware: mentioned in leanConditions, i.e. executed in predictions!
    */
   afterBrace( test, arg ) {
     if (!test) {
-      this.afterBrace$
-        = (!arg || this.afterBrace$ > 0 && this.tokens[this.afterBrace$ - 1].keyword === arg)
-          ? this.tokenIdx
-          : -1;
+      if (arg === 'normal' && this.lb().type !== '}') {
+        const { type, keyword } = this.la();
+        if (type !== ';' && type !== '}' && type !== 'EOF' && keyword !== 'actions') {
+          const prev = this.lb().location;
+          const loc = new Location( prev.file, prev.endLine, prev.endCol );
+          this.warning( 'syntax-missing-proj-semicolon', loc,
+                        { expecting: [ "';'" ], offending: this.antlrName( this.la() ) },
+                        'Missing $(EXPECTING) before $(OFFENDING)');
+        }
+      }
+      // with arg 'init' (used in rule `start`/`artifactsBlock`), and arg 'sloppy'
+      // or 'normal' (used in rule `entityDef`), set marker in dynamic context:
+      if (!arg)
+        this.afterBrace$ = this.tokenIdx;
+      else if (arg === 'init')
+        this.dynamic_.sloppySemicolon$ = [ false ];
+      else if (arg === 'sloppy' || this.la().keyword === 'actions')
+        this.dynamic_.sloppySemicolon$[0] = (arg === 'sloppy');
+      return null;
     }
     // TODO TOOL: the following test belongs to the BaseParser.js:
     if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
         this.conditionStackLength == null && // after error recover
         test !== 'M')
       return false;
-    // Strange optional `;` after PROJECTION ON source: the rule exit prediction
-    // for fromRefWithOptAlias etc now checks C(afterBrace):
-    if (test === 'E' && this.afterBrace$ > 0 &&
-        this.tokens[this.afterBrace$ - 1]?.keyword === 'projection' &&
-        this.tokens[this.afterBrace$].keyword === 'on')
-      return false;
-    return this.afterBrace$ !== this.tokenIdx;
+    const { sloppySemicolon$ } = this.dynamic_;
+    if (!sloppySemicolon$?.[0])
+      return this.afterBrace$ !== this.tokenIdx;
+    if (test === true && sloppySemicolon$) // TODO: single-let mode for running parser
+      sloppySemicolon$[0] = false;
+    return this.afterBrace$ !== this.tokenIdx && test === 'M';
+    // TODO: should we always fail for expected set (test === 'M'), at least if
+    // token is not on a new line?
+  }
+
+  atRightParen() {
+    return this.l() !== ')';
   }
 
   /**
@@ -731,14 +760,15 @@ class AstBuildingParser extends BaseParser {
   }
 
   taggedIfQuery( query ) {
-    return (query.op && queryOps[query.op.val])
+    // attached actions are run even if rules ends prematurely → query can be
+    // undefined
+    return (query?.op && queryOps[query.op.val])
       ? { query, location: query.$parens?.at( -1 ) ?? query.location }
       : query;
   }
 
-  addNamedArg( args, idToken, expr ) {
-    expr.name = this.identAst( idToken );
-    (args.args ?? args)[expr.name.id] = expr;
+  addNamedArg( pathItem, idToken, expr ) {
+    this.addDef( expr, pathItem, 'args', 0, this.identAst( idToken ) );
   }
 
   ixprAst( args ) {
@@ -1096,7 +1126,6 @@ class AstBuildingParser extends BaseParser {
   }
 
   // make sure that the parens of `IN (…)` do not disappear:
-  // TODO: make this a to-csn thing
   secureParens( expr ) {
     const op = expr?.op?.val;
     const $parens = expr?.$parens;
@@ -1155,6 +1184,10 @@ class AstBuildingParser extends BaseParser {
       // TODO: we could have an opt(?) parameter funcToken for speed-up (passing this.lr())
       if (funcToken)
         funcToken.parsedAs = 'func';
+
+      const filter = path[0].cardinality || path[0].where; // XSN TODO: filter$location
+      if (filter) // TODO v7: make this be reported via guard, as error
+        this.message( 'syntax-unexpected-filter', filter.location, {} );
       // TODO: XSN representation of functions is a bit strange - rework
       const op = { location, val: 'call' };
       return this.attachLocation( { op, func: ref, args } );
@@ -1171,13 +1204,18 @@ class AstBuildingParser extends BaseParser {
     // Everything after the first function is also a function, and not a reference.
 
     for (let i = firstFunc; i < path.length; ++i) {
-      if (path[i].args && path[i].$syntax === ':') {
+      const item = path[i];
+      if (item.args && item.$syntax === ':') {
         // Error for `a(P => 1).b.c(P: 1)`: no ref after function.
-        this.error( 'syntax-invalid-ref', path[i].args[$location], {
+        // TODO v6: make this be reported via guard
+        this.error( 'syntax-invalid-ref', item.args[$location], {
+          // TODO: msg text - huh? → syntax-invalid-named-arg ?
           code: '=>',
         }, 'References after function calls can\'t be resolved. Use $(CODE) in function arguments');
-        break;
       }
+      const filter = item.cardinality || item.where; // XSN TODO: filter$location
+      if (filter) // TODO v7: make this be reported via guard, as error
+        this.message( 'syntax-unexpected-filter', filter.location, {} );
     }
 
     const args = [];