@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/language/genericAntlrParser.js

@@ -19,6 +19,8 @@ const {
 } = require('../compiler/builtins');
 const { pathName } = require('../compiler/utils');
 const { isBetaEnabled } = require('../base/model');
+const { weakLocation } = require('../base/messages');
+const { normalizeNewLine } = require('./textUtils');
 
 const $location = Symbol.for('cds.$location');
 
@@ -73,9 +75,11 @@ Object.assign(GenericAntlrParser.prototype, {
   info(...args) {
     return _message( this, 'info', ...args );
   },
+  isBetaEnabled,
   attachLocation,
   assignAnnotation,
   addAnnotation,
+  expressionAsAnnotationValue,
   checkExtensionDict,
   handleDuplicateExtension,
   startLocation,
@@ -86,6 +90,7 @@ Object.assign(GenericAntlrParser.prototype, {
   previousTokenAtLocation,
   combinedLocation,
   surroundByParens,
+  tokensToStringRepresentation,
   secureParens,
   unaryOpForParens,
   leftAssocBinaryOp,
@@ -96,6 +101,7 @@ Object.assign(GenericAntlrParser.prototype, {
   pushXprToken,
   argsExpression,
   valuePathAst,
+  fixNewKeywordPlacement,
   signedExpression,
   numberLiteral,
   quotedLiteral,
@@ -120,6 +126,7 @@ Object.assign(GenericAntlrParser.prototype, {
   associationInSelectItem,
   reportExpandInline,
   checkTypeFacet,
+  checkTypeArgs,
   csnParseOnly,
   noAssignmentInSameLine,
   noSemicolonHere,
@@ -361,15 +368,12 @@ function assignAnnotation( art, anno, prefix = '' ) {
 }
 
 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
-    this.error( 'syntax-duplicate-anno', [ location ], { anno: n },
-                'Duplicate assignment with $(ANNO)' );
-    a.$errorReported = 'syntax-duplicate-anno';
-    // do not report again later as anno-duplicate-xyz
-  } );
+  const old = art[prop];
+  if (old) {
+    this.error( 'syntax-duplicate-anno', old.name.location, { anno: prop },
+                'Assignment for $(ANNO) is overwritten by another one below' );
+  }
+  art[prop] = anno;
 }
 
 const extensionDicts = {
@@ -525,18 +529,24 @@ function fixMultiLineTokenEndLocation( token, location ) {
 }
 
 /**
- * Return `val` with the location of `token`.  If `endToken` is provided, use its end
- * location as end location in the result.
+ * Return `val` with a location; if `val` and `endToken` are not provided, use the
+ * lower-cased token string of `startToken` as `val`.  As location, use the
+ * location covered by `startToken` and `endToken`, or only `startToken` if no
+ * `endToken` is provided.  The `startToken` defaults to the previous token.
  *
  * @param {object} startToken
  * @param {object} endToken
  * @param {any} val
  */
-function valueWithTokenLocation( val, startToken, endToken = null ) {
-  if (!startToken)
-    return undefined;
+function valueWithTokenLocation( val = undefined, startToken = this._input.LT(-1),
+                                 endToken = undefined ) {
+  // if (!startToken)
+  //   startToken = this._input.LT(-1);
   const loc = this.tokenLocation( startToken, endToken );
-  return { location: loc, val };
+  return {
+    location: loc,
+    val: (endToken || val !== undefined) ? val : startToken.text.toLowerCase(),
+  };
 }
 
 function previousTokenAtLocation( location ) {
@@ -584,6 +594,23 @@ function surroundByParens( expr, open, close, asQuery = false ) {
   return (asQuery) ? { query: expr, location } : expr;
 }
 
+
+function tokensToStringRepresentation( matchedRule ) {
+  const tokens = this._input.getTokens(
+    matchedRule.start.tokenIndex,
+    matchedRule.stop.tokenIndex + 1, null
+  ).filter(tok => tok.channel === antlr4.Token.DEFAULT_CHANNEL);
+  if (tokens.length === 0)
+    return '';
+
+  let result = tokens[0].text;
+  for (let i = 1; i < tokens.length; ++i) {
+    const str = normalizeNewLine(tokens[i].text);
+    result += (tokens[i].start > tokens[i - 1].stop + 1) ? ` ${ str }` : str;
+  }
+  return result;
+}
+
 function unaryOpForParens( query, val ) {
   const parens = query?.$parens;
   if (!parens)
@@ -652,7 +679,7 @@ function fragileAlias( ast, safe = false ) {
   return ast;
 }
 
-// Return AST for identifier token `token`.  Also check that identifer is not empty.
+// Return AST for identifier token `token`.  Also check that identifier is not empty.
 function identAst( token, category, noTokenTypeCheck = false ) {
   token.isIdentifier = category;
   let id = token.text;
@@ -696,8 +723,11 @@ function argsExpression( args, nary, location ) {
       location: undefined,
     } );
   }
+  // eslint-disable-next-line no-nested-ternary
+  const val = nary === '?:' ? nary
+    : (nary && nary !== '=' ? 'nary' : 'ixpr');
   const op = {
-    val: (nary && nary !== '=' ? 'nary' : 'ixpr'), // there is no n-ary in rule conditionTerm
+    val, // there is no n-ary in rule conditionTerm
     location: this.startLocation(),
   };
   return this.attachLocation( { op, args, location: location && { ...location } } );
@@ -713,35 +743,115 @@ function pushXprToken( args ) {
 }
 
 function valuePathAst( ref ) {
-  // TODO: XSN representation of functions is a bit strange - rework if methods
-  // are introduced
+  // TODO: XSN representation of functions is a bit strange - rework
   const { path } = ref;
   if (!path || path.broken)
     return ref;
   if (path.length !== 1) {
     const item = path.find( i => i.args && i.$syntax !== ':' );
-    if (!item)
+    if (!item) // also covers empty paths
       return ref;
-    this.error( 'syntax-unsupported-method', item.location, {},
-                'Methods in expressions are not supported yet' );
-    path.broken = true;
-    path.length = 1;
   }
-  const { args, id, location } = path[0];
-  if (args
+  else if (path.length === 1) {
+    const { args, id, location } = path[0];
+    if (args
       ? path[0].$syntax === ':'
       : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
-    return ref;
+      return ref;
+
+    const implicit = this.previousTokenAtLocation( location );
+    if (implicit && implicit.isIdentifier)
+      implicit.isIdentifier = 'func';
+    const op = { location, val: 'call' };
+    return (args)
+      ? {
+        op, func: ref, location: ref.location, args,
+      }
+      : { op, func: ref, location: ref.location };
+  }
+
+  // method call ---------------------------
+
+  const args = [];
+  const pathRest = [ ...path ];
+  let pathHead = pathRest.shift();
 
-  const implicit = this.previousTokenAtLocation( location );
-  if (implicit && implicit.isIdentifier)
-    implicit.isIdentifier = 'func';
-  const op = { location, val: 'call' };
-  return (args)
-    ? {
-      op, func: ref, location: ref.location, args,
+  if (pathHead.args) {
+    args.push({
+      op: { location: pathHead.location, val: 'call' },
+      func: { path: [ pathHead ] },
+      location: pathHead.location,
+      args: pathHead.args || [],
+    });
+    pathHead = pathRest.shift();
+  }
+  else {
+    const refPath = [];
+    while (pathHead && !pathHead.args) {
+      refPath.push(pathHead);
+      pathHead = pathRest.shift();
     }
-    : { op, func: ref, location: ref.location };
+    args.push({ path: refPath, location: refPath[0].location });
+  }
+
+  if (pathHead?.args)
+    pathRest.unshift(pathHead);
+
+  for (const method of pathRest) {
+    args.push({
+      // TODO: Update parser to have proper location for `.`?
+      location: weakLocation(method.location),
+      val: '.',
+      literal: 'token',
+    });
+    const func = {
+      op: { location: method.location, val: 'call' },
+      func: { path: [ method ] },
+      location: method.location,
+    };
+    if (method.args)
+      func.args = method.args;
+    args.push(func);
+  }
+
+  return {
+    op: {
+      val: 'ixpr',
+      location: this.startLocation(),
+    },
+    args,
+    location: ref.location,
+  };
+}
+
+
+/**
+ * Adds the first argument of `args` ('new' keyword) to the second argument, if it's a method-ixpr.
+ *
+ * @todo Cleanup, remove.
+ * @param args
+ */
+function fixNewKeywordPlacement( args ) {
+  // TODO: Currently, the parser creates an args-array with `new` and an `ixpr` for
+  //      `new P().abc()`.  That is, "new" is separate from the methods.
+  //      This function tries to work around it, but its more of a hack.
+  if (args.length !== 2 || !args[1].args || args[1].op?.val !== 'ixpr')
+    return;
+  const ixpr = args[1];
+  ixpr.args.unshift(args[0]);
+  args.length = 0;
+  args.push(ixpr);
+}
+
+function expressionAsAnnotationValue( assignment, cond ) {
+  if (!cond.cond) // parse error
+    return;
+  Object.assign(assignment, cond.cond);
+  assignment.$tokenTexts = this.tokensToStringRepresentation(cond);
+  if (!this.isBetaEnabled(this.options, 'annotationExpressions')) {
+    this.error( 'syntax-unsupported-expression', [ cond.cond.location ], {},
+                'Expressions in annotation values are not supported' );
+  }
 }
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
@@ -992,7 +1102,7 @@ function aspectWithoutElements( art ) {
   }
 }
 
-// must be in action directly after having parsed '{' or '(`
+// must be in action directly after having parsed '{', '(`, or a keyword before
 function createDict() {
   const dict = Object.create(null);
   dict[$location] = this.startLocation( this._input.LT(-1) );
@@ -1174,4 +1284,14 @@ function checkTypeFacet( art, argIdent ) {
   return false;
 }
 
+function checkTypeArgs( art ) {
+  const args = art.$typeArgs;
+  // One or two arguments are interpreted as either length or precision/scale.
+  if (args.length > 2) {
+    const loc = args[2].location;
+    this.error( 'syntax-unexpected-argument', loc, {}, 'Too many type arguments' );
+    art.$typeArgs = undefined;
+  }
+}
+
 module.exports = GenericAntlrParser;