@sap/cds-compiler 3.9.4 → 4.0.2

package/lib/json/to-csn.js

@@ -33,6 +33,7 @@ let universalCsn = false;
 let strictMode = false;        // whether to dump with unknown properties (in standard)
 let projectionAsQuery = false;
 let withLocations = false;
+let withDocComments = false;
 let structXpr = false;
 let dictionaryPrototype = null;
 
@@ -54,7 +55,7 @@ const transformers = {
   // early and modifiers (without null / not null) ---------------------------
   kind,
   id: n => n,                   // in path item
-  doc: value,
+  doc: docComment,
   '@': anno,
   virtual: value,
   key: value,
@@ -159,7 +160,7 @@ const transformers = {
 // which should appear at that place in order.
 const csnPropertyNames = {
   virtual: [ 'abstract' ],      // abstract is compiler v1 CSN property
-  kind: [ 'annotate', 'extend', '$origin' ],
+  kind: [ 'annotate', 'extend', '$origin' ], // TODO: $origin better at the end? see addOrigin()
   op: [ 'join', 'func', 'xpr' ],    // TODO: 'func','xpr' into 'quantifier'?  TODO: 'global'(scope)?
   quantifier: [
     'some', 'any', 'distinct',  // 'all' explicitly listed
@@ -521,7 +522,7 @@ function targetAspect( val, csn, node ) {
   if (universalCsn) {
     if (val.$inferred)
       return undefined;
-    if (node.target) {
+    if (node.target) {          // TODO: use addOrigin() for this
       csn.$origin = { target: (val.elements) ? standard( val ) : artifactRef( val, true ) };
       return undefined;
     }
@@ -536,13 +537,17 @@ function targetAspect( val, csn, node ) {
   return undefined;
 }
 
-function target( val, _csn, node ) {
-  if (gensrcFlavor && node._origin && node._origin.$inferred === 'REDIRECTED')
-    val = node._origin.target;
+function target( val, csn, node ) {
   if (val.elements)
     return standard( val );       // elements in target (parse-cdl)
+  // Mention user-provided target in $origin if outside query entity:
+  if (val.$inferred === '' && universalCsn && !gensrcFlavor && !node._main?.query) {
+    if (!csn.$origin)
+      csn.$origin = {};
+    csn.$origin.target = artifactRef( val, '.path' ); // TODO: to addOrigin()
+  }
   if (!universalCsn || gensrcFlavor || node.on)
-    return artifactRef( val, true );
+    return artifactRef( val, !gensrcFlavor || val.$inferred !== '' || '.path' );
   const tref = artifactRef( val, true );
   const proto = node.type && !node.type.$inferred ? node.type._artifact : node._origin;
   return (proto && proto.target && artifactRef( proto.target, true ) === tref)
@@ -668,8 +673,7 @@ function ignore() { /* no-op: ignore property */ }
 
 function location( loc, csn, xsn ) {
   if (xsn.kind && xsn.kind.charAt(0) !== '$' && xsn.kind !== 'select' &&
-      (!xsn.$inferred || !xsn._main) &&
-      xsn.$inferred !== 'REDIRECTED') { // TODO: also for 'select'
+      (!xsn.$inferred || !xsn._main)) { // TODO: also for 'select'
     // Also include $location for elements in queries (if not via '*')
     addLocation( xsn.name && xsn.name.location || loc, csn );
   }
@@ -738,8 +742,6 @@ function foreignKeys( dict, csn, node ) {
     return;
 
   if (gensrcFlavor) {
-    if (node._origin?.$inferred === 'REDIRECTED')
-      dict = node._origin.foreignKeys;
     if (dict[$inferred])
       return;
   }
@@ -1050,8 +1052,6 @@ function originRef( art, user ) {
 }
 
 function kind( k, csn, node ) {
-  if (node.$inferred === 'REDIRECTED')
-    return;
   if (k === 'annotate' || k === 'extend') {
     // We just use `name.absolute` because it is very likely a "constructed"
     // extensions.  The CSN parser must produce name.path like for other refs.
@@ -1077,18 +1077,11 @@ function kind( k, csn, node ) {
     csn.$generated = generated;
 }
 
-function type( node, csn, xsn ) {
+function type( node ) {
   if (!universalCsn)
     return artifactRef( node, !node.$extra );
   if (node.$inferred && node.$inferred !== 'cast')
     return undefined;
-  if (xsn._origin) {
-    if (xsn._origin.$inferred === 'REDIRECTED') { // auto-redirected user-provided target
-      const $origin = definition( xsn._origin );
-      if ($origin)              // if not rendered as column
-        csn.$origin = $origin;
-    }
-  }
   return artifactRef( node, !node.$extra );
 }
 
@@ -1106,73 +1099,39 @@ function artifactRef( node, terse ) {
   if (node.$inferred && gensrcFlavor)
     return undefined;
   // Works also on XSN directly coming from parser and with XSN from CDL->CSN transformation
-  const { path } = node;
-  if (terse && node._artifact && !node._artifact._main)
+  // Shortcut for many cases:
+  if (terse && node._artifact && !node._artifact._main && terse !== '.path')
     return node._artifact.name.absolute;
+  let { path } = node;
   if (!path)
     return undefined;           // TODO: complain with strict
-  else if (!path.length)
+  if (!path.length)
     return [];
 
-  const link = path[0]._artifact; // XSN TODO: store double definitions differently
-  const root = Array.isArray(link) ? link[0] : link;
-  if (!root) {                  // XSN directly coming from the parser
-    if (strictMode && node.scope === 'typeOf')
-      throw new CompilerAssertion( `Unexpected TYPE OF in ${ locationString(node.location) }`);
-    return renderArtifactPath( node, path, terse, node.scope );
-  }
-  const { absolute } = root.name;
-  if (node.scope !== 'typeOf' && typeof node.scope !== 'number') {
-    // CSN input or generated in compiler (XSN TODO: remove scope:'global')
-    if (absolute === path[0].id) // normal case (no localization view)
-      return renderArtifactPath( node, path, terse );
-    // scope:param is not valid (and would be lost)
-    const head = Object.assign( {}, path[0], { id: absolute } );
-    return renderArtifactPath( node, [ head, ...path.slice(1) ], terse );
-  }
-  if (node.scope === 'typeOf') { // TYPE OF without ':' in path
-    // Root _artifact which is either element or main artifact for paths starting with $self.
-    // To make the CDL->CSN transformation simpler, the _artifact for first item could be
-    // a fake element with just a correct absolute name and  _parent/_main links.
-    if (!root._main || root.kind === 'select') { // $self/$projection
-      // in query, only correct for leading query ->
-      // TODO: forbid TYPE OF elem / TYPE OF $self.elem in queries
-      return renderArtifactPath( node, [ { id: absolute }, ...path.slice(1) ], terse );
-    }
-    const parent = root._parent;
-    const structs = parent.name.element ? parent.name.element.split('.') : [];
-    return extra( { ref: [ absolute, ...structs, ...path.map( pathItem ) ] }, node );
-  }
-  let { scope } = node;
-  if (!scope) {                 // no ':' in CDL path - try to be nice and guess it via links
-    const { length } = path;
-    for (; scope < length; ++scope) {
-      const art = path[scope]._artifact;
-      if (!art) {
-        scope = 0;              // unsuccessful, not all path items have links
-        break;
-      }
-      if (art._main)
-        break;                  // successful, found first element
-    }
-  }
-  const head = Object.assign( {}, path[0], { id: absolute } );
-  return renderArtifactPath( node, [ head, ...path.slice(1) ], terse, scope );
-}
+  const head = path[0];
+  const root = head._artifact;
+  const id = root?.name.absolute;
+  const scope = node.scope || path.length;
 
-function renderArtifactPath( node, path, terse, scope ) {
-  if (scope === 0) {
-    // try to find ':' position syntactically for FROM
-    scope = !terse && path.findIndex( i => i.where || i.args || i.cardinality) + 1 ||
-            path.length;
-  }
   if (typeof scope === 'number' && scope > 1) {
     const item = path[scope - 1];
-    const name = item._artifact && item._artifact.name;
-    // In localization views, the _artifact link of `item` is important
-    const id = name && name.absolute ||
-               pathName( path.slice( 0, scope ) );
-    path = [ Object.assign( {}, item, { id } ), ...path.slice( scope ) ];
+    const name = item._artifact?.name;
+    const absolute = name?.absolute ||
+      `${ id || head.id }.${ path.slice( 1, scope ).map( i => i.id ).join('.') }`;
+    path = [ Object.assign( {}, item, { id: absolute } ), ...path.slice( scope ) ];
+  }
+  else if (scope === 'typeOf') {     // TYPE OF without ':' in path
+    if (root) {
+      const structs = root.name.element?.split('.').map( n => ({ id: n }) );
+      // TODO: change (follow parents) if we introduce sparse names
+      path = [ { id }, ...(structs || []), ...path.slice(1) ];
+    }
+    else if (strictMode) {
+      throw new CompilerAssertion( `Unexpected TYPE OF in ${ locationString(node.location) }`);
+    }
+  }
+  else if (root && id !== head.id) {
+    path = [ Object.assign( {}, head, { id } ), ...path.slice( 1 ) ];
   }
   const ref = path.map( pathItem );
   return (!terse || ref.length !== 1 || typeof ref[0] !== 'string')
@@ -1183,6 +1142,10 @@ function renderArtifactPath( node, path, terse, scope ) {
 function pathItem( item ) {
   if (!item.args &&
       !item.where &&
+      !item.groupBy &&
+      !item.having &&
+      !item.limit &&
+      !item.orderBy &&
       !item.cardinality &&
       !item.$extra &&
       !item.$syntax)
@@ -1205,8 +1168,15 @@ function anno( node ) {
   return value(node);
 }
 
+function docComment( doc ) {
+  // Value is `true` if options.docComment is falsey for CDL input.
+  if (withDocComments && doc?.val !== true)
+    return value( doc );
+  return undefined;
+}
+
 function value( node ) {
-// "Short" value form, e.g. for annotation assignments
+  // "Short" value form, e.g. for annotation assignments
   if (!node)
     return true;                // `@aBool` short for `@aBool: true`
   if (universalCsn && node.$inferred) {
@@ -1242,22 +1212,21 @@ function value( node ) {
 function enumValueOrCalc( v, csn, node ) {
   if (v.$inferred && (universalCsn || gensrcFlavor))
     return undefined;
-  // Enums can have values but if enums are extended, their kind is 'element'
-  if (node.kind === 'enum' || node.$syntax === 'enum') {
+  // Enums can have values but if enums are extended, their kind is 'element'.
+  // In v4, we don't check `node.$syntax === 'enum'` anymore.
+  if (node.kind === 'enum') {
     Object.assign( csn, expression( v ) );
   }
-  else if (node.$syntax === 'calc') { // TODO: || node._parent?.kind === 'extend'
+  else if (node.$syntax === 'calc' || node._parent?.kind === 'extend') {
     const stored = v.stored ? { stored: value(v.stored) } : {};
     return Object.assign( stored, expression( v ) );
   }
   return undefined;
 }
 
-function onCondition( cond, csn, node ) {
+function onCondition( cond ) {
   if (gensrcFlavor) {
-    if (node._origin && node._origin.$inferred === 'REDIRECTED')
-      cond = node._origin.on;
-    else if (cond.$inferred)
+    if (cond.$inferred)
       return undefined;
   }
   return condition( cond );
@@ -1475,6 +1444,7 @@ function addElementAsColumn( elem, cols ) {
   try {
     gensrcFlavor = gensrcFlavor || 'column';
     set( 'virtual', col, elem );
+    // TODO if (!elem.key?.$specifiedElement)
     set( 'key', col, elem );
     const expr = expression( elem.value );
     Object.assign( col, (expr.cast ? { xpr: [ expr ] } : expr) );
@@ -1533,7 +1503,7 @@ function cast( csn, node ) {
   else
     r.cast = {};                // TODO: what about $extra in cast?
   for (const prop of typeProperties)
-    set( prop, r.cast, node );
+    set(prop, r.cast, node);
   return r;
 }
 
@@ -1596,6 +1566,7 @@ function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
     ? proto
     : (proto) ? Object.prototype : null;
   withLocations = options.withLocations;
+  withDocComments = options.docComment !== false;
   structXpr = options.structXpr;
   projectionAsQuery = isDeprecatedEnabled( options, '_projectionAsQuery' );
 }

package/lib/language/antlrParser.js

@@ -11,7 +11,6 @@
 const antlr4 = require('antlr4');
 
 const { CompileMessage } = require('../base/messages');
-const { isBetaEnabled } = require('../base/model');
 const errorStrategy = require('./errorStrategy');
 
 const Parser = require('../gen/languageParser').default;
@@ -30,11 +29,6 @@ class ErrorListener extends antlr4.error.ErrorListener {
 }
 
 class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
-  constructor(lexer, v4newKeyword) {
-    super(lexer);
-    this.v4newKeyword = v4newKeyword;
-  }
-
   LT( k ) {
     const t = super.LT(k);
     if (!t || !t.type)
@@ -56,7 +50,7 @@ class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
     else if (t.type === this.NEW) {
       const n = super.LT(k + 1);
       // TODO v4: rewrite token in grammar via `this.setLocalToken`
-      if (n?.type === this.Identifier && (this.v4newKeyword || /^st_/i.test( n.text ))) {
+      if (n?.type === this.Identifier) {
         const o = super.LT(k + 2);
         if (o?.type === this.PAREN)
           return t;
@@ -118,8 +112,7 @@ function parse( source, filename = '<undefined>.cds',
                 options = {}, messageFunctions = null,
                 rule = 'cdl' ) {
   const lexer = new Lexer( new antlr4.InputStream(source) );
-  const v4newKeyword = isBetaEnabled(options, 'v4preview');
-  const tokenStream = new RewriteTypeTokenStream(lexer, v4newKeyword);
+  const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
   const parser = new Parser( tokenStream );
   const errorListener = new ErrorListener();
@@ -161,19 +154,30 @@ function parse( source, filename = '<undefined>.cds',
 
 
   const rulespec = rules[rule];
-  const tree = rule && parser[rulespec.func]();
+  let tree;
+  try {
+    tree = rule && parser[rulespec.func]();
+  }
+  catch (e) {
+    if (e instanceof RangeError && e.message.match(/Maximum.*exceeded$/i)) {
+      messageFunctions.error('syntax-invalid-source', { file: filename },
+                             { '#': 'cdl-stackoverflow' } );
+    }
+    else {
+      throw e;
+    }
+  }
   const ast = tree && tree[rulespec.returns] || {};
   ast.options = options;
   if (rulespec.$frontend)
     ast.$frontend = rulespec.$frontend;
 
-  // Warn about unused doc-comments.
   // Do not warn if docComments are explicitly disabled.
   if (options.docComment !== false) {
     for (const token of tokenStream.tokens) {
       if (token.type === parser.constructor.DocComment && !token.isUsed) {
-        messageFunctions.info( 'syntax-ignoring-doc-comment', parser.tokenLocation(token), {},
-                               'Ignoring doc comment as it is not written at a defined position' );
+        messageFunctions.info('syntax-ignoring-doc-comment', parser.tokenLocation(token), {},
+                              'Ignoring doc comment as it is not written at a defined position');
       }
     }
   }

package/lib/language/docCommentParser.js

@@ -15,6 +15,12 @@ const hasContentOnFirstLineRegEx = /\/\*+\s*\S/;
  * If the comment only contains whitespace it is seen as empty and `null` is returned
  * which also stops doc comment propagation.
  *
+ * Notes on escape sequences:
+ *  - For `*\/`, the `\` is removed.
+ *  - Nothing else is escaped, meaning `\n` will be `\` and `n` and not a newline character.
+ *  - _If requested_, we could parse the doc comment similar to multiline string literals, but
+ *    via an option.
+ *
  * @param {string} comment Raw comment, e.g. '/** comment ... '.
  *                         Must be a valid doc comment.
  * @returns {string|null} Parsed contents or if the comment has an invalid format or
@@ -34,6 +40,7 @@ function parseDocComment( comment ) {
     const content = lines[0]
       .replace(/^\/[*]{2,}/, '')
       .replace(/\*+\/$/, '')
+      .replace('*\\/', '*/') // escape sequence
       .trim();
     return isWhitespaceOrNewLineOnly(content) ? null : content;
   }
@@ -66,7 +73,10 @@ function parseDocComment( comment ) {
   const startIndex = (lines[0] === '') ? 1 : 0;
   const endIndex = (lines[lines.length - 1] === '') ? lines.length - 1 : lines.length;
 
-  const content = lines.slice(startIndex, endIndex).join('\n');
+  const content = lines
+    .slice(startIndex, endIndex)
+    .join('\n')
+    .replace('*\\/', '*/'); // escape sequence
   return isWhitespaceOrNewLineOnly(content) ? null : content;
 }
 

package/lib/language/genericAntlrParser.js

@@ -401,7 +401,8 @@ function checkExtensionDict( dict ) {
           this.addAnnotation( def, prop, dup[prop] );
         }
         else if (prop === 'doc') {
-          if (def.doc) {
+          // With explicit docComment:false, we don't emit a warning.
+          if (def.doc && this.options.docComment !== false) {
             this.warning( 'syntax-duplicate-doc-comment', def.doc.location, {},
                           'Doc comment is overwritten by another one below' );
           }
@@ -646,13 +647,15 @@ function docComment( node ) {
   // This token is actually used by / assigned to an artifact.
   token.isUsed = true;
 
-  if (!this.options.docComment)
-    return;
-  if (node.doc) {
+  // With explicit docComment:false, we don't emit a warning.
+  if (node.doc && this.options.docComment !== false) {
     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 );
+
+  // Either store the doc comment or a marker that there is one.
+  const val = !this.options.docComment ? true : parseDocComment( token.text );
+  node.doc = this.valueWithTokenLocation( val, token );
 }
 
 // Classify token (identifier category) for implicit names,
@@ -1099,7 +1102,7 @@ function aspectWithoutElements( art ) {
   // TODO: Checking it here does not prevent aspect in CSN input having no elements!
   art.elements = this.createDict();
   if (!isBetaEnabled( this.options, 'aspectWithoutElements' )) {
-    this.error( null, [ art.name.location ], {},
+    this.error( null, [ art.name.location, null ], {},
                 'Aspects without elements are not supported, yet' );
   }
 }
@@ -1189,7 +1192,7 @@ function setNullability( art, token1, token2 ) {
   art.notNull = notNull;
 }
 
-function reportDuplicateClause( prop, errorneous, chosen, keywords ) {
+function reportDuplicateClause( prop, erroneous, chosen, keywords ) {
   // probably easier for message linters not to use (?:) for the message id...?
   const args = {
     '#': prop,
@@ -1197,10 +1200,10 @@ function reportDuplicateClause( prop, errorneous, chosen, keywords ) {
     line: chosen.location.line,
     col: chosen.location.col,
   };
-  if (errorneous.val === chosen.val)
-    this.warning( 'syntax-duplicate-equal-clause', errorneous.location, args );
+  if (erroneous.val === chosen.val)
+    this.warning( 'syntax-duplicate-equal-clause', erroneous.location, args );
   else
-    this.message( 'syntax-duplicate-clause', errorneous.location, args );
+    this.message( 'syntax-duplicate-clause', erroneous.location, args );
 }
 
 const extensionsCode = {