@sap/cds-compiler 3.9.4 → 4.0.0

package/lib/render/toCdl.js

@@ -92,6 +92,8 @@ function csnToCdl( csn, options ) {
   }
 
   timetrace.stop('CDL rendering');
+
+  msg.throwWithError();
   return cdlResult;
 
   /**
@@ -104,7 +106,7 @@ function csnToCdl( csn, options ) {
     let result = '';
     const env = createEnv();
     forEachDefinition(csn, (artifact, artifactName) => {
-      const sourceStr = renderArtifact(artifactName, artifact, env);
+      const sourceStr = renderDefinition(artifactName, artifact, env);
       if (sourceStr !== '')
         result += `${sourceStr}\n`;
     });
@@ -127,7 +129,7 @@ function csnToCdl( csn, options ) {
       if (!anno._ignore) {
         // This environment is passed down the call hierarchy, for dealing with
         // indentation and name resolution issues
-        const env = envNewPath(createEnv(), [ 'vocabularies', name ]);
+        const env = createEnv({ path: [ 'vocabularies', name ] });
         const sourceStr = renderTypeOrAnnotation(name, anno, env, 'annotation');
         result += `${sourceStr}\n`;
       }
@@ -145,8 +147,8 @@ function csnToCdl( csn, options ) {
    */
   function renderExtensions( extensions, env ) {
     if (!env.path)
-      env = envNewPath(env, [ 'extensions' ]);
-    return extensions.map((ext, index) => renderExtension(ext, envAddPath(env, [ index ]))).join('\n');
+      env = env.cloneWith({ path: [ 'extensions' ] });
+    return extensions.map((ext, index) => renderExtension(ext, env.withSubPath([ index ]))).join('\n');
   }
 
   /**
@@ -181,7 +183,7 @@ function csnToCdl( csn, options ) {
     if (ext.includes && ext.includes.length > 0) {
       // Includes can't be combined with anything in braces {}.
       const affix = isElementExtend ? 'element ' : '';
-      const includes = ext.includes.map(inc => renderDefinitionReference(inc, env)).join(', ');
+      const includes = ext.includes.map((inc, i) => renderDefinitionReference(inc, env.withSubPath([ 'includes', i ]))).join(', ');
       result += `${env.indent}extend ${affix}${extName} with ${includes};\n`;
       return result;
     }
@@ -210,18 +212,17 @@ function csnToCdl( csn, options ) {
       result += `${env.indent}extend ${extName} with ${getExtendPostfixVariant(ext)}{\n`;
 
     if (ext.columns)
-      result += renderViewColumns(ext.columns, increaseIndent(env));
+      result += renderViewColumns(ext, env.withIncreasedIndent());
 
     else if (ext.elements || ext.enum)
       result += renderExtendStatementElements(ext, env);
 
-
     // Not part of if/else cascade, because it may be in postfix notation.
     if (ext.actions) {
-      const childEnv = increaseIndent(env);
+      const childEnv = env.withIncreasedIndent();
       let actions = '';
       forEach(ext.actions, (actionName, action) => {
-        actions += renderActionOrFunction(actionName, action, childEnv);
+        actions += renderActionOrFunction(actionName, action, childEnv.withSubPath([ 'actions', actionName ]));
       });
       if (!usePrefixNotation)
         result += actions;
@@ -281,13 +282,15 @@ function csnToCdl( csn, options ) {
    */
   function renderExtendStatementElements( ext, env ) {
     let result = '';
-    forEach(ext.elements || ext.enum || {}, (elemName, element) => {
+    const prop = ext.elements ? 'elements' : 'enum';
+    forEach(ext[prop] || {}, (elemName, element) => {
+      const childEnv = env.withIncreasedIndent().withSubPath([ 'elements', elemName ]);
       if (element.kind === 'extend')
-        result += renderExtendStatement(elemName, element, increaseIndent(env));
+        result += renderExtendStatement(elemName, element, childEnv);
       else
         // As soon as we are inside an element, nested `extend` are not possible,
         // since we can't extend an existing element of a new one.
-        result += renderElement(elemName, element, increaseIndent(env));
+        result += renderElement(elemName, element, childEnv.withSubPath([ prop, elemName ]));
     });
     return result;
   }
@@ -307,42 +310,36 @@ function csnToCdl( csn, options ) {
     result += `${env.indent}annotate ${renderArtifactName(ext.annotate, env)}`;
 
     if (ext.params)
-      result += renderAnnotateParamsInParentheses(ext.params, env);
+      result += renderAnnotateParamsInParentheses(ext, env);
 
     // Element extensions and annotations (possibly nested)
+    // TODO: Deduplicate coding, see renderAnnotateStatementElements()
     if (ext.elements)
-      result += renderAnnotateStatementElements(ext.elements, env);
-    if (ext.enum)
-      result += renderAnnotateStatementElements(ext.enum, env);
-
-    // Returns annotations
-    if (ext.returns) {
-      const childEnv = increaseIndent(env);
-      result += ` returns${renderAnnotateStatementElements(ext.returns.elements, childEnv)}`;
-    }
+      result += ` ${renderAnnotateStatementElements(ext.elements, env.withSubPath([ 'elements' ]))}`;
+    else if (ext.enum)
+      result += ` ${renderAnnotateStatementElements(ext.enum, env.withSubPath([ 'enum' ]))}`;
+    else if (ext.returns)
+      result += renderAnnotateReturns(ext, env);
 
-    // Action annotations
-    if (ext.actions) {
+    if (ext.actions) { // Bound action annotations
       result += ' actions {\n';
-      const childEnv = increaseIndent(env);
       for (const name in ext.actions) {
+        const childEnv = env.withIncreasedIndent().withSubPath([ 'actions', name ]);
         const action = ext.actions[name];
-        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(name, env);
+        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(name, childEnv);
         // Action parameter annotations
         if (action.params)
-          result += renderAnnotateParamsInParentheses(action.params, childEnv);
-
-        // Annotations on action returns
-        if (action.returns && action.returns.elements) {
-          const grandChildEnv = increaseIndent(childEnv);
-          result += ` returns${renderAnnotateStatementElements(action.returns.elements, grandChildEnv)}`;
-        }
+          result += renderAnnotateParamsInParentheses(action, childEnv);
+        if (action.returns)
+          result += renderAnnotateReturns(action, childEnv);
 
+        result = removeTrailingNewline(result);
         result += ';\n';
       }
       result += `${env.indent}}`;
     }
 
+    result = removeTrailingNewline(result);
     result += ';\n';
     return result;
   }
@@ -357,16 +354,16 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderAnnotateStatementElements( elements, env ) {
-    let result = ' {\n';
-    const childEnv = increaseIndent(env);
+    let result = '{\n';
     for (const name in elements) {
+      const childEnv = env.withIncreasedIndent().withSubPath([ name ]);
       const elem = elements[name];
       result += renderAnnotationAssignmentsAndDocComment(elem, childEnv);
       result += childEnv.indent + quoteNonIdentifierOrKeyword(name, env);
       if (elem.elements)
-        result += renderAnnotateStatementElements(elem.elements, childEnv);
-      if (elem.enum)
-        result += renderAnnotateStatementElements(elem.enum, childEnv);
+        result += ` ${renderAnnotateStatementElements(elem.elements, childEnv.withSubPath([ 'elements' ]))}`;
+      else if (elem.enum)
+        result += ` ${renderAnnotateStatementElements(elem.enum, childEnv.withSubPath([ 'enum' ]))}`;
 
       result += ';\n';
     }
@@ -374,19 +371,45 @@ function csnToCdl( csn, options ) {
     return result;
   }
 
+  /**
+   * Renders the `returns` part of an `annotate` statement for (bound) actions.
+   * `ext` must be an object with a `returns` property.
+   *
+   * @param {CSN.Extension} ext
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderAnnotateReturns( ext, env ) {
+    env = env.withSubPath([ 'returns', 'elements' ]);
+    let result = ' returns';
+
+    const returnAnnos = renderAnnotationAssignmentsAndDocComment(ext.returns, env.withIncreasedIndent());
+    if (returnAnnos)
+      result += `\n${returnAnnos}`;
+
+    if (ext.returns.elements) {
+      // Annotations are on separate lines: Have it aligned nicely
+      result += returnAnnos ? `${env.indent}` : ' ';
+      result += renderAnnotateStatementElements(ext.returns.elements, env);
+    }
+    return result;
+  }
+
   /**
    * Render a parameter list for `annotate` statements, in parentheses `()`.
    *
-   * @param {object} params
+   * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateParamsInParentheses( params, env ) {
-    const childEnv = increaseIndent(env);
+  function renderAnnotateParamsInParentheses( art, env ) {
+    const childEnv = env.withIncreasedIndent();
     let result = '(\n';
     const paramAnnotations = [];
-    forEach(params, (paramName, param) => {
-      paramAnnotations.push( renderAnnotationAssignmentsAndDocComment(param, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(paramName, env) );
+    forEach(art.params, (paramName, param) => {
+      const annos = renderAnnotationAssignmentsAndDocComment(param, childEnv);
+      const name = quoteNonIdentifierOrKeyword(paramName, env.withSubPath([ 'params', paramName ]));
+      paramAnnotations.push( annos + childEnv.indent + name );
     });
     result += `${paramAnnotations.join(',\n')}\n${env.indent})`;
     return result;
@@ -399,11 +422,11 @@ function csnToCdl( csn, options ) {
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function renderArtifact( artifactName, art, env ) {
-    env = envNewPath(env, [ 'definitions', artifactName ]);
-    env.artifactName = artifactName;
+  function renderDefinition( artifactName, art, env ) {
+    env = env.cloneWith({ path: [ 'definitions', artifactName ] });
 
-    switch (art.kind) {
+    const kind = art.kind || 'type'; // the default kind is "type".
+    switch (kind) {
       case 'entity':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
@@ -427,6 +450,7 @@ function csnToCdl( csn, options ) {
         return renderEvent(artifactName, art, env);
 
       default:
+        // TODO: Make it a error message.
         throw new ModelError(`to.cdl: Unknown artifact kind: ${art.kind}`);
     }
   }
@@ -444,8 +468,9 @@ function csnToCdl( csn, options ) {
       result += renderIncludes(art.includes, env);
     if (art.query || art.projection) {
       result += ' : ';
-      result += renderQuery(getNormalizedQuery(art).query, true, 'projection', env,
-                            [ 'definitions', artifactName, 'query' ]);
+      // events (should) only support "projections"
+      result += renderQuery(getNormalizedQuery(art).query, true, 'projection',
+                            env.withSubPath([ art.projection ? 'projection' : 'query' ]));
       result += ';\n';
     }
     else if (art.type) {
@@ -527,13 +552,11 @@ function csnToCdl( csn, options ) {
    */
   function renderElements( artifact, env ) {
     let elements = '';
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     for (const name in artifact.elements)
-      elements += renderElement(name, artifact.elements[name], childEnv);
+      elements += renderElement(name, artifact.elements[name], childEnv.withSubPath([ 'elements', name ]));
 
-    if (elements === '')
-      return '{ }';
-    return `{\n${elements}${env.indent}}`;
+    return (elements === '') ? '{ }' : `{\n${elements}${env.indent}}`;
   }
 
   /**
@@ -546,7 +569,6 @@ function csnToCdl( csn, options ) {
    * @param {CdlRenderEnvironment} env
    */
   function renderElement( elementName, element, env ) {
-    env = envAddPath(env, [ 'elements', elementName ]);
     let result = renderAnnotationAssignmentsAndDocComment(element, env);
     result += env.indent;
     result += element.virtual ? 'virtual ' : '';
@@ -569,9 +591,9 @@ function csnToCdl( csn, options ) {
     if (element.value !== undefined) { // calculated element // @ts-ignore
       result += ' = ';
       if (element.value.xpr && xprContainsCondition(element.value.xpr))
-        result += exprRenderer.renderSubExpr(element.value, env);
+        result += exprRenderer.renderSubExpr(element.value, env.withSubPath([ 'value' ]));
       else
-        result += exprRenderer.renderExpr(element.value, env);
+        result += exprRenderer.renderExpr(element.value, env.withSubPath([ 'value' ]));
       if (element.value.stored === true)
         result += ' stored';
     }
@@ -589,13 +611,12 @@ function csnToCdl( csn, options ) {
    *       however, in client CSN, annotations are not part of the column and in parseCdl CSN,
    *       no `elements` exist.
    *
-   * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderQueryElementAndEnumAnnotations( artifactName, art, env ) {
-    const annotate = collectAnnotationsOfElementsAndEnum(art, createEnv({ artifactName, path: env.path }));
+  function renderQueryElementAndEnumAnnotations( art, env ) {
+    const annotate = collectAnnotationsOfElementsAndEnum(art, env);
     if (annotate)
       return renderExtensions([ annotate ], env);
     return '';
@@ -612,7 +633,7 @@ function csnToCdl( csn, options ) {
   function collectAnnotationsOfElementsAndEnum( artifact, env ) {
     // Array, which may be annotated as well.
     if (artifact.items) {
-      env = envAddPath(env, [ 'items' ]);
+      env = env.withSubPath([ 'items' ]);
       artifact = artifact.items;
     }
 
@@ -699,7 +720,7 @@ function csnToCdl( csn, options ) {
   function renderViewSource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
-      const subEnv = increaseIndent(env);
+      const subEnv = env.withIncreasedIndent();
       let result = `(\n${subEnv.indent}${renderQuery(source, false, 'view', subEnv)}\n${env.indent})`;
       if (source.as)
         result += renderAlias(source.as, env);
@@ -709,13 +730,13 @@ function csnToCdl( csn, options ) {
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `(${renderViewSource(source.args[0], env)}`;
+      let result = `(${renderViewSource(source.args[0], env.withSubPath([ 'args', 0 ]))}`;
       for (let i = 1; i < source.args.length; i++) {
         result += ` ${source.join} `;
         result += renderJoinCardinality(source.cardinality);
-        result += `join ${renderViewSource(source.args[i], env)}`;
+        result += `join ${renderViewSource(source.args[i], env.withSubPath([ 'args', i ]))}`;
         if (source.on)
-          result += ` on ${exprRenderer.renderExpr(source.on, env)}`;
+          result += ` on ${exprRenderer.renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
       }
       result += ')';
       return result;
@@ -762,12 +783,12 @@ function csnToCdl( csn, options ) {
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
-      result += `(${renderArguments(path.ref[0], ':', env)})`;
+      result += `(${renderArguments(path.ref[0], ':', env.withSubPath([ 'ref', 0 ]))})`;
 
     if (path.ref[0].where) {
       // TODO: Unify with other filter rendering
       const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
-      const expr = exprRenderer.renderExpr(path.ref[0].where, env);
+      const expr = exprRenderer.renderExpr(path.ref[0].where, env.withSubPath([ 'ref', 0, 'where' ]));
       if (expr.endsWith(']')) // for cases such as [… ![id] ]
         result += `[ ${cardinality}${expr} ]`;
       else
@@ -804,14 +825,13 @@ function csnToCdl( csn, options ) {
   /**
    * Render the given columns.
    *
-   * @param {any[]} columns
+   * @param {CSN.Artifact} art
    * @param {object} elements
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderViewColumns( columns, env, elements = Object.create(null) ) {
-    const result = columns.map(col => renderViewColumn(col, env, findElement(elements, col)))
-      .filter(s => s !== '')
+  function renderViewColumns( art, env, elements = Object.create(null) ) {
+    const result = art.columns.map((col, i) => renderViewColumn(col, env.withSubPath([ 'columns', i ]), findElement(elements, col)))
       .join(',\n');
     return `${result}\n`;
   }
@@ -859,9 +879,9 @@ function csnToCdl( csn, options ) {
     if (col.cast) {
       // Special case: Explicit association type is actually a redirect
       if (col.cast.target && !col.cast.type)
-        result += ` : ${renderRedirectedTo(col.cast, env)}`;
+        result += ` : ${renderRedirectedTo(col.cast, env.withSubPath([ 'cast' ]))}`;
       else
-        result += ` : ${renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true })}`;
+        result += ` : ${renderTypeReferenceAndProps(col.cast, env.withSubPath([ 'cast' ]), { typeRefOnly: true, noAnnoCollect: true })}`;
     }
     return result;
   }
@@ -885,9 +905,9 @@ function csnToCdl( csn, options ) {
     // We found a leaf - no further drilling
     if (!obj.inline && !obj.expand) {
       if (obj.cast && obj.cast.type)
-        result += ` : ${renderTypeReferenceAndProps(obj.cast, createEnv(), { noAnnoCollect: true })}`;
+        result += ` : ${renderTypeReferenceAndProps(obj.cast, env.withSubPath([ 'cast' ]), { noAnnoCollect: true })}`;
       else if (obj.cast && obj.cast.target) // test tbd
-        result += ` : ${renderRedirectedTo(obj.cast, env)}`;
+        result += ` : ${renderRedirectedTo(obj.cast, env.withSubPath([ 'cast' ]))}`;
       return result;
     }
 
@@ -897,7 +917,7 @@ function csnToCdl( csn, options ) {
       result += result !== '' ? ' {\n' : '{\n';
 
     // Drill down and render children of the expand/inline
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     const expandInline = obj.expand || obj.inline;
     result += expandInline //
       .map(elm => renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + renderInlineExpand(elm, childEnv))
@@ -929,8 +949,8 @@ function csnToCdl( csn, options ) {
       return `\n${env.indent}/** */\n`;
 
     let { doc } = obj;
-    if (/[^\\][*]\//.test(doc))
-      doc = doc.replace(/([^\\])[*]\//g, '$1*\\/');
+    if (/[*]\//.test(doc)) // only escape sequence allowed in CDL for doc comments
+      doc = doc.replace(/[*]\//g, '*\\/');
 
     // Smaller comment for single-line comments.  If the comment starts or ends with whitespace
     // we must use a block comment, or it will be lost when compiling the source again.
@@ -953,11 +973,11 @@ function csnToCdl( csn, options ) {
     if (art.params)
       result += renderParameters(art, env);
     result += ' as ';
-    result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
+    result += renderQuery(getNormalizedQuery(art).query, true, syntax, env.withSubPath([ art.projection ? 'projection' : 'query' ]), art.elements);
     if (art.actions) // Views/Projections also allow actions. Just the VIEW keyword variant did not.
       result += renderActionsAndFunctions(art, env);
     result += ';\n';
-    result += renderQueryElementAndEnumAnnotations(artifactName, art, env);
+    result += renderQueryElementAndEnumAnnotations(art, env);
     if (art.includes)
       result += renderExtension({ extend: artifactName, includes: art.includes }, env);
     return result;
@@ -973,10 +993,9 @@ function csnToCdl( csn, options ) {
    * @param {boolean} isLeadingQuery
    * @param {string} syntax The query syntax, either "projection", "entity" or "view"
    * @param {CdlRenderEnvironment} env
-   * @param {CSN.Path} [path=[]]
    * @param {object} [elements]
    */
-  function renderQuery( query, isLeadingQuery, syntax, env, path = [], elements = query.elements || Object.create(null) ) {
+  function renderQuery( query, isLeadingQuery, syntax, env, elements = query.elements || Object.create(null) ) {
     if (query.SET) {
       // Set operator, such as UNION, INTERSECT, or EXCEPT...
       return renderQuerySet();
@@ -988,16 +1007,16 @@ function csnToCdl( csn, options ) {
 
     let result = '';
     const select = query.SELECT;
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
 
     // If not a projection, must be view/entity.
     result += (syntax === 'projection') ? 'projection on ' : 'select from ';
-    result += renderViewSource(select.from, env);
+    result += renderViewSource(select.from, env.withSubPath([ 'from' ]));
 
     if (select.mixin) {
       let elems = '';
       forEach(select.mixin, (name, mixin) => {
-        elems += renderElement(name, mixin, childEnv);
+        elems += renderElement(name, mixin, childEnv.withSubPath([ 'mixin', name ]));
       });
       if (elems) {
         result += ' mixin {\n';
@@ -1008,7 +1027,7 @@ function csnToCdl( csn, options ) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += renderViewColumns(select.columns, increaseIndent(env), elements);
+      result += renderViewColumns(select, env.withIncreasedIndent(), elements);
       result += `${env.indent}}`;
     }
 
@@ -1022,19 +1041,19 @@ function csnToCdl( csn, options ) {
       result += renderActionsAndFunctions(query, env);
 
     if (select.where)
-      result += `${continueIndent(result, env)}where ${exprRenderer.renderExpr(select.where, env)}`;
+      result += `${continueIndent(result, env)}where ${exprRenderer.renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
 
     if (select.groupBy)
-      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => exprRenderer.renderExpr(expr, env)).join(', ')}`;
+      result += `${continueIndent(result, env)}group by ${select.groupBy.map((expr, i) => exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
 
     if (select.having)
-      result += `${continueIndent(result, env)}having ${exprRenderer.renderExpr(select.having, env)}`;
+      result += `${continueIndent(result, env)}having ${exprRenderer.renderExpr(select.having, env.withSubPath([ 'having' ]))}`;
 
     if (select.orderBy)
-      result += `${continueIndent(result, env)}order by ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
+      result += `${continueIndent(result, env)}order by ${select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
 
     if (select.limit)
-      result += `${continueIndent(result, env)}${renderLimit(select.limit, env)}`;
+      result += `${continueIndent(result, env)}${renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
 
     return result;
 
@@ -1051,26 +1070,7 @@ function csnToCdl( csn, options ) {
         return ' ';
       }
       // Otherwise, start new line and indent normally
-      return `\n${increaseIndent(indentEnv).indent}`;
-    }
-
-    /**
-     * Render a query's LIMIT clause, which may also have OFFSET.
-     *
-     * @param {CSN.QueryLimit} limit
-     * @param {CdlRenderEnvironment} limitEnv
-     * @return {string}
-     */
-    function renderLimit( limit, limitEnv ) {
-      let limitStr = '';
-      if (limit.rows !== undefined)
-        limitStr += `limit ${exprRenderer.renderExpr(limit.rows, limitEnv)}`;
-
-      if (limit.offset !== undefined) {
-        const offsetIndent = (limitStr === '') ? '' : `\n${increaseIndent(limitEnv).indent}`;
-        limitStr += `${offsetIndent}offset ${exprRenderer.renderExpr(limit.offset, limitEnv)}`;
-      }
-      return limitStr;
+      return `\n${indentEnv.withIncreasedIndent().indent}`;
     }
 
     /**
@@ -1081,7 +1081,8 @@ function csnToCdl( csn, options ) {
     function renderQuerySet() {
       const subQueries = query.SET.args.map((arg, i) => {
         // First arg may be leading query
-        const subQuery = renderQuery(arg, isLeadingQuery && (i === 0), 'view', env, path.concat([ 'SET', 'args', i ]), elements);
+        const subEnv = env.withSubPath([ 'SET', 'args', i ]);
+        const subQuery = renderQuery(arg, isLeadingQuery && (i === 0), 'view', subEnv, elements);
         return `(${subQuery})`;
       });
 
@@ -1089,10 +1090,10 @@ function csnToCdl( csn, options ) {
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
       if (query.SET.orderBy)
-        setResult += `${continueIndent(setResult, env)}order by ${query.SET.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
+        setResult += `${continueIndent(setResult, env)}order by ${query.SET.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'SET', 'orderBy', i ]))).join(', ')}`;
 
       if (query.SET.limit)
-        setResult += `${continueIndent(setResult, env)}${renderLimit(query.SET.limit, env)}`;
+        setResult += `${continueIndent(setResult, env)}${renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ]))}`;
       return setResult;
     }
   }
@@ -1116,6 +1117,25 @@ function csnToCdl( csn, options ) {
     return result;
   }
 
+  /**
+   * Render a query's LIMIT clause, which may also have OFFSET.
+   *
+   * @param {CSN.QueryLimit} limit
+   * @param {CdlRenderEnvironment} limitEnv
+   * @return {string}
+   */
+  function renderLimit( limit, limitEnv ) {
+    let limitStr = '';
+    if (limit.rows !== undefined)
+      limitStr += `limit ${exprRenderer.renderExpr(limit.rows, limitEnv.withSubPath([ 'rows' ]))}`;
+
+    if (limit.offset !== undefined) {
+      const offsetIndent = (limitStr === '') ? '' : `\n${limitEnv.withIncreasedIndent().indent}`;
+      limitStr += `${offsetIndent}offset ${exprRenderer.renderExpr(limit.offset, limitEnv.withSubPath([ 'offset' ]))}`;
+    }
+    return limitStr;
+  }
+
   /**
    * Render an entity's actions and functions (if any)
    * (expect an entity with trailing '}' or an 'extend' statement ending with 'with'
@@ -1128,9 +1148,9 @@ function csnToCdl( csn, options ) {
    */
   function renderActionsAndFunctions( art, env ) {
     let result = '';
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     for (const name in art.actions)
-      result += renderActionOrFunction(name, art.actions[name], envAddPath(childEnv, [ 'actions', name ]));
+      result += renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]));
 
     // Even if we have seen actions/functions, they might all have been ignored
     if (result !== '')
@@ -1152,8 +1172,12 @@ function csnToCdl( csn, options ) {
     result += ` ${renderArtifactName(actionName, env)}`;
     result += renderParameters(act, env);
     if (act.returns) {
-      const actEnv = envAddPath(env, [ 'returns' ]);
-      result += ` returns ${renderTypeReferenceAndProps(act.returns, actEnv)}`;
+      let actEnv = env.withSubPath([ 'returns' ]);
+      const annos = renderAnnotationAssignmentsAndDocComment(act.returns, actEnv.withIncreasedIndent());
+      if (annos) // if `returns` has annotations, increase indent for nicer aligned output
+        actEnv = actEnv.withIncreasedIndent();
+      const type = renderTypeReferenceAndProps(act.returns, actEnv);
+      result += ` returns${annos ? '\n' : ' '}${annos}${annos ? actEnv.indent : ''}${type}`;
     }
 
     result += ';\n';
@@ -1170,8 +1194,8 @@ function csnToCdl( csn, options ) {
    * @returns {string}
    */
   function renderParameters( art, env ) {
-    const childEnv = increaseIndent(env);
-    const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv));
+    const childEnv = env.withIncreasedIndent();
+    const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv.withSubPath([ 'params', name ])));
     if (parameters.length === 0)
       return '()';
     return `(\n${parameters.join(',\n')}\n${env.indent})`;
@@ -1186,7 +1210,7 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderParameter( parName, par, env ) {
-    env = envAddPath(env, [ 'params', parName ]);
+    env = env.withSubPath( [ 'params', parName ]);
     let result = `${renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
     result += `${quoteNonIdentifierOrKeyword(parName, env)} : ${renderTypeReferenceAndProps(par, env)}`;
     return result;
@@ -1199,7 +1223,7 @@ function csnToCdl( csn, options ) {
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
-   * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind.
+   * @param {String} [artType] Used for rendering `csn.vocabularies`, as the annotations there do not have a kind.
    * @return {string}
    */
   function renderTypeOrAnnotation( artifactName, art, env, artType ) {
@@ -1232,7 +1256,7 @@ function csnToCdl( csn, options ) {
     const { typeRefOnly, noAnnoCollect } = config;
 
     if (typeRefOnly && !artifact.type)
-      throw new ModelError(`Expected artifact to have a type; in: ${env.artifactName}`);
+      throw new ModelError(`Expected artifact to have a type; in: ${JSON.stringify(env.path)}`);
 
     if (artifact.localized) // works even for type definitions
       result += 'localized ';
@@ -1240,7 +1264,8 @@ function csnToCdl( csn, options ) {
     if (!artifact.type && artifact.items) {
       checkArrayedArtifact(artifact, env);
       result += 'many '; // alternative: 'array of'; but not used
-      ({ art: artifact, env } = checkInnerMostArray(artifact, env));
+      artifact = artifact.items;
+      env = env.withSubPath([ 'items' ]);
     }
 
     const type = normalizeTypeRef(artifact.type);
@@ -1263,13 +1288,13 @@ function csnToCdl( csn, options ) {
       // In parseCdl, `target` may still be an object containing elements.  This would be replaced
       // by targetAspect in client CSN, but we can't rely on that.
       // If a name exists (either in target or targetAspect), prefer it over rendering elements.
-      const elements = artifact.target && artifact.target.elements || artifact.targetAspect && artifact.targetAspect.elements;
+      const elements = artifact.target?.elements || artifact.targetAspect?.elements;
       if (typeof artifact.target === 'string' || typeof artifact.targetAspect === 'string') {
         result += renderAbsolutePath({ ref: [ artifact.target || artifact.targetAspect ] }, env);
       }
       else if (elements) {
         // anonymous aspect, either parseCdl or client CSN.
-        result += renderElements({ elements }, env);
+        result += renderElements({ elements }, env.withSubPath([ artifact.target?.elements ? 'target' : 'targetAspect' ]));
       }
       else {
         throw new ModelError('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
@@ -1277,11 +1302,11 @@ function csnToCdl( csn, options ) {
 
       // ON-condition (if any)
       if (artifact.on)
-        result += ` on ${exprRenderer.renderExpr(artifact.on, env)}`;
+        result += ` on ${exprRenderer.renderExpr(artifact.on, env.withSubPath([ 'on' ]))}`;
 
       // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
       if (artifact.keys && !artifact.on)
-        result += ` { ${Object.keys(artifact.keys).map(name => renderForeignKey(artifact.keys[name], env)).join(', ')} }`;
+        result += ` { ${Object.keys(artifact.keys).map(name => renderForeignKey(artifact.keys[name], env.withSubPath([ 'keys', name ]))).join(', ')} }`;
 
       if (artifact.notNull !== undefined && !artifact.on) // unmanaged associations can't be followed by "not null"
         result += renderNullability(artifact);
@@ -1315,8 +1340,11 @@ function csnToCdl( csn, options ) {
       result += renderEnum(artifact.enum, env);
     if (artifact.notNull !== undefined)
       result += renderNullability(artifact);
-    if (artifact.default !== undefined)
-      result += ` default ${exprRenderer.renderExpr(artifact.default, env)}`;
+
+    // If there is a default value, and it's a calculated element, do not
+    // render the default (because it's not supported for calc elements).
+    if (artifact.default !== undefined && !artifact.value)
+      result += ` default ${exprRenderer.renderExpr(artifact.default, env.withSubPath([ 'default' ]))}`;
 
     return result;
   }
@@ -1331,9 +1359,9 @@ function csnToCdl( csn, options ) {
   function renderRedirectedTo( art, env ) {
     let result = `redirected to ${renderDefinitionReference(art.target, env)}`;
     if (art.on)
-      result += ` on ${exprRenderer.renderExpr(art.on, env)}`;
+      result += ` on ${exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ]))}`;
     else if (art.keys)
-      result += ` { ${Object.keys(art.keys).map(name => renderForeignKey(art.keys[name], env)).join(', ')} }`;
+      result += ` { ${Object.keys(art.keys).map(name => renderForeignKey(art.keys[name], env.withSubPath([ 'keys', name ]))).join(', ')} }`;
     return result;
   }
 
@@ -1377,9 +1405,9 @@ function csnToCdl( csn, options ) {
    */
   function renderEnum( enumPart, env ) {
     let result = ' enum {\n';
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     for (const name in enumPart)
-      result += renderElement(name, enumPart[name], childEnv);
+      result += renderElement(name, enumPart[name], childEnv.withSubPath([ 'enum', name ]));
     result += `${env.indent}}`;
     return result;
   }
@@ -1407,17 +1435,17 @@ function csnToCdl( csn, options ) {
     }
     else if (typeof annoValue === 'object' && annoValue !== null) {
       // Enum symbol
-      if (annoValue['#']) {
+      if (annoValue['#'] !== undefined) {
         return `#${annoValue['#']}`;
       }
       // Shorthand for absolute path (as string)
-      else if (annoValue['=']) {
+      else if (annoValue['='] !== undefined) {
         if (annoValue['='].startsWith('@'))
           return quoteAnnotationPathIfRequired(annoValue['='], env);
         return quotePathIfRequired(annoValue['='], env);
       }
       // Shorthand for ellipsis: `... up to <val>`
-      else if (annoValue['...']) {
+      else if (annoValue['...'] !== undefined) {
         if (annoValue['...'] === true)
           return '...';
         return `... up to ${renderAnnotationValue(annoValue['...'], env)}`;
@@ -1427,8 +1455,8 @@ function csnToCdl( csn, options ) {
       // Render as one-liner if there is at most one key.  Render as multi-line
       // struct if there are more and use nicer indentation.
       const keys = Object.keys(annoValue);
-      const childEnv = keys.length <= 1 ? env : increaseIndent(env);
-      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key, env)}: ${renderAnnotationValue(annoValue[key], childEnv)}`);
+      const childEnv = keys.length <= 1 ? env : env.withIncreasedIndent();
+      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key, env)}: ${renderAnnotationValue(annoValue[key], childEnv.withSubPath([ key ]))}`);
       if (values.length <= 1)
         return `{ ${values.join(', ')} }`;
       const valueList = values.join(`,\n${childEnv.indent}`);
@@ -1455,12 +1483,12 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderAnnotationArrayValue( annoValue, env ) {
-    const childEnv = increaseIndent(env);
+    const childEnv = env.withIncreasedIndent();
     // Render array parts as values.
     let length = 0;
     let hasLineBreak = false;
-    const items = annoValue.map((item) => {
-      const result = renderAnnotationValue(item, childEnv);
+    const items = annoValue.map((item, i) => {
+      const result = renderAnnotationValue(item, childEnv.withSubPath([ i ]));
       length += result.length + 2; // just a heuristic; add 2 for `, `.
       if (!hasLineBreak && result.includes('\n'))
         hasLineBreak = true;
@@ -1508,14 +1536,35 @@ function csnToCdl( csn, options ) {
         // View parameters
         result += `(${renderArguments(s, ':', env)})`;
       }
+
+      const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
+      let filter = '';
+
+      // TODO: Unify with other filter rendering for SELECT
+      if (s.groupBy)
+        filter += ` group by ${s.groupBy.map((expr, i) => exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
+      if (s.having)
+        filter += ` having ${exprRenderer.renderExpr(s.having, env.withSubPath([ 'having' ]))}`;
+      if (s.orderBy)
+        filter += ` order by ${s.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
+      if (s.limit)
+        filter += ` ${renderLimit(s.limit, env.withSubPath([ 'limit' ]))}`;
+
       if (s.where) {
-        // Filter, possibly with cardinality
-        const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
-        const expr = exprRenderer.renderExpr(s.where, env);
-        if (expr.endsWith(']')) // for cases such as [… ![id] ]
-          result += `[ ${cardinality}${expr} ]`;
+        let where = exprRenderer.renderExpr(s.where, env.withSubPath([ 'where' ]));
+        // Special rules in CDS parser: If filter starts with one of these SQL keywords, WHERE is mandatory.
+        if (filter || /^(?:group|having|order|limit)\s/i.test(where))
+          where = ` where ${where}`;
+        filter = `${where} ${filter}`;
+      }
+
+      filter = filter.trim();
+
+      if (cardinality || filter) {
+        if (filter.endsWith(']')) // for cases such as [… ![id] ]
+          result += `[ ${cardinality}${filter} ]`;
         else
-          result += `[${cardinality}${expr}]`;
+          result += `[${cardinality}${filter}]`;
       }
 
       return result;
@@ -1554,7 +1603,7 @@ function csnToCdl( csn, options ) {
    */
   function renderNamedArguments( node, separator, env ) {
     return Object.keys(node.args).map(function renderNamedArgument(key) {
-      return `${quoteNonIdentifierOrKeyword(key, env)} ${separator} ${renderArgument(node.args[key], env)}`;
+      return `${quoteNonIdentifierOrKeyword(key, env)} ${separator} ${renderArgument(node.args[key], env.withSubPath([ 'args', key ]))}`;
     }).join(', ');
   }
 
@@ -1571,10 +1620,10 @@ function csnToCdl( csn, options ) {
     const func = node.func?.toUpperCase();
     if (func) {
       return node.args.map(function renderFunctionArg(arg, i) {
-        return renderArgument(arg, env, getKeywordsForSpecialFunctionArgument(func, i));
+        return renderArgument(arg, env.withSubPath([ 'args', i ]), getKeywordsForSpecialFunctionArgument(func, i));
       }).join(', ');
     }
-    return node.args.map(arg => renderArgument(arg, env)).join(', ');
+    return node.args.map((arg, i) => renderArgument(arg, env.withSubPath([ 'args', i ]))).join(', ');
   }
 
   /**
@@ -1589,7 +1638,7 @@ function csnToCdl( csn, options ) {
   function renderArgument( arg, env, additionalKeywords = [] ) {
     // If the argument is a xpr with e.g. `=`, it may require parentheses.
     // For nested xpr, `exprRenderer.renderExpr()` will already add parentheses.
-    env = { ...env, additionalKeywords };
+    env = env.cloneWith({ additionalKeywords });
     if (isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords))
       return exprRenderer.renderExpr(arg, env);
     return exprRenderer.renderSubExpr(arg, env);
@@ -1744,7 +1793,7 @@ function csnToCdl( csn, options ) {
     let result = renderDocComment(obj, env);
     for (const name in obj) {
       if (name.startsWith('@'))
-        result += renderAnnotationAssignment(obj[name], name, env, config);
+        result += renderAnnotationAssignment(obj[name], name, env.withSubPath([ name ]), config);
     }
     return result;
   }
@@ -1814,14 +1863,14 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderIncludes( includes, env ) {
-    return ` : ${includes.map(name => renderDefinitionReference(name, env)).join(', ')}`;
+    return ` : ${includes.map((name, i) => renderDefinitionReference(name, env.withSubPath([ 'includes', i ]))).join(', ')}`;
   }
 
   function createCdlExpressionRenderer() {
     return createExpressionRenderer({
       finalize: x => x,
       typeCast(x) {
-        const typeRef = renderTypeReferenceAndProps(x.cast, this.env, { typeRefOnly: true, noAnnoCollect: true });
+        const typeRef = renderTypeReferenceAndProps(x.cast, this.env.withSubPath([ 'cast' ]), { typeRefOnly: true, noAnnoCollect: true });
         const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
         return `cast(${renderArgument(arg, this.env)} as ${typeRef})`;
       },
@@ -1850,11 +1899,11 @@ function csnToCdl( csn, options ) {
       aliasOnly: x => x.as,
       enum: x => `#${x['#']}`,
       ref(x) {
-        return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env)).join('.')}`;
+        return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
       },
       windowFunction(x) {
         const funcDef = this.func(x);
-        return `${funcDef} ${this.renderExpr(x.xpr)}`; // xpr[0] is 'over'
+        return `${funcDef} ${this.renderExpr(x.xpr, this.env.withSubPath([ 'xpr' ]))}`; // xpr[0] is 'over'
       },
       func(x) {
         if (keywords.cdl_functions.includes(x.func.toUpperCase()) && !x.args)
@@ -1865,67 +1914,36 @@ function csnToCdl( csn, options ) {
         return `${name}(${renderArguments( x, '=>', this.env )})`;
       },
       xpr(x) {
+        const xprEnv = this.env.withSubPath([ 'xpr' ]);
         if (this.isNestedXpr && !x.cast)
-          return `(${this.renderExpr(x.xpr)})`;
-        return this.renderExpr(x.xpr);
+          return `(${this.renderExpr(x.xpr, xprEnv)})`;
+        return this.renderExpr(x.xpr, xprEnv);
       },
       // Sub-queries in expressions need to be in parentheses, otherwise
       // left-associativity of UNIONS may result in different results.
       // For example: `select from E where id in (select from E union select from E);`:
       // Without parentheses, it would be different query.
       SET(x) {
-        return `(${renderQuery(x, false, 'view', increaseIndent(this.env))})`;
+        return `(${renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
       },
       SELECT(x) {
-        return `(${renderQuery(x, false, 'view', increaseIndent(this.env))})`;
+        return `(${renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
       },
-    });
+    }, true);
   }
 
   // checks -------------------------------------------------------------------
   // The CDL backend has very few checks, but we need to tell the user if
   // something can't be rendered.
 
-  /**
-   * to.cdl() can only render one nesting level of `items`.  `items` inside `items, etc.
-   * can't be represented in CDL, hence can't be rendered.
-   * However, it's possible that due to CSN expansion because of type-ofs, we have
-   * nested `.items` with a `.type` next to it.  In that case, return the node with `.type`.
-   *
-   * Returns the most deeply nested `.items`.  Upper bound are 100 nesting levels.
-   *
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @return {{art: CSN.Artifact, env: CdlRenderEnvironment}} `art` and new `env` with adapted `env.path`.
-   */
-  function checkInnerMostArray( art, env ) {
-    env = envNewPath(env, env.path); // copy path, so we can modify it directly
-
-    let nesting = 0;
-    while (art.items && nesting < 100) {
-      art = art.items;
-      env.path.push( 'items');
-      ++nesting;
-      if (art.type)
-        break; // after first `.items`, break at nesting level that has a type.
-    }
-
-    if (nesting >= 100) {
-      msg.error('def-invalid-nesting', env.path, { count: nesting, prop: 'items' },
-                'Property $(PROP) is nested more than $(COUNT) levels and can\'t be rendered');
-    }
-    else if (nesting > 1) {
-      msg.warning('def-unexpected-nesting', env.path, { prop: 'items' },
-                  'Property $(PROP) is nested more than one level; only rendering deepest level');
-    }
-    return { art, env };
-  }
-
   /**
    * If an artifact is an array via `.items`, some properties on `art` can't be rendered,
    * for example "not null", because there is no CDL representation for it.  Only "not null"
    * on `.items` can be rendered.
    *
+   * Furthermore, to.cdl() can only render one nesting level of `items`.  `items` inside
+   *  `items, etc. can't be represented in CDL, hence can't be rendered.
+   *
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
@@ -1936,6 +1954,16 @@ function csnToCdl( csn, options ) {
       msg.warning('def-unexpected-nullability', env.path, { prop: 'not null', otherprop: 'items' },
                   'Property $(PROP) not rendered, because it can only be rendered inside $(OTHERPROP) for arrayed artifacts');
     }
+
+    if (art.items.items && !art.items.type)
+      msg.message('type-invalid-items', [ ...env.path, 'items' ], { '#': 'nested', prop: 'items' } );
+
+    const type = art.items.type && normalizeTypeRef(art.items.type);
+    if (type === 'cds.Association' || type === 'cds.Composition') {
+      // check for `art.items.target` not sufficient; could be indirect type reference
+      const isComp = type === 'cds.Composition';
+      msg.message('type-invalid-items', [ ...env.path, 'items' ], { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
+    }
   }
 
   /**
@@ -2049,19 +2077,28 @@ function csnToCdl( csn, options ) {
   }
 }
 
-
 class CdlRenderEnvironment {
   indent = '';
   path = null;
-  artifactName = null;
   elementName = null;
   additionalKeywords = [];
 
   constructor(values) {
     Object.assign(this, values);
   }
+
+  withIncreasedIndent() {
+    return new CdlRenderEnvironment({ ...this, indent: `  ${this.indent}` });
+  }
+  withSubPath(path) {
+    return new CdlRenderEnvironment({ ...this, path: [ ...this.path, ...path ] });
+  }
+  cloneWith(values) {
+    return Object.assign(new CdlRenderEnvironment(this), values);
+  }
 }
 
+
 /**
  * Returns a newly created default environment (which keeps track of indentation, required USING
  * declarations and name prefixes.
@@ -2073,21 +2110,17 @@ function createEnv( values = {} ) {
   return new CdlRenderEnvironment( values );
 }
 
-function envAddPath( env, path ) {
-  return Object.assign(new CdlRenderEnvironment(env), { path: [ ...env.path, ...path ] } );
-}
-function envNewPath( env, path ) {
-  return Object.assign(new CdlRenderEnvironment(env), { path: [ ...path ] } );
-}
-
 /**
- * Returns a copy of 'env' with increased indentation (and reset name prefix)
+ * Remove a trailing `\n`/newline/LF from `str` and return the modified string.
+ * Useful if you want to append a `;` to the string, but not on a separate line.
  *
- * @param {object} env
- * @returns {object}
+ * @param {string} str
+ * @return {string}
  */
-function increaseIndent( env ) {
-  return Object.assign({}, env, { indent: `${env.indent}  ` });
+function removeTrailingNewline( str ) {
+  if (str[str.length - 1] === '\n')
+    str = str.substring(0, str.length - 1);
+  return str;
 }
 
 /**
@@ -2152,7 +2185,7 @@ function isSimpleFunctionExpression( xpr, additionalAllowedKeywords = [] ) {
 
 /**
  * If `xpr` contains tokens that are used in conditions, it may be required to put the
- * rendered expression in parentheses.  This function checks if any direkt entry in
+ * rendered expression in parentheses.  This function checks if any direct entry in
  * `xpr` is a condition token such as `AND`.
  *
  * May report false positives for e.g. `CASE WHEN 1>1 THEN …`.
@@ -2219,8 +2252,8 @@ function getAllKeywordsForSpecialFunction( funcName ) {
  * Render the given string.  Uses back-tick strings.
  * env is used for indentation of three-back-tick strings.
  *
- * @param str
- * @param env
+ * @param {string} str
+ * @param {CdlRenderEnvironment} env
  * @returns {string}
  */
 function renderString( str, env ) {