@sap/cds-compiler 3.3.2 → 3.4.0

package/lib/language/genericAntlrParser.js

@@ -12,17 +12,21 @@ const { dictAdd, dictAddArray } = require('../base/dictionaries');
 const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
 const { parseMultiLineStringLiteral } = require('./multiLineStringParser');
-const { functionsWithoutParens, specialFunctions, quotedLiteralPatterns } = require('../compiler/builtins');
-const { pathName } = require("../compiler/utils");
+const {
+  functionsWithoutParens,
+  specialFunctions,
+  quotedLiteralPatterns,
+} = require('../compiler/builtins');
+const { pathName } = require('../compiler/utils');
+const { isBetaEnabled } = require('../base/model');
 
 const $location = Symbol.for('cds.$location');
 
 // Push message `msg` with location `loc` to array of errors:
 function _message( parser, severity, id, loc, ...args ) {
   const msg = parser.$messageFunctions[severity]; // set in antlrParser.js
-  if (loc instanceof antlr4.CommonToken) {
+  if (loc instanceof antlr4.CommonToken)
     loc = parser.tokenLocation(loc);
-  }
   return msg( id, loc, ...args );
 }
 
@@ -57,10 +61,18 @@ class GenericAntlrParser extends antlr4.Parser {
 
 // TODO: Use actual methods.
 Object.assign(GenericAntlrParser.prototype, {
-  message: function(...args) { return _message( this, 'message', ...args ); },
-  error: function(...args) { return _message( this, 'error', ...args ); },
-  warning: function(...args) { return _message( this, 'warning', ...args ); },
-  info: function(...args) { return _message( this, 'info', ...args ); },
+  message(...args) {
+    return _message( this, 'message', ...args );
+  },
+  error(...args) {
+    return _message( this, 'error', ...args );
+  },
+  warning(...args) {
+    return _message( this, 'warning', ...args );
+  },
+  info(...args) {
+    return _message( this, 'info', ...args );
+  },
   attachLocation,
   assignAnnotation,
   addAnnotation,
@@ -91,6 +103,7 @@ Object.assign(GenericAntlrParser.prototype, {
   addDef,
   addItem,
   addExtension,
+  aspectWithoutElements,
   createSource,
   createDict,
   createArray,
@@ -103,7 +116,6 @@ Object.assign(GenericAntlrParser.prototype, {
   associationInSelectItem,
   reportExpandInline,
   checkTypeFacet,
-  notSupportedYet,
   csnParseOnly,
   disallowElementExtension,
   noAssignmentInSameLine,
@@ -126,30 +138,19 @@ Object.assign(GenericAntlrParser.prototype, {
 // language construct can come from a CSN as source.
 // TODO: this is not completely done this way
 
-function notSupportedYet( text, ...tokens ) {
-  if (!text)
-    return;
-  if (typeof text !== 'string') {
-    tokens = [ text, ...tokens ];
-    text = `${ tokens.map( t => t.text.toUpperCase() ).join(' ') } is not supported`;
-  }
-  this.error( null, this.tokenLocation( tokens[0], tokens[tokens.length - 1] ), {}, text );
-}
-
 // Use the following function for language constructs which we (currently) do
 // not really compile, just use to produce a CSN for functions parse.cql() and
 // parse.expr().
-function csnParseOnly( text, ...tokens ) {
-  if (!text || this.options.parseOnly)
+// This function has a similar interface to our message functions on purpose!
+// (tokens ~= location)
+function csnParseOnly( msgId, tokens, textArgs ) {
+  if (!msgId || this.options.parseOnly)
     return;
-  if (typeof text !== 'string') {
-    tokens = [ text, ...tokens ];
-    text = `${ tokens.map( t => t.text.toUpperCase() ).join(' ') } is not supported`;
-  }
-  this.error( null, this.tokenLocation( tokens[0], tokens[tokens.length - 1] ), {}, text );
+  const loc = this.tokenLocation( tokens[0], tokens[tokens.length - 1] );
+  this.error( msgId, loc, textArgs );
 }
 
- /** @this {object} */
+/** @this {object} */
 function noSemicolonHere() {
   const handler = this._errHandler;
   const t = this.getCurrentToken();
@@ -193,7 +194,7 @@ function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
 }
 
 function setLocalTokenForId( tokenNameMap ) {
-  const tokenName = tokenNameMap[ this._input.LT(2).text || '' ];
+  const tokenName = tokenNameMap[this._input.LT(2).text || ''];
   const ll1 = this.getCurrentToken();
   if (tokenName &&
       (ll1.type === this.constructor.Identifier || /^[a-zA-Z_]+$/.test( ll1.text )))
@@ -227,8 +228,10 @@ function setLocalTokenForId( tokenNameMap ) {
  */
 function disallowElementExtension(elemName, outer, extensionVariant) {
   if (elemName.path) {
-    this.message( 'syntax-invalid-extend', this.tokenLocation(this.getCurrentToken()), { 'kind': extensionVariant } );
-    outer.extensions.length = outer.extensions.length - 1; // remove last, i.e. new extension
+    const loc = this.tokenLocation(this.getCurrentToken());
+    this.error( 'syntax-invalid-extend', loc, { kind: extensionVariant } );
+    // remove last, i.e. new extension
+    outer.extensions.pop();
   }
 }
 
@@ -266,7 +269,7 @@ const genericTokenTypes = {
 
 function prepareGenericKeywords( pathItem, expected = null) {
   const length = pathItem?.args?.length || 0;
-  const argPos = (expected ? length -1 : length);
+  const argPos = (expected ? length - 1 : length);
   const func = pathItem?.id && specialFunctions[pathItem.id.toUpperCase()];
   const spec = func && func[argPos] || specialFunctions[''][argPos ? 1 : 0];
   this.$genericKeywords = spec;
@@ -298,7 +301,7 @@ function prepareGenericKeywords( pathItem, expected = null) {
 // To be called before having matched ( HideAlternatives | … )
 function reportErrorForGenericKeyword() {
   this._errHandler.reportUnwantedToken( this );
-  //this._errHandler.reportInputMismatch( this, { offending: this._input.LT(1) }, null );
+  // this._errHandler.reportInputMismatch( this, { offending: this._input.LT(1) }, null );
 }
 
 // Attach location matched by current rule to node `art`.  If a location is
@@ -317,11 +320,12 @@ function attachLocation( art ) {
   // case we can't rely on `this._ctx.stop.line`.
   if (this.isMultiLineToken(this._ctx.stop)) {
     this.fixMultiLineTokenEndLocation(this._ctx.stop, art.location);
-
-  } else {
+  }
+  else {
     const { stop } = this._ctx;
     art.location.endLine = stop.line;
-    art.location.endCol = stop.stop - stop.start + stop.column + 2; // after the last char (special for EOF?)
+    // after the last char (special for EOF?)
+    art.location.endCol = stop.stop - stop.start + stop.column + 2;
   }
 
   return art;
@@ -355,7 +359,7 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant = false ) {
   }
   else {
     name.absolute = absolute;
-    this.addAnnotation( art, '@' + absolute, anno );
+    this.addAnnotation( art, `@${ absolute }`, anno );
   }
   if (!prefix) {                // set deprecated $annotations for cds-lsp
     if (!art.$annotations)
@@ -366,6 +370,7 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant = false ) {
 }
 
 function addAnnotation( art, prop, anno ) {
+  // TODO: just overwrite after having reported the error
   dictAddArray( art, prop, anno, (n, location, a) => {
     // if we would make it a warning, we would still need to keep it an error
     // with '...'; otherwise parse.cdl would have to split annotate statements
@@ -376,7 +381,9 @@ function addAnnotation( art, prop, anno ) {
   } );
 }
 
-const extensionDicts = { elements: true, enum: true, params: true, returns: true };
+const extensionDicts = {
+  elements: true, enum: true, params: true, returns: true,
+};
 
 function checkExtensionDict( dict ) {
   for (const name in dict) {
@@ -385,8 +392,8 @@ function checkExtensionDict( dict ) {
       continue;
 
     if (def.kind !== 'annotate') {
-      const numDefines =
-            def.$duplicates.reduce( addOneForDefinition, addOneForDefinition( 0, def ) );
+      const numDefines
+            = def.$duplicates.reduce( addOneForDefinition, addOneForDefinition( 0, def ) );
       this.handleDuplicateExtension( def, name, numDefines );
       for (const dup of def.$duplicates)
         this.handleDuplicateExtension( dup, name, numDefines );
@@ -396,12 +403,13 @@ function checkExtensionDict( dict ) {
     for (const dup of def.$duplicates) {
       for (const prop of Object.keys( dup )) {
         if (prop.charAt(0) === '@') {
-          this.addAnnotation( def, prop, dup[prop] )
+          this.addAnnotation( def, prop, dup[prop] );
         }
         else if (prop === 'doc') {
-          if (def.doc)
+          if (def.doc) {
             this.warning( 'syntax-duplicate-doc-comment', def.doc.location, {},
                           'Doc comment is overwritten by another one below' );
+          }
           def.doc = dup.doc;
         }
         else if (extensionDicts[prop]) {
@@ -427,11 +435,13 @@ function addOneForDefinition( count, ext ) {
  * @param {number} numDefines
  */
 function handleDuplicateExtension( ext, name, numDefines ) {
-  if (ext.kind === 'extend')
+  if (ext.kind === 'extend') {
     this.error( 'syntax-duplicate-extend', [ ext.name.location ],
                 { name, '#': (numDefines ? 'define' : 'extend') } );
-  else if (numDefines === 1)
-    ext.$errorReported = 'syntax-duplicate-extend'; // a definition, but not duplicate
+  }
+  else if (numDefines === 1) {
+    ext.$errorReported = 'syntax-duplicate-extend';
+  } // a definition, but not duplicate
 }
 
 
@@ -470,8 +480,9 @@ function tokenLocation( token, endToken = null ) {
     col: token.column + 1,
     // Default for single line tokens
     endLine: endToken.line,
-    endCol: endToken.stop - endToken.start + endToken.column + 2, // after the last char (special for EOF?)
-  }
+    // after the last char (special for EOF?)
+    endCol: endToken.stop - endToken.start + endToken.column + 2,
+  };
 
   // This check is done for performance reason. No need to access a token's
   // data if we know that it spans only one single line.
@@ -514,9 +525,11 @@ function fixMultiLineTokenEndLocation( token, location ) {
   if (newLineCount > 0) {
     location.endLine = token.line + newLineCount;
     location.endCol = token.stop - lastNewlineIndex + 1;
-  } else {
+  }
+  else {
     location.endLine = token.line;
-    location.endCol = token.stop - token.start + token.column + 2; // after the last char (special for EOF?)
+    // after the last char (special for EOF?)
+    location.endCol = token.stop - token.start + token.column + 2;
   }
 }
 
@@ -568,7 +581,7 @@ function unaryOpForParens( query, val ) {
   if (!parens)
     return query;
   const location = parens[parens.length - 1];
-  return { op: { val, location }, location, args: [query] };
+  return { op: { val, location }, location, args: [ query ] };
 }
 
 // If the token before the current one is a doc comment (ignoring other tokens
@@ -609,12 +622,14 @@ function classifyImplicitName( category, ref ) {
 function fragileAlias( ast, safe = false ) {
   if (this.getCurrentToken().text === '.')
     return ast;
-  if (safe || ast.$delimited || !/^[a-zA-Z][a-zA-Z_]+$/.test( ast.id ))
+  if (safe || ast.$delimited || !/^[a-zA-Z][a-zA-Z_]+$/.test( ast.id )) {
     this.warning( 'syntax-sloppy-alias', ast.location, { keyword: 'as' },
                   'Please add the keyword $(KEYWORD) in front of the alias name' );
-  else                          // configurable error
+  }
+  else {                         // configurable error
     this.message( 'syntax-fragile-alias', ast.location, { keyword: 'as' },
                   'Please add the keyword $(KEYWORD) in front of the alias name' );
+  }
   return ast;
 }
 
@@ -645,6 +660,7 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   }
   else {
     this.message( 'syntax-deprecated-ident', token, { delimited: id },
+                  // eslint-disable-next-line max-len
                   'Deprecated delimited identifier syntax, use $(DELIMITED) - strings are delimited by single quotes' );
   }
   return { id, $delimited: true, location: this.tokenLocation( token ) };
@@ -676,7 +692,7 @@ function setLastAsXpr( args ) {
 
 function xprToken() {
   const token = this._input.LT(-1);
-  return { location: this.tokenLocation( token ), val: token.text, literal: 'token' }
+  return { location: this.tokenLocation( token ), val: token.text, literal: 'token' };
 }
 
 function valuePathAst( ref ) {
@@ -690,7 +706,7 @@ function valuePathAst( ref ) {
     if (!item)
       return ref;
     this.error( 'syntax-not-supported', item.location, {},
-      'Methods in expressions are not supported yet' );
+                'Methods in expressions are not supported yet' );
     path.broken = true;
     path.length = 1;
   }
@@ -705,7 +721,9 @@ function valuePathAst( ref ) {
     implicit.isIdentifier = 'func';
   const op = { location, val: 'call' };
   return (args)
-    ? { op, func: ref, location: ref.location, args }
+    ? {
+      op, func: ref, location: ref.location, args,
+    }
     : { op, func: ref, location: ref.location };
 }
 
@@ -713,15 +731,15 @@ function valuePathAst( ref ) {
 // otherwise (including for '+'), represent it as extra unary prefix operator.
 function signedExpression( signToken, expr ) {
   const sign = this.valueWithTokenLocation( signToken.text, signToken );
-  const nval =
-        (signToken.text === '-' &&
+  const nval
+        = (signToken.text === '-' &&
         expr && // expr may be null if `-` rule can't be parsed
         expr.literal === 'number' &&
         sign.location.endLine === expr.location.line &&
         sign.location.endCol === expr.location.col &&
         (typeof expr.val === 'number'
-         ? expr.val >= 0 && -expr.val
-         : !expr.val.startsWith('-') && `-${ expr.val }`)) || false;
+          ? expr.val >= 0 && -expr.val
+          : !expr.val.startsWith('-') && `-${ expr.val }`)) || false;
   if (nval === false)
     return { op: sign, args: expr ? [ expr ] : [] };
   expr.val = nval;
@@ -747,9 +765,11 @@ 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-expected-integer', token, { '#': !text.match(/^[0-9]*$/) ? 'normal' : 'unsafe'} );
+      this.error( 'syntax-expecting-integer', token,
+                  { '#': !text.match(/^[0-9]*$/) ? 'normal' : 'unsafe' } );
     }
-    else if (text !== `${num}`) {
+
+    else if (text !== `${ num }`) {
       return { literal: 'number', val: text, location };
     }
   }
@@ -768,7 +788,8 @@ function quotedLiteral( token, literal ) {
   if (token.text.startsWith('`')) {
     val = this.parseMultiLineStringLiteral(token);
     literal = 'string';
-  } else {
+  }
+  else {
     pos = token.text.search( '\'' ) + 1; // pos of char after quote
     val = token.text.slice( pos, -1 ).replace( /''/g, '\'' );
   }
@@ -782,7 +803,7 @@ function quotedLiteral( token, literal ) {
 
   if (p.unexpected_char) {
     const idx = val.search(p.unexpected_char);
-    if (~idx) {
+    if (idx > -1) {
       this.warning( 'syntax-invalid-literal', {
         file: location.file,
         line: location.line,
@@ -934,6 +955,15 @@ function addExtension( ext, parent, kind, artName, elemPath ) {
   }
 }
 
+function aspectWithoutElements( art ) {
+  // Empty dictionary to allow element extensions.
+  art.elements = this.createDict();
+  if (!isBetaEnabled( this.options, 'aspectWithoutElements' )) {
+    this.error( null, [ art.name.location ], {},
+                'Aspects without elements are not supported, yet' );
+  }
+}
+
 // must be in action directly after having parsed '{' or '(`
 function createDict() {
   const dict = Object.create(null);
@@ -977,10 +1007,10 @@ function createPrefixOp( token, args ) {
 
 // Create AST node for binary operator `op` and arguments `args`
 function leftAssocBinaryOp( left, opToken, eToken, right, extraProp = 'quantifier' ) {
-  const op = this.valueWithTokenLocation( opToken.text.toLowerCase() , opToken);
+  const op = this.valueWithTokenLocation( opToken.text.toLowerCase(), opToken);
   const extra = eToken
-        ? this.valueWithTokenLocation( eToken.text.toLowerCase(), eToken )
-        : undefined;
+    ? this.valueWithTokenLocation( eToken.text.toLowerCase(), eToken )
+    : undefined;
   if (!left.$parens &&
       (left.op && left.op.val) === (op && op.val) &&
       (left[extraProp] && left[extraProp].val) === (extra && extra.val)) {
@@ -988,11 +1018,12 @@ function leftAssocBinaryOp( left, opToken, eToken, right, extraProp = 'quantifie
     return left;
   }
   else if (extra) {
-    return { op, [extraProp]: extra, args: [ left, right ], location: left.location };
-  }
-  else {
-    return { op, args: [ left, right ], location: left.location };
+    return {
+      op, [extraProp]: extra, args: [ left, right ], location: left.location,
+    };
   }
+
+  return { op, args: [ left, right ], location: left.location };
 }
 
 // Set property `prop` of `target` to value `value`.  Issue error if that
@@ -1003,7 +1034,7 @@ function setOnce( target, prop, value, ...tokens ) {
   const prev = target[prop];
   if (prev) {
     this.error( 'syntax-repeated-option', loc, { option: prev.option },
-                  'Option $(OPTION) has already been specified' );
+                'Option $(OPTION) has already been specified' );
   }
   if (typeof value === 'boolean') {
     if (!value)
@@ -1041,25 +1072,27 @@ 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 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 {
+    }
+    else {
       // Use alias if provided, i.e. ignore art.value.path.
       this.error( 'query-unexpected-alias', art.name.location, {},
-        'Unexpected alias for association' );
+                  'Unexpected alias for association' );
     }
     delete art.value;
-  } else {
+  }
+  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) {
+      if (isPath)
         art.name = art.value.path[art.value.path.length - 1];
-      }
+
       delete art.value;
     }
   }
@@ -1091,21 +1124,19 @@ function reportExpandInline( column, isInline ) {
 }
 
 function checkTypeFacet( art, argIdent ) {
-  const id = argIdent.id;
+  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 } );
+                  { '#': 'duplicate', code: id } );
       this.error( 'syntax-duplicate-argument', art[id].location,
-        { '#': 'duplicate', code: id } );
+                  { '#': 'duplicate', code: id } );
     }
     return true;
-
-  } else {
-    this.error( 'syntax-duplicate-argument', argIdent.location,
-      { '#': 'unknown', code: id } );
-    return false;
   }
+  this.error( 'syntax-duplicate-argument', argIdent.location,
+              { '#': 'unknown', code: id } );
+  return false;
 }
 
 module.exports = GenericAntlrParser;

package/lib/language/language.g4

@@ -721,16 +721,21 @@ aspectDef[ art, outer ] locals[ name = {} ]
         )*
       )?
     )?
-    '{' { $art.elements = this.createDict(); }
-    ( elementDef[ $art ]* )
-    '}' { this.finalizeDictOrArray( $art.elements ); }
-    // TODO: action definitions in a specific section?
-    (
-      ACTIONS '{' { $art.actions = this.createDict(); }
-      actionFunctionDef[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.actions ); }
-    )?
-    optionalSemi
+    ( // `aspect MyAspect {};`
+      '{' { $art.elements = this.createDict(); }
+      ( elementDef[ $art ]* )
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      // TODO: action definitions in a specific section?
+      (
+        ACTIONS '{' { $art.actions = this.createDict(); }
+        actionFunctionDef[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.actions ); }
+      )?
+      optionalSemi
+    | // `aspect MyAspect;`, e.g. for annotation aspects.
+      { this.aspectWithoutElements( $art ); }
+      requiredSemi
+    )
   ;
 
 typeDef[ art, outer ] locals[ name = {} ]
@@ -1075,12 +1080,12 @@ mixinElementDef[ outer ] locals[ art = {} ]
       |
         typeRefOptArgs[ $art ]
         ( as='=' expression
-          { this.notSupportedYet( 'Calculated fields are not supported yet', $as ); }
+          { this.error( 'syntax-unsupported-field', $as ); }
         )?
       )
     |
       as='=' expression
-      { this.notSupportedYet( 'Calculated fields are not supported yet', $as ); }
+      { this.error( 'syntax-unsupported-field', $as ); }
     )
     requiredSemi
   ;
@@ -1099,8 +1104,7 @@ elementDefInner[ art, outer, allowEq ]
     ( masked=MASKED
       {
         $art.masked = this.valueWithTokenLocation( true, $masked ) ;
-        this.message( 'syntax-invalid-masked', $masked, { keyword: 'masked' },
-                      'Keyword $(KEYWORD) not supported' );
+        this.message( 'syntax-unsupported-masked', $masked, { keyword: 'masked' } );
       }
     )?
     // TODO: order?
@@ -1212,7 +1216,7 @@ elementDefInner[ art, outer, allowEq ]
       eq='=' e=expression       // never introduce AS as syntax variant of '='
       {
         if (!$allowEq || $e.expr && !$e.expr.literal )
-          this.notSupportedYet( 'Calculated fields are not supported yet', $eq );
+          this.error( 'syntax-unsupported-field', $eq );
         else if ($e.expr)
           $art.value = $e.expr;
       }
@@ -1394,7 +1398,7 @@ elementProperties[ elem ]
     nullability[ $elem ]?
   |
     eq='='
-    { this.notSupportedYet( 'Calculated fields are not supported yet', $eq ); }
+    { this.error( 'syntax-unsupported-field', $eq ); }
     expression
   ;
 
@@ -2226,7 +2230,7 @@ conditionTerm returns [ cond ]
       { $cond = { op: this.valueWithTokenLocation( 'exists', $ex ), args: [
           { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' }
         ] };
-        this.csnParseOnly( 'Dynamic parameter "?" is not supported', $qm );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
       }
     |
       ep=valuePath[ 'ref' ]
@@ -2350,7 +2354,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
       ne=NEW nqp=valuePath[ 'ref', null] // token rewrite for NEW
       // please note: there will be no compiler-supported code completion after NEW
       { $expr = { op: this.valueWithTokenLocation( 'new', $ne ), args: [] };
-        this.notSupportedYet( $ne ); }
+        this.error( 'syntax-unsupported-new', $ne, { keyword: $ne.text }, '$(KEYWORD) is not supported' ); }
     |
       vp=valuePath[ 'ref', null ] { $expr = this.valuePathAst( $vp.qp ); }
       { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
@@ -2363,7 +2367,7 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         { $expr = $vp.qp;; $expr.scope = 'param'; }
       | pp=Number
         { $expr = { param: this.numberLiteral( $pp ), scope: 'param' };
-          this.csnParseOnly( 'Positional parameter ":' + $pp.text + '" is not supported', $pp );
+          this.csnParseOnly( 'syntax-unsupported-param', [ $pp ], { '#': 'positional', name: ':' + $pp.text } );
         }
       )
     |
@@ -2371,7 +2375,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( 'Dynamic parameter "?" is not supported', $qm );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
       }
     |
       open='('
@@ -2661,8 +2665,9 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
             const item = { literal: 'token', val: '...', location: this.tokenLocation($e) };
             if ($ctx.upTo) item.upTo = $upTo.val;
             $assignment.val.push( item );
-            if ($seenEllipsis === true) // TODO: adapt msg to UP TO
-              this.error( 'syntax-unexpected-ellipsis', $e, { '#': 'std', code: '...' } );
+            if ($seenEllipsis === true)
+              this.error( 'syntax-unexpected-ellipsis', $e,
+                          { '#': 'duplicate', code: '...', keyword: 'up to' } );
             else
               $seenEllipsis = !$ctx.upTo || 'upTo';
           }}
@@ -2672,9 +2677,8 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
     cb=']'
     {
       if ($seenEllipsis === 'upTo')
-        this.error( 'syntax-expecting-ellipsis', $cb, // at closing bracket
-                    { code: '... up to', newcode: '...' },
-                   'Expecting an array item $(NEWCODE) after an item with $(CODE)' );
+        this.error( 'syntax-missing-ellipsis', $cb, // at closing bracket
+                    { code: '... up to', newcode: '...' } );
     }
   |
     v1=literalValue { Object.assign( $assignment, $v1.val ); }