@sap/cds-compiler 3.1.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
@@ -607,12 +620,16 @@ function classifyImplicitName( category, ref ) {
 }
 
 function fragileAlias( ast, safe = false ) {
-  if (safe || ast.$delimited || !/^[a-zA-Z][a-zA-Z_]+$/.test( ast.id ))
+  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' },
                   '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;
 }
 
@@ -643,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 ) };
@@ -674,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 ) {
@@ -687,7 +705,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-not-supported', item.location, {},
                 'Methods in expressions are not supported yet' );
     path.broken = true;
     path.length = 1;
@@ -703,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 };
 }
 
@@ -711,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;
@@ -745,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 };
     }
   }
@@ -766,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, '\'' );
   }
@@ -780,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,
@@ -932,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);
@@ -975,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)) {
@@ -986,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
@@ -1001,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)
@@ -1039,57 +1072,71 @@ 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;
     }
   }
 }
 
-function reportExpandInline( clauseName ) {
-  let token = this.getCurrentToken();
-  // improve error location when using "inline" `.{…}` after ref (arguments and
-  // filters not covered, not worth the effort); after an expression where
-  // the last token is an identifier, not the `.` is wrong, but the `{`:
-  if (token.text === '.' && this._input.LT(-1).type >= this.constructor.Identifier)
-    token = this._input.LT(2);
-  this.error( 'syntax-unexpected-refclause', token, { prop: clauseName },
-              'Unexpected nested $(PROP), can only be used after a reference' );
+function reportExpandInline( column, isInline ) {
+  const { name } = column;
+  if (column.value && !column.value.path) {
+    let token = this.getCurrentToken();
+    // improve error location when using "inline" `.{…}` after ref (arguments and
+    // filters not covered, not worth the effort); after an expression where
+    // the last token is an identifier, not the `.` is wrong, but the `{`:
+    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' } );
+    // 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
+    // - think about: reference to these (sub) elements from other view
+  }
+  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)' );
+    // continuation semantics: ignore AS
+  }
 }
 
 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;