@sap/cds-compiler 3.0.0 → 3.1.2

package/lib/language/genericAntlrParser.js

@@ -12,7 +12,8 @@ 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 { functionsWithoutParens, specialFunctions, quotedLiteralPatterns } = require('../compiler/builtins');
+const { pathName } = require("../compiler/utils");
 
 const $location = Symbol.for('cds.$location');
 
@@ -62,8 +63,13 @@ Object.assign(GenericAntlrParser.prototype, {
   info: function(...args) { return _message( this, 'info', ...args ); },
   attachLocation,
   assignAnnotation,
+  addAnnotation,
+  checkExtensionDict,
+  handleDuplicateExtension,
   startLocation,
   tokenLocation,
+  isMultiLineToken,
+  fixMultiLineTokenEndLocation,
   valueWithTokenLocation,
   previousTokenAtLocation,
   combinedLocation,
@@ -113,40 +119,6 @@ Object.assign(GenericAntlrParser.prototype, {
   parseMultiLineStringLiteral,
 });
 
-// Patterns for literal token tests and creation.  The value is a map from the
-// `prefix` argument of function `quotedliteral` to the following properties:
-//  - `test_msg`: error message which is issued if `test_fn` or `test_re` fail.
-//  - `test_fn`: function called with argument `value`, fails falsy return value
-//  - `test_re`: regular expression, fails if it does not match argument `value`
-//  - `unexpected_msg`: error message which is issued if `unexpected_char` matches
-//  - `unexpected_char`: regular expression matching an illegal character in `value`,
-//    the error location is only correct for a literal <prefix>'<value>'
-//  - `literal`: the value which is used instead of `prefix` in the AST
-// TODO: we might do a range check (consider leap seconds, i.e. max value 60),
-//       but always allow Feb 29 (no leap year computation)
-// TODO: make it a configurable error (syntax-invalid-literal)
-// TODO: also use for CSN input
-const quotedLiteralPatterns = {
-  x: {
-    test_variant: 'uneven-hex',
-    test_fn: (str => Number.isInteger(str.length / 2)),
-    unexpected_variant: 'invalid-hex',
-    unexpected_char: /[^0-9a-f]/i,
-  },
-  time: {
-    test_variant: 'time',
-    test_re: /^[0-9]{1,2}:[0-9]{1,2}(:[0-9]{1,2})?$/,
-  },
-  date: {
-    test_variant: 'date',
-    test_re: /^[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}$/,
-  },
-  timestamp: {
-    test_variant: 'timestamp',
-    test_re: /^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}(:[0-9]{2}(\.[0-9]{1,7})?)?$/,
-  },
-};
-
 // Use the following function for language constructs which we (currently)
 // just being able to parse, in able to run tests from HANA CDS.  As soon as we
 // create ASTs for the language construct and put it into a CSN, a
@@ -221,12 +193,12 @@ function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
 }
 
 function setLocalTokenForId( tokenNameMap ) {
+  const tokenName = tokenNameMap[ this._input.LT(2).text || '' ];
   const ll1 = this.getCurrentToken();
-  if (ll1.type === this.constructor.Identifier || /^[a-zA-Z_]+$/.test( ll1.text )) {
-    const tokenName = tokenNameMap[ this._input.LT(2).text || '' ];
-    if (tokenName)
-      ll1.type = this.constructor[tokenName];
-  }
+  if (tokenName &&
+      (ll1.type === this.constructor.Identifier || /^[a-zA-Z_]+$/.test( ll1.text )))
+    ll1.type = this.constructor[tokenName];
+  return !!tokenName;
 }
 
 // // Special function for rule `requiredSemi` before return $ctx
@@ -298,9 +270,6 @@ function prepareGenericKeywords( pathItem, expected = null) {
   const func = pathItem?.id && specialFunctions[pathItem.id.toUpperCase()];
   const spec = func && func[argPos] || specialFunctions[''][argPos ? 1 : 0];
   this.$genericKeywords = spec;
-  // currently, we only have 'TODO', i.e. a keyword which is alternative to expression
-  // TODO: If not just at the beginning, we need a stack for $genericKeywords,
-  // as we can have nested special functions
   // @ts-ignore
   const token = this.getCurrentToken() || { text: '' };
   const text = token.text.toUpperCase();
@@ -339,15 +308,26 @@ function reportErrorForGenericKeyword() {
 function attachLocation( art ) {
   if (!art || art.$parens)
     return art;
-  if (!art.location)
-    art.location = this.startLocation();
-  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?)
+  if (!art.location) {
+    art.location = this.tokenLocation(this._ctx.start, this._ctx.stop);
+    return art;
+  }
+
+  // The last token (this._ctx.stop) may be a multi-line string literal, in which
+  // case we can't rely on `this._ctx.stop.line`.
+  if (this.isMultiLineToken(this._ctx.stop)) {
+    this.fixMultiLineTokenEndLocation(this._ctx.stop, art.location);
+
+  } 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?)
+  }
+
   return art;
 }
 
-function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
+function assignAnnotation( art, anno, prefix = '', iHaveVariant = false ) {
   const { name, $flatten } = anno;
   const { path } = name;
   if (path.broken || !path[path.length - 1].id)
@@ -355,7 +335,8 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
   const pathname = pathName( path );
   let absolute = '';
   if (name.variant) {
-    absolute = `${ prefix }${ pathname }#${ name.variant.id }`;
+    const variant = pathName( name.variant.path );
+    absolute = `${ prefix }${ pathname }#${ variant }`;
     if (iHaveVariant) {       // TODO: do we really care in the parser / core compiler?
       this.error( 'anno-duplicate-variant', [ name.variant.location ],
                   {},      // TODO: params
@@ -374,18 +355,9 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
   }
   else {
     name.absolute = absolute;
-    const prop = '@' + absolute;
-    const old = art[prop];
-    if (old && old.$inferred)
-      art[prop] = anno;
-    else
-      dictAddArray( art, prop, anno, (n, location, a) => {
-        this.error( 'syntax-duplicate-anno', [ location ], { anno: n },
-                    'Duplicate assignment with $(ANNO)' );
-        a.$errorReported = true; // do not report again later as anno-duplicate-xyz
-      } );
+    this.addAnnotation( art, '@' + absolute, anno );
   }
-  if (!prefix) {                // set deprecated $annnotations for cds-lsp
+  if (!prefix) {                // set deprecated $annotations for cds-lsp
     if (!art.$annotations)
       art.$annotations = [];
     const location = locUtils.combinedLocation( anno.name, anno );
@@ -393,6 +365,76 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
   }
 }
 
+function addAnnotation( art, prop, anno ) {
+  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 extensionDicts = { elements: true, enum: true, params: true, returns: true };
+
+function checkExtensionDict( dict ) {
+  for (const name in dict) {
+    const def = dict[name];
+    if (!def.$duplicates)
+      continue;
+
+    if (def.kind !== 'annotate') {
+      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 );
+      continue;
+    }
+    // move annotations, 'doc' and 'elements' etc to main member
+    for (const dup of def.$duplicates) {
+      for (const prop of Object.keys( dup )) {
+        if (prop.charAt(0) === '@') {
+          this.addAnnotation( def, prop, dup[prop] )
+        }
+        else if (prop === '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]) {
+          if (def[prop])
+            this.message( 'syntax-duplicate-annotate', [ def.name.location ], { name, prop } );
+          def[prop] = dup[prop]; // continuation semantics: last wins
+        }
+      }
+    }
+    def.$duplicates = null;
+  }
+}
+
+function addOneForDefinition( count, ext ) {
+  return (ext.kind === 'extend') ? count : count + 1;
+}
+
+/**
+ * Handle duplicate extensions.  Does not handle `annotate`.
+ *
+ * @param {XSN.Extension} ext
+ * @param {string} name
+ * @param {number} numDefines
+ */
+function handleDuplicateExtension( ext, name, numDefines ) {
+  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
+}
+
+
 /**
  * Return start location of `token`, or the first token matched by the current
  * rule if `token` is undefined
@@ -433,31 +475,49 @@ function tokenLocation( token, endToken = null ) {
 
   // 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 (this.isMultiLineToken(token))
+    this.fixMultiLineTokenEndLocation(token, loc);
+
+  return loc;
+}
+
+function isMultiLineToken(token) {
+  return (
+    token.type === this.constructor.DocComment ||
+    token.type === this.constructor.String ||
+    token.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;
+}
+
+/**
+ * Adapt end location of `location` according to `token`, assuming that `token` is a multi-line
+ * token such as a multi-line string or doc comment.
+ *
+ * Sets `endLine`/`endCol`, respecting newline characters in the token.
+ *
+ * @param token
+ * @param {CSN.Location} location
+ */
+function fixMultiLineTokenEndLocation( token, location ) {
+  // Count the number of newlines in the token.
+  const source = token.source[1].data;
+  let newLineCount = 0;
+  let lastNewlineIndex = token.start;
+  for (let i = token.start; i < token.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;
     }
   }
-
-  return loc;
+  if (newLineCount > 0) {
+    location.endLine = token.line + newLineCount;
+    location.endCol = token.stop - lastNewlineIndex + 1;
+  } else {
+    location.endLine = token.line;
+    location.endCol = token.stop - token.start + token.column + 2; // after the last char (special for EOF?)
+  }
 }
 
 /**
@@ -504,7 +564,7 @@ function surroundByParens( expr, open, close, asQuery = false ) {
 }
 
 function unaryOpForParens( query, val ) {
-  const parens = query.$parens;
+  const parens = query?.$parens;
   if (!parens)
     return query;
   const location = parens[parens.length - 1];
@@ -530,8 +590,8 @@ function docComment( node ) {
   if (!this.options.docComment)
     return;
   if (node.doc) {
-    this.warning( 'syntax-duplicate-doc-comment', token, {},
-                  'Repeated doc comment - previous doc is replaced' );
+    this.warning( 'syntax-duplicate-doc-comment', node.doc.location, {},
+                  'Doc comment is overwritten by another one below' );
   }
   node.doc = this.valueWithTokenLocation( parseDocComment( token.text ), token );
 }
@@ -715,8 +775,7 @@ function quotedLiteral( token, literal ) {
     literal = token.text.slice( 0, pos - 1 ).toLowerCase();
   const p = quotedLiteralPatterns[literal] || {};
 
-  if ((p.test_fn && !p.test_fn(val) || p.test_re && !p.test_re.test(val)) &&
-      !this.options.parseOnly)
+  if (p.test_fn && !p.test_fn(val) && !this.options.parseOnly)
     this.warning( 'syntax-invalid-literal', location, { '#': p.test_variant } );
 
   if (p.unexpected_char) {
@@ -743,10 +802,6 @@ function quotedLiteral( token, literal ) {
   }
 }
 
-function pathName( path, brokenName ) {
-  return (path && !path.broken) ? path.map( id => id.id ).join('.') : brokenName;
-}
-
 function pushIdent( path, ident, prefix ) {
   if (!ident) {
     path.broken = true;
@@ -981,6 +1036,9 @@ function handleComposition( cardinality, isComposition ) {
 }
 
 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 isIdentifier = isPath && art.value.path.length === 1;
   if (isIdentifier) {