@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/language/errorStrategy.js

@@ -55,8 +55,11 @@ function match( ttype ) {
   const token = this.getCurrentToken();
   if (token.type === identType || !keywordRegexp.test( token.text ))
     return antlr4.Parser.prototype.match.call( this, ttype );
-
-  this.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text } );
+  // This is very likely to be dead code: we do not use a simple Identifier
+  // without alternatives in the grammar.  With alternatives, recoverInline() is
+  // the place to go.  (But this code should work with a changed grammar…)
+  this.message( 'syntax-unexpected-reserved-word', token,
+                { code: token.text, delimited: token.text } );
   this._errHandler.reportMatch(this);
   this.consume();
   return token;
@@ -72,7 +75,6 @@ class KeywordErrorStrategy extends DefaultErrorStrategy {
     super( ...args );
 
     this._super = {
-      consumeUntil: super.consumeUntil,
       recoverInline: super.recoverInline,
       getExpectedTokens: super.getExpectedTokens,
     };
@@ -89,6 +91,7 @@ Object.assign( KeywordErrorStrategy.prototype, {
   reportIgnoredWith,
   // getErrorRecoverySet,
   consumeUntil,
+  consumeAndMarkUntil,
   recoverInline,
   getMissingSymbol,
   getExpectedTokensForMessage,
@@ -137,16 +140,19 @@ function sync( recognizer ) {
   }
 
   // Expected token is identifier, current is (reserved) KEYWORD:
-  // TODO: do not use this if "close enough" (1 char diff) to a keyword in nextTokens
+  // TODO: do not use this if "close enough" (1 char diff or prefix)
+  // to a keyword in nextTokens
   //
   // NOTE: it is important to do this only if EPSILON is not in `nextTokens`,
-  // which means that we cannot bring the better special syntax-fragile-ident
+  // which means that we cannot bring the better special syntax-unexpected-reserved
   // in all cases.  Reason: high performance impact of the alternative,
   // i.e. calling method Parser#isExpectedToken() = invoking the ATN
   // interpreter to see behind EPSILON.
   const identType = recognizer.constructor.Identifier;
   if (keywordRegexp.test( token.text ) && nextTokens.contains( identType )) {
-    recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text } );
+    recognizer.message( 'syntax-unexpected-reserved-word', token,
+                        { code: token.text, delimited: token.text } );
+    // TODO: attach tokens like for 'syntax-unexpected-token'
     token.type = identType;     // make next ANTLR decision assume identifier
     return;
   }
@@ -210,11 +216,11 @@ function reportInputMismatch( recognizer, e, deadEnds ) {
   const expecting = deadEnds !== true && // true: cannot compute expecting
                   this.getExpectedTokensForMessage( recognizer, e.offendingToken, deadEnds );
   const offending = this.getTokenDisplay( e.offendingToken, recognizer );
+  e.offendingToken.$isSkipped = 'offending';
   let err;
   if (expecting && expecting.length) {
-    err = recognizer.error( 'syntax-mismatched-token', e.offendingToken,
-                            { offending, expecting },
-                            'Mismatched $(OFFENDING), expecting $(EXPECTING)' );
+    err = recognizer.error( 'syntax-unexpected-token', e.offendingToken,
+                            { offending, expecting } );
     err.expectedTokens = expecting;
   }
   else {                        // should not really happen anymore... -> no messageId !
@@ -232,11 +238,12 @@ function reportUnwantedToken( recognizer ) {
   this.beginErrorCondition(recognizer);
 
   const token = recognizer.getCurrentToken();
+  token.$isSkipped = 'offending';
   const expecting = this.getExpectedTokensForMessage( recognizer, token );
   const offending = this.getTokenDisplay( token, recognizer );
-  const err = recognizer.error( 'syntax-extraneous-token', token,
-                                { offending, expecting },
-                                'Extraneous $(OFFENDING), expecting $(EXPECTING)' );
+  // Just text variant, no other message id!  Would depend on ANTLR-internals
+  const err = recognizer.error( 'syntax-unexpected-token', token,
+                                { '#': 'unwanted', offending, expecting } );
   err.expectedTokens = expecting; // TODO: remove next token?
   if (!recognizer.avoidErrorListeners) // with --trace-parser or --trace-parser-ambig
     recognizer.notifyErrorListeners( err.message, token, err );
@@ -249,9 +256,11 @@ function reportMissingToken( recognizer ) {
   this.beginErrorCondition(recognizer);
 
   const token = recognizer.getCurrentToken();
+  token.$isSkipped = 'offending';
   const expecting = this.getExpectedTokensForMessage( recognizer, token );
   const offending = this.getTokenDisplay( token, recognizer );
   // TODO: if non-reserved keyword will not been parsed as keyword, use Identifier for offending
+  // Hopefully not too ANTLR-specific, so extra message id is ok:
   const err = recognizer.error( 'syntax-missing-token', token,
                                 { offending, expecting },
                                 'Missing $(EXPECTING) before $(OFFENDING)' );
@@ -264,10 +273,10 @@ function reportIgnoredWith( recognizer, t ) {
   const next = recognizer._interp.atn.states[recognizer.state].transitions[0].target;
   recognizer.state = next.stateNumber; // previous match() does not set the state
   const expecting = this.getExpectedTokensForMessage( recognizer, t );
-  const m = recognizer.warning( 'syntax-ignored-with', t,
-                                { offending: "';'", expecting },
+  const m = recognizer.warning( 'syntax-unexpected-semicolon', t,
+                                { offending: "';'", expecting, keyword: 'with' },
     // eslint-disable-next-line max-len
-                                'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous WITH' );
+                                'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
   m.expectedTokens = expecting;
 }
 
@@ -280,10 +289,10 @@ function consumeUntil( recognizer, set ) {
 
   // let s=this.getTokenDisplay( recognizer.getCurrentToken(), recognizer );
   if (SEMI < 1 || RBRACE < 1) {
-    this._super.consumeUntil.call( this, recognizer, set );
+    this.consumeAndMarkUntil( recognizer, set );
   }
   else if (set.contains(SEMI)) { // do not check for RBRACE here!
-    this._super.consumeUntil.call( this, recognizer, set );
+    this.consumeAndMarkUntil( recognizer, set );
     // console.log('CONSUMED-ORIG:',s,this.getTokenDisplay( recognizer.getCurrentToken(),
     // recognizer ),recognizer.getCurrentToken().line,intervalSetToArray( recognizer, set ));
   }
@@ -295,9 +304,9 @@ function consumeUntil( recognizer, set ) {
     stop.addOne( SEMI );
     // I am not that sure whether to add RBRACE...
     stop.addOne( RBRACE );
-    this._super.consumeUntil.call( this, recognizer, stop );
-    if (recognizer.getTokenStream().LA(1) === SEMI ||
-        recognizer.getTokenStream().LA(1) === RBRACE && !set.contains(RBRACE)) {
+    this.consumeAndMarkUntil( recognizer, stop );
+    const ttype = recognizer.getTokenStream().LA(1);
+    if (ttype === SEMI || ttype === RBRACE && !set.contains(RBRACE)) {
       recognizer.consume();
       this.reportMatch(recognizer); // we know current token is correct
     }
@@ -312,6 +321,15 @@ function consumeUntil( recognizer, set ) {
   }
 }
 
+function consumeAndMarkUntil( recognizer, set ) {
+  let t = recognizer.getTokenStream().LT(1);
+  while (t.type !== antlr4.Token.EOF && !set.contains( t.type )) {
+    if (!t.$isSkipped)
+      t.$isSkipped = true;
+    recognizer.consume();
+    t = recognizer.getTokenStream().LT(1);
+  }
+}
 
 // As the `match` function of the parser `recognizer` does not allow to check
 // against a set of token types, the generated parser code checks against that
@@ -328,7 +346,9 @@ function recoverInline( recognizer ) {
   if (!keywordRegexp.test( token.text ))
     return this._super.recoverInline.call( this, recognizer );
 
-  recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text } );
+  // TODO: attach `Identifier` as valid name to message?
+  recognizer.message( 'syntax-unexpected-reserved-word', token,
+                      { code: token.text, delimited: token.text } );
   this.reportMatch(recognizer); // we know current token is correct
   recognizer.consume();
   return token;
@@ -496,14 +516,14 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   // expected.toString(recognizer.literalNames, recognizer.symbolicNames));
   return intervalSetToArray( recognizer, expected );
 
-  function addSet(other) {
+  function addSet( other ) {
     if (!other.contains( hideAltsType ))
       origAddSet.call( this, other );
   }
 
   // Add an interval `v` to the IntervalSet `this`.  If `v` contains the token
   // type `Identifier`, do not add non-reserved keywords in `v`.
-  function addInterval(v) {
+  function addInterval( v ) {
     if (v.stop <= identType) {
       origAddInterval.call(this, v);
     }

package/lib/language/genericAntlrParser.js

@@ -86,14 +86,15 @@ Object.assign(GenericAntlrParser.prototype, {
   previousTokenAtLocation,
   combinedLocation,
   surroundByParens,
+  secureParens,
   unaryOpForParens,
   leftAssocBinaryOp,
   classifyImplicitName,
+  warnIfColonFollows,
   fragileAlias,
   identAst,
-  functionAst,
-  setLastAsXpr,
-  xprToken,
+  pushXprToken,
+  argsExpression,
   valuePathAst,
   signedExpression,
   numberLiteral,
@@ -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,9 +249,15 @@ const genericTokenTypes = {
   intro: 'GenericIntro',
 };
 
-function prepareGenericKeywords( pathItem, expected = null) {
+/**
+ * @memberOf GenericAntlrParser
+ *
+ * @param pathItem
+ * @param [expected]
+ */
+function prepareGenericKeywords( pathItem, expected = null ) {
   const length = pathItem?.args?.length || 0;
-  const argPos = (expected ? length - 1 : length);
+  const argPos = length;
   const func = pathItem?.id && specialFunctions[pathItem.id.toUpperCase()];
   const spec = func && func[argPos] || specialFunctions[''][argPos ? 1 : 0];
   this.$genericKeywords = spec;
@@ -492,10 +480,10 @@ function tokenLocation( token, endToken = null ) {
   return loc;
 }
 
-function isMultiLineToken(token) {
+function isMultiLineToken( token ) {
   return (
     token.type === this.constructor.DocComment ||
-    token.type === this.constructor.String ||
+    token.type === this.constructor.String || // TODO: do not check every string content
     token.type === this.constructor.UnterminatedLiteral
   );
 }
@@ -565,6 +553,23 @@ function combinedLocation( start, end ) {
   return locUtils.combinedLocation( start, end );
 }
 
+// make sure that the parens of `IN (…)` do not disappear:
+function secureParens( expr ) {
+  const op = expr?.op?.val;
+  const $parens = expr?.$parens;
+  if (!$parens || expr.query || op && op !== 'call' && op !== 'cast')
+    return expr;
+  // ensure that references, literals and functions keep their surrounding parentheses
+  // (is for expressions the case anyway)
+  delete expr.$parens;
+  return {
+    op: { val: 'xpr', location: this.startLocation() },
+    args: [ expr ],
+    location: { ...expr.location },
+    $parens,
+  };
+}
+
 function surroundByParens( expr, open, close, asQuery = false ) {
   if (!expr)
     return expr;
@@ -584,6 +589,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 +627,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 +639,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 +658,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 +670,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 },
@@ -666,33 +680,27 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   return { id, $delimited: true, location: this.tokenLocation( token ) };
 }
 
-function functionAst( token, xpr ) { // only for special function TRIM and EXTRACT
-  // TODO: XSN func cleanup
-  const location = this.tokenLocation( token );
-  const args = xpr
-    ? [ { op: { location, val: 'ixpr' }, args: [], location: this.tokenLocation( xpr ) } ]
-    : [];
-  return {
-    op: { location, val: 'call' },
-    func: { path: [ { id: token.text, location, args } ], location },
-    args,
-    location,
-  };
-}
-
-function setLastAsXpr( args ) {
-  const pos = args.length - 1;
-  const last = args[pos];
-  if (!last || last?.op?.val === 'ixpr') // actuall an internal xpr, which is always flattened
-    return last;
-  const location = { ...last.location };
-  args[pos] = { op: { location, val: 'ixpr' }, args: [ last ], location };
-  return args[pos].args;
+// only to be used in @after
+// TODO: remove compatible stuff (A2J/checks use op: 'and'/'=')
+function argsExpression( args, useFirstLocation, compatible = null ) {
+  // console.log('AE:',args);
+  if (args.length === 1)
+    return args[0];
+  const location = useFirstLocation && args[0] && { ...args[0].location };
+  const op = compatible && args.length === 3 && args[1].val === compatible && args[1];
+  const expr = (op)
+    ? { op: { val: op.val, location: op.location }, args: [ args[0], args[2] ], location }
+    : { op: { val: 'ixpr', location: this.startLocation() }, args, location };
+  return this.attachLocation( expr );
 }
 
-function xprToken() {
+function pushXprToken( args ) {
   const token = this._input.LT(-1);
-  return { location: this.tokenLocation( token ), val: token.text, literal: 'token' };
+  args.push( {
+    location: this.tokenLocation( token ),
+    val: token.text.toLowerCase(), // TODO: remove toLowerCase() ?
+    literal: 'token',
+  } );
 }
 
 function valuePathAst( ref ) {
@@ -705,7 +713,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;
@@ -729,10 +737,11 @@ function valuePathAst( ref ) {
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
 // otherwise (including for '+'), represent it as extra unary prefix operator.
-function signedExpression( signToken, expr ) {
-  const sign = this.valueWithTokenLocation( signToken.text, signToken );
+function signedExpression( args, expr ) {
+  // if (args.length !== 1) throw Error()
+  const sign = args[0];
   const nval
-        = (signToken.text === '-' &&
+        = (sign.val === '-' &&
         expr && // expr may be null if `-` rule can't be parsed
         expr.literal === 'number' &&
         sign.location.endLine === expr.location.line &&
@@ -740,11 +749,14 @@ function signedExpression( signToken, expr ) {
         (typeof expr.val === 'number'
           ? expr.val >= 0 && -expr.val
           : !expr.val.startsWith('-') && `-${ expr.val }`)) || false;
-  if (nval === false)
-    return { op: sign, args: expr ? [ expr ] : [] };
-  expr.val = nval;
-  --expr.location.col;
-  return expr;
+  if (nval === false) {
+    args.push( expr );
+  }
+  else {
+    expr.val = nval;
+    --expr.location.col;
+    args[0] = expr;
+  }
 }
 
 // Return AST for number token `token` with optional token `sign`.  Represent
@@ -765,7 +777,7 @@ function numberLiteral( token, sign, text = token.text ) {
   const num = Number.parseFloat( text || '0' ); // not Number.parseInt() !
   if (!Number.isSafeInteger(num)) {
     if (sign == null) {
-      this.error( 'syntax-expecting-integer', token,
+      this.error( 'syntax-expecting-unsigned-int', token,
                   { '#': !text.match(/^[0-9]*$/) ? 'normal' : 'unsafe' } );
     }
 
@@ -819,7 +831,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 +855,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 +912,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 +1038,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 +1062,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 +1088,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 +1097,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;
 }