@sap/cds-compiler 3.6.2 → 3.7.2

package/lib/language/language.g4

@@ -1050,6 +1050,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       ')' { this.finalizeDictOrArray( $art.params ); }
       { this.checkExtensionDict( $art.params ); }
       (
+        // TODO: set proper $art.returns
         RETURNS { $art['$'+'syntax'] = 'returns'; }
         '{' { $art.elements = this.createDict(); }
         annotateElement[ $art ]*
@@ -1060,6 +1061,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         requiredSemi
       )
     |
+      // TODO: set proper $art.returns
       RETURNS { $art['$'+'syntax'] = 'returns'; }
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
@@ -1111,7 +1113,9 @@ annotateAction [ outer ] locals [ art = {} ]
       { this.checkExtensionDict( $art.params ); }
     )?
     (
-      RETURNS '{' { $art.elements = this.createDict(); }
+      // TODO: set proper $art.returns
+      RETURNS { $art['$'+'syntax'] = 'returns'; }
+      '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
@@ -1511,6 +1515,7 @@ typeRefOptArgs[ art ]
   ;
 
 typeRefArgs[ art ]
+@after { this.checkTypeArgs($art); }
   :
     paren='(' { $art['$'+'typeArgs'] = this.createArray(); }
     (
@@ -2181,10 +2186,9 @@ expressionTerm returns [ expr ] locals [ args = [] ]
     END { this.pushXprToken( $args ); }
   |
     ne=NEW  { this.pushXprToken( $args ); } // token rewrite for NEW
-    // please note: there will be no compiler-supported code completion after NEW
-    { $expr = { op: this.valueWithTokenLocation( 'new', $ne ), args: [] };
-      this.error( 'syntax-unsupported-new', $ne, { keyword: $ne.text }, '$(KEYWORD) is not supported' ); }
     nqp=valuePath[ 'ref', null ]
+    { $args.push( this.valuePathAst( $nqp.qp ) ); }
+    { this.fixNewKeywordPlacement( $args ); }
   |
     vp=valuePath[ 'ref', null ] { $args.push( this.valuePathAst( $vp.qp ) ); }
     { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
@@ -2752,6 +2756,18 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
   |
     ( plus='+' | min='-' ) num=Number
     {  Object.assign( $assignment, this.numberLiteral( $num, $plus||$min ) ); }
+  |
+    '('
+      cond=condition // 'condition' is also used in 'expression' inside '()'.
+      // TODO: (1,2,3) not supported, yet, only ((1,2,3)); we could support it via:
+      // (',' condition)*
+      { $assignment.value = $cond.cond;
+        if (!this.isBetaEnabled(this.options, 'annotationExpressions')) {
+          this.error( 'syntax-unsupported-expression', [ $cond.cond.location ], {},
+                      'Expressions in annotation values are not supported' );
+        }
+      }
+    ')'
   ;
 
 flattenedValue[ assignment ] locals[ val = { name: {} } ]

package/lib/model/csnRefs.js

@@ -657,7 +657,7 @@ function csnRefs( csn, universalReady ) {
       if (!art) {
         const { env } = links[i - 1];
         const loc = env.name && env.name.$location || env.$location;
-        throw new ModelError( `Path item ${ i }=${ pathId( path[i] ) } on ${ locationString( loc ) } refers to nothing` );
+        throw new ModelError( `Path item ${ i }=${ pathId( path[i] ) } refers to nothing; in ${ locationString( loc ) }; path=${ JSON.stringify(path) }` );
       }
       links[i].art = art;
     }

package/lib/model/csnUtils.js

@@ -423,6 +423,7 @@ function getUtils( model, universalReady ) {
     //  - r({ref: ['\\', '\\', '\\\\'] }) != r({ref: ['\\', '\\\\', '\\'] })
     //  - r({ref: ['\\', '\\', '\\\\'] }) != r({ref: ['\\', '\\\\2:\\\\'] })
     const resolvedKey = (typeof type === 'object')
+      // eslint-disable-next-line sonarjs/no-nested-template-literals
       ? `ref[${ type.ref.length }]:${ type.ref.map((val, i) => `${ i }:${ val }`).join('\\') }`
       : `type:${ type }`;
 

package/lib/model/revealInternalProperties.js

@@ -170,8 +170,7 @@ function revealInternalProperties( model, nameOrPath ) {
     if (!Array.isArray(deps))
       return primOrString( deps );
     return deps
-      .filter( d => d.location )
-      .map( d => artifactIdentifier( d.art ) );
+      .map( d => `${ d.location ? '' : '-' }${ artifactIdentifier( d.art ) }`);
   }
 
   function layerExtends( dict ) {

package/lib/modelCompare/compare.js

@@ -120,6 +120,7 @@ function getArtifactComparator(otherModel, options, addedEntities, deletedEntiti
       // Arguments are interchanged in this case: `artifact` from beforeModel and `otherArtifact` from afterModel.
       if (isPersisted && !isPersistedOther) {
         deletedEntities[name] = artifact;
+      // eslint-disable-next-line sonarjs/no-duplicated-branches
       } else if(isPersistedAsView(artifact) && isPersistedOther) { // view turned into table - need to render a drop for the view
         deletedEntities[name] = artifact;
       }
@@ -254,7 +255,7 @@ module.exports = {
 /**
  * A ModelDiff encapsulates the changes between two models ("before" and "after"). It contains information
  * about changes to .elements and removed artifacts.
- * 
+ *
  * @typedef {object} ModelDiff
  * @property {CSN.Definitions} definitions The artifacts present in the "after" model
  * @property {CSN.Definitions} deletions The artifacts present in the "before", but not in the "after"

package/lib/render/manageConstraints.js

@@ -23,12 +23,15 @@ const { sortCsn } = require('../json/to-csn');
  * @param {CSN.Options} options
  */
 function alterConstraintsWithCsn( csn, options ) {
-  const { error } = makeMessageFunction(csn, options, 'manageConstraints');
+  const { error, warning } = makeMessageFunction(csn, options, 'manageConstraints');
 
   const {
-    drop, alter, src, violations,
+    drop, alter, src, violations, sqlDialect,
   } = options || {};
 
+  if (!sqlDialect || sqlDialect === 'h2' || sqlDialect === 'plain')
+    warning(null, null, { prop: sqlDialect || 'plain' }, 'Referential Constraints are not available for sql dialect $(PROP)');
+
   if (drop && alter)
     error(null, null, 'Option “--drop” can\'t be combined with “--alter”');
 

package/lib/render/toCdl.js

@@ -1380,17 +1380,28 @@ function csnToCdl( csn, options ) {
   }
 
   /**
-   * Render an annotation value (somewhat like a simplified expression, with slightly different
-   * representation)
+   * Render an annotation value, which is either
+   *  - a normal expressions
+   *  - a somewhat simplified expression, with slightly different representation
    *
-   * @param {any} x
+   * @param {any} annoValue
    * @param {CdlRenderEnvironment} env
    */
-  function renderAnnotationValue( x, env ) {
+  function renderAnnotationValue( annoValue, env ) {
+    const isXpr = annoValue?.['='] !== undefined && (Object.keys(annoValue).length > 1) &&
+        isBetaEnabled(options, 'annotationExpressions');
+    if (isXpr) {
+      const xpr = exprRenderer.renderExpr(annoValue, env);
+      return `( ${xpr} )`;
+    }
+    return renderSimpleAnnotationValue(annoValue, env);
+  }
+
+  function renderSimpleAnnotationValue( x, env ) {
     if (Array.isArray(x)) {
       // Render array parts as values. Spaces required if last array value is
       // a delimited identifier.
-      return `[ ${x.map(item => renderAnnotationValue(item, env)).join(', ')} ]`;
+      return `[ ${x.map(item => renderSimpleAnnotationValue(item, env)).join(', ')} ]`;
     }
     else if (typeof x === 'object' && x !== null) {
       // Enum symbol
@@ -1405,7 +1416,7 @@ function csnToCdl( csn, options ) {
       else if (x['...']) {
         if (x['...'] === true)
           return '...';
-        return `... up to ${renderAnnotationValue(x['...'], env)}`;
+        return `... up to ${renderSimpleAnnotationValue(x['...'], env)}`;
       }
 
       // Struct value (can currently only occur within an array)
@@ -1413,7 +1424,7 @@ function csnToCdl( csn, options ) {
       // struct if there are more and use nicer indentation.
       const keys = Object.keys(x);
       const childEnv = keys.length <= 1 ? env : increaseIndent(env);
-      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key)}: ${renderAnnotationValue(x[key], childEnv)}`);
+      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key)}: ${renderSimpleAnnotationValue(x[key], childEnv)}`);
       if (values.length <= 1)
         return `{ ${values.join(', ')} }`;
       const valueList = values.join(`,\n${childEnv.indent}`);
@@ -1814,6 +1825,8 @@ function csnToCdl( csn, options ) {
         if (keywords.cdl_functions.includes(x.func.toUpperCase()) && !x.args)
           return x.func;
         const name = smartFunctionId(x.func);
+        if (!x.args) // e.g. for methods without arguments, `args` is not set at all.
+          return `${name}`;
         return `${name}(${renderArguments( x, '=>', this.env )})`;
       },
       xpr(x) {

package/lib/render/toHdbcds.js

@@ -1684,25 +1684,19 @@ function toHdbcdsSource( csn, options ) {
   }
 
   /**
-   * Return an id 'id' with appropriate "-quotes
+   * Return an id 'id' with appropriate double-quotes
    *
    * @param {string} id Identifier to quote
    * @returns {string} Properly quoted identifier
    */
   function quoteId( id ) {
-    // Should only ever be called for real IDs (i.e. no dots inside)
-    if (id.indexOf('.') !== -1)
-      throw new ModelError(`HDBCDS: Tried to quote id with dot: ${id}`);
-
-
     switch (options.sqlMapping) {
       case 'plain':
         return smartId(id, 'hdbcds');
       case 'quoted':
       case 'hdbcds':
-        return delimitedId(id, 'hdbcds');
       default:
-        return null;
+        return delimitedId(id, 'hdbcds');
     }
   }
 

package/lib/render/toSql.js

@@ -93,10 +93,11 @@ function toSqlDdl( csn, options ) {
       return `CAST(${this.renderExpr(withoutCast(x))} AS ${typeRef})`;
     },
     val: renderExpressionLiteral,
-    enum: (x) => {
-      // TODO: Signal is not covered by tests + better location
+    enum(x) {
+      // TODO: better location; callers should set env.$path
       // FIXME: We can't do enums yet because they are not resolved (and we don't bother finding their value by hand)
-      error(null, x.$location, 'Enum values are not yet supported for conversion to SQL');
+      const loc = x.$location || this.env?._artifact?.$location;
+      error('expr-unexpected-enum', [ loc, null ], 'Enum values are not yet supported for conversion to SQL');
       return '';
     },
     ref: renderExpressionRef,

package/lib/render/utils/common.js

@@ -54,10 +54,10 @@ function funcWithoutParen( node, dialect ) {
 }
 
 /**
- * Process already rendered expression parts by joining them nicely
- *
- * @param {Array} tokens Array of expression tokens
+ * Process already rendered expression parts by joining them nicely.
+ * For example, it adds spaces around operators such as `+`, but not around `.`.
  *
+ * @param {any[]} tokens Array of expression tokens
  * @returns {string} The rendered xpr
  */
 function beautifyExprArray( tokens ) {
@@ -65,8 +65,12 @@ function beautifyExprArray( tokens ) {
   let result = '';
   for (let i = 0; i < tokens.length; i++) {
     result += tokens[i];
-    // No space after last token, after opening parentheses, before closing parentheses, before comma
-    if (i !== tokens.length - 1 && tokens[i] !== '(' && ![ ')', ',' ].includes(tokens[i + 1]))
+    // No space after last token, after opening parentheses, before closing parentheses, before comma, before and after dot
+    if (i !== tokens.length - 1 &&
+        // current token
+        tokens[i] !== '(' && tokens[i] !== '.' &&
+        // next token
+        tokens[i + 1] !== ')' && tokens[i + 1] !== '.' && tokens[i + 1] !== ',')
       result += ' ';
   }
   return result;

package/lib/transform/db/assertUnique.js

@@ -19,11 +19,12 @@ const { pathName } = require('../../compiler/utils');
  * @param {CSN.Options} options Options
  * @param {Function} error Message function for errors
  * @param {Function} info Message function for info
+ * @returns {Function} forEachDefinition callback
  */
 function processAssertUnique( csn, options, error, info ) {
   const { resolvePath, flattenPath } = getTransformers(csn, options);
 
-  forEachDefinition(csn, handleAssertUnique);
+  return handleAssertUnique;
   /**
    * The detailed processing - see comment above for what is going on here
    *

package/lib/transform/db/expansion.js

@@ -361,6 +361,8 @@ function expandStructureReferences( csn, options, pathDelimiter, { error, info,
           expanded.push(Object.assign({}, current, { as: currentAlias.join(pathDelimiter) } ));
         }
         else { // preserve stuff like .cast for redirection
+          if (base[currentAlias[currentAlias.length - 1]]?.value)
+            error('query-unsupported-calc', col.$path, { '#': 'inside' });
           expanded.push(Object.assign({}, current, { ref: currentRef, as: currentAlias.join(pathDelimiter) } ));
         }
       }

package/lib/transform/db/flattening.js

@@ -293,7 +293,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
         // TODO: use $ignore - _ is for links
         element._ignore = true;
 
-        const branches = getBranches(element, elementName);
+        const branches = getBranches(element, elementName, effectiveType, pathDelimiter);
         const flatElems = flattenStructuredElement(element, elementName, [], path.concat([ 'elements', elementName ]));
 
         for (const flatElemName in flatElems) {
@@ -308,7 +308,7 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
           const flatElement = flatElems[flatElemName];
 
           // Check if we have a valid notNull chain
-          const branch = branches[flatElemName];
+          const branch = branches[flatElemName].steps;
           if (flatElement.notNull !== false && !branch.some(s => !s.notNull))
             flatElement.notNull = true;
 
@@ -357,49 +357,49 @@ function flattenElements( csn, options, pathDelimiter, error, iterateOptions = {
       return elements;
     }, Object.create(null));
   }
+}
 
-
+/**
+ * Get not just the leaves, but all branches of a structured element.
+ *
+ * @param {object} element Structured element
+ * @param {string} elementName Name of the structured element
+ * @param {Function} effectiveType
+ * @param {string} pathDelimiter
+ * @returns {object} Returns a dictionary, where the key is the flat name of the branch and the value is an array of element-steps.
+ */
+function getBranches( element, elementName, effectiveType, pathDelimiter ) {
+  const branches = {};
+  const subbranchNames = [];
+  const subbranchElements = [];
+  walkElements(element, elementName);
   /**
-   * Get not just the leafs, but all the branches of a structured element
+   * Walk the element chain
    *
-   * @param {object} element Structured element
-   * @param {string} elementName Name of the structured element
-   * @returns {object} Returns a dictionary, where the key is the flat name of the branch and the value is an array of element-steps.
+   * @param {object} e
+   * @param {string} name
    */
-  function getBranches( element, elementName ) {
-    const branches = {};
-    const subbranchNames = [];
-    const subbranchElements = [];
-    walkElements(element, elementName);
-    /**
-     * Walk the element chain
-     *
-     * @param {object} e
-     * @param {string} name
-     */
-    function walkElements( e, name ) {
-      if (isBuiltinType(e.type)) {
-        branches[subbranchNames.concat(name).join(pathDelimiter)] = subbranchElements.concat(e);
+  function walkElements( e, name ) {
+    if (isBuiltinType(e.type)) {
+      branches[subbranchNames.concat(name).join(pathDelimiter)] = { steps: subbranchElements.concat(e), ref: subbranchNames.concat(name) };
+    }
+    else {
+      const subelements = e.elements || effectiveType(e).elements;
+      if (subelements) {
+        subbranchElements.push(e);
+        subbranchNames.push(name);
+        for (const [ subelementName, subelement ] of Object.entries(subelements))
+          walkElements(subelement, subelementName);
+
+        subbranchNames.pop();
+        subbranchElements.pop();
       }
       else {
-        const eType = effectiveType(e);
-        const subelements = e.elements || eType.elements;
-        if (subelements) {
-          subbranchElements.push(e);
-          subbranchNames.push(name);
-          for (const [ subelementName, subelement ] of Object.entries(subelements))
-            walkElements(subelement, subelementName);
-
-          subbranchNames.pop();
-          subbranchElements.pop();
-        }
-        else {
-          branches[subbranchNames.concat(name).join(pathDelimiter)] = subbranchElements.concat(e);
-        }
+        branches[subbranchNames.concat(name).join(pathDelimiter)] = { steps: subbranchElements.concat(e), ref: subbranchNames.concat(name) };
       }
     }
-    return branches;
   }
+  return branches;
 }
 
 /**
@@ -792,4 +792,5 @@ module.exports = {
   flattenElements,
   removeLeadingSelf,
   handleManagedAssociationsAndCreateForeignKeys,
+  getBranches,
 };