@sap/cds-compiler 3.8.2 → 3.9.2

package/lib/render/toCdl.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const keywords = require('../base/keywords');
+const { cdlNewLineRegEx } = require('../language/textUtils');
 const { findElement, createExpressionRenderer, withoutCast } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
@@ -79,7 +80,7 @@ function csnToCdl( csn, options ) {
     cdlResult.model += renderExtensions(csn.extensions, createEnv());
 
   if (csn.namespace) {
-    cdlResult.namespace = `namespace ${renderArtifactName(csn.namespace)};\n`;
+    cdlResult.namespace = `namespace ${renderArtifactName(csn.namespace, createEnv())};\n`;
     cdlResult.namespace += 'using from \'./model.cds\';';
   }
 
@@ -175,12 +176,12 @@ function csnToCdl( csn, options ) {
     // Element extensions have `kind` set. Don't use for enum extension.
     const isElementExtend = (ext.kind === 'extend' && !ext.enum);
     let result = renderAnnotationAssignmentsAndDocComment(ext, env);
-    extName = isElementExtend ? renderArtifactName(extName) : renderDefinitionReference(extName);
+    extName = isElementExtend ? renderArtifactName(extName, env) : renderDefinitionReference(extName, env);
 
     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)).join(', ');
+      const includes = ext.includes.map(inc => renderDefinitionReference(inc, env)).join(', ');
       result += `${env.indent}extend ${affix}${extName} with ${includes};\n`;
       return result;
     }
@@ -303,7 +304,7 @@ function csnToCdl( csn, options ) {
     let result = renderAnnotationAssignmentsAndDocComment(ext, env);
     // Note: Not renderDefinitionReference, because we don't care if there
     //       are annotations to unknown things. That's allowed!
-    result += `${env.indent}annotate ${renderArtifactName(ext.annotate)}`;
+    result += `${env.indent}annotate ${renderArtifactName(ext.annotate, env)}`;
 
     if (ext.params)
       result += renderAnnotateParamsInParentheses(ext.params, env);
@@ -326,7 +327,7 @@ function csnToCdl( csn, options ) {
       const childEnv = increaseIndent(env);
       for (const name in ext.actions) {
         const action = ext.actions[name];
-        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(name);
+        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(name, env);
         // Action parameter annotations
         if (action.params)
           result += renderAnnotateParamsInParentheses(action.params, childEnv);
@@ -361,7 +362,7 @@ function csnToCdl( csn, options ) {
     for (const name in elements) {
       const elem = elements[name];
       result += renderAnnotationAssignmentsAndDocComment(elem, childEnv);
-      result += childEnv.indent + quoteNonIdentifierOrKeyword(name);
+      result += childEnv.indent + quoteNonIdentifierOrKeyword(name, env);
       if (elem.elements)
         result += renderAnnotateStatementElements(elem.elements, childEnv);
       if (elem.enum)
@@ -385,7 +386,7 @@ function csnToCdl( csn, options ) {
     let result = '(\n';
     const paramAnnotations = [];
     forEach(params, (paramName, param) => {
-      paramAnnotations.push( renderAnnotationAssignmentsAndDocComment(param, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(paramName) );
+      paramAnnotations.push( renderAnnotationAssignmentsAndDocComment(param, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(paramName, env) );
     });
     result += `${paramAnnotations.join(',\n')}\n${env.indent})`;
     return result;
@@ -437,10 +438,10 @@ function csnToCdl( csn, options ) {
    */
   function renderEvent( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    const normalizedArtifactName = renderArtifactName(artifactName);
+    const normalizedArtifactName = renderArtifactName(artifactName, env);
     result += `${env.indent}event ${normalizedArtifactName}`;
     if (art.includes)
-      result += renderIncludes(art.includes);
+      result += renderIncludes(art.includes, env);
     if (art.query || art.projection) {
       result += ' : ';
       result += renderQuery(getNormalizedQuery(art).query, true, 'projection', env,
@@ -465,7 +466,7 @@ function csnToCdl( csn, options ) {
    */
   function renderContextOrService( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}${art.kind} ${renderArtifactName(artifactName)}`;
+    result += `${env.indent}${art.kind} ${renderArtifactName(artifactName, env)}`;
     return `${result} {};\n`;
   }
 
@@ -480,12 +481,12 @@ function csnToCdl( csn, options ) {
   function renderEntity( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += env.indent + (art.abstract ? 'abstract ' : '');
-    result += `entity ${renderArtifactName(artifactName)}`;
+    result += `entity ${renderArtifactName(artifactName, env)}`;
 
     if (art.params)
       result += renderParameters(art, env);
     if (art.includes)
-      result += renderIncludes(art.includes);
+      result += renderIncludes(art.includes, env);
     result += ` ${renderElements(art, env)}`;
     result += `${renderActionsAndFunctions(art, env)};\n`;
     return result;
@@ -503,9 +504,9 @@ function csnToCdl( csn, options ) {
    */
   function renderAspect( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}aspect ${renderArtifactName(artifactName)}`;
+    result += `${env.indent}aspect ${renderArtifactName(artifactName, env)}`;
     if (art.includes)
-      result += renderIncludes(art.includes);
+      result += renderIncludes(art.includes, env);
 
     if (art.elements)
       result += ` ${renderElements(art, env)}`;
@@ -552,7 +553,7 @@ function csnToCdl( csn, options ) {
     result += element.key ? 'key ' : '';
     // TODO(v4): Remove once deprecated flag for `masked` is removed.
     result += element.masked ? 'masked ' : '';
-    result += quoteNonIdentifierOrKeyword(elementName);
+    result += quoteNonIdentifierOrKeyword(elementName, env);
     if (element.val !== undefined) { // enum value
       result += ` = ${exprRenderer.renderExpr(element, env)}`;
     }
@@ -566,7 +567,13 @@ function csnToCdl( csn, options ) {
     }
 
     if (element.value !== undefined) { // calculated element // @ts-ignore
-      result += ` = ${exprRenderer.renderExpr(element.value, env)}`;
+      result += ' = ';
+      if (element.value.xpr && xprContainsCondition(element.value.xpr))
+        result += exprRenderer.renderSubExpr(element.value, env);
+      else
+        result += exprRenderer.renderExpr(element.value, env);
+      if (element.value.stored === true)
+        result += ' stored';
     }
 
     return `${result};\n`;
@@ -695,7 +702,7 @@ function csnToCdl( csn, options ) {
       const subEnv = increaseIndent(env);
       let result = `(\n${subEnv.indent}${renderQuery(source, false, 'view', subEnv)}\n${env.indent})`;
       if (source.as)
-        result += renderAlias(source.as);
+        result += renderAlias(source.as, env);
 
       return result;
     }
@@ -751,7 +758,7 @@ function csnToCdl( csn, options ) {
     const firstArtifactName = path.ref[0].id || path.ref[0];
 
     // Render the first path step (absolute name, with different quoting/naming ..)
-    let result = renderDefinitionReference(firstArtifactName);
+    let result = renderDefinitionReference(firstArtifactName, env);
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
@@ -789,7 +796,7 @@ function csnToCdl( csn, options ) {
     let result = renderAbsolutePath(path, env);
     if (path.as) {
       // Source had an alias - render it
-      result += renderAlias(path.as);
+      result += renderAlias(path.as, env);
     }
     return result;
   }
@@ -837,6 +844,8 @@ function csnToCdl( csn, options ) {
     // Use special rendering for .expand/.inline - renderExpr cannot easily handle some cases
     if (col.expand || col.inline)
       result += renderInlineExpand(col, env);
+    else if (col.xpr && xprContainsCondition(col.xpr))
+      result += exprRenderer.renderSubExpr(withoutCast(col), env);
     else
       result += exprRenderer.renderExpr(withoutCast(col), env);
 
@@ -844,7 +853,7 @@ function csnToCdl( csn, options ) {
     // A new association (cast with `type` and `target`) uses `as` as its primary name, not alias.
     const isNewAssociation = col.cast?.type && col.cast.target;
     if (!isNewAssociation && col.as && !col.inline && !col.expand)
-      result += renderAlias(col.as);
+      result += renderAlias(col.as, env);
 
     // Explicit type provided for the view element?
     if (col.cast) {
@@ -871,7 +880,7 @@ function csnToCdl( csn, options ) {
 
     // s as alias { * }
     if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
-      result += renderAlias(obj.as);
+      result += renderAlias(obj.as, env);
 
     // We found a leaf - no further drilling
     if (!obj.inline && !obj.expand) {
@@ -901,7 +910,7 @@ function csnToCdl( csn, options ) {
 
     // { * } as expand
     if (!obj.ref && obj.as)
-      result += renderAlias(obj.as);
+      result += renderAlias(obj.as, env);
 
     return result;
   }
@@ -940,7 +949,7 @@ function csnToCdl( csn, options ) {
   function renderView( artifactName, art, env ) {
     const syntax = (art.projection) ? 'projection' : 'entity';
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}entity ${renderArtifactName(artifactName)}`;
+    result += `${env.indent}entity ${renderArtifactName(artifactName, env)}`;
     if (art.params)
       result += renderParameters(art, env);
     result += ' as ';
@@ -1004,7 +1013,7 @@ function csnToCdl( csn, options ) {
     }
 
     if (select.excluding) {
-      const excludes = select.excluding.map(id => `${childEnv.indent}${quoteNonIdentifierOrKeyword(id)}`).join(',\n');
+      const excludes = select.excluding.map(id => `${childEnv.indent}${quoteNonIdentifierOrKeyword(id, env)}`).join(',\n');
       result += ` excluding {\n${excludes}\n`;
       result += `${env.indent}}`;
     }
@@ -1140,7 +1149,7 @@ function csnToCdl( csn, options ) {
    */
   function renderActionOrFunction( actionName, act, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind;
-    result += ` ${renderArtifactName(actionName)}`;
+    result += ` ${renderArtifactName(actionName, env)}`;
     result += renderParameters(act, env);
     if (act.returns) {
       const actEnv = envAddPath(env, [ 'returns' ]);
@@ -1179,7 +1188,7 @@ function csnToCdl( csn, options ) {
   function renderParameter( parName, par, env ) {
     env = envAddPath(env, [ 'params', parName ]);
     let result = `${renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
-    result += `${quoteNonIdentifierOrKeyword(parName)} : ${renderTypeReferenceAndProps(par, env)}`;
+    result += `${quoteNonIdentifierOrKeyword(parName, env)} : ${renderTypeReferenceAndProps(par, env)}`;
     return result;
   }
 
@@ -1195,9 +1204,9 @@ function csnToCdl( csn, options ) {
    */
   function renderTypeOrAnnotation( artifactName, art, env, artType ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName)}`;
+    result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName, env)}`;
     if (art.includes)
-      result += renderIncludes(art.includes);
+      result += renderIncludes(art.includes, env);
 
     if (!art.type && art.elements) // For nicer output, no colon if unnamed structure is used.
       result += ` ${renderTypeReferenceAndProps(art, env)}`;
@@ -1296,7 +1305,7 @@ function csnToCdl( csn, options ) {
     // Reference to another artifact
     if (typeof type === 'string') {
       // If we get here, it must be a named type
-      result += renderNamedTypeWithParameters(artifact);
+      result += renderNamedTypeWithParameters(artifact, env);
     }
     else if (type?.ref) {
       result += renderAbsolutePath(artifact.type, env);
@@ -1320,7 +1329,7 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderRedirectedTo( art, env ) {
-    let result = `redirected to ${renderDefinitionReference(art.target)}`;
+    let result = `redirected to ${renderDefinitionReference(art.target, env)}`;
     if (art.on)
       result += ` on ${exprRenderer.renderExpr(art.on, env)}`;
     else if (art.keys)
@@ -1330,10 +1339,12 @@ function csnToCdl( csn, options ) {
 
   /**
    * Render the named type with optional parameters, e.g. `MyString(length: 10)`.
+   *
    * @param {CSN.Artifact} artWithType
+   * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderNamedTypeWithParameters( artWithType ) {
+  function renderNamedTypeWithParameters( artWithType, env ) {
     const type = normalizeTypeRef(artWithType.type);
     let result = '';
 
@@ -1349,7 +1360,7 @@ function csnToCdl( csn, options ) {
         result += shortHand;
     }
     else {
-      result += renderDefinitionReference(type);
+      result += renderDefinitionReference(type, env);
     }
 
     result += renderTypeParameters(artWithType);
@@ -1402,8 +1413,8 @@ function csnToCdl( csn, options ) {
       // Shorthand for absolute path (as string)
       else if (annoValue['=']) {
         if (annoValue['='].startsWith('@'))
-          return quoteAnnotationPathIfRequired(annoValue['=']);
-        return quotePathIfRequired(annoValue['=']);
+          return quoteAnnotationPathIfRequired(annoValue['='], env);
+        return quotePathIfRequired(annoValue['='], env);
       }
       // Shorthand for ellipsis: `... up to <val>`
       else if (annoValue['...']) {
@@ -1417,7 +1428,7 @@ function csnToCdl( csn, options ) {
       // 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)}: ${renderAnnotationValue(annoValue[key], childEnv)}`);
+      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key, env)}: ${renderAnnotationValue(annoValue[key], childEnv)}`);
       if (values.length <= 1)
         return `{ ${values.join(', ')} }`;
       const valueList = values.join(`,\n${childEnv.indent}`);
@@ -1479,7 +1490,7 @@ function csnToCdl( csn, options ) {
       // FIXME: We should rather explicitly recognize quoting somehow
       if (idx === 0 && s.startsWith('$'))
         return s;
-      return quoteNonIdentifierOrKeyword(s, env.additionalKeywords);
+      return quoteNonIdentifierOrKeyword(s, env);
     }
     // ID with filters or parameters
     else if (typeof s === 'object') {
@@ -1492,7 +1503,7 @@ function csnToCdl( csn, options ) {
         return `${s.func}(${renderArguments(s, '=>', env)})`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${quoteNonIdentifierOrKeyword(s.id, env.additionalKeywords)}`;
+      let result = `${quoteNonIdentifierOrKeyword(s.id, env)}`;
       if (s.args) {
         // View parameters
         result += `(${renderArguments(s, ':', env)})`;
@@ -1543,7 +1554,7 @@ function csnToCdl( csn, options ) {
    */
   function renderNamedArguments( node, separator, env ) {
     return Object.keys(node.args).map(function renderNamedArgument(key) {
-      return `${quoteNonIdentifierOrKeyword(key, env.additionalKeywords)} ${separator} ${renderArgument(node.args[key], env)}`;
+      return `${quoteNonIdentifierOrKeyword(key, env)} ${separator} ${renderArgument(node.args[key], env)}`;
     }).join(', ');
   }
 
@@ -1599,6 +1610,8 @@ function csnToCdl( csn, options ) {
   /**
    * Render a cardinality (only those parts that were actually provided)
    *
+   * TODO: Check srcmin as well?
+   *
    * @param {CSN.Artifact} art
    * @return {string}
    */
@@ -1674,7 +1687,7 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderForeignKey( fKey, env ) {
-    const alias = fKey.as ? renderAlias(fKey.as) : '';
+    const alias = fKey.as ? renderAlias(fKey.as, env) : '';
     return exprRenderer.renderExpr(fKey, env) + alias;
   }
 
@@ -1682,10 +1695,11 @@ function csnToCdl( csn, options ) {
    * Render an explicit alias, e.g. for columns.
    *
    * @param {string} alias
+   * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAlias( alias ) {
-    return ` as ${quoteNonIdentifierOrKeyword(alias)}`;
+  function renderAlias( alias, env ) {
+    return ` as ${quoteNonIdentifierOrKeyword(alias, env)}`;
   }
 
   /**
@@ -1758,11 +1772,11 @@ function csnToCdl( csn, options ) {
     if (parentheses)
       result += '(';
 
-    result += quoteAnnotationPathIfRequired(nameBeforeVariant);
+    result += quoteAnnotationPathIfRequired(nameBeforeVariant, env);
     if (variant !== undefined)
       // Unfortunately, the compiler does not allow `.@` after the first variant identifier,
       // so we're back at simple paths.
-      result += `#${quotePathIfRequired(variant)}`;
+      result += `#${quotePathIfRequired(variant, env)}`;
     result += ` : ${renderAnnotationValue(anno, env)}`;
 
     if (parentheses)
@@ -1774,10 +1788,11 @@ function csnToCdl( csn, options ) {
    * Render the name of an artifact, quote path steps if necessary.
    *
    * @param {string} artifactName Artifact name to render
+   * @param {CdlRenderEnvironment} env
    * @return {string} Artifact name ready for rendering
    */
-  function renderArtifactName( artifactName ) {
-    return quotePathIfRequired(artifactName);
+  function renderArtifactName( artifactName, env ) {
+    return quotePathIfRequired(artifactName, env);
   }
 
   /**
@@ -1785,19 +1800,21 @@ function csnToCdl( csn, options ) {
    * is available in the rendered CDL.  Otherwise, a USING is added.
    *
    * @param {string} name
+   * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderDefinitionReference( name ) {
+  function renderDefinitionReference( name, env ) {
     usings.addIfRequired(name);
-    return quotePathIfRequired(name);
+    return quotePathIfRequired(name, env);
   }
 
   /**
    * @param {string[]} includes
+   * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderIncludes( includes ) {
-    return ` : ${includes.map(name => renderDefinitionReference(name)).join(', ')}`;
+  function renderIncludes( includes, env ) {
+    return ` : ${includes.map(name => renderDefinitionReference(name, env)).join(', ')}`;
   }
 
   function createCdlExpressionRenderer() {
@@ -1842,13 +1859,13 @@ function csnToCdl( csn, options ) {
       func(x) {
         if (keywords.cdl_functions.includes(x.func.toUpperCase()) && !x.args)
           return x.func;
-        const name = smartFunctionId(x.func);
+        const name = quoteFunctionIfRequired(x.func, this.env);
         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) {
-        if (this.isNestedXpr && !x.cast || x.xpr.some(s => s === 'exists'))
+        if (this.isNestedXpr && !x.cast)
           return `(${this.renderExpr(x.xpr)})`;
         return this.renderExpr(x.xpr);
       },
@@ -1920,6 +1937,129 @@ function csnToCdl( csn, options ) {
                   'Property $(PROP) not rendered, because it can only be rendered inside $(OTHERPROP) for arrayed artifacts');
     }
   }
+
+  /**
+   * Quote simple path steps with `![]` if necessary. For simple ids such as
+   * `elem` use `quoteNonIdentifierOrKeyword` instead.
+   *
+   * In contrast to quoteNonIdentifierOrKeyword, does not handle additional keywords,
+   * because it was not required, yet.
+   *
+   * Due to token rewrite, all keywords after a dot (`.`) are rewritten to
+   * identifiers, i.e. we only need to check for the identifier RegEx.
+   *
+   * @param {string} path
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function quotePathIfRequired( path, env ) {
+    return path.split('.').map((step, index) => {
+      if (index === 0)
+        return quoteNonIdentifierOrKeyword(step, env);
+      else if (!identifierRegex.test(step))
+        return delimitedId(step, env);
+      return step;
+    }).join('.');
+  }
+
+  /**
+   * Quote the id with `![]` if necessary. For paths such as `E.key` use
+   * `quotePathIfRequired` instead.
+   * See quoteNonIdentifier() if you want to ignore keywords.
+   *
+   * Set env.additionalKeywords to an array of UPPERCASE keywords
+   * that also need quoting, e.g. in special functions.
+   *
+   * @param {string} id
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function quoteNonIdentifierOrKeyword( id, env ) {
+    // Quote if required for CDL
+    if (requiresQuotingForCdl(id, env?.additionalKeywords || []))
+      return delimitedId(id, env);
+    return id;
+  }
+
+  /**
+   * Quote the id with `![]` if necessary. For paths such as `E.key` use
+   * `quotePathIfRequired` instead.
+   * See quoteNonIdentifierOrKeyword() if you want to quote identifiers
+   * that are keywords as well.
+   *
+   * Does not quote the given id if it is a keyword.
+   *
+   * @param {string} id
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function quoteNonIdentifier( id, env ) {
+    if (!identifierRegex.test(id))
+      return delimitedId(id, env);
+    return id;
+  }
+
+  /**
+   * Quote the given function name if required.
+   *
+   * @param {string} funcName
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function quoteFunctionIfRequired( funcName, env ) {
+    if (cdlNewLineRegEx.test(funcName)) {
+      msg.error('name-invalid-identifier', env.path, {},
+                'An identifier can\'t contain newline characters in CDL');
+    }
+    return apiSmartFunctionId(funcName);
+  }
+
+  /**
+   * Quote an annotation path, e.g. `@My.@Anno.Description` if necessary.
+   * `anno` can start with `@` but is not required to be.
+   * Example of an annotation path that needs to be quoted:
+   * `@![ spaces in path ].@!["double quotes"]`.
+   *
+   * @param {string} anno
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  function quoteAnnotationPathIfRequired( anno, env ) {
+    return anno.split('.').map((segment) => {
+      if (segment.startsWith('@'))
+        return `@${quoteNonIdentifier(segment.slice(1), env)}`;
+      return quoteNonIdentifier(segment, env);
+    }).join('.');
+  }
+
+  /**
+   * The same as the exported function apiDelimitedId, but checks that we can actually represent the
+   * string: newline characters are not allowed.
+   *
+   * @param {string} id
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function delimitedId( id, env ) {
+    if (cdlNewLineRegEx.test(id)) {
+      msg.error('name-invalid-identifier', env.path, {},
+                'An identifier can\'t contain newline characters in CDL');
+    }
+    return apiDelimitedId(id);
+  }
+}
+
+
+class CdlRenderEnvironment {
+  indent = '';
+  path = null;
+  artifactName = null;
+  elementName = null;
+  additionalKeywords = [];
+
+  constructor(values) {
+    Object.assign(this, values);
+  }
 }
 
 /**
@@ -1930,20 +2070,14 @@ function csnToCdl( csn, options ) {
  * @return {CdlRenderEnvironment}
  */
 function createEnv( values = {} ) {
-  return Object.assign({
-    // Current indentation string
-    indent: '',
-    path: null,
-    artifactName: '',
-    elementName: '',
-  }, values);
+  return new CdlRenderEnvironment( values );
 }
 
 function envAddPath( env, path ) {
-  return Object.assign({}, env, { path: [ ...env.path, ...path ] } );
+  return Object.assign(new CdlRenderEnvironment(env), { path: [ ...env.path, ...path ] } );
 }
 function envNewPath( env, path ) {
-  return Object.assign({}, env, { path: [ ...path ] } );
+  return Object.assign(new CdlRenderEnvironment(env), { path: [ ...path ] } );
 }
 
 /**
@@ -1956,92 +2090,6 @@ function increaseIndent( env ) {
   return Object.assign({}, env, { indent: `${env.indent}  ` });
 }
 
-/**
- * Quote simple path steps with `![]` if necessary. For simple ids such as
- * `elem` use `quoteNonIdentifierOrKeyword` instead.
- *
- * In contrast to quoteNonIdentifierOrKeyword, does not handle additional keywords,
- * because it was not required, yet.
- *
- * Due to token rewrite, all keywords after a dot (`.`) are rewritten to
- * identifiers, i.e. we only need to check for the identifier RegEx.
- *
- * @param {string} path
- * @returns {string}
- */
-function quotePathIfRequired( path ) {
-  return path.split('.').map((step, index) => {
-    if (index === 0)
-      return quoteNonIdentifierOrKeyword(step);
-    else if (!identifierRegex.test(step))
-      return delimitedId(step);
-    return step;
-  }).join('.');
-}
-
-/**
- * Quote the id with `![]` if necessary. For paths such as `E.key` use
- * `quotePathIfRequired` instead.
- * See quoteNonIdentifier() if you want to ignore keywords.
- *
- * Set additionalKeywords to an array of UPPERCASE keywords
- * that also need quoting, e.g. in special functions.
- *
- * @param {string} id
- * @param {string[]} [additionalKeywords]
- * @return {string}
- */
-function quoteNonIdentifierOrKeyword( id, additionalKeywords ) {
-  // Quote if required for CDL
-  if (requiresQuotingForCdl(id, additionalKeywords || []))
-    return delimitedId(id);
-  return id;
-}
-
-/**
- * Quote the id with `![]` if necessary. For paths such as `E.key` use
- * `quotePathIfRequired` instead.
- * See quoteNonIdentifierOrKeyword() if you want to quote identifiers
- * that are keywords as well.
- *
- * Does not quote the given id if it is a keyword.
- *
- * @param {string} id
- * @return {string}
- */
-function quoteNonIdentifier( id ) {
-  if (!identifierRegex.test(id))
-    return delimitedId(id);
-  return id;
-}
-
-/**
- * Quote an annotation path, e.g. `@My.@Anno.Description` if necessary.
- * `anno` can start with `@` but is not required to be.
- * Example of an annotation path that needs to be quoted:
- * `@![ spaces in path ].@!["double quotes"]`.
- *
- * @param {string} anno
- * @returns {string}
- */
-function quoteAnnotationPathIfRequired( anno ) {
-  return anno.split('.').map((segment) => {
-    if (segment.startsWith('@'))
-      return `@${quoteNonIdentifier(segment.slice(1))}`;
-    return quoteNonIdentifier(segment);
-  }).join('.');
-}
-
-/**
- * Quotes the identifier using CDL-style ![]-quotes.
- *
- * @param id
- * @returns {string}
- */
-function delimitedId( id ) {
-  return `![${id.replace(/]/g, ']]')}]`;
-}
-
 /**
  * Returns true if 'id' requires quotes for CDL, i.e. if 'id'
  * does not match the first part of the `Identifier` rule of `language.g4`
@@ -2061,7 +2109,7 @@ function requiresQuotingForCdl( id, additionalKeywords ) {
     additionalKeywords.includes(id.toUpperCase());
 }
 
-const functionExpressionOperatorsRequireParentheses = [
+const conditionOperators = [
   // Antlr rule 'condition', 'conditionAnd'
   'AND', 'OR',
 
@@ -2080,8 +2128,7 @@ const functionExpressionOperatorsRequireParentheses = [
  * in a `fct(<xpr>)` expression such as `cast(<xpr> as Type)`.  We only need to
  * look at the first nesting level.  Otherwise, `renderExpr()` will already add parentheses.
  *
- * The list of `functionExpressionOperatorsRequireParentheses` was created by looking at
- * the `expression` Antlr rule.
+ * The list of `conditionOperators` was created by looking at the `expression` Antlr rule.
  * Because of token-rewrites, there are functions that allow operators/tokens that would
  * require parentheses in other functions.  For example *regex functions allow `IN` but
  * if `IN` is used in other functions, it requires parentheses.  To allow for that case,
@@ -2100,7 +2147,22 @@ const functionExpressionOperatorsRequireParentheses = [
 function isSimpleFunctionExpression( xpr, additionalAllowedKeywords = [] ) {
   return !xpr || xpr.every(val => typeof val !== 'string' ||
       (additionalAllowedKeywords.includes(val.toUpperCase()) ||
-        !functionExpressionOperatorsRequireParentheses.includes(val.toUpperCase())));
+        !conditionOperators.includes(val.toUpperCase())));
+}
+
+/**
+ * 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
+ * `xpr` is a condition token such as `AND`.
+ *
+ * May report false positives for e.g. `CASE WHEN 1>1 THEN …`.
+ *
+ * @param {any[]} xpr
+ * @return {boolean}
+ */
+function xprContainsCondition( xpr ) {
+  return xpr && xpr.some(val => typeof val === 'string' &&
+    conditionOperators.includes(val.toUpperCase()));
 }
 
 /**
@@ -2241,50 +2303,64 @@ function availableFirstPathSteps( csn ) {
   return Array.from(unique);
 }
 
+/**
+ * Quotes the identifier using CDL-style ![]-quotes.
+ *
+ * NOTE: It is not guaranteed that the resulting string can _always_ be parsed!
+ *       If `id` contains newline characters, the resulting delimited identifier
+ *       will not be parsable by the compiler!
+ *
+ * @param id
+ * @returns {string}
+ */
+function apiDelimitedId( id ) {
+  return `![${id.replace(/]/g, ']]')}]`;
+}
+
 /**
  * Returns a delimited identifier if the given identifier needs quoting.
  * Because "special functions" such as SAP HANA RegEx functions have local keywords that
  * are not default CDL keywords, specify a function name to take care of that.
  *
+ * NOTE: It is not guaranteed that the resulting string can _always_ be parsed!
+ *       If `id` contains newline characters, the resulting delimited identifier
+ *       will not be parsable by the compiler!
+ *
  * @param {string} id
  * @param {null|string} insideFunction
  * @return {string}
  */
-function smartId( id, insideFunction = null ) {
+function apiSmartId( id, insideFunction = null ) {
   insideFunction = insideFunction?.toUpperCase();
-  if (!insideFunction || !specialFunctions[insideFunction])
-    return quoteNonIdentifierOrKeyword(id);
-  return quoteNonIdentifierOrKeyword(id, getAllKeywordsForSpecialFunction(insideFunction));
+  const extra = insideFunction && specialFunctions[insideFunction] ? getAllKeywordsForSpecialFunction(insideFunction) : [];
+  if (requiresQuotingForCdl(id, extra))
+    return apiDelimitedId(id);
+  return id;
 }
 
 /**
  * Quote the given function name if required.
  *
+ * NOTE: It is not guaranteed that the resulting string can _always_ be parsed!
+ *       If `funcName` contains newline characters, the resulting delimited identifier
+ *       will not be parsable by the compiler!
+ *
  * @param {string} funcName
  * @return {string}
  */
-function smartFunctionId( funcName ) {
+function apiSmartFunctionId( funcName ) {
   const funcId = funcName.toUpperCase();
   const requiresQuoting = !identifierRegex.test(funcName) ||
     (keywords.cdl.includes(funcId) && !specialFunctions[funcId]);
   if (requiresQuoting)
-    return delimitedId(funcName);
+    return apiDelimitedId(funcName);
   return funcName;
 }
 
-/**
- * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
- *
- * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
- * @property {CSN.Path} [path] CSN path to the current artifact
- * @property {string}   [artifactName] Name of the artifact - set in renderArtifact
- * @property {string}   [elementName] Name of the element being rendered - set in renderElement
- * @property {string[]} [additionalKeywords] For function rendering: Words that are also keywords.
- */
 
 module.exports = {
   csnToCdl,
-  smartId,
-  smartFunctionId,
-  delimitedId,
+  smartId: apiSmartId,
+  smartFunctionId: apiSmartFunctionId,
+  delimitedId: apiDelimitedId,
 };