@sap/cds-compiler 3.4.2 → 3.4.4

package/lib/language/genericAntlrParser.js

@@ -89,6 +89,7 @@ Object.assign(GenericAntlrParser.prototype, {
   unaryOpForParens,
   leftAssocBinaryOp,
   classifyImplicitName,
+  warnIfColonFollows,
   fragileAlias,
   identAst,
   functionAst,
@@ -109,7 +110,6 @@ Object.assign(GenericAntlrParser.prototype, {
   createArray,
   finalizeDictOrArray,
   createPrefixOp,
-  setOnce,
   setMaxCardinality,
   pushIdent,
   handleComposition,
@@ -117,7 +117,6 @@ Object.assign(GenericAntlrParser.prototype, {
   reportExpandInline,
   checkTypeFacet,
   csnParseOnly,
-  disallowElementExtension,
   noAssignmentInSameLine,
   noSemicolonHere,
   setLocalToken,
@@ -217,29 +216,12 @@ function setLocalTokenForId( tokenNameMap ) {
 //     // throw new antlr4.error.InputMismatchException(this);
 // }
 
-/**
- * For element extensions (`extend E:elem` syntax).
- * If `elemName.path` is set, remove the last extension from `$outer` and
- * emit an error that the extension is invalid.
- *
- * @param {object} elemName
- * @param {object} outer
- * @param {string} extensionVariant
- */
-function disallowElementExtension(elemName, outer, extensionVariant) {
-  if (elemName.path) {
-    const loc = this.tokenLocation(this.getCurrentToken());
-    this.error( 'syntax-invalid-extend', loc, { kind: extensionVariant } );
-    // remove last, i.e. new extension
-    outer.extensions.pop();
-  }
-}
-
 function noAssignmentInSameLine() {
   const t = this.getCurrentToken();
   if (t.text === '@' && t.line <= this._input.LT(-1).line) {
-    this.warning( 'syntax-anno-same-line', t, {},
-                  'Annotation assignment belongs to next statement' );
+    this.warning( 'syntax-missing-newline', t, { anno: '‹anno›' }, // TODO: single quotes, @()
+                  // eslint-disable-next-line max-len
+                  'Add a newline before $(ANNO) to indicate that it belongs to the next statement' );
   }
 }
 
@@ -267,7 +249,7 @@ const genericTokenTypes = {
   intro: 'GenericIntro',
 };
 
-function prepareGenericKeywords( pathItem, expected = null) {
+function prepareGenericKeywords( pathItem, expected = null ) {
   const length = pathItem?.args?.length || 0;
   const argPos = (expected ? length - 1 : length);
   const func = pathItem?.id && specialFunctions[pathItem.id.toUpperCase()];
@@ -492,7 +474,7 @@ function tokenLocation( token, endToken = null ) {
   return loc;
 }
 
-function isMultiLineToken(token) {
+function isMultiLineToken( token ) {
   return (
     token.type === this.constructor.DocComment ||
     token.type === this.constructor.String ||
@@ -584,6 +566,17 @@ function unaryOpForParens( query, val ) {
   return { op: { val, location }, location, args: [ query ] };
 }
 
+// ANTLR on some OS might corrupt non-ASCII chars for messages
+function warnIfColonFollows( anno ) {
+  const t = this.getCurrentToken();
+  if (t.text === ':') {
+    this.warning( 'syntax-missing-parens', anno.name.location,
+                  { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
+                  // eslint-disable-next-line max-len
+                  'When $(CODE) is followed by $(OP), use $(NEWCODE) for annotation assignments at this position' );
+  }
+}
+
 // If the token before the current one is a doc comment (ignoring other tokens
 // on the hidden channel), put its "cleaned-up" text as value of property `doc`
 // of arg `node` (which could be an array).  Complain if `doc` is already set.
@@ -611,9 +604,9 @@ function docComment( node ) {
 
 // Classify token (identifier category) for implicit names,
 // to be used in the empty alternative to AS <explicitName>.
-function classifyImplicitName( category, ref ) {
+function classifyImplicitName( category, ref, tokpos = 1 ) {
   if (!ref || ref.path && this.getCurrentToken().text !== '.') {
-    const implicit = this._input.LT(-1);
+    const implicit = this._input.LT( tokpos - 1 || -1 );
     if (implicit.isIdentifier)
       implicit.isIdentifier = category;
   }
@@ -623,11 +616,11 @@ function fragileAlias( ast, safe = false ) {
   if (this.getCurrentToken().text === '.')
     return ast;
   if (safe || ast.$delimited || !/^[a-zA-Z][a-zA-Z_]+$/.test( ast.id )) {
-    this.warning( 'syntax-sloppy-alias', ast.location, { keyword: 'as' },
+    this.warning( 'syntax-deprecated-auto-as', ast.location, { keyword: 'as' },
                   'Please add the keyword $(KEYWORD) in front of the alias name' );
   }
   else {                         // configurable error
-    this.message( 'syntax-fragile-alias', ast.location, { keyword: 'as' },
+    this.message( 'syntax-missing-as', ast.location, { keyword: 'as' },
                   'Please add the keyword $(KEYWORD) in front of the alias name' );
   }
   return ast;
@@ -642,10 +635,9 @@ function identAst( token, category, noTokenTypeCheck = false ) {
     id = '';
   if (token.text[0] === '!') {
     id = id.slice( 2, -1 ).replace( /]]/g, ']' );
-    if (!id) {
-      this.error( 'syntax-empty-ident', token, {},
-                  'Delimited identifier must contain at least one character' );
-    }
+    if (!id)
+      this.message( 'syntax-invalid-name', token, {} );
+
     // $delimited is used to complain about ![$self] and other magic vars usage;
     // we might complain about that already here via @arg{category}
     return { id, $delimited: true, location: this.tokenLocation( token ) };
@@ -655,8 +647,7 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   // delimited:
   id = id.slice( 1, -1 ).replace( /""/g, '"' );
   if (!id) {
-    this.error( 'syntax-empty-ident', token, {},
-                'Delimited identifier must contain at least one character' );
+    this.message( 'syntax-invalid-name', token, {} );
   }
   else {
     this.message( 'syntax-deprecated-ident', token, { delimited: id },
@@ -705,7 +696,7 @@ function valuePathAst( ref ) {
     const item = path.find( i => i.args && i.$syntax !== ':' );
     if (!item)
       return ref;
-    this.error( 'syntax-not-supported', item.location, {},
+    this.error( 'syntax-unsupported-method', item.location, {},
                 'Methods in expressions are not supported yet' );
     path.broken = true;
     path.length = 1;
@@ -819,7 +810,7 @@ function quotedLiteral( token, literal ) {
     location,
   };
 
-  function atChar(i) {
+  function atChar( i ) {
     // Is only used with single-line strings.
     return location.col + pos + i;
   }
@@ -843,7 +834,7 @@ function pushIdent( path, ident, prefix ) {
         endLine: ident.location.line,
         endCol: ident.location.col,
       };
-      this.error( 'syntax-anno-space', wsLocation, {}, // TODO: really Error?
+      this.error( 'syntax-unexpected-space', wsLocation, {}, // TODO: really Error?
                   'Expected identifier after \'@\' but found whitespace' );
     }
     ident.location.line = tokenLoc.line;
@@ -900,15 +891,15 @@ function addDef( art, parent, env, kind, name ) {
     dictAdd( parent[env], art.name.id, art, ( duplicateName, loc ) => {
       // do not use function(), otherwise `this` is wrong:
       if (kind === 0) {
-        this.error( 'duplicate-argument', loc, { name: duplicateName },
+        this.error( 'syntax-duplicate-argument', loc, { name: duplicateName },
                     'Duplicate value for parameter $(NAME)' );
       }
       else if (kind === '') {
-        this.error( 'duplicate-excluding', loc, { name: duplicateName, keyword: 'excluding' },
-                    'Duplicate $(NAME) in the $(KEYWORD) clause' );
+        this.error( 'syntax-duplicate-excluding', loc,
+                    { name: duplicateName, keyword: 'excluding' } );
       }
       else {
-        this.error( 'duplicate-prop', loc, { name: duplicateName },
+        this.error( 'syntax-duplicate-property', loc, { name: duplicateName },
                     'Duplicate value for structure property $(NAME)' );
       }
     } );
@@ -1026,33 +1017,14 @@ function leftAssocBinaryOp( left, opToken, eToken, right, extraProp = 'quantifie
   return { op, args: [ left, right ], location: left.location };
 }
 
-// Set property `prop` of `target` to value `value`.  Issue error if that
-// property has been set before, while mentioning the keywords previously
-// provided (as arguments `tokens`).
-function setOnce( target, prop, value, ...tokens ) {
-  const loc = this.tokenLocation( tokens[0], tokens[tokens.length - 1] );
-  const prev = target[prop];
-  if (prev) {
-    this.error( 'syntax-repeated-option', loc, { option: prev.option },
-                'Option $(OPTION) has already been specified' );
-  }
-  if (typeof value === 'boolean') {
-    if (!value)
-      loc.value = false;
-    value = loc;
-  }
-  value.option = tokens.map( t => t.text.toUpperCase() ).join(' ');
-  target[prop] = value;
-}
-
 function setMaxCardinality( art, token, max ) {
   const location = this.tokenLocation( token );
   if (!art.cardinality) {
     art.cardinality = { targetMax: Object.assign( { location }, max ), location };
   }
   else {
-    this.warning( 'syntax-repeated-cardinality', location, { keyword: token.text },
-                  'The target cardinality has already been specified - ignored $(KEYWORD)' );
+    this.warning( 'syntax-duplicate-cardinality', location, { keyword: token.text },
+                  'The target cardinality has already been specified - ignoring $(KEYWORD)' );
   }
 }
 
@@ -1069,33 +1041,20 @@ function handleComposition( cardinality, isComposition ) {
 }
 
 function associationInSelectItem( art ) {
-  if (!art.value) // e.g. `expand` without value (for new structures)
-    return;
-
-  const isPath = art.value.path && art.value.path.length;
-  const isIdentifier = isPath && art.value.path.length === 1;
-  if (isIdentifier) {
-    if (!art.name) {
-      art.name = art.value.path[0];
-    }
-    else {
-      // Use alias if provided, i.e. ignore art.value.path.
-      this.error( 'query-unexpected-alias', art.name.location, {},
-                  'Unexpected alias for association' );
-    }
-    delete art.value;
-  }
-  else {
-    const loc = isPath ? art.value.path[1].location : art.value.location;
-    // If neither path nor alias are present, `query-req-name` is emitted in `populate.js`.
-    if (isPath || art.name) {
-      this.error( 'query-expected-identifier', loc, { '#': 'assoc' } );
-      if (isPath)
-        art.name = art.value.path[art.value.path.length - 1];
-
+  const { value } = art;
+  const path = value?.path;
+  // we cannot compare "just one token before `:`" because there might be annos
+  if (path && path.length === 1 && !art.name && !art.expand && !art.inline) {
+    const name = value.path[0];
+    if (path.length === 1 && !name.args && !name.cardinality && !name.where) {
+      art.name = name;
       delete art.value;
+      return art;
     }
   }
+  this.error( 'syntax-unexpected-assoc', this.getCurrentToken(), {},
+              'Unexpected association definition in select item' );
+  return {};         // result of the association rules are written into /dev/null
 }
 
 function reportExpandInline( column, isInline ) {
@@ -1108,8 +1067,8 @@ function reportExpandInline( column, isInline ) {
     if (isInline && !name && this._input.LT(-1).type >= this.constructor.Identifier)
       token = this._input.LT(2);
     this.error( 'syntax-unexpected-nested-proj', token,
-                { prop: isInline ? 'inline' : 'expand' },
-                { std: 'Unexpected nested $(PROP), can only be used after a reference' } );
+                { code: isInline ? '.{ ‹inline› }' : '{ ‹expand› }' },
+                'Unexpected $(CODE); nested projections can only be used after a reference' );
     // continuation semantics:
     // - add elements anyway (could lead to duplicate errors as usual)
     // - no errors for refs inside expand/inline, but for refs in sibling expr
@@ -1117,25 +1076,25 @@ function reportExpandInline( column, isInline ) {
   }
   if (isInline && name) {
     const location = this.tokenLocation( isInline, this._input.LT(-1) );
-    this.error( 'syntax-unexpected-alias', location, { prop: 'inline' },
-                'Unexpected alias name before nested $(PROP)' );
+    this.error( 'syntax-unexpected-alias', location, { code: '.{ ‹inline› }' },
+                'Unexpected alias name before $(CODE)' );
     // continuation semantics: ignore AS
   }
 }
 
 function checkTypeFacet( art, argIdent ) {
+  // TODO: use dictAddArray or dictAdd?
   const { id } = argIdent;
   if (id === 'length' || id === 'scale' || id === 'precision' || id === 'srid') {
     if (art[id] !== undefined) {
-      this.error( 'syntax-duplicate-argument', argIdent.location,
-                  { '#': 'duplicate', code: id } );
       this.error( 'syntax-duplicate-argument', art[id].location,
-                  { '#': 'duplicate', code: id } );
+                  { '#': 'type', name: id } );
+      // continuation semantics: use last
     }
     return true;
   }
-  this.error( 'syntax-duplicate-argument', argIdent.location,
-              { '#': 'unknown', code: id } );
+  this.error( 'syntax-undefined-param', argIdent.location, { name: id },
+              'There is no type parameter called $(NAME)');
   return false;
 }
 

package/lib/language/language.g4

@@ -239,10 +239,11 @@ annotationAssignment_paren[ art ]
     {
       this.meltKeywordToIdentifier();
       if (this.isStraightBefore(')')) {
-        this.warning( 'syntax-anno-useless',
-                      this.tokenLocation( this._input.LT(-2), this.getCurrentToken() ),
-                      { code: '@()' },
-                      'Ignored useless $(CODE)' );
+        // TODO: or should we simple accept this without warning? (but still no CC)
+        this.warning( 'syntax-unexpected-right-paren',
+                      this.tokenLocation( this.getCurrentToken() ),
+                      { offending: "')'", expecting: ['Identifier'], code: '@()' },
+                      'Unexpected $(OFFENDING), expecting $(EXPECTING); ignoring $(CODE)' );
         this.matchWildcard();   // we know it is the ')' - we do not reach the final match
         return $ctx;
       }
@@ -273,13 +274,7 @@ annotationAssignment_fix[ art ] locals[ assignment ]
       { $assignment = { name: {} }; }
       annotationPath[ $assignment.name, 'anno' ]
       annotationPathVariant[ $assignment.name ]?
-      {
-        var t = this.getCurrentToken();
-        if (t.text === ':')
-          this.warning( 'syntax-anno-short', $assignment.name.location,
-                        { code: '@(...)' },
-                        'Better use $(CODE) for annotation assignments here' );
-      }
+      { this.warnIfColonFollows( $assignment ); }
     )
   ;
 
@@ -709,8 +704,7 @@ aspectDef[ art, outer ] locals[ name = {} ]
     { this.addDef( $art, $outer, 'artifacts', 'aspect', $name );
       // backends do not like ['$'+'syntax']: ($ent ? 'entity' : 'aspect')
       if ($ent)
-        this.warning( 'syntax-deprecated-abstract', this.tokenLocation( $abs, $ent ), {},
-                      'Abstract entity definitions are deprecated; use aspect definitions instead' );
+        this.warning( 'syntax-deprecated-abstract', this.tokenLocation( $abs, $ent ) );
       this.docComment( $art ); }
     annotationAssignment_fix[ $art ]*
     ( ':'
@@ -751,12 +745,33 @@ typeDef[ art, outer ] locals[ name = {} ]
 extendType[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    // aspects are types, i.e. kind is 'type' for aspects
     TYPE simplePath[ $name, 'Extend' ]
     { $art.expectedKind = 'type'; $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
-    extendWithOptElementsOrType[ $art, $art ]
+    // extendWithOptElementsOrType + includeRef:
+    (
+      extendWithOptElementsNoWith[ art ]
+    |
+      WITH { this.noSemicolonHere(); this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+      (
+        '{' { $art.elements = this.createDict(); }
+        elementDefOrExtend[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
+        optionalSemi
+      |
+        // extend type|element Art with (length: 10);
+        typeNamedArgList[ $art ]
+        requiredSemi
+      |
+        requiredSemi
+      |
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
+        requiredSemi
+      )
+    )
   ;
 
 annotationDef[ art, outer ] locals[ name = {} ]
@@ -779,12 +794,21 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
 @after{ /* #ATN 1 */ this.attachLocation( $art ); }
   :
     simplePath[ $name, 'Extend' ]
-    ( ':' simplePath[ $elemName, 'Element'] )?
-    { this.addExtension( $art, $outer, 'extend', $name, $elemName.path ); }
     (
-      { this.docComment( $art ); }
+      ':' simplePath[ $elemName, 'Element']
+      { this.addExtension( $art, $outer, 'extend', $name, $elemName.path ); }
+      extendWithOptElementsOrType[ art ]
+    |
+      { this.addExtension( $art, $outer, 'extend', $name ); }
+      extendWithOptElementsNoWith[ art ]
+    |
+      { this.addExtension( $art, $outer, 'extend', $name ); }
+      WITH { this.noSemicolonHere(); this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]*
+      // #ATN: ELEMENTS, ENUM, DEFINITIONS, COLUMNS, ACTIONS are not reserved and
+      // could be includeRef
       (
+        // all the alternatives from `extendWithOptElementsOrType` --------------
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
@@ -792,32 +816,33 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         optionalSemi
       |
         requiredSemi
-      )
-    |
-      WITH { this.noSemicolonHere(); this.docComment( $art ); }
-      annotationAssignment_ll1[ $art ]*
-      // #ATN: DEFINITIONS, COLUMNS, ACTIONS etc are not reserved and could be identifiers (ref).
-      // TODO: exclude "expected" according to disallowElementExtension()
-      (
-        includeRef[ $art ] ( ',' includeRef[ $art ] )*
-        requiredSemi
       |
-        '{' { $art.elements = this.createDict(); }
+        ELEMENTS '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
+        optionalSemi
+      |
+        ENUM '{' { $art.enum = this.createDict(); }
+        enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
+        '}' { this.finalizeDictOrArray( $art.enum ); }
         optionalSemi
       |
+        // extend Art with (length: 10);
+        // `with` is required, or we could have `extend String(length:10);`.
+        typeNamedArgList[ $art ]
+        requiredSemi
+      |
+        // extension alternatives for main definitions --------------------------
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
-        { this.disallowElementExtension( $elemName, $outer, 'definitions' ); }
         DEFINITIONS
         '{' { $art.artifacts = this.createDict(); }
         artifactDef[ $art, true ]*
         '}' { this.finalizeDictOrArray( $art.artifacts ); }
         optionalSemi
       |
-        { this.disallowElementExtension( $elemName, $outer, 'columns' ); }
         COLUMNS
         '{' { $art.columns = []; }
         (
@@ -829,44 +854,37 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         '}'
         optionalSemi
       |
-        { this.disallowElementExtension( $elemName, $outer, 'actions' ); }
         ACTIONS '{' { $art.actions = this.createDict(); }
         actionFunctionDef[ $art ]* // TODO: no EXTEND in actions? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.actions ); }
         optionalSemi
-      |
-        ELEMENTS '{' { $art.elements = this.createDict(); }
-        elementDefOrExtend[ $art ]*
-        '}' { this.finalizeDictOrArray( $art.elements ); }
-        { this.checkExtensionDict( $art.elements ); }
-        optionalSemi
-      |
-        ENUM '{' { $art.enum = this.createDict(); }
-        enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
-        '}' { this.finalizeDictOrArray( $art.enum ); }
-        optionalSemi
-      |
-        // extend Art with (length: 10);
-        // `with` is required, or we could have `extend String(length:10);`.
-        typeNamedArgList[ $art ]
-        requiredSemi
       )
     )
   ;
 
 extendWithOptElementsOrType[ art ]
   :
+    extendWithOptElementsNoWith[ art ]
+  |
     WITH { this.noSemicolonHere(); this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
-      includeRef[ $art ] ( ',' includeRef[ $art ] )*
-      requiredSemi
-    |
       '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
       optionalSemi
+    |
+      ELEMENTS '{' { $art.elements = this.createDict(); }
+      elementDefOrExtend[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
+      optionalSemi
+    |
+      ENUM '{' { $art.enum = this.createDict(); }
+      enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
+      '}' { this.finalizeDictOrArray( $art.enum ); }
+      optionalSemi
     |
       // extend type|element Art with (length: 10);
       typeNamedArgList[ $art ]
@@ -874,7 +892,10 @@ extendWithOptElementsOrType[ art ]
     |
       requiredSemi
     )
-  |
+  ;
+
+extendWithOptElementsNoWith[ art ]
+  :
     { this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
@@ -1080,12 +1101,12 @@ mixinElementDef[ outer ] locals[ art = {} ]
       |
         typeRefOptArgs[ $art ]
         ( as='=' expression
-          { this.error( 'syntax-unsupported-field', $as ); }
+          { this.error( 'syntax-unsupported-calc-field', $as ); }
         )?
       )
     |
       as='=' expression
-      { this.error( 'syntax-unsupported-field', $as ); }
+      { this.error( 'syntax-unsupported-calc-field', $as ); }
     )
     requiredSemi
   ;
@@ -1216,7 +1237,7 @@ elementDefInner[ art, outer, allowEq ]
       eq='=' e=expression       // never introduce AS as syntax variant of '='
       {
         if (!$allowEq || $e.expr && !$e.expr.literal )
-          this.error( 'syntax-unsupported-field', $eq );
+          this.error( 'syntax-unsupported-calc-field', $eq );
         else if ($e.expr)
           $art.value = $e.expr;
       }
@@ -1251,7 +1272,7 @@ selectItemDef[ outer ] locals[ art ]
     selectItemDefBody[ $art, $outer ]
   ;
 
-selectItemDefBody[ art, outer ]
+selectItemDefBody[ art, outer ] locals[ assoc ]
 @after{ /* #ATN 2 */ }
   :
     { $outer.push( $art ); }
@@ -1261,7 +1282,7 @@ selectItemDefBody[ art, outer ]
       // AS (using rule 'ident' instead of 'identNoKeyword') -> ambiguities
       ( as=AS n1=ident['Item'] { $art.name = $n1.id }
       | n2=ident['Item'] { $art.name = this.fragileAlias( $n2.id, true ); }
-      | { if (this.getCurrentToken().text !== '.') this.classifyImplicitName( 'Item', $e.expr ); }
+      | { this.classifyImplicitName( 'Item', $e.expr ); }
       )
       { if ($art.value && !$art.value.path) this.excludeExpected( ["'.'", "'{'"] );
         else if ($art.name) this.excludeExpected( ["'.'"] );
@@ -1290,7 +1311,7 @@ selectItemDefBody[ art, outer ]
     { this.docComment( $art ); }
     annotationAssignment_fix[ $art ]*
     ( ':'
-      // #ATN: typeRefOptArgs can start with TYPE, REDIRECTED
+      // #ATN: typeRefOptArgs can start with TYPE, REDIRECTED, ASSOCIATION
       ( re=REDIRECTED to=TO
         { $art.target = {}; }
         simplePath[ $art.target, 'artref' ]
@@ -1303,15 +1324,20 @@ selectItemDefBody[ art, outer ]
       | typeTypeOf[ $art ]
         { this.docComment( $art ); }
         annotationAssignment_ll1[ $art ]*
+      | l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
+        typeRefOptArgs[ $art ]
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
       | typeRefOptArgs[ $art ]
         { this.docComment( $art ); }
         annotationAssignment_ll1[ $art ]*
       |
-        typeAssociationBase[ $art, false ]
+        { $assoc = this.associationInSelectItem( $art ); }
+        typeAssociationBase[ $assoc, false ]
         // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
-        ( typeToMany[ $art ] | typeToOne[ $art ] | simplePath[ $art.target, 'artref' ] )
-        typeAssociationCont[ $art ]?
-        { this.associationInSelectItem( $art ); }
+        ( typeToMany[ $assoc ] | typeToOne[ $assoc ] | simplePath[ $assoc.target, 'artref' ] )
+        ON cond=condition
+        { $assoc.on=$cond.cond; }
       )
     )?
   ;
@@ -1398,7 +1424,7 @@ elementProperties[ elem ]
     nullability[ $elem ]?
   |
     eq='='
-    { this.error( 'syntax-unsupported-field', $eq ); }
+    { this.error( 'syntax-unsupported-calc-field', $eq ); }
     expression
   ;
 
@@ -2230,7 +2256,7 @@ conditionTerm returns [ cond ]
       { $cond = { op: this.valueWithTokenLocation( 'exists', $ex ), args: [
           { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' }
         ] };
-        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', code: '?' } );
       }
     |
       ep=valuePath[ 'ref' ]
@@ -2367,7 +2393,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         { $expr = $vp.qp;; $expr.scope = 'param'; }
       | pp=Number
         { $expr = { param: this.numberLiteral( $pp ), scope: 'param' };
-          this.csnParseOnly( 'syntax-unsupported-param', [ $pp ], { '#': 'positional', name: ':' + $pp.text } );
+          this.csnParseOnly( 'syntax-unsupported-param', [ $pp ], { '#': 'positional', code: ':' + $pp.text } );
         }
       )
     |
@@ -2375,7 +2401,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
       // if we have an HideAlternatives here, we would block it to use it in
       // parallel to an expression (would produce adaptivePredict() otherwise)
       { $expr = { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' };
-        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', code: '?' } );
       }
     |
       open='('

package/lib/language/multiLineStringParser.js

@@ -24,7 +24,7 @@ const {
  * @returns {[string, number]} The indentation-stripped string and the number
  *                             of whitespace characters removed.
  */
-function stripIndentation(str) {
+function stripIndentation( str ) {
   if (str === '')
     return [ '', 0 ];
 
@@ -510,7 +510,7 @@ class MultiLineStringParser {
  *
  * @param {object} token
  */
-function parseMultiLineStringLiteral(token) {
+function parseMultiLineStringLiteral( token ) {
   const p = new MultiLineStringParser(this, token);
   return p.parse();
 }

package/lib/language/textUtils.js

@@ -11,7 +11,7 @@ const cdlNewLineRegEx = /\r\n?|\n|\u2028|\u2029/u;
  * @param {string} str
  * @returns {boolean}
  */
-function isWhitespaceOrNewLineOnly(str) {
+function isWhitespaceOrNewLineOnly( str ) {
   return /^\s*$/.test(str);
 }
 
@@ -33,7 +33,7 @@ function isWhitespaceOrNewLineOnly(str) {
  * @param char
  * @returns {boolean}
  */
-function isWhitespaceCharacterNoNewline(char) {
+function isWhitespaceCharacterNoNewline( char ) {
   return whitespaceRegEx.test(char);
 }