@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/language/docCommentParser.js

@@ -1,6 +1,10 @@
 'use strict';
 
-const { splitLines } = require('../utils/file');
+const {
+  isWhitespaceOrNewLineOnly,
+  isWhitespaceCharacterNoNewline,
+  cdlNewLineRegEx,
+} = require('./textUtils');
 
 /**
  * Get the content of a JSDoc-like comment and remove all surrounding asterisks, etc.
@@ -18,39 +22,40 @@ function parseDocComment(comment) {
   if (comment.length <= 5) // at least "/***/"
     return null;
 
-  let lines = splitLines(comment);
+  let lines = comment.split(cdlNewLineRegEx);
 
   if (lines.length === 1) {
-    // special case for one-liners
-    // remove "/***/" and trim white space
-    const content = lines[0].replace(/^\/[*]{2,}/, '').replace(/\*\/$/, '').trim();
-    return isWhiteSpaceOnly(content) ? null : content;
+    // Special case for one-liners.
+    // Remove "/***/" and trim white space and asterisks.
+    const content = lines[0]
+      .replace(/^\/[*]{2,}/, '')
+      .replace(/\*+\/$/, '')
+      .trim();
+    return isWhitespaceOrNewLineOnly(content) ? null : content;
   }
 
-  lines[0] = removeHeaderFence(lines[0]);
+  // If the comment already has content on the first line, i.e. after `/**`,
+  // its leading whitespace is ignored for whitespace trimming.
+  const hasContentOnFirstLine = /\/\*+\s*\S/.test(lines[0]);
+
+  // First line, i.e. header, is always trimmed from left.
+  lines[0] = removeHeaderFence(lines[0]).trimStart();
   lines[lines.length - 1] = removeFooterFence(lines[lines.length - 1]);
 
-  if (isFencedComment(lines)) {
-    lines = lines.map((line, index) => ((index === 0) ? line : removeFence(line)));
-  }
-  else if (lines.length === 2) {
+  if (lines.length === 2) {
     // Comment that is essentially just a header + footer.
-    // First line, i.e. header, is always trimmed from left.
-    lines[0] = lines[0].trimLeft();
-
     // If the second line starts with an asterisk then remove it.
-    // Otherwise trim all whitespace.
+    // Otherwise, trim all left whitespace.
     if ((/^\s*[*]/.test(lines[1])))
       lines[1] = removeFence(lines[1]);
     else
-      lines[1] = lines[1].trimLeft();
+      lines[1] = lines[1].trimStart();
+  }
+  else if (isFencedComment(lines)) {
+    lines = lines.map((line, index) => ((index === 0) ? line : removeFence(line)));
   }
   else {
-    const firstNonEmptyLine = lines.find((line, index) => index !== 0 && /[^\s]/.test(line)) || '';
-    // Tabs are regarded as one space.
-    const spacesAtBeginning = firstNonEmptyLine.match(/^\s*/)[0].length;
-    if (spacesAtBeginning > 0)
-      lines = lines.map(line => removeWhitespace(line, spacesAtBeginning));
+    stripCommentIndentation(lines, hasContentOnFirstLine);
   }
 
   // Remove empty header and footer.
@@ -58,18 +63,47 @@ function parseDocComment(comment) {
   const endIndex = (lines[lines.length - 1] === '') ? lines.length - 1 : lines.length;
 
   const content = lines.slice(startIndex, endIndex).join('\n');
-
-  return isWhiteSpaceOnly(content) ? null : content;
+  return isWhitespaceOrNewLineOnly(content) ? null : content;
 }
 
 /**
- * Checks whether the given string is whitespace only, i.e. newline
- * spaces, tabs.
+ * Strips and counts the indentation from the given comment string.
+ * This function is similar to the one in multiLineStringParser.js, but does not
+ * have special handling for the first and last line of the string.
+ *
+ * @example
+ *     |        hello
+ *     |          world
+ *     |        foo bar
+ *   becomes
+ *     | hello
+ *     |   world
+ *     | foo bar
  *
- * @param {string} content
+ * @param {string[]} lines String split into lines.
+ * @param {boolean} ignoreFirstLine Whether to ignore the first line for indentation counting.
  */
-function isWhiteSpaceOnly(content) {
-  return /^\s*$/.test(content);
+function stripCommentIndentation(lines, ignoreFirstLine) {
+  const n = lines.length;
+
+  const minIndent = lines.reduce((min, line, index) => {
+    // Blank lines are ignored.
+    if (isWhitespaceOrNewLineOnly(line) || (index === 0 && ignoreFirstLine))
+      return min;
+
+    let count = 0;
+    const length = Math.min(min, line.length);
+    while (count < length && isWhitespaceCharacterNoNewline(line[count])) {
+      count++;
+    }
+    return Math.min(min, count);
+  }, Number.MAX_SAFE_INTEGER);
+
+  for (let i = (ignoreFirstLine ? 1 : 0); i < n; ++i) {
+    // Note: Line may be empty and have fewer characters than `min`.
+    //       In that case, slice() returns an empty string.
+    lines[i] = lines[i].slice(minIndent);
+  }
 }
 
 /**
@@ -85,17 +119,6 @@ function removeFence(line) {
   return line.replace(/^\s*[*]\s?/, '');
 }
 
-/**
- * Remove the TODO
- *
- * @param {string} line
- * @param {number} spaces Number of whitespace to remove at the beginning of the line
- * @returns {string} line without fence
- */
-function removeWhitespace(line, spaces) {
-  return line.replace(new RegExp(`^\\s{0,${ spaces }}`), ''); // Trailing spaces with '*'? => .replace(/\s+[*]$/, '');
-}
-
 /**
  * Removes a header fence, i.e. '/**'.
  * May remove more than two asterisks e.g. '/*******'

package/lib/language/errorStrategy.js

@@ -29,12 +29,12 @@
 'use strict';
 
 const antlr4 = require('antlr4');
-const IntervalSet = require('antlr4/IntervalSet');
-const antlr4_error = require('antlr4/error/ErrorStrategy');
-const antlr4_LL1Analyzer = require('antlr4/LL1Analyzer.js').LL1Analyzer;
-const predictionContext = require('antlr4/PredictionContext').predictionContextFromRuleContext;
-const { ATNState } = require('antlr4/atn/ATNState');
-const { InputMismatchException } = antlr4.error;
+const antlr4_LL1Analyzer = require('antlr4/src/antlr4/LL1Analyzer');
+const { DefaultErrorStrategy } = require('antlr4/src/antlr4/error/ErrorStrategy');
+const { InputMismatchException } = require('antlr4/src/antlr4/error/Errors');
+const { predictionContextFromRuleContext: predictionContext } = require('antlr4/src/antlr4/PredictionContext');
+const { ATNState } = require('antlr4/src/antlr4/atn/ATNState');
+const { IntervalSet, Interval } = require('antlr4/src/antlr4/IntervalSet');
 
 const keywordRegexp = /^[a-zA-Z]+$/; // we don't have keywords with underscore
 
@@ -65,30 +65,35 @@ function match( ttype ) {
 //
 // An instance of this class should be set as property `_errHandler` to the
 // parser (prototype).
-function KeywordErrorStrategy( ...args ) {
-  antlr4_error.DefaultErrorStrategy.call( this, ...args );
-}
-const super1 = antlr4_error.DefaultErrorStrategy.prototype;
-
-KeywordErrorStrategy.prototype = Object.assign(
-  Object.create( super1 ), {
-    sync,
-    reportNoViableAlternative,
-    reportInputMismatch,
-    reportUnwantedToken,
-    reportMissingToken,
-    reportIgnoredWith,
-    // getErrorRecoverySet,
-    consumeUntil,
-    recoverInline,
-    getMissingSymbol,
-    getExpectedTokensForMessage,
-    getTokenDisplay,
-    constructor: KeywordErrorStrategy,
+class KeywordErrorStrategy extends DefaultErrorStrategy {
+  constructor( ...args ) {
+    super( ...args );
+
+    this._super = {
+      consumeUntil: super.consumeUntil,
+      recoverInline: super.recoverInline,
+      getExpectedTokens: super.getExpectedTokens,
+    };
   }
-);
+}
 
-// Attemp to recover from problems in subrules, except if rule has defined a
+// TODO: Use actual methods
+Object.assign( KeywordErrorStrategy.prototype, {
+  sync,
+  reportNoViableAlternative,
+  reportInputMismatch,
+  reportUnwantedToken,
+  reportMissingToken,
+  reportIgnoredWith,
+  // getErrorRecoverySet,
+  consumeUntil,
+  recoverInline,
+  getMissingSymbol,
+  getExpectedTokensForMessage,
+  getTokenDisplay,
+});
+
+// Attempt to recover from problems in subrules, except if rule has defined a
 // local variable `_sync` with value 'nop'
 function sync( recognizer ) {
   // If already recovering, don't try to sync
@@ -166,7 +171,7 @@ function sync( recognizer ) {
     case ATNState.STAR_LOOP_BACK: { // 9
       // TODO: do not delete a '}'
       this.reportUnwantedToken(recognizer);
-      const expecting = new IntervalSet.IntervalSet();
+      const expecting = new IntervalSet();
       expecting.addSet(recognizer.getExpectedTokens());
       const whatFollowsLoopIterationOrRule = expecting.addSet(this.getErrorRecoverySet(recognizer));
       this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);
@@ -270,21 +275,21 @@ function consumeUntil( recognizer, set ) {
 
   // let s=this.getTokenDisplay( recognizer.getCurrentToken(), recognizer );
   if (SEMI < 1 || RBRACE < 1) {
-    super1.consumeUntil.call( this, recognizer, set );
+    this._super.consumeUntil.call( this, recognizer, set );
   }
   else if (set.contains(SEMI)) { // do not check for RBRACE here!
-    super1.consumeUntil.call( this, recognizer, set );
+    this._super.consumeUntil.call( this, recognizer, set );
     // console.log('CONSUMED-ORIG:',s,this.getTokenDisplay( recognizer.getCurrentToken(), recognizer ),recognizer.getCurrentToken().line,intervalSetToArray( recognizer, set ));
   }
   else {
     // DO NOT modify input param `set`, as the set might be cached in the ATN
-    const stop = new IntervalSet.IntervalSet();
+    const stop = new IntervalSet();
     stop.addSet( set );
     stop.removeOne( recognizer.constructor.Identifier );
     stop.addOne( SEMI );
     // I am not that sure whether to add RBRACE...
     stop.addOne( RBRACE );
-    super1.consumeUntil.call( this, recognizer, stop );
+    this._super.consumeUntil.call( this, recognizer, stop );
     if (recognizer.getTokenStream().LA(1) === SEMI ||
         recognizer.getTokenStream().LA(1) === RBRACE && !set.contains(RBRACE)) {
       recognizer.consume();
@@ -310,11 +315,11 @@ function consumeUntil( recognizer, set ) {
 function recoverInline( recognizer ) {
   const identType = recognizer.constructor.Identifier;
   if (!identType || !recognizer.isExpectedToken( identType ))
-    return super1.recoverInline.call( this, recognizer );
+    return this._super.recoverInline.call( this, recognizer );
 
   const token = recognizer.getCurrentToken();
   if (!keywordRegexp.test( token.text ))
-    return super1.recoverInline.call( this, recognizer );
+    return this._super.recoverInline.call( this, recognizer );
 
   recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text },
                       '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it' );
@@ -344,8 +349,12 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
     for (let j = v.start; j < v.stop; j++) {
       // a generic keyword as such does not appear in messages, only its replacements,
       // which are function name and argument position dependent:
-      if (j === pc.GenericArgFull)
-        names.push( ...recognizer.$genericKeywords.argFull );
+      if (j === pc.GenericExpr)
+        names.push( ...recognizer.$genericKeywords.expr );
+      else if (j === pc.GenericSeparator)
+        names.push( ...recognizer.$genericKeywords.separator );
+      else if (j === pc.GenericIntro)
+        names.push( ...recognizer.$genericKeywords.introMsg );
       // other expected tokens usually appear in messages, except the helper tokens
       // which are used to solve ambiguities via the parser method setLocalToken():
       else if (j !== pc.HelperToken1 && j !== pc.HelperToken2)
@@ -362,6 +371,9 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
   else if (names.includes("';'")) {
     names = names.filter( n => n !== "'}'" );
   }
+  else if (names.includes("'?'")) {
+    names = names.filter( n => n !== "'?'" );
+  }
   names.sort( (a, b) => (tokenPrecedence(a) < tokenPrecedence(b) ? -1 : 1) );
   return names;
 }
@@ -421,10 +433,10 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   const hideAltsType = recognizer.constructor.HideAlternatives;
   const beforeUnreserved = recognizer.constructor.Number;
   if (!identType || !beforeUnreserved || beforeUnreserved + 2 > identType)
-    return intervalSetToArray( recognizer, super1.getExpectedTokens.call( this, recognizer ) );
+    return intervalSetToArray( recognizer, this._super.getExpectedTokens.call( this, recognizer ) );
 
   const ll1 = new antlr4_LL1Analyzer(atn);
-  const expected = new IntervalSet.IntervalSet();
+  const expected = new IntervalSet();
   const orig_addInterval = expected.addInterval;
   const orig_addSet = expected.addSet;
   expected.addInterval = addInterval;
@@ -485,7 +497,7 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   }
 
   function addRange( interval, start, stop ) {
-    orig_addInterval.call( interval, new IntervalSet.Interval( start, stop || start + 1 ) );
+    orig_addInterval.call( interval, new Interval( start, stop || start + 1 ) );
   }
 }