@sap/cds-compiler 2.11.2 → 2.13.6

package/lib/language/genericAntlrParser.js

@@ -11,14 +11,18 @@ const { ATNState } = require('antlr4/atn/ATNState');
 const { dictAdd, dictAddArray } = require('../base/dictionaries');
 const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
+const { parseMultiLineStringLiteral } = require('./multiLineStringParser');
 const { functionsWithoutParens, specialFunctions } = require('../compiler/builtins');
 
+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
-  return msg( id,
-              (loc instanceof antlr4.CommonToken) ? parser.tokenLocation(loc) : loc, ...args );
+  if (loc instanceof antlr4.CommonToken) {
+    loc = parser.tokenLocation(loc);
+  }
+  return msg( id, loc, ...args );
 }
 
 // Class which is to be used as grammar option with
@@ -32,6 +36,19 @@ function GenericAntlrParser( ...args ) {
   // ANTLR restriction: we cannot add parameters to the constructor.
   antlr4.Parser.call( this, ...args );
   this.buildParseTrees = false;
+
+  // Common properties.
+  // We set them here so that they are available in the prototype.
+  // This improved performance by 25% for certain scenario tests.
+  // Probably because there was no need to look up the prototype chain anymore.
+  this.$adaptExpectedToken = null;
+  this.$adaptExpectedExcludes = [ ];
+  this.$nextTokensToken = null;
+  this.$nextTokensContext = null;
+
+  this.prepareGenericKeywords();
+  this.options = {};
+
   return this;
 }
 
@@ -49,9 +66,11 @@ GenericAntlrParser.prototype = Object.assign(
     attachLocation,
     startLocation,
     tokenLocation,
-    multiLineTokenLocation,
+    valueWithTokenLocation,
     previousTokenAtLocation,
     combinedLocation,
+    createDict,
+    setDictEndLocation,
     surroundByParens,
     unaryOpForParens,
     leftAssocBinaryOp,
@@ -67,6 +86,7 @@ GenericAntlrParser.prototype = Object.assign(
     docComment,
     addDef,
     addItem,
+    artifactForElementAnnotateOrExtend,
     assignProps,
     createPrefixOp,
     setOnce,
@@ -76,6 +96,7 @@ GenericAntlrParser.prototype = Object.assign(
     reportExpandInline,
     notSupportedYet,
     csnParseOnly,
+    disallowElementExtension,
     noAssignmentInSameLine,
     noSemicolonHere,
     setLocalToken,
@@ -84,6 +105,7 @@ GenericAntlrParser.prototype = Object.assign(
     isStraightBefore,
     meltKeywordToIdentifier,
     prepareGenericKeywords,
+    parseMultiLineStringLiteral,
     constructor: GenericAntlrParser, // keep this last
   }
 );
@@ -209,6 +231,22 @@ function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
 //     // 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) {
+    this.message( 'syntax-invalid-extend', this.tokenLocation(this.getCurrentToken()), { 'kind': extensionVariant } );
+    outer.extensions.length = outer.extensions.length - 1; // remove last, i.e. new extension
+  }
+}
+
 function noAssignmentInSameLine() {
   const t = this.getCurrentToken();
   if (t.text === '@' && t.line <= this._input.LT(-1).line) {
@@ -290,61 +328,66 @@ function startLocation( token = this._ctx.start ) {
  *
  * @param {object} token
  * @param {object} endToken
- * @param {any} val
+ * @return {CSN.Location}
  */
-function tokenLocation( token, endToken, val ) {
+function tokenLocation( token, endToken = null ) {
   if (!token)
     return undefined;
   if (!endToken)                // including null
     endToken = token;
+
   /** @type {CSN.Location} */
-  const r = {
+  const loc = {
     file: this.filename,
     line: token.line,
     col: token.column + 1,
-    // we only have single-line tokens, except for docComments
+    // Default for single line tokens
     endLine: endToken.line,
     endCol: endToken.stop - endToken.start + endToken.column + 2, // after the last char (special for EOF?)
-  };
-  if (val !== undefined)
-    return { location: r, val };
-  return r;
+  }
+
+  // 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.
+  const isMultiLineToken = (
+    endToken.type === this.constructor.DocComment ||
+    endToken.type === this.constructor.String ||
+    endToken.type === this.constructor.UnterminatedLiteral
+  );
+  if (isMultiLineToken) {
+    // Count the number of newlines in the token.
+    const source = endToken.source[1].data;
+    let newLineCount = 0;
+    let lastNewlineIndex = endToken.start;
+    for (let i = endToken.start; i < endToken.stop; i++) {
+      // Note: We do NOT check for CR, LS, and PS (/[\r\u2028\u2029]/)
+      //       because ANTLR only uses LF for line break detection.
+      if (source[i] === 10) { // code point of '\n'
+        newLineCount++;
+        lastNewlineIndex = i;
+      }
+    }
+    if (newLineCount > 0) {
+      loc.endLine = endToken.line + newLineCount;
+      loc.endCol = endToken.stop - lastNewlineIndex + 1;
+    }
+  }
+
+  return loc;
 }
 
 /**
- * Return location of `token`.  In contrast to `tokenLocation()`, this function
- * can handle multiline tokens.
+ * Return `val` with the location of `token`.  If `endToken` is provided, use its end
+ * location as end location in the result.
+ *
+ * @param {object} startToken
+ * @param {object} endToken
+ * @param {any} val
  */
-function multiLineTokenLocation(token, val) {
-  if (!token)
+function valueWithTokenLocation( val, startToken, endToken = null ) {
+  if (!startToken)
     return undefined;
-
-  // Count the number of newlines in the token.
-  // TODO: I want to avoid a substring, that's why I don't use RegEx here
-  const source = token.source[1].data;
-  let newLineCount = 0;
-  let lastNewlineIndex = token.start;
-  for (let i = token.start; i < token.stop; i++) {
-    if (source[i] === 10) { // ASCII code for '\n'
-      newLineCount++;
-      lastNewlineIndex = i;
-    }
-  }
-  if (newLineCount === 0)
-    // endCol calculation below requires at least one newLine.
-    return this.tokenLocation(token, token, val);
-
-  /** @type {CSN.Location} */
-  const r = {
-    file: this.filename,
-    line: token.line,
-    col: token.column + 1,
-    endLine: token.line + newLineCount,
-    endCol: token.stop - lastNewlineIndex + 1, // after the last char (special for EOF?)
-  };
-  if (val !== undefined)
-    return { location: r, val };
-  return r;
+  const loc = this.tokenLocation( startToken, endToken );
+  return { location: loc, val };
 }
 
 function previousTokenAtLocation( location ) {
@@ -364,6 +407,20 @@ function combinedLocation( start, end ) {
   return locUtils.combinedLocation( start, end );
 }
 
+function createDict( location = null ) {
+  const dict = Object.create(null);
+  dict[$location] = location || this.startLocation( this._input.LT(-1) );
+  return dict;
+}
+
+function setDictEndLocation( dict ) {
+  const stop = this._input.LT(-1);
+  Object.assign( dict[$location], {
+    endLine: stop.line,
+    endCol: stop.stop - stop.start + stop.column + 2,
+  } );
+}
+
 function surroundByParens( expr, open, close, asQuery = false ) {
   if (!expr)
     return expr;
@@ -405,7 +462,7 @@ function docComment( node ) {
     this.warning( 'syntax-duplicate-doc-comment', token, {},
                   'Repeated doc comment - previous doc is replaced' );
   }
-  node.doc = this.multiLineTokenLocation( token, parseDocComment( token.text ) );
+  node.doc = this.valueWithTokenLocation( parseDocComment( token.text ), token );
 }
 
 // Classify token (identifier category) for implicit names,
@@ -506,7 +563,7 @@ 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.tokenLocation( signToken, undefined, signToken.text );
+  const sign = this.valueWithTokenLocation( signToken.text, signToken );
   const nval =
         (signToken.text === '-' &&
         expr && // expr may be null if `-` rule can't be parsed
@@ -556,8 +613,16 @@ function numberLiteral( token, sign, text = token.text ) {
 function quotedLiteral( token, literal ) {
   /** @type {CSN.Location} */
   const location = this.tokenLocation( token );
-  const pos = token.text.search( '\'' ) + 1; // pos of char after quote
-  const val = token.text.slice( pos, -1 ).replace( /''/g, '\'' );
+  let pos;
+  let val;
+
+  if (token.text.startsWith('`')) {
+    val = this.parseMultiLineStringLiteral(token);
+    literal = 'string';
+  } else {
+    pos = token.text.search( '\'' ) + 1; // pos of char after quote
+    val = token.text.slice( pos, -1 ).replace( /''/g, '\'' );
+  }
 
   if (!literal)
     literal = token.text.slice( 0, pos - 1 ).toLowerCase();
@@ -587,6 +652,7 @@ function quotedLiteral( token, literal ) {
   };
 
   function atChar(i) {
+    // Is only used with single-line strings.
     return location.col + pos + i;
   }
 }
@@ -646,13 +712,13 @@ function addDef( parent, env, kind, name, annos, props, location ) {
     }
   }
   else if (name && name.id == null) {
-    name.id = pathName(name.path ); // A.B.C -> 'A.B.C'
+    name.id = pathName( name.path ); // A.B.C -> 'A.B.C'
   }
   const art = this.assignProps( { name }, annos, props, location );
   if (kind)
     art.kind = kind;
-  if (!parent[env])
-    parent[env] = Object.create(null);
+  if (!parent[env])      // TODO: dump with --test-mode, env !== 'artifacts'
+    parent[env] = env === 'args' ? Object.create(null) : this.createDict( { ...location } );
   if (!art.name || art.name.id == null) {
     // no id was parsed, but with error recovery: no further error
     // TODO: add to  parent[env]['']
@@ -709,6 +775,31 @@ function addItem( parent, env, kind, annos, props, location ) {
   return art;
 }
 
+/**
+ * For `annotate/extend E:elem.sub`, create the `elements` structure
+ * that can be used by the core compiler to annotate/extend elements.
+ *
+ * @param {string} kind Either `annotate` or `extend`
+ * @param {object} artifact Main artifact that shall have `elements`.
+ * @param {XSN.Path} elementPath Path as returned by `simplePath` token.
+ * @param {object[]} annos  Existing annotations that shall be added to the _last_ path step.
+ * @param {XSN.Location} artifactLocation Start location of the `annotate` statement.
+ * @returns {object} Deepest element
+ */
+function artifactForElementAnnotateOrExtend(kind, artifact, elementPath, annos, artifactLocation ) {
+  if (!Array.isArray(elementPath) || elementPath.broken || elementPath.length < 1)
+    return artifact;
+
+  for (const seg of elementPath.slice(0, -1)) {
+    artifact = this.addDef( artifact, 'elements', kind,
+      { path: [seg], location: seg.location }, null, {}, artifactLocation );
+  }
+  const last = elementPath[elementPath.length - 1];
+  artifact = this.addDef( artifact, 'elements', kind,
+    { path: [ last ], location: last.location }, annos, {}, artifactLocation );
+  return artifact;
+}
+
 /** Assign all non-empty (undefined, null, {}, []) properties in argument
  * `props` and argument `annos` as property `$annotations` to `target`
  * and return it.  Hack: if argument `annos` is exactly `true`, return
@@ -729,7 +820,7 @@ function assignProps( target, annos = [], props = null, location = null) {
   for (const key in props) {
     let val = props[key];
     if (val instanceof antlr4.CommonToken)
-      val = this.tokenLocation( val, undefined, true);
+      val = this.valueWithTokenLocation( true, val);
     // only copy properties which are not undefined, null, {} or []
     if (val != null &&
         (typeof val !== 'object' ||
@@ -743,15 +834,15 @@ function assignProps( target, annos = [], props = null, location = null) {
 
 // Create AST node for prefix operator `op` and arguments `args`
 function createPrefixOp( token, args ) {
-  const op = this.tokenLocation( token, undefined, token.text.toLowerCase() );
+  const op = this.valueWithTokenLocation( token.text.toLowerCase(), token );
   return { op, args, location: this.combinedLocation( op, args[args.length - 1] ) };
 }
 
 // Create AST node for binary operator `op` and arguments `args`
 function leftAssocBinaryOp( left, opToken, eToken, right, extraProp = 'quantifier' ) {
-  const op = this.tokenLocation( opToken, undefined, opToken.text.toLowerCase() );
+  const op = this.valueWithTokenLocation( opToken.text.toLowerCase() , opToken);
   const extra = eToken
-        ? this.tokenLocation( eToken, undefined, eToken.text.toLowerCase() )
+        ? this.valueWithTokenLocation( eToken.text.toLowerCase(), eToken )
         : undefined;
   if (!left.$parens &&
       (left.op && left.op.val) === (op && op.val) &&