@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/render/toCdl.js

@@ -1,41 +1,33 @@
 'use strict';
 
-const {
-  getLastPartOf,
-  getLastPartOfRef,
-} = require('../model/csnUtils');
-const {
-  isBuiltinType, generatedByCompilerVersion, getNormalizedQuery,
-} = require('../model/csnUtils');
 const keywords = require('../base/keywords');
-const { renderFunc, beautifyExprArray, findElement } = require('./utils/common');
+const { isBuiltinType, generatedByCompilerVersion, getNormalizedQuery } = require('../model/csnUtils');
+const { findElement, getExpressionRenderer } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
-const { csnRefs } = require('../model/csnRefs');
 const { forEachDefinition } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
 const { ModelError } = require('../base/error');
+const { typeParameters, specialFunctions } = require('../compiler/builtins');
+const { forEach } = require('../utils/objectUtils');
+
+const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
 
 /**
- * Render the CSN model 'model' to CDS source text. One source is created per
- * top-level artifact. Return a dictionary of top-level artifacts
- * by their names, like this:
- * { "foo" : "using XY; context foo {...};",
- *   "bar::wiz" : "namespace bar::; entity wiz {...};"
- * }
- * FIXME: This comment no longer tells the whole truth
+ * Render the CSN model 'model' to CDS source text.
+ * Returned object has the following properties:
+ *  - `model`: CSN model rendered as CDL (string).
+ *  - `namespace`: Namespace statement + `using from './model.cds'.
+ *  - `unappliedExtensions`: Annotations / Extensions from the `csn.extensions` array.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} [options]
  */
-function toCdsSourceCsn(csn, options) {
+function csnToCdl(csn, options) {
   timetrace.start('CDL rendering');
-  const { artifactRef } = csnRefs(csn);
-
-  // Skip compactModel if already using CSN
-  // const csn = cloneCsn(model, options);
+  let _renderExpr = null;
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
     enrichUniversalCsn(csn, options);
@@ -43,177 +35,284 @@ function toCdsSourceCsn(csn, options) {
   checkCSNVersion(csn, options);
 
   const cdlResult = Object.create(null);
+  cdlResult.model = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
 
-  const main = 'model';
+  const subelementAnnotates = [];
 
-  cdlResult[main] = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
+  cdlResult.model += renderDefinitions();
+  // sub-element annotations that can't be written directly.
+  cdlResult.model += renderExtensions(subelementAnnotates, createEnv());
 
-  const subelementAnnotates = [];
+  if (csn.vocabularies)
+    cdlResult.model += renderVocabularies(csn.vocabularies);
+
+  if (csn.namespace) {
+    cdlResult.namespace = `namespace ${renderArtifactName(csn.namespace)};\n`;
+    cdlResult.namespace += 'using from \'./model.cds\';';
+  }
+
+  // If there are extensions, such as 'extend' and 'annotate' statements, render them separately.
+  // Used for e.g. parseCdl-style CSN or Universal CSN.
+  if (csn.extensions)
+    cdlResult.unappliedExtensions = renderExtensions(csn.extensions, createEnv());
 
-  forEachDefinition(csn, (artifact, artifactName) => {
+  timetrace.stop();
+  return cdlResult;
+
+  /**
+   * Render entries from the `csn.definitions` dictionary.
+   * Returns an empty string if nothing is rendered.
+   *
+   * @return {string}
+   */
+  function renderDefinitions() {
+    let result = '';
     const env = createEnv();
-    const sourceStr = renderArtifact(artifactName, artifact, env);
-    if (sourceStr !== '')
-      cdlResult[main] += `${sourceStr}\n`;
-  });
+    forEachDefinition(csn, (artifact, artifactName) => {
+      const sourceStr = renderArtifact(artifactName, artifact, env);
+      if (sourceStr !== '')
+        result += `${sourceStr}\n`;
+    });
+    return result;
+  }
 
-  // Apply possible subelement/action return annotations with an "annotate X with"
-  // Some of them appear in csn.extensions, some not...
-  if (subelementAnnotates.length > 0) {
-    for (const [ artName, element, elementName, suffix ] of subelementAnnotates) {
-      // Suffix is used with action return annotations
-      let sourceStr = `annotate ${artName} with ${suffix ? `${suffix} ` : ''}{\n`;
-      if (elementName) // action returns do not have element name - we need less {} there
-        sourceStr += `  ${elementName} {\n`;
-      const env = increaseIndent(increaseIndent(createEnv()));
-      const subelements = renderSubelementAnnotates(element, env);
-      if (subelements !== '') {
-        sourceStr += `${subelements}\n`;
-        if (elementName) // action returns do not have element name - we need less {} there
-          sourceStr += '  }\n';
-        sourceStr += '}\n';
-        cdlResult[main] += `${sourceStr}\n`;
+  /**
+   * Render annotation definitions, i.e. entries from csn.vocabularies.
+   * Returns an empty string if there isn't anything to render.
+   *
+   * @param {object} vocabularies
+   * @return {string}
+   */
+  function renderVocabularies(vocabularies) {
+    let result = '';
+    forEach(vocabularies, renderVocabulariesEntry);
+    return result;
+
+    function renderVocabulariesEntry(name, anno) {
+      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 sourceStr = renderTypeOrAnnotation(name, anno, env, 'annotation');
+        result += `${sourceStr}\n`;
       }
     }
   }
 
   /**
-   * Render annotations for subelements as part of an "annotate X with" statement
+   * Render 'extend' and 'annotate' statements from the `extensions` array.
+   * Could be annotate-statements for sub-elements annotations or from parseCdl's
+   * extensions array or just unapplied extensions.
    *
-   * @param {CSN.Element} element The element to annotate the subelements for
-   * @param {CdlRenderEnvironment} env Render environment
-   * @returns {String}
+   * @param {CSN.Extension[]} extensions
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
    */
-  function renderSubelementAnnotates(element, env) {
-    const result = [];
-    for (const [ name, subelement ] of Object.entries(element.elements)) {
-      const subresult = [];
-      const annos = renderAnnotationAssignments(subelement, env);
-      if (annos !== '')
-        subresult.push(annos.slice(0, -1));
-
-      const quotedElementName = quoteOrUppercaseId(name);
-      if (subelement.elements) {
-        subresult.push(`${env.indent}${quotedElementName} {`);
-        subresult.push(renderSubelementAnnotates(subelement, increaseIndent(env)));
-        subresult.push(`${env.indent}};`);
-      }
-      else {
-        subresult.push(`${env.indent}${quotedElementName};`);
-      }
-      // Only add result if there really was "something"
-      if (annos || subelement.elements)
-        result.push(...subresult);
-    }
-    return result.join('\n');
+  function renderExtensions(extensions, env) {
+    return extensions.map(ext => renderExtension(ext, env)).join('\n');
   }
 
-  if (csn.vocabularies) {
-    for (const annotationName of Object.keys(csn.vocabularies)) {
-      // This environment is passed down the call hierarchy, for dealing with
-      // indentation and name resolution issues
-      const anno = csn.vocabularies[annotationName];
-      const env = createEnv();
-      let sourceStr;
-      if (!anno._ignore)
-        sourceStr = renderTypeOrAnnotation(annotationName, anno, env, 'annotation');
+  /**
+   * Render an 'extend' and 'annotate' statement.
+   *
+   * @param {CSN.Extension} ext
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderExtension(ext, env) {
+    if (ext.extend)
+      return renderExtendStatement(ext.extend, ext, env);
+    return renderAnnotateStatement(ext, env);
+  }
 
-      if (sourceStr !== '')
-        cdlResult[main] += `${sourceStr}\n`;
+  /**
+   * Render an 'extend' statement.
+   * `extName` is the extension's artifact's name, most likely `ext.extend`.
+   * This function is recursive, which is why you need to pass it explicitly.
+   *
+   * @param {string} extName
+   * @param {object} ext
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderExtendStatement(extName, ext, env) {
+    extName = renderArtifactName(extName);
+    // Element extensions have `kind` set.
+    const isElementExtend = (ext.kind === 'extend');
+    let result = renderAnnotationAssignmentsAndDocComment(ext, env);
+
+    if (ext.includes && ext.includes.length > 0) {
+      // Includes can't be combined with anything in braces {}.  Multiple includes
+      // are possible through CSN, but in CDL, only one include at once is possible.
+      const affix = isElementExtend ? 'element ' : '';
+      for (const id of ext.includes)
+        result += `${env.indent}extend ${affix}${extName} with ${quotePathIfRequired(id)};\n`;
+      return result;
     }
-  }
 
-  if (csn.namespace) {
-    cdlResult[csn.namespace] = `namespace ${renderArtifactName(csn.namespace)};\n`;
-    cdlResult[csn.namespace] += `using from './${main}.cds';`;
+    // We have the "old-style" prefix syntax and the "new-style" postfix "with <type>" syntax.
+    // The former one can not only extend (sub-)elements but also actions in the same statement whereas
+    // the latter cannot.
+    // If there are actions, check if there are also elements/columns, and if so, use the prefix notation.
+    const usePrefixNotation = isElementExtend || ext.actions && (ext.columns || ext.elements);
+    if (usePrefixNotation)
+      result += `${env.indent}extend ${getExtendPrefixVariant(ext)} ${extName} with {\n`;
+    else
+      result += `${env.indent}extend ${extName} with ${getExtendPostfixVariant(ext)} {\n`;
+
+    if (ext.columns) {
+      result += renderViewColumns(ext.columns, increaseIndent(env));
+    }
+    else if (ext.elements) {
+      result += renderExtendStatementElements(ext, env);
+    }
+    else if (ext.enum) {
+      const childEnv = increaseIndent(env);
+      forEach(ext.enum, (name, value) => {
+        result += renderEnumElement(name, value, childEnv);
+      });
+    }
+
+    // Not part of if/else cascade, because it may be in postfix notation.
+    if (ext.actions) {
+      // TODO: Merge with renderActionsAndFunctions() -> requires removal of static `with actions`
+      const childEnv = increaseIndent(env);
+      let actions = '';
+      forEach(ext.actions, (actionName, action) => {
+        actions += renderActionOrFunction(actionName, action, childEnv);
+      });
+      if (!usePrefixNotation)
+        result += actions;
+      else if (actions !== '')
+        result += `${env.indent}} actions {\n${actions}`;
+    }
+
+    result += `${env.indent}};\n`;
+    return result;
   }
 
+  /**
+   * What <extend> prefix type to use.  Used to render `extend <type> <ref>` statements.
+   *
+   * @param {object} ext
+   * @return {string}
+   */
+  function getExtendPrefixVariant(ext) {
+    if (ext.kind === 'extend')
+      return 'element'; // element extensions inside an `extend`
+    if (ext.columns)
+      return 'projection';
+    if (ext.elements)
+      return 'entity';
+    return '';
+  }
 
-  // If there are unapplied 'extend' and 'annotate' statements, render them separately
-  // FIXME: Clarify if we should also do this for HANA (probably not?)
-  if (csn.extensions) {
-    const env = createEnv();
-    const sourceStr = renderUnappliedExtensions(csn.extensions, env);
-    cdlResult.unappliedExtensions = sourceStr;
+  /**
+   * What <extend> postfix type to use.  Used to render `extend <ref> with <type>` statements.
+   *
+   * @param {CSN.Extension} ext
+   * @return {string}
+   */
+  function getExtendPostfixVariant(ext) {
+    if (ext.columns)
+      return 'columns';
+    if (ext.actions)
+      return 'actions';
+    if (ext.elements)
+      return 'elements';
+    if (ext.enum)
+      return 'enum';
+    return '';
   }
 
-  timetrace.stop();
-  return cdlResult;
+  /**
+   * Render the elements inside an `extend` statement. They may themselves be `extend` statements.
+   *
+   * @param {CSN.Extension} ext
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderExtendStatementElements(ext, env) {
+    let result = '';
+    forEach(ext.elements || {}, (elemName, element) => {
+      if (element.kind === 'extend')
+        result += renderExtendStatement(elemName, element, increaseIndent(env));
+      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), true);
+    });
+    return result;
+  }
 
   /**
-   * Render unapplied 'extend' and 'annotate' statements from the 'extensions array'
+   * Render an 'annotate' statement.
    *
-   * @param {CSN.Extension[]} extensions
+   * @param {CSN.Extension} ext
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderUnappliedExtensions(extensions, env) {
-    return extensions.map((ext) => {
-      // Top-level annotations of the artifact
-      let result = renderAnnotationAssignments(ext, env);
-      result += `annotate ${ext.annotate}`;
-      // Element extensions and annotations (possibly nested)
-      if (ext.elements)
-        result += renderElementExtensions(ext.elements, env);
-
-      // Returns annotations
-      if (ext.returns) {
-        const childEnv = increaseIndent(env);
-        result += ` with returns${renderElementExtensions(ext.returns.elements, childEnv)}`;
-      }
+  function renderAnnotateStatement(ext, env) {
+    // Top-level annotations of the artifact
+    let result = renderAnnotationAssignmentsAndDocComment(ext, env);
+    result += `${env.indent}annotate ${renderArtifactName(ext.annotate)}`;
 
-      // Action annotations
-      if (ext.actions) {
-        result += ' actions {\n';
-        const childEnv = increaseIndent(env);
-        for (const name in ext.actions) {
-          const action = ext.actions[name];
-          result += renderAnnotationAssignments(action, childEnv) + childEnv.indent + quoteIdIfRequired(name);
-          // Action parameter annotations
-          if (action.params) {
-            result += '(\n';
-            const grandChildEnv = increaseIndent(childEnv);
-            const paramAnnotations = [];
-            for (const paramName in action.params)
-              paramAnnotations.push(renderAnnotationAssignments(action.params[paramName], grandChildEnv) + grandChildEnv.indent + quoteIdIfRequired(paramName));
-
-            result += `${paramAnnotations.join(',\n')}\n${childEnv.indent})`;
-          }
-          // Annotations on action returns
-          if (action.returns && action.returns.elements) {
-            const grandChildEnv = increaseIndent(childEnv);
-            result += ` returns${renderElementExtensions(action.returns.elements, grandChildEnv)}`;
-          }
+    if (ext.params)
+      result += renderAnnotateParamsInParentheses(ext.params, env);
 
+    // Element extensions and annotations (possibly nested)
+    if (ext.elements)
+      result += renderAnnotateStatementElements(ext.elements, env);
 
-          result += ';\n';
+    // Returns annotations
+    if (ext.returns) {
+      const childEnv = increaseIndent(env);
+      result += ` returns${renderAnnotateStatementElements(ext.returns.elements, childEnv)}`;
+    }
+
+    // Action annotations
+    if (ext.actions) {
+      result += ' actions {\n';
+      const childEnv = increaseIndent(env);
+      for (const name in ext.actions) {
+        const action = ext.actions[name];
+        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteIdIfRequired(name);
+        // 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 += `${env.indent}}`;
-      }
 
+        result += ';\n';
+      }
+      result += `${env.indent}}`;
+    }
 
-      result += ';';
-      return result;
-    }).join('\n');
+    result += ';\n';
+    return result;
   }
 
   /**
-   * Render the elements-specific part of an 'extend' or 'annotate' statement for an element dictionary
+   * Render the elements-specific part of an 'annotate' statement for an element dictionary
    * 'elements' (assuming that the surrounding parent has just been rendered, without trailing newline).
-   * Return the resulting source string, ending without a trailing newline, too.
+   * Returns the resulting source string, ending without a trailing newline.
    *
    * @param {CSN.Elements} elements
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderElementExtensions(elements, env) {
+  function renderAnnotateStatementElements(elements, env) {
     let result = ' {\n';
     const childEnv = increaseIndent(env);
     for (const name in elements) {
       const elem = elements[name];
-      result += renderAnnotationAssignments(elem, childEnv) + childEnv.indent + quoteIdIfRequired(name);
+      result += renderAnnotationAssignmentsAndDocComment(elem, childEnv) + childEnv.indent + quoteIdIfRequired(name);
       if (elem.elements)
-        result += renderElementExtensions(elem.elements, childEnv);
+        result += renderAnnotateStatementElements(elem.elements, childEnv);
 
       result += ';\n';
     }
@@ -221,6 +320,24 @@ function toCdsSourceCsn(csn, options) {
     return result;
   }
 
+  /**
+   * Render a parameter list for `annotate` statements, in parentheses `()`.
+   *
+   * @param {object} params
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderAnnotateParamsInParentheses(params, env) {
+    const childEnv = increaseIndent(env);
+    let result = '(\n';
+    const paramAnnotations = [];
+    forEach(params, (paramName, param) => {
+      paramAnnotations.push( renderAnnotationAssignmentsAndDocComment(param, childEnv) + childEnv.indent + quoteIdIfRequired(paramName) );
+    });
+    result += `${paramAnnotations.join(',\n')}\n${env.indent})`;
+    return result;
+  }
+
   /**
    * Render an artifact. Return the resulting source string.
    *
@@ -229,29 +346,27 @@ function toCdsSourceCsn(csn, options) {
    * @param {CdlRenderEnvironment} env
    */
   function renderArtifact(artifactName, art, env) {
-    // FIXME: Correctly build the paths during runtime to give better locations
-    env.path = [ 'definitions', artifactName ];
+    env = envNewPath(env, [ 'definitions', artifactName ]);
     env.artifactName = artifactName;
 
     switch (art.kind) {
       case 'entity':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
-
         return renderEntity(artifactName, art, env);
 
       case 'context':
       case 'service':
-        return renderContext(artifactName, art, env);
+        return renderContextOrService(artifactName, art, env);
       case 'type':
       case 'aspect':
-      case 'annotation':
-        return renderTypeOrAnnotation(artifactName, art, env, art.$syntax);
+      case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
+        return renderTypeOrAnnotation(artifactName, art, env);
       case 'action':
       case 'function':
         return renderActionOrFunction(artifactName, art, env);
       case 'event':
-        return renderEventIfCDLMode(artifactName, art, env);
+        return renderEvent(artifactName, art, env);
       default:
         throw new ModelError(`Unknown artifact kind: ${art.kind}`);
     }
@@ -262,26 +377,22 @@ function toCdsSourceCsn(csn, options) {
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function renderEventIfCDLMode(artifactName, art, env) {
-    let result = renderDocComment(art, env) + renderAnnotationAssignments(art, env);
+  function renderEvent(artifactName, art, env) {
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
     const childEnv = increaseIndent(env);
     const normalizedArtifactName = renderArtifactName(artifactName);
     result += `${env.indent}event ${normalizedArtifactName}`;
-    if (art.includes) {
-      // Includes are never flattened (don't exist in HANA)
-      result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name)).join(', ')}`;
-    }
+    if (art.includes)
+      result += renderIncludes(art.includes);
     if (art.query || art.projection) {
-      env._artifact = art;
       result += ' : ';
       result += renderQuery(getNormalizedQuery(art).query, true, 'projection', env,
                             [ 'definitions', artifactName, 'query' ]);
       result += ';\n';
-      delete env._artifact;
     }
     else if (art.type) {
       // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env)};\n`;
+      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
     }
     else if (art.elements) {
       result += ' {\n';
@@ -293,63 +404,15 @@ function toCdsSourceCsn(csn, options) {
     return result;
   }
 
-  /* FIXME: Not yet required
-  // Returns the artifact or element that constitutes the final type of
-  // construct 'node', i.e. the object in which we would find type properties for
-  // 'node'. Note that this may well be 'node' itself.
-  function getFinalTypeOf(node) {
-    if (node && node.type) {
-      if (isBuiltinType(node.type)) {
-        return node;
-      }
-      return getFinalTypeOf(node.type);
-    }
-    return node;
-  }
-
-  // Resolve path array 'ref' against artifact 'base' (or against 'csn.definitions'
-  // if no 'base' given).
-  // Return the resulting artifact or element (or 'undefined' if not found).
-  function resolveRef(ref, base) {
-    let result = base;
-    for (let i = 0; i < ref.length; i++) {
-      let pathStep = ref[i].id || ref[i];
-      // Only first path step may be looked up in 'definitions'
-      if (i === 0 && !base) {
-        result = csn.definitions[pathStep];
-        continue;
-      }
-      // Structured type
-      else if (result && result.elements) {
-        result = getFinalTypeOf(result.elements[pathStep]);
-      }
-      // Association
-      else if (result && result.target) {
-        result = resolveRef([pathStep], csn.definitions[result.target]);
-      }
-      // Not resolvable
-      else {
-        return undefined;
-      }
-    }
-    return result;
-  }
-*/
-
   /**
-   * Render a context or service. Return the resulting source string.
-   *
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
+   * @returns {string}
    */
-  function renderContext(artifactName, art, env) {
-    let result = renderDocComment(art, env) + renderAnnotationAssignments(art, env);
-    result += `${env.indent + (art.abstract ? 'abstract ' : '') + art.kind} ${renderArtifactName(artifactName)}`;
-    if (art.includes) {
-      // Includes are never flattened (don't exist in HANA)
-      result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name)).join(', ')}`;
-    }
+  function renderContextOrService(artifactName, art, env) {
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent}${art.kind} ${renderArtifactName(artifactName)}`;
     return `${result} {};\n`;
   }
 
@@ -362,23 +425,17 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderEntity(artifactName, art, env) {
-    let result = renderDocComment(art, env) + renderAnnotationAssignments(art, env);
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
     const childEnv = increaseIndent(env);
     const normalizedArtifactName = renderArtifactName(artifactName);
     result += `${env.indent + (art.abstract ? 'abstract ' : '')}entity ${normalizedArtifactName}`;
     const parameters = Object.keys(art.params || []).map(name => renderParameter(name, art.params[name], childEnv)).join(',\n');
     result += (parameters === '') ? '' : ` (\n${parameters}\n${env.indent})`;
-    if (art.includes) {
-      // Includes are never flattened (don't exist in HANA)
-      result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name)).join(', ')}`;
-    }
+    if (art.includes)
+      result += renderIncludes(art.includes);
     result += ' {\n';
     for (const name in art.elements) {
       const element = art.elements[name];
-      // For subelement annotations, this seems to be a pattern to recognize them
-      // plus some other stuff unfortunately...
-      if (element.type && element.elements)
-        subelementAnnotates.push([ artifactName, element, name ]);
       result += renderElement(name, element, childEnv);
     }
 
@@ -397,36 +454,16 @@ function toCdsSourceCsn(csn, options) {
    * @param {Boolean} [isSubElement]
    */
   function renderElement(elementName, elm, env, isSubElement) {
-    env.elementName = elementName;
-    let result = renderDocComment(elm, env) + renderAnnotationAssignments(elm, env);
-    const quotedElementName = quoteOrUppercaseId(elementName);
-    result += `${env.indent + (elm.virtual ? 'virtual ' : '') +
-                         (elm.key && !isSubElement ? 'key ' : '') +
-                         ((elm.masked && !elm._ignoreMasked) ? 'masked ' : '') +
-                         quotedElementName} : ${
-      renderTypeReference(elm, env, undefined)
-    }${elm.on ? '' : renderNullability(elm)}`;
-    if (elm.default)
-      result += ` default ${renderExpr(elm.default, env)}`;
-
-    delete env.elementName;
-    return `${result};\n`;
-  }
-
-  /**
-   * Return the SELECT of the leading query of query 'query'
-   *
-   * @param {CSN.Query} query
-   */
-  function leadingQuerySelect(query) {
-    if (query.SELECT)
-      return query.SELECT;
-
-    // Sanity checks
-    if (!query.SET || !query.SET.args || !query.SET.args[0])
-      throw new ModelError(`Expecting set with args in query: ${JSON.stringify(query)}`);
+    env = envAddPath(env, [ 'elements', elementName ]);
+    let result = renderAnnotationAssignmentsAndDocComment(elm, env);
+    result += env.indent;
+    result += elm.virtual ? 'virtual ' : '';
+    result += elm.key && !isSubElement ? 'key ' : '';
+    // TODO(v4): Remove once deprecated flag for `masked` is removed.
+    result += elm.masked ? 'masked ' : '';
+    result += `${quoteIdIfRequired(elementName)} : ${renderTypeReferenceAndProps(elm, env)}`;
 
-    return leadingQuerySelect(query.SET.args[0]);
+    return `${result};\n`;
   }
 
   /**
@@ -452,9 +489,13 @@ function toCdsSourceCsn(csn, options) {
 
   /**
    * Render annotations that were extended to a query element of a view or projection (they only
-   * appear in the view's 'elements', not in their 'columns', because the element itself may not
-   * even be in 'columns', e.g. if it was expanded from a '*'). Return the resulting 'annotate'
-   * statement or an empty string if none required.
+   * appear in the view's 'elements', not in their 'columns' for client CSN, because the element
+   * itself may not even be in 'columns', e.g. if it was expanded from a '*').  Return the
+   * resulting rendered 'annotate' statement or an empty string if none required.
+   *
+   * Note: In the past, we checked if the annotation also exists in the respective column,
+   *       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
@@ -462,43 +503,88 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderQueryElementAnnotations(artifactName, art, env) {
-    // For preparation, create a map from element names to column objects
-    const columnMap = Object.create(null);
-    const select = leadingQuerySelect(getNormalizedQuery(art).query);
-    for (const col of select.columns || [ '*' ]) {
-      // Ignore '*'
-      if (col === '*')
-        continue;
-
-      // Column must have an alias or be a path - take last part of that as element name
-      columnMap[col.as || col.func || getLastPartOfRef(col.ref)] = col;
+    const annotate = collectAnnotationsOfElements(art, { artifactName, path: env.path });
+    if (annotate)
+      return renderExtensions([ annotate ], env);
+    return '';
+  }
+
+  /**
+   * Create an "annotate" statement as a CSN extension for all annotations of (sub-)elements.
+   * If no annotation was found, we return `null`.
+   *
+   * @param {CSN.Artifact} artWithElements
+   * @param {CdlRenderEnvironment} env
+   * @return {CSN.Extension|null}
+   */
+  function collectAnnotationsOfElements(artWithElements, env) {
+    // Array of structures, which may be annotated as well.
+    if (!artWithElements.elements && artWithElements.items) {
+      env = envAddPath(env, [ 'items' ]);
+      artWithElements = artWithElements.items;
     }
-    // Now iterate elements - render an annotation if it is different from the column's
-    const childEnv = increaseIndent(env);
-    let result = '';
-    for (const elemName in art.elements) {
-      let elemAnnotations = '';
-      const elem = art.elements[elemName];
-      for (const name in elem) {
-        if (!name.startsWith('@'))
-          continue;
-
-        const annotationValue = renderAnnotationAssignment(elem[name], name, childEnv);
-        // Skip annotation if column has the same
-        if (columnMap[elemName] && columnMap[elemName][name] &&
-          renderAnnotationAssignment(columnMap[elemName][name], name, childEnv) === annotationValue)
-          continue;
-
-        // Annotation names are never flattened
-        elemAnnotations += annotationValue;
+
+    const annotate = { annotate: env.path[1] };
+
+    // Based on the current path, create a correctly nested structure
+    // of elements for which we collect annotations.
+    // TODO: More properties?
+    let obj = annotate;
+    for (let i = 2; i < env.path.length; ++i) {
+      const key = env.path[i];
+      if (key === 'elements' || key === 'actions') {
+        obj[key] = Object.create(null);
+        const elem = env.path[i + 1];
+        obj[key][elem] = {};
+        obj = obj[key][elem];
+      }
+      else if (key === 'returns') {
+        obj.returns = {};
+        obj = obj.returns;
+      }
+      else {
+        // ignore others, e.g. 'items'
       }
-      if (elemAnnotations !== '')
-        result += `${elemAnnotations}${childEnv.indent}${quoteOrUppercaseId(elemName)};\n`;
     }
-    if (result !== '')
-      result = `${env.indent}annotate ${renderArtifactName(artifactName)} with {\n${result}${env.indent}};\n`;
+    return collectAnnos(obj, artWithElements) ? annotate : null;
 
-    return result;
+    /**
+     * Recursive function to collect annotations. `annotateObj` will get an `elements`
+     * object with annotations only if there are annotations on `art`'s (sub-)elements.
+     *
+     * @return {boolean} True, if there were annotations, false otherwise.
+     */
+    function collectAnnos(annotateObj, art) {
+      if (!art.elements)
+        return false;
+
+      const collected = { elements: Object.create(null) };
+      let hasAnnotation = false;
+
+      forEach(art.elements, (elemName, element) => {
+        if (!collected.elements[elemName])
+          collected.elements[elemName] = { };
+
+        let hasElementAnnotations = false;
+        for (const name in element) {
+          if (name.startsWith('@')) {
+            collected.elements[elemName][name] = element[name];
+            hasElementAnnotations = true;
+            hasAnnotation = true;
+          }
+        }
+
+        const hasSubAnnotations = collectAnnos(collected.elements[elemName], element);
+        if (!hasElementAnnotations && !hasSubAnnotations)
+          delete collected.elements[elemName]; // delete if no annotations exist
+        hasAnnotation = hasAnnotation || hasSubAnnotations;
+      });
+
+      if (hasAnnotation)
+        annotateObj.elements = collected.elements;
+
+      return hasAnnotation;
+    }
   }
 
   /**
@@ -513,25 +599,24 @@ function toCdsSourceCsn(csn, options) {
   function renderViewSource(source, env) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
-      let result = `(${renderDocComment(source, env)}${renderQuery(source, false, 'view', increaseIndent(env))})`;
+      let result = `(${renderQuery(source, false, 'view', increaseIndent(env))})`;
       if (source.as)
-        result += ` as ${quoteOrUppercaseId(source.as)}`;
+        result += ` as ${quoteIdIfRequired(source.as)}`;
 
       return result;
     }
     // JOIN
     else if (source.join) {
       // One join operation, possibly with ON-condition
-      let result = `${renderDocComment(source, env)}${renderViewSource(source.args[0], env)}`;
+      let result = `(${renderViewSource(source.args[0], env)}`;
       for (let i = 1; i < source.args.length; i++) {
-        result = `(${result} ${source.join} `;
+        result += ` ${source.join} `;
         result += renderJoinCardinality(source.cardinality);
         result += `join ${renderViewSource(source.args[i], env)}`;
         if (source.on)
           result += ` on ${renderExpr(source.on, env, true, true)}`;
-
-        result += ')';
       }
+      result += ')';
       return result;
     }
     // Ordinary path, possibly with an alias
@@ -572,9 +657,8 @@ function toCdsSourceCsn(csn, options) {
     // Determine the absolute name of the first artifact on the path (before any associations or element traversals)
     const firstArtifactName = path.ref[0].id || path.ref[0];
 
-    let result = renderDocComment(path, env);
     // Render the first path step (absolute name, with different quoting/naming ..)
-    result += getResultingName(firstArtifactName);
+    let result = renderArtifactName(firstArtifactName);
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
@@ -605,11 +689,26 @@ function toCdsSourceCsn(csn, options) {
     let result = renderAbsolutePath(path, env);
     if (path.as) {
       // Source had an alias - render it
-      result += ` as ${quoteOrUppercaseId(path.as)}`;
+      result += ` as ${quoteIdIfRequired(path.as)}`;
     }
     return result;
   }
 
+  /**
+   * Render the given columns.
+   *
+   * @param {any[]} columns
+   * @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 !== '')
+      .join(',\n');
+    return `${result}\n`;
+  }
+
   /**
    * Render a single view or projection column 'col', as it occurs in a select list or
    * projection list within 'art', possibly with annotations.
@@ -621,7 +720,14 @@ function toCdsSourceCsn(csn, options) {
    */
   function renderViewColumn(col, env, element) {
     // Annotations and column
-    let result = renderDocComment(col.doc ? col : element, env) + renderAnnotationAssignments(col, env);
+    let result = '';
+    if (!col.doc) {
+      // TODO: In contrast to annotations, we do not render the doc comment as part
+      //       of an `annotate` statement.  That may change in the future.
+      result += renderDocComment(element, env);
+    }
+    // Note: parentheses are a workaround for #9015
+    result += renderAnnotationAssignmentsAndDocComment(col, env, { parens: true });
     result += env.indent;
 
     // only if column is virtual, keyword virtual was present in the source text
@@ -632,22 +738,19 @@ function toCdsSourceCsn(csn, options) {
     // Use special rendering for .expand/.inline - renderExpr cannot easily handle some cases
     result += key + ((col.expand || col.inline) ? renderInlineExpand(col, env) : renderExpr(col, env, true));
 
-    // Alias is already handled by renderInlineExpand
-    if (!col.inline && !col.expand && col.as)
-      result += ` as ${quoteOrUppercaseId(col.as)}`;
+    // Alias for inline/expand is already handled by renderInlineExpand
+    // A new association (cast with `type` and `target`) uses `as` as its primary name, not alias.
+    const isNewAssociation = col.cast && col.cast.type && col.cast.target;
+    if (col.as && !col.inline && !col.expand && !isNewAssociation)
+      result += ` as ${quoteIdIfRequired(col.as)}`;
 
     // Explicit type provided for the view element?
     if (col.cast) {
       // Special case: Explicit association type is actually a redirect
-      if (col.cast.target) {
-        // Redirections are never flattened (don't exist in HANA)
-        result += ` : redirected to ${renderAbsoluteNameWithQuotes(col.cast.target)}`;
-        if (col.cast.on)
-          result += ` on ${renderExpr(col.cast.on, env, true, true)}`;
-      }
-      else {
-        result += ` : ${renderTypeReference(col.cast, env, true)}`;
-      }
+      if (col.cast.target && !col.cast.type)
+        result += ` : ${renderRedirectedTo(col.cast, env)}`;
+      else
+        result += ` : ${renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true })}`;
     }
     return result;
   }
@@ -656,71 +759,58 @@ function toCdsSourceCsn(csn, options) {
    * For the current column, render a (nested) inline/expand. If the current column
    * does not have an .expand/.inline, '' is returned
    *
-   * @param {object} col Thing with .expand or .inline
-   * @param {CdlRenderEnvironment} parentEnv
+   * @param {object} obj Thing with .expand or .inline
+   * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderInlineExpand(col, parentEnv) {
-    if (!col.inline && !col.expand)
-      return '';
-
-    return renderIX(col, parentEnv);
-
-    function renderIX(obj, env) {
-      // No expression to render for { * } as alias
-      let result = (obj.as && obj.expand && !obj.ref) ? '' : renderExpr(obj, env);
-
-      // s as alias { * }
-      if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
-        result += ` as ${obj.as}`;
-
-      // We found a leaf - no further drilling
-      if (!obj.inline && !obj.expand) {
-        if (obj.cast && obj.cast.type) {
-          result += ` : ${renderTypeReference(obj.cast, createEnv())}`;
-        }
-        else if (obj.cast && obj.cast.target) { // test tbd
-          result += ` : redirected to ${renderAbsoluteNameWithQuotes(obj.cast.target)}`;
-          if (obj.cast.on)
-            result += ` on ${renderExpr(obj.cast.on, env, true, true)}`;
-          else if (obj.cast.keys)
-            result += ` { ${Object.keys(obj.cast.keys).map(name => renderForeignKey(obj.cast.keys[name], env)).join(', ')} }`;
-        }
-        return result;
-      }
-
-      if (obj.inline)
-        result += '.{\n';
-      else
-        result += result !== '' ? ' {\n' : '{\n';
-
-      // Drill down and render children of the expand/inline
-      const childEnv = increaseIndent(env);
-      const expandInline = obj.expand || obj.inline;
-      expandInline.forEach((elm, i) => {
-        result += `${childEnv.indent}${renderIX(elm, childEnv)}`;
-        if (i < expandInline.length - 1)
-          result += ',\n';
-      });
-      result += `\n${env.indent}}`;
+  function renderInlineExpand(obj, env) {
+    // No expression to render for { * } as alias
+    let result = (obj.as && obj.expand && !obj.ref) ? '' : renderExpr(obj, env);
+
+    // s as alias { * }
+    if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
+      result += ` as ${obj.as}`;
+
+    // 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 })}`;
+      else if (obj.cast && obj.cast.target) // test tbd
+        result += ` : ${renderRedirectedTo(obj.cast, env)}`;
+      return result;
+    }
 
-      // Don't forget about the .excluding
-      if (obj.excluding)
-        result += ` excluding { ${obj.excluding.join(',')} }`;
+    if (obj.inline)
+      result += '.{\n';
+    else
+      result += result !== '' ? ' {\n' : '{\n';
 
-      // { * } as expand
-      if (!obj.ref && obj.as)
-        result += ` as ${obj.as}`;
+    // Drill down and render children of the expand/inline
+    const childEnv = increaseIndent(env);
+    const expandInline = obj.expand || obj.inline;
+    expandInline.forEach((elm, i) => {
+      result += `${childEnv.indent}${renderInlineExpand(elm, childEnv)}`;
+      if (i < expandInline.length - 1)
+        result += ',\n';
+    });
+    result += `\n${env.indent}}`;
+
+    // Don't forget about the .excluding
+    if (obj.excluding)
+      result += ` excluding { ${obj.excluding.join(',')} }`;
+
+    // { * } as expand
+    if (!obj.ref && obj.as)
+      result += ` as ${obj.as}`;
 
-      return result;
-    }
+    return result;
   }
 
   /**
    * Render .doc properties as comments in CDL
    *
    * @param {object} obj Object to render for
-   * @param {object} env Env - for indent
+   * @param {CdlRenderEnvironment} env
    * @returns {String}
    */
   function renderDocComment(obj, env) {
@@ -729,7 +819,13 @@ function toCdsSourceCsn(csn, options) {
     else if (obj && obj.doc === null) // empty doc comment needs to be rendered
       return `\n${env.indent}/** */\n`;
 
-    return `\n${env.indent}/**\n${obj.doc.split('\n').map(line => `${env.indent} * ${line}`).join('\n')}\n${env.indent} */\n`;
+    // Smaller comment for single-line comments.  If the comments starts or ends with whitespace
+    // we must use a block comment, or it will be lost when compiling the source again.
+    if (!obj.doc.includes('\n') && !/^\s|\s$/.test(obj.doc))
+      return `${env.indent}/** ${obj.doc} */\n`;
+
+    const comment = obj.doc.split('\n').map(line => `${env.indent} * ${line}`).join('\n');
+    return `${env.indent}/**\n${comment}\n${env.indent} */\n`;
   }
 
   /**
@@ -743,7 +839,7 @@ function toCdsSourceCsn(csn, options) {
    */
   function renderView(artifactName, art, env) {
     const syntax = (art.projection) ? 'projection' : 'entity';
-    let result = renderDocComment(art, env) + renderAnnotationAssignments(art, env);
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent}${art.abstract ? 'abstract ' : ''}${syntax === 'projection' ? 'entity' : syntax} ${renderArtifactName(artifactName)}`;
     if (art.params) {
       const childEnv = increaseIndent(env);
@@ -753,7 +849,6 @@ function toCdsSourceCsn(csn, options) {
     else {
       result += ' as ';
     }
-    env._artifact = art;
     result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
     result += ';\n';
     result += renderQueryElementAnnotations(artifactName, art, env);
@@ -775,48 +870,28 @@ function toCdsSourceCsn(csn, options) {
    * @param {object} [elements]
    */
   function renderQuery(query, isLeadingQuery, syntax, env, path = [], elements = query.elements || Object.create(null)) {
-    let result = renderDocComment(query, env);
-    // Set operator, like UNION, INTERSECT, ...
     if (query.SET) {
-      // First arg may be leading query
-      result += `(${renderQuery(query.SET.args[0], isLeadingQuery, 'view', env, path.concat([ 'SET', 'args', 0 ]), elements)}`;
-      // FIXME: Clarify if set operators can be n-ary (assuming binary here)
-      if (query.SET.op) {
-        // Loop over all other arguments, i.e. for A UNION B UNION C UNION D ...
-        for (let i = 1; i < query.SET.args.length; i++)
-          result += `\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} ${renderQuery(query.SET.args[i], false, 'view', env, path.concat([ 'SET', 'args', i ]), elements)}`;
-      }
-      result += ')';
-      // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
-      // each SELECT)
-      if (query.SET.orderBy)
-        result += `${continueIndent(result, env)}order by ${query.SET.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
-
-      if (query.SET.limit)
-        result += `${continueIndent(result, env)}${renderLimit(query.SET.limit, env)}`;
-
-      return result;
+      // Set operator, such as UNION, INTERSECT, or EXCEPT...
+      return renderQuerySet();
     }
-    // Otherwise must have a SELECT
     else if (!query.SELECT) {
+      // ...otherwise must have a SELECT
       throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
     }
+
+    let result = '';
     const select = query.SELECT;
     const childEnv = increaseIndent(env);
 
-    if (syntax === 'projection')
-      result += `projection on ${renderViewSource(select.from, env)}`;
-    else if (syntax === 'view' || syntax === 'entity')
-      result += `select from ${renderViewSource(select.from, env)}`;
-    else
-      throw new ModelError(`Unknown query syntax: ${syntax}`);
+    // If not a projection, must be view/entity.
+    result += (syntax === 'projection') ? 'projection on ' : 'select from ';
+    result += renderViewSource(select.from, env);
 
     if (select.mixin) {
       let elems = '';
-      for (const name in select.mixin) {
-        if (!select.mixin[name]._ignore)
-          elems += renderElement(name, select.mixin[name], childEnv);
-      }
+      forEach(select.mixin, (name, mixin) => {
+        elems += renderElement(name, mixin, childEnv);
+      });
       if (elems) {
         result += ' mixin {\n';
         result += elems;
@@ -826,13 +901,12 @@ function toCdsSourceCsn(csn, options) {
     result += select.distinct ? ' distinct' : '';
     if (select.columns) {
       result += ' {\n';
-      result += `${select.columns.map(col => renderViewColumn(col, childEnv, findElement(elements, col)))
-        .filter(s => s !== '')
-        .join(',\n')}\n`;
+      result += renderViewColumns(select.columns, increaseIndent(env), elements);
       result += `${env.indent}}`;
     }
+
     if (select.excluding) {
-      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${quoteOrUppercaseId(id)}`).join(',\n')}\n`;
+      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${quoteIdIfRequired(id)}`).join(',\n')}\n`;
       result += `${env.indent}}`;
     }
     // FIXME: Currently, only projections can have actions and functions, but we cannot distinguish
@@ -874,7 +948,7 @@ function toCdsSourceCsn(csn, options) {
     }
 
     /**
-     * Render a query's LIMIT clause, which may have also have OFFSET.
+     * Render a query's LIMIT clause, which may also have OFFSET.
      *
      * @param {CSN.QueryLimit} limit
      * @param {CdlRenderEnvironment} limitEnv
@@ -890,6 +964,29 @@ function toCdsSourceCsn(csn, options) {
 
       return limitStr;
     }
+
+    /**
+     * Render UNION, INTERSECT, and EXCEPT, i.e. sets.
+     *
+     * @return {string}
+     */
+    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);
+        return `(${subQuery})`;
+      });
+
+      let setResult = subQueries.join(`\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} `);
+      // 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(', ')}`;
+
+      if (query.SET.limit)
+        setResult += `${continueIndent(setResult, env)}${renderLimit(query.SET.limit, env)}`;
+      return setResult;
+    }
   }
 
   /**
@@ -901,7 +998,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderDocComment(entry, env) + renderExpr(entry, env, true, false, true);
+    let result = renderAnnotationAssignmentsAndDocComment(entry, env) + renderExpr(entry, env, true, false, true);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -925,7 +1022,7 @@ function toCdsSourceCsn(csn, options) {
     let result = '';
     const childEnv = increaseIndent(env);
     for (const name in art.actions)
-      result += renderDocComment(art.actions[name], childEnv) + renderActionOrFunction(name, art.actions[name], childEnv);
+      result += renderActionOrFunction(name, art.actions[name], envAddPath(childEnv, [ 'actions', name ]));
 
     // Even if we have seen actions/functions, they might all have been ignored
     if (result !== '')
@@ -943,14 +1040,13 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderActionOrFunction(actionName, act, env) {
-    let result = `${renderDocComment(act, env) + renderAnnotationAssignments(act, env) + env.indent + act.kind} ${renderArtifactName(actionName)}`;
+    let result = `${renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind} ${renderArtifactName(actionName)}`;
     const childEnv = increaseIndent(env);
     const parameters = Object.keys(act.params || []).map(name => renderParameter(name, act.params[name], childEnv)).join(',\n');
     result += (parameters === '') ? '()' : `(\n${parameters}\n${env.indent})`;
     if (act.returns) {
-      if (act.returns.type && act.returns.elements) // action returns annotations
-        subelementAnnotates.push([ actionName, act.returns, '', 'returns' ]);
-      result += ` returns ${renderTypeReference(act.returns, env)}${renderNullability(act.returns)}`;
+      const actEnv = envAddPath(env, [ 'returns' ]);
+      result += ` returns ${renderTypeReferenceAndProps(act.returns, actEnv)}`;
     }
 
     result += ';\n';
@@ -966,11 +1062,9 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderParameter(parName, par, env) {
-    let result = `${renderDocComment(par, env) + renderAnnotationAssignments(par, env) + env.indent + quoteOrUppercaseId(parName)} : ${renderTypeReference(par, env)}`;
-    if (par.default)
-      result += ` default ${renderExpr(par.default, env)}`;
-
-    result += renderNullability(par);
+    env = envAddPath(env, [ 'params', parName ]);
+    let result = `${renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
+    result += `${quoteIdIfRequired(parName)} : ${renderTypeReferenceAndProps(par, env)}`;
     return result;
   }
 
@@ -981,102 +1075,87 @@ function toCdsSourceCsn(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. Only in toCdl mode
+   * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind. Only in toCdl mode
    * @return {string}
    */
   function renderTypeOrAnnotation(artifactName, art, env, artType) {
-    if (!options.toCdl && art.kind === 'aspect')
-      return '';
-    let result = renderDocComment(art, env) + renderAnnotationAssignments(art, env);
-    result += `${env.indent + (options.toCdl && (artType || art.$syntax) || art.kind )} ${renderArtifactName(artifactName)}`;
-    if (art.includes) {
-      // Includes are never flattened (don't exist in HANA)
-      result += ` : ${art.includes.map(name => renderAbsoluteNameWithQuotes(name)).join(', ')}`;
-    }
-    const childEnv = increaseIndent(env);
-    if (art.elements && !art.type) {
-      // Structured type or annotation with anonymous struct type
-      result += ' {\n';
-      for (const name in art.elements)
-        result += renderElement(name, art.elements[name], childEnv);
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName)}`;
+    if (art.includes)
+      result += renderIncludes(art.includes);
 
-      result += `${env.indent}};\n`;
-    }
-    else {
-      // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env, false)}`;
-      if (art.default)
-        result += ` default ${renderExpr(art.default, env)}`;
-      result += ';\n';
-    }
+    if (!art.type && art.elements) // For nicer output, no colon if unnamed structure is used.
+      result += ` ${renderTypeReferenceAndProps(art, env)};\n`;
+    else
+      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
     return result;
   }
 
   /**
-   * Render a reference to a type used by 'elm' (named or inline)
-   * Allow suppressing enum-rendering - used in columns for example
+   * Render a reference to a type used by 'artifact' (named or inline) and (element) properties
+   * such as `not null` and `default <xpr>`.
+   * Allow suppressing rendering of structs such as enums - used in columns for example.
    *
-   * @param {CSN.Element} elm
+   * @param {object} artifact
    * @param {CdlRenderEnvironment} env
-   * @param {boolean} [noEnum=false]
+   * @param {object} [config={}] - `typeRefOnly`   Whether to only render type defs, no arrayed/structured/enum.
+   *                             - `noAnnoCollect` Do not collect annotations of sub-elements.
    * @return {string}
    */
-  function renderTypeReference(elm, env, noEnum = false) {
+  function renderTypeReferenceAndProps(artifact, env, config = {}) {
     let result = '';
-
-    // Array type: Render items instead
-    if (elm.items && !elm.type) {
-      // HANA CDS does not support keyword many
-      let rc = `many ${renderTypeReference(elm.items, env)}`;
-      if (elm.items.notNull != null)
-        rc += elm.items.notNull ? ' not null' : ' null';
-      // many sub element annotates
-      if (elm.items.type && elm.items.elements && env.artifactName)
-        subelementAnnotates.push([ env.artifactName, elm.items, env.elementName ]);
-
-      return rc;
+    const { typeRefOnly, noAnnoCollect } = config;
+    let isTypeDef = env.path?.length === 2; // e.g [ 'definitions', typeDef ];
+
+    if (typeRefOnly && !artifact.type)
+      throw new ModelError(`Expected artifact to have a type; in: ${env.artifactName}`);
+
+    if (artifact.localized) // works even for type definitions
+      result += 'localized ';
+
+    if (!artifact.type && artifact.items) {
+      result += 'many '; // alternative: 'array of'; but not used
+      artifact = artifact.items;
+      env = envAddPath(env, 'items');
+      // element keywords allowed in MANY case; was an oversight when arrays were introduced.
+      isTypeDef = false;
+      // "many many" does not work in CDL, so we don't check for it.
     }
 
-    // FIXME: Is this a type attribute?
-    result += (elm.localized ? 'localized ' : '');
-
-    // Anonymous structured type
-    if (!elm.type) {
-      if (!elm.elements)
-        throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
-
+    if (!artifact.type && artifact.elements) {
       result += '{\n';
-      const childEnv = increaseIndent(env);
-      for (const name in elm.elements)
-        result += renderElement(name, elm.elements[name], childEnv, null);
+      const childEnv = envAddPath(increaseIndent(env), 'items');
+      for (const name in artifact.elements)
+        result += renderElement(name, artifact.elements[name], childEnv, null);
 
       result += `${env.indent}}`;
+      if (!isTypeDef)
+        result += renderNullability(artifact);
+      // structured default not possible at the moment
       return result;
     }
 
-    const comp = 'cds.Composition';
     // Association type
-    if ([ 'cds.Association', comp ].includes(elm.type)) {
+    if (artifact.type === 'cds.Association' || artifact.type === 'cds.Composition') {
+      const isComp = artifact.type === 'cds.Composition';
       // Type, cardinality and target; CAPire uses CamelCase
-      result += (elm.type === comp) ? 'Composition' : 'Association';
-
-      if (isSimpleCardinality(elm.cardinality)) {
-        result += renderSimpleCardinality(elm);
-      }
-      else {
-        result += renderCardinality(elm.cardinality) +
-          ((elm.type === comp) ? ' of ' : ' to ');
-      }
-
-      // normal target or named aspect
-      if (elm.target || elm.targetAspect && typeof elm.targetAspect === 'string') {
-        result += renderAbsolutePath({ ref: [ elm.target || elm.targetAspect ] }, env);
+      result += isComp ? 'Composition' : 'Association';
+      result += renderCardinality(artifact);
+
+      // `targetAspect` may be set by the core compiler and refers to the original named or unnamed aspect.
+      // 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;
+      if (typeof artifact.target === 'string' || typeof artifact.targetAspect === 'string') {
+        result += renderAbsolutePath({ ref: [ artifact.target || artifact.targetAspect ] }, env);
       }
-      else if (elm.targetAspect && elm.targetAspect.elements) { // anonymous aspect
+      else if (elements) {
+        // anonymous aspect, either parseCdl or client CSN.
         const childEnv = increaseIndent(env);
         result += '{\n';
-        for (const name in elm.targetAspect.elements)
-          result += renderElement(name, elm.targetAspect.elements[name], childEnv);
+        for (const name in elements)
+          result += renderElement(name, elements[name], childEnv);
 
         result += `${env.indent}}`;
       }
@@ -1084,65 +1163,94 @@ function toCdsSourceCsn(csn, options) {
         throw new ModelError('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
       }
 
-
       // ON-condition (if any)
-      if (elm.on)
-        result += ` on ${renderExpr(elm.on, env, true, true)}`;
+      if (artifact.on)
+        result += ` on ${renderExpr(artifact.on, env, true, true)}`;
 
 
       // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
-      if (elm.keys && !elm.on)
-        result += ` { ${Object.keys(elm.keys).map(name => renderForeignKey(elm.keys[name], env)).join(', ')} }`;
+      if (artifact.keys && !artifact.on)
+        result += ` { ${Object.keys(artifact.keys).map(name => renderForeignKey(artifact.keys[name], env)).join(', ')} }`;
+
+      if (!isTypeDef && !artifact.on) // unmanaged associations can't be followed by "not null"
+        result += renderNullability(artifact);
+      // DEFAULT not possible here.
 
       return result;
     }
 
-    // Reference to another element
-    if (elm.type.ref) {
-      if (elm.enum) {
-        const source = artifactRef(elm.type);
-        if (!source.enum) {
-          // enum was defined at this element and not at the referenced one
-          result += renderAbsolutePath(elm.type, env) + renderEnum(elm.enum, env);
-        }
-        else {
-          result += renderAbsolutePath(elm.type, env);
-        }
-      }
-      else {
-        result += renderAbsolutePath(elm.type, env);
-      }
-      return result;
+    // At this point, we will render a named type.
+
+    // If we have a type and elements, we may have sub-structure annotates that would
+    // get lost if we only render the type name.
+    // TODO: Can we annotate elements of targetAspect?
+    //       If so, move this block before the composition rendering.
+    if (!noAnnoCollect && (artifact.elements || artifact.items?.elements)) {
+      const annotate = collectAnnotationsOfElements(artifact, env);
+      if (annotate)
+        subelementAnnotates.push(annotate);
     }
 
-    // If we get here, it must be a named type
-    if (isBuiltinType(elm.type)) {
-      result += renderBuiltinType(elm);
+    // Reference to another artifact
+    if (typeof artifact.type === 'string') {
+      // If we get here, it must be a named type
+      result += renderNamedTypeWithParameters(artifact);
     }
-    else {
-      // Simple absolute name
-      // Type names are never flattened (derived types are unraveled in HANA)
-      result += getResultingName(elm.type);
+    else if (artifact.type?.ref) {
+      result += renderAbsolutePath(artifact.type, env);
     }
-    if (elm.enum && !noEnum)
-      result += renderEnum(elm.enum, env);
+
+    if (artifact.enum && !typeRefOnly)
+      result += renderEnum(artifact.enum, env);
+    if (!isTypeDef) // NOT NULL not possible for not-arrayed type definitions
+      result += renderNullability(artifact);
+    if (artifact.default)
+      result += ` default ${renderExpr(artifact.default, env)}`;
 
     return result;
   }
 
   /**
-   * @param {CSN.Element} elm
+   * Render REDIRECTED TO with its keys/on condition for the given artifact.
+   *
+   * @param {object} art
+   * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderBuiltinType(elm) {
-    // If there is a user-defined type with the same short name (cds.Integer -> Integer),
-    // we render the full name, including the leading "cds."
-    if (csn.definitions[elm.type.slice(4)])
-      return elm.type + renderTypeParameters(elm);
+  function renderRedirectedTo(art, env) {
+    let result = `redirected to ${quotePathIfRequired(art.target)}`;
+    if (art.on)
+      result += ` on ${renderExpr(art.on, env, true, true)}`;
+    else if (art.keys)
+      result += ` { ${Object.keys(art.keys).map(name => renderForeignKey(art.keys[name], env)).join(', ')} }`;
+    return result;
+  }
 
-    return elm.type.slice(4) + renderTypeParameters(elm);
+  /**
+   * Render the named type with optional parameters, e.g. `MyString(length: 10)`.
+   * @param {CSN.Artifact} artWithType
+   * @return {string}
+   */
+  function renderNamedTypeWithParameters(artWithType) {
+    let result = '';
+
+    if (isBuiltinType(artWithType.type)) {
+      // If there is a user-defined type with the same short name (cds.Integer -> Integer),
+      // we render the full name, including the leading "cds."
+      if (csn.definitions[artWithType.type.slice(4)])
+        result += artWithType.type;
+      else
+        result += artWithType.type.slice(4);
+    }
+    else {
+      result += renderArtifactName(artWithType.type);
+    }
+
+    result += renderTypeParameters(artWithType);
+    return result;
   }
 
+
   /**
    * Render the 'enum { ... } part of a type declaration
    *
@@ -1153,21 +1261,32 @@ function toCdsSourceCsn(csn, options) {
   function renderEnum(enumPart, env) {
     let result = ' enum {\n';
     const childEnv = increaseIndent(env);
-    for (const name in enumPart) {
-      const enumConst = enumPart[name];
-      result += renderDocComment(enumConst, childEnv);
-      result += renderAnnotationAssignments(enumConst, childEnv);
-      result += childEnv.indent + quoteIdIfRequired(name);
-      if (enumConst.val !== undefined)
-        result += ` = ${renderExpr(enumConst, childEnv)}`;
-      else if (enumConst['#'] !== undefined)
-        result += ` = #${enumConst['#']}`;
-      result += ';\n';
-    }
+    for (const name in enumPart)
+      result += renderEnumElement(name, enumPart[name], childEnv);
     result += `${env.indent}}`;
     return result;
   }
 
+  /**
+   * Render the element of a `<type> enum {}` structure.
+   *
+   * @param {string} name
+   * @param {CSN.EnumValue} enumValue
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderEnumElement(name, enumValue, env) {
+    let result = '';
+    result += renderAnnotationAssignmentsAndDocComment(enumValue, env);
+    result += env.indent + quoteIdIfRequired(name);
+    if (enumValue.val !== undefined)
+      result += ` = ${renderExpr(enumValue, env)}`;
+    else if (enumValue['#'] !== undefined)
+      result += ` = #${enumValue['#']}`;
+    result += ';\n';
+    return result;
+  }
+
   /**
    * Render an annotation value (somewhat like a simplified expression, with slightly different
    * representation)
@@ -1177,23 +1296,35 @@ function toCdsSourceCsn(csn, options) {
    */
   function renderAnnotationValue(x, env) {
     if (Array.isArray(x)) {
-      // Render array parts as values
-      return `[${x.map(item => renderAnnotationValue(item, env)).join(', ')}]`;
+      // Render array parts as values. Spaces required if last array value is
+      // a delimited identifier.
+      return `[ ${x.map(item => renderAnnotationValue(item, env)).join(', ')} ]`;
     }
     else if (typeof x === 'object' && x !== null) {
       // Enum symbol
-      if (x['#'])
+      if (x['#']) {
         return `#${x['#']}`;
-
+      }
       // Shorthand for absolute path (as string)
-      else if (x['='])
-        return quotePathString(x['=']);
-
-      // Struct value (can actually only occur within an array)
+      else if (x['=']) {
+        return quotePathIfRequired(x['=']);
+      }
+      // Shorthand for ellipsis: `... up to <val>`
+      else if (x['...']) {
+        if (x['...'] === true)
+          return '...';
+        return `... up to ${renderAnnotationValue(x['...'], env)}`;
+      }
 
-      // Note that we have to quote the struct keys here manually and not use quoteIdIfRequired, because they may even contain dots (yuc!)
-      // FIXME: Should that really be allowed?
-      return `{${Object.keys(x).map(key => `![${key}]: ${renderAnnotationValue(x[key], env)}`).join(', ')}}`;
+      // Struct value (can currently only occur within an array)
+      // 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(x);
+      const childEnv = keys.length <= 1 ? env : increaseIndent(env);
+      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key)}: ${renderAnnotationValue(x[key], childEnv)}`);
+      if (values.length <= 1)
+        return `{ ${values.join(', ')} }`;
+      return `{\n${childEnv.indent}${values.join(`,\n${childEnv.indent}`)}\n${env.indent}}`;
     }
     // Null
     else if (x === null) {
@@ -1206,172 +1337,54 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * Render an expression (including paths and values) or condition 'x'.
-   * (no trailing LF, don't indent if inline)
+   * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
    *
-   * @param {any} x
-   * @param {CdlRenderEnvironment} env
-   * @param {boolean} [inline=true]
-   * @param {boolean} [inExpr=false] Whether the expression is already inside another expression
-   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `inExpr === false`
-   *                                           Note: This is a hack for casts() inside groupBy.
+   * @param {string|object} s
+   * @param {number} idx
+   * @returns {string}
    */
-  function renderExpr(x, env, inline = true, inExpr = false, alwaysRenderCast = false) {
-    // Compound expression
-    if (Array.isArray(x))
-      return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
-
-    if (typeof x === 'object' && x !== null) {
-      if ((inExpr || alwaysRenderCast) && x.cast && x.cast.type)
-        return renderExplicitTypeCast(renderExprObject());
-      return renderExprObject();
-    }
-
-    // Not a literal value but part of an operator, function etc - just leave as it is
-    return x;
+  function renderPathStep(s, idx, inline, env) {
+    // Simple id or absolute name
+    if (typeof s === 'string') {
+      // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
+      // FIXME: We should rather explicitly recognize quoting somehow
 
+      if (idx === 0 &&
+              s.startsWith('$'))
+        return s;
 
-    /**
-     * Various special cases represented as objects
-     *
-     * @returns {string}
-     */
-    function renderExprObject() {
-      if (x.list) {
-        // set "inExpr" to false: treat list elements as new expressions
-        return `(${x.list.map(item => renderExpr(item, env, inline, false)).join(', ')})`;
-      }
-      else if (x.val !== undefined) {
-        // Literal value, possibly with explicit 'literal' property
-        switch (x.literal || typeof x.val) {
-          case 'number':
-          case 'boolean':
-          case 'null':
-            return x.val;
-          case 'x':
-          case 'date':
-          case 'time':
-          case 'timestamp':
-            return `${x.literal}'${x.val}'`;
-          case 'string':
-            return renderString(x.val, env);
-          case 'object':
-            if (x.val === null)
-              return 'null';
-
-            // otherwise fall through to
-          default:
-            throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
-        }
-      }
-      // Enum symbol
-      else if (x['#']) {
-        return `#${x['#']}`;
-      }
-      // Reference: Array of path steps, possibly preceded by ':'
-      else if (x.ref) {
-        // FIXME: no extra magic with x.param or x.global
-        return `${(x.param || x.global) ? ':' : ''}${x.ref.map(renderPathStep).join('.')}`;
-      }
-      else if (x.xpr && x.func) {
-        // window function
-        const funcDef = renderFunc( x.func, x, null, a => renderArgs(a, '=>', env) );
-        const windowFunctionOperator = x.xpr.shift(); // OVER ...
-        return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
-      }
-      // Function call, possibly with args (use '=>' for named args)
-      else if (x.func) {
-        // test for non-regular HANA identifier that needs to be quoted
-        // identifier                  {letter}({letter_or_digit}|[#$])*
-        // letter                      [A-Za-z_]
-        // letter_or_digit             [A-Za-z_0-9]
-
-        const regex = RegExp(/^[a-zA-Z][\w#$]*$/, 'g');
-        const funcName = regex.test(x.func) ? x.func : quoteIdIfRequired(x.func);
-        return renderFunc( funcName, x, 'cap', a => renderArgs(a, '=>', env) );
-      }
-      // Nested expression
-      else if (x.xpr) {
-        // Ensure `exists` is always enclosed by parentheses
-        if ((inExpr && !x.cast ) || x.xpr.some(s => s === 'exists'))
-          return `(${renderExpr(x.xpr, env, inline, true)})`;
-
-        return renderExpr(x.xpr, env, inline, true);
-      }
-      // Sub-select
-      else if (x.SELECT) {
-        // renderQuery for SELECT does not bring its own parentheses (because it is also used in renderView)
-        return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
-      }
-      else if (x.SET) {
-        // renderQuery for SET always brings its own parentheses (because it is also used in renderViewSource)
-        return `${renderQuery(x, false, 'view', increaseIndent(env))}`;
-      }
-      else {
-        throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
-      }
+      return quoteIdIfRequired(s);
     }
-
-    /**
-     * Renders an explicit `cast()` inside an 'xpr'.
-     * @param {string} value
-     * @returns {string}
-     */
-    function renderExplicitTypeCast(value) {
-      const typeRef = renderTypeReference(x.cast, env, true);
-      return `cast(${value} as ${typeRef})`;
-    }
-
-    /**
-     * Render a single path step 's' at path position 'idx', which can have filters or parameters or be a function
-     *
-     * @param {string|object} s
-     * @param {number} idx
-     * @returns {string}
-     */
-    function renderPathStep(s, idx) {
-      // Simple id or absolute name
-      if (typeof s === 'string') {
-        // In first path position, do not quote $projection and magic $-variables like CURRENT_DATE, $now etc.
-        // FIXME: We should rather explicitly recognize quoting somehow
-
-        if (idx === 0 &&
-            s.startsWith('$'))
-          return s;
-
-        return quoteOrUppercaseId(s);
+    // ID with filters or parameters
+    else if (typeof s === 'object') {
+      // Sanity check
+      if (!s.func && !s.id)
+        throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
+
+      // Not really a path step but an object-like function call
+      if (s.func)
+        return `${s.func}(${renderArgs(s, '=>', env)})`;
+
+      // Path step, possibly with view parameters and/or filters
+      let result = `${quoteIdIfRequired(s.id)}`;
+      if (s.args) {
+        // View parameters
+        result += `(${renderArgs(s, ':', env)})`;
       }
-      // ID with filters or parameters
-      else if (typeof s === 'object') {
-        // Sanity check
-        if (!s.func && !s.id)
-          throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
-
-        // Not really a path step but an object-like function call
-        if (s.func)
-          return `${s.func}(${renderArgs(s, '=>', env)})`;
-
-        // Path step, possibly with view parameters and/or filters
-        let result = `${quoteOrUppercaseId(s.id)}`;
-        if (s.args) {
-          // View parameters
-          result += `(${renderArgs(s, ':', env)})`;
-        }
-        if (s.where) {
-          // Filter, possibly with cardinality
-          result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
-        }
-
-        return result;
+      if (s.where) {
+        // Filter, possibly with cardinality
+        result += `[${s.cardinality ? (`${s.cardinality.max}: `) : ''}${renderExpr(s.where, env, inline, true)}]`;
       }
 
-      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+      return result;
     }
+
+    throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
   }
 
   /**
    * Render function arguments or view parameters (positional if array, named if object/dict),
-   * using 'sep' as separator for positional parameters
+   * using 'sep' as separator for named parameters
    *
    * @param {object} node with `args` to render
    * @param {string} sep
@@ -1379,28 +1392,65 @@ function toCdsSourceCsn(csn, options) {
    * @returns {string}
    */
   function renderArgs(node, sep, env) {
-    const args = node.args ? node.args : {};
+    const args = node.args || [];
+
     // Positional arguments
-    if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env, true, false, true)).join(', ');
+    if (Array.isArray(args)) {
+      const func = node.func?.toUpperCase();
+      if (func)
+        return args.map((arg, i) => renderArgument(arg, env, getKeywordsForSpecialFunctionArgument(func, i))).join(', ');
 
-    // Named arguments (object/dict)
-    else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${quoteOrUppercaseId(key)} ${sep} ${renderExpr(args[key], env, true, false, true)}`).join(', ');
+      return args.map(arg => renderArgument(arg, env)).join(', ');
+    }
 
+    // Named arguments (object/dict)
+    else if (typeof args === 'object') {
+      return Object.keys(args).map(key => `${quoteIdIfRequired(key)} ${sep} ${renderArgument(args[key], env)}`).join(', ');
+    }
 
     throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
   }
 
+  /**
+   * Render a function argument, e.g. for generic functions or CAST().
+   * Ensures that parentheses are used if necessary, e.g. for `someFct( (1=1), (1=1) )`.
+   *
+   * @param {any} arg
+   * @param {CdlRenderEnvironment} env
+   * @param {string[]} additionalAllowedKeywords
+   * @return {string}
+   */
+  function renderArgument(arg, env, additionalAllowedKeywords = []) {
+    // If the argument is a xpr with e.g. `=`, it may require parentheses.
+    // For nested xpr, `renderExpr()` will already add parentheses.
+    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalAllowedKeywords), true);
+  }
+
+  /**
+   * Render an artifact's cardinality.
+   *
+   * @param artifact
+   * @returns {string}
+   */
+  function renderCardinality(artifact) {
+    if (isSimpleCardinality(artifact.cardinality))
+      return renderSimpleCardinality(artifact);
+    return renderBracketCardinality(artifact);
+  }
+
   /**
    * Render a cardinality (only those parts that were actually provided)
    *
-   * @param {CSN.Cardinality} card
+   * @param {CSN.Artifact} art
    * @return {string}
    */
-  function renderCardinality(card) {
+  function renderBracketCardinality(art) {
+    const isComp = art.type === 'cds.Composition';
+    const suffix = (isComp ? ' of ' : ' to ');
+    const card = art.cardinality;
+
     if (!card)
-      return '';
+      return suffix;
 
     let result = '[';
     if (card.src !== undefined)
@@ -1412,7 +1462,7 @@ function toCdsSourceCsn(csn, options) {
     if (card.max !== undefined)
       result += card.max;
 
-    return `${result}]`;
+    return `${result}]${suffix}`;
   }
 
   /**
@@ -1470,28 +1520,29 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * Render (primitive) type parameters of element 'elm', i.e.
+   * Render (primitive) type parameters of artifact 'artWithType', i.e.
    * length, precision and scale (even if incomplete), plus any other unknown ones.
    *
-   * @param {CSN.Element} elm
+   * @param {CSN.Artifact} artWithType
    * @returns {string}
    */
-  function renderTypeParameters(elm /* , env */) {
-    const params = [];
-    // Length, precision and scale (even if incomplete)
-    if (elm.length !== undefined)
-      params.push(elm.length);
-
-    if (elm.precision !== undefined)
-      params.push(elm.precision);
+  function renderTypeParameters(artWithType) {
+    const params = typeParameters.list.filter(param => artWithType[param] !== undefined);
+    if (params.length === 0)
+      return '';
 
-    if (elm.scale !== undefined)
-      params.push(elm.scale);
+    // Special cases for 1 or 2 arguments.
+    if (params.length === 1 && artWithType.length !== undefined)
+      return `(${artWithType.length})`;
+    if (params.length === 2 && artWithType.precision !== undefined && artWithType.scale !== undefined)
+      return `(${artWithType.precision}, ${artWithType.scale})`;
 
-    if (elm.srid !== undefined)
-      params.push(elm.srid);
+    // Render named params
+    const renderedParams = [];
+    for (const param of params)
+      renderedParams.push(`${param}: ${artWithType[param]}`);
 
-    return params.length === 0 ? '' : `(${params.join(', ')})`;
+    return `(${renderedParams.join(', ')})`;
   }
 
   /**
@@ -1499,13 +1550,14 @@ function toCdsSourceCsn(csn, options) {
    *
    * @param {object} obj Object that has annotations
    * @param {CdlRenderEnvironment} env
+   * @param {{parens: boolean}} [config] Config for renderAnnotationAssignment()
    * @return {string}
    */
-  function renderAnnotationAssignments(obj, env) {
-    let result = '';
+  function renderAnnotationAssignmentsAndDocComment(obj, env, config) {
+    let result = renderDocComment(obj, env);
     for (const name in obj) {
       if (name.startsWith('@'))
-        result += renderAnnotationAssignment(obj[name], name, env);
+        result += renderAnnotationAssignment(obj[name], name, env, config);
     }
     return result;
   }
@@ -1518,208 +1570,324 @@ function toCdsSourceCsn(csn, options) {
    * @param {any} anno Annotation value
    * @param {string} name Annotation name, e.g. `@A.B.C#foo.C`
    * @param {CdlRenderEnvironment} env
+   * @param {object} [config] parens: Whether the annotation assignment must be surrounded by parentheses.
    * @return {string} Rendered annotation, possibly quoted: `@![A.B.C#foo.C]: value`
    */
-  function renderAnnotationAssignment(anno, name, env) {
+  function renderAnnotationAssignment(anno, name, env, config = { parens: false }) {
     name = name.substring(1);
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
     const nameBeforeVariant = parts[0];
     const variant = parts[1];
+    const { parens } = config;
 
     // Identifier according to our grammar: /[$_a-zA-Z][$_a-zA-Z0-9]*/
     // We expand this pattern to also include dots after the first character.
     // If the annotation does not follow this pattern `ident(.@ident)*`, it must be quoted:
     // `@identifier@identifier` must be quoted but `@identifier.@identifier` should not.
+    // TODO: Use quoteAnnotationPathIfRequired()
     const annoRequiresQuoting = !/^[$_a-zA-Z][$_a-zA-Z0-9.]*(?:\.@[$_a-zA-Z][$_a-zA-Z0-9.]*)*$/.test(nameBeforeVariant);
     // Unfortunately, the compiler does not allow `.` after the first variant identifier,
     // even though that is the result after flattening.
     const variantRequiresQuoting = variant && !/^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(variant);
 
-    let result;
+    let result = `${env.indent}@`;
+    if (parens)
+      result += '(';
+
     if (annoRequiresQuoting || variantRequiresQuoting)
-      result = `${env.indent}@${quote(name)}`;
+      result += quote(name);
     else
-      result = `${env.indent}@${name}`;
+      result += name;
 
     result += ` : ${renderAnnotationValue(anno, env)}`;
+    if (parens)
+      result += ')';
     return `${result}\n`;
   }
 
   /**
-   * Render an absolute name 'absName', with appropriate quotes. Also record the
-   * fact that 'absName' is used in 'env', so that an appropriate USING can be constructed
-   * if necessary.
-   *
-   * @param {string} absName
-   * @return {string}
-   */
-  function renderAbsoluteNameWithQuotes(absName) {
-    return absName;
-  }
-
-  /**
-   * Returns a newly created default environment (which keeps track of indentation, required USING
-   * declarations and name prefixes.
+   * Render the name of an artifact, quote path steps if necessary.
    *
-   * @return {CdlRenderEnvironment}
+   * @param {string} artifactName Artifact name to render
+   * @return {string} Artifact name ready for rendering
    */
-  function createEnv() {
-    return {
-      // Current indentation string
-      indent: '',
-      // Dictionary of aliases for used artifact names, each entry like 'name' : { quotedName, quotedAlias }
-      topLevelAliases: Object.create(null),
-      // Current name prefix (including trailing dot if not empty)
-      namePrefix: '',
-      artifactName: null,
-      elementName: null,
-    };
+  function renderArtifactName(artifactName) {
+    return quotePathIfRequired(artifactName);
   }
 
   /**
-   * Returns a copy of 'env' with increased indentation (and resetted name prefix)
+   * Render a function expression.
    *
+   * @param {object} obj Object with .func and optionally .args
    * @param {CdlRenderEnvironment} env
-   * @returns {CdlRenderEnvironment}
+   * @returns {string}
    */
-  function increaseIndent(env) {
-    return Object.assign({}, env, { namePrefix: '', indent: `${env.indent}  ` });
+  function renderFuncExpr( obj, env ) {
+    if (keywords.cdl_functions.includes(obj.func.toUpperCase()))
+      return obj.func;
+    const name = identifierRegex.test(obj.func) ? obj.func : quote(obj.func);
+    return `${name}(${renderArgs( obj, '=>', env )})`;
   }
 
   /**
-   * Return a path string 'path' with appropriate "-quotes.
+   * Render an expression.
    *
-   * @param {string} path
+   * @param {any} expr
+   * @param {CdlRenderEnvironment} exprEnv
+   * @param {boolean} [isInline]
+   * @param {boolean} [isNestedExpr]
+   * @param {boolean} [alwaysRenderCast]
    * @returns {string}
    */
-  function quotePathString(path) {
-    // "foo"."bar"."wiz"."blub"
-    return path.split('.').map(quoteIdIfRequired).join('.');
+  function renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast) {
+    if (!_renderExpr) {
+      _renderExpr = getExpressionRenderer({
+        finalize(x) {
+          return x;
+        },
+        explicitTypeCast(x, env) {
+          const typeRef = renderTypeReferenceAndProps(x.cast, env, { typeRefOnly: true, noAnnoCollect: true });
+          const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
+          return `cast(${renderArgument(arg, env)} as ${typeRef})`;
+        },
+        val(x, env) {
+          // Literal value, possibly with explicit 'literal' property
+          switch (x.literal || typeof x.val) {
+            case 'number':
+            case 'boolean':
+            case 'null':
+              return x.val;
+            case 'x':
+            case 'date':
+            case 'time':
+            case 'timestamp':
+              return `${x.literal}'${x.val}'`;
+            case 'string':
+              return renderString(x.val, env);
+            case 'object':
+              if (x.val === null)
+                return 'null';
+            // otherwise fall through to
+            default:
+              throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+          }
+        },
+        aliasOnly(x, _env) {
+          return x.as;
+        },
+        enum(x) {
+          return `#${x['#']}`;
+        },
+        ref(x, env) {
+          const { inline } = this;
+          return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, inline, env)).join('.')}`;
+        },
+        windowFunction(x, env) {
+          const funcDef = renderFuncExpr(x, env);
+          const windowFunctionOperator = x.xpr.shift(); // OVER ...
+          return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
+        },
+        func(x, env) {
+          return renderFuncExpr(x, env);
+        },
+        xpr(x, env) {
+          if (this.nestedExpr && !x.cast || x.xpr.some(s => s === 'exists'))
+            return `(${renderExpr(x.xpr, env, this.inline, true)})`;
+          return renderExpr(x.xpr, env, this.inline, true);
+        },
+        // 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, env) {
+          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
+        },
+        SELECT(x, env) {
+          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
+        },
+      });
+    }
+
+    return _renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast);
   }
+}
 
-  /**
-   * Return an id 'id' with appropriate "-quotes
-   *
-   * @param {string} id
-   * @return {string}
-   */
-  function quoteIdIfRequired(id) {
-    // Quote if required for CDL
-    if (requiresQuotingForCdl(id))
-      return quote(id);
+/**
+ * Returns a newly created default environment (which keeps track of indentation, required USING
+ * declarations and name prefixes.
+ *
+ * @return {CdlRenderEnvironment}
+ */
+function createEnv() {
+  return {
+    // Current indentation string
+    indent: '',
+    path: null,
+    artifactName: '',
+    elementName: '',
+  };
+}
 
-    return id;
-  }
+function envAddPath(env, path) {
+  return Object.assign({}, env, { path: [ ...env.path, ...path ] } );
+}
+function envNewPath(env, path) {
+  return Object.assign({}, env, { path: [ ...path ] } );
+}
 
-  /**
-   * Quotes the identifier using CDL-style ![]-quotes.
-   *
-   * @param id
-   * @returns {string}
-   */
-  function quote(id) {
-    return `![${id.replace(/]/g, ']]')}]`;
-  }
+/**
+ * Returns a copy of 'env' with increased indentation (and reset name prefix)
+ *
+ * @param {CdlRenderEnvironment} env
+ * @returns {CdlRenderEnvironment}
+ */
+function increaseIndent(env) {
+  return Object.assign({}, env, { indent: `${env.indent}  ` });
+}
 
-  /**
-   * Returns true if 'id' requires quotes for CDL, i.e. if 'id'
-   *  1. starts with a digit
-   *  2. contains chars different than:
-   *   - uppercase letters
-   *   - lowercase letters
-   *   - digits
-   *   - underscore
-   *  3. is a CDL keyword or a CDL function without parentheses (CURRENT_*, SYSUUID, ...)
-   *
-   * @param {string} id
-   * @return {boolean}
-   */
-  function requiresQuotingForCdl(id) {
-    return /^\d/.test(id) ||
-        /\W/g.test(id.replace(/\./g, '')) ||
-        keywords.cdl.includes(id.toUpperCase()) ||
-        keywords.cdl_functions.includes(id.toUpperCase());
-  }
+/**
+ * Quote the path steps with `![]` if necessary. For simple ids such as
+ * `elem` use `quoteIdIfRequired` instead.
+ *
+ * @param {string} path
+ * @returns {string}
+ *
+ * @todo For paths such as `E.key`, `key` does not have to be in quotes.
+ */
+function quotePathIfRequired(path) {
+  return path.split('.').map(quoteIdIfRequired).join('.');
+}
 
-  /**
-   * Quote or uppercase an identifier 'id', depending on naming strategy
-   *
-   * @todo Remove: Now part of toHdbcds.js
-   * @param {string} id
-   * @return {string}
-   */
-  function quoteOrUppercaseId(id) {
-    return quoteIdIfRequired(id);
-  }
+/**
+ * Quote the id with `![]` if necessary. For paths such as `E.key` use
+ * `quotePathIfRequired` instead.
+ *
+ * @param {string} id
+ * @return {string}
+ */
+function quoteIdIfRequired(id) {
+  // Quote if required for CDL
+  if (requiresQuotingForCdl(id))
+    return quote(id);
 
-  /**
-   * Render the name of an artifact, using the current name prefix from 'env'
-   * and the real name of the artifact. In case of plain names, this
-   * is equivalent to simply flattening and uppercasing the whole name.
-   *
-   * In cdlMode, the prefix is extended to handle cases like an entity shadowing the prefix
-   * of another entity -> Service.E and Service.E.Sub
-   *
-   * To handle such cases for hdbcds in quoted/hdbcds, we:
-   * - Find the part of the name that is no longer prefix (context/service)
-   * - For Service.E -> E, for Service.E.Sub -> E.Sub
-   * - Replace all dots in this "real name" with underscores
-   * - Join with the env prefix
-   *
-   *
-   * @param {string} artifactName Artifact name to render
-   * @return {string} Artifact name ready for rendering
-   */
-  function renderArtifactName(artifactName) {
-    const realname = getRealName(artifactName);
-    const prefix = (realname !== artifactName) ? artifactName.slice(0, artifactName.length - realname.length - 1) : '';
-    return prefix ? `${quoteIdIfRequired(prefix)}.${realname.split('.').map(quoteIdIfRequired).join('.')}` : realname.split('.').map(quoteIdIfRequired).join('.');
-  }
+  return id;
+}
 
-  /**
-   * Get the name that the artifact definition has been rendered as.
-   * Without quoting/escaping stuff.
-   *
-   * @param {String} artifactName Artifact name to use
-   * @returns {String}
-   */
-  function getResultingName(artifactName) {
-    return renderArtifactName(artifactName);
-  }
+/**
+ * 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 `@${quoteIdIfRequired(segment.slice(1))}`;
+    return quoteIdIfRequired(segment);
+  }).join('.');
+}
 
-  /**
-   * Get the part that is really the name of this artifact and not just prefix caused by a context/service
-   *
-   * @param {String} artifactName Artifact name to use
-   * @returns {String} non-prefix part of the artifact name
-   */
-  function getRealName(artifactName) {
-    const parts = artifactName.split('.');
-    // Length of 1 -> There can be no prefix
-    if (parts.length === 1)
-      return artifactName;
+/**
+ * Quotes the identifier using CDL-style ![]-quotes.
+ *
+ * @param id
+ * @returns {string}
+ */
+function quote(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`
+ * or if 'id' is a reserved keyword.
+ *
+ * @param {string} id
+ * @return {boolean}
+ */
+function requiresQuotingForCdl(id) {
+  return !identifierRegex.test(id) ||
+    keywords.cdl.includes(id.toUpperCase()) ||
+    keywords.cdl_functions.includes(id.toUpperCase());
+}
 
-    let seen = '';
-    for (let i = 0; i < parts.length; i++) {
-      if (seen !== '')
-        seen = `${seen}.${parts[i]}`;
-      else
-        seen = parts[i];
+const functionExpressionOperatorsRequireParentheses = [
+  // Antlr rule 'condition', 'conditionAnd'
+  'and', 'or',
 
+  // Antlr rule 'conditionTerm'
+  '=', '<>', '>', '>=', '<', '<=', '!=',
+  // These are not forbidden, since they must be preceded by one of the comparators above.
+  // 'any', 'some', 'all',
 
-      const art = csn.definitions[seen];
-      if (!art || (art.kind !== 'service' && art.kind !== 'context')) {
-        // We found a case where the prefix ended
-        // Return everything following
-        return parts.slice(i).join('.');
-      }
-    }
+  'is', 'in', 'not', 'null', 'exists',
+  // Antlr rule 'predicate'
+  'between', 'like', 'escape',
+];
 
-    // we seem to have a normal case - just return the last part
-    return getLastPartOf(artifactName);
-  }
+/**
+ * Returns true if the given xpr-array can be rendered without parentheses
+ * 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.
+ * 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,
+ * you can set `additionalAllowedKeywords` to list of tokens that are allowed.
+ *
+ * Note that this is more of a heuristic for "nicer" CDL output.  For example the
+ * following snippet is parsable without parentheses:
+ *   `cast( case when int > 1 then int else 0 end as Integer ),`
+ * However, because it is a flat xpr-array, we see `>` and assume that it is not
+ * a simple expression.
+ *
+ * @param {any[]} xpr
+ * @param {string[]} additionalAllowedKeywords
+ * @return {boolean}
+ */
+function isSimpleFunctionExpression(xpr, additionalAllowedKeywords = []) {
+  return !xpr || xpr.every(val => typeof val !== 'string' ||
+      (additionalAllowedKeywords.includes(val) ||
+        !functionExpressionOperatorsRequireParentheses.includes(val.toLowerCase())));
+}
+
+/**
+ * Special functions may have special parser rules, such as SAP HANA RegEx functions.
+ * They allow certain keywords in their arguments.
+ *
+ * This function is used to determine if arguments need to be put in parentheses or not.
+ * See {@link isSimpleFunctionExpression}.
+ *
+ * @param {string} funcName
+ * @param {number} argumentIndex
+ * @returns {string[]}
+ */
+function getKeywordsForSpecialFunctionArgument(funcName, argumentIndex) {
+  const f = specialFunctions[funcName] && specialFunctions[funcName][argumentIndex];
+  if (!f)
+    return [];
+  const additionalKeywords = [];
+  if (f.intro)
+    additionalKeywords.push(...f.intro);
+  if (f.expr)
+    additionalKeywords.push(...f.expr);
+  if (f.separator)
+    additionalKeywords.push(...f.separator);
+  return additionalKeywords;
+}
+
+/**
+ * @param {string[]} includes
+ * @return {string}
+ */
+function renderIncludes(includes) {
+  return ` : ${includes.map(name => quotePathIfRequired(name)).join(', ')}`;
 }
 
 /**
@@ -1800,17 +1968,9 @@ function isSimpleString(str) {
  * @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 {{[name: string]: {
-      quotedName: string,
-      quotedAlias: string
-    }}} topLevelAliases Dictionary of aliases for used artifact names
- *
- * @property {string} namePrefix Current name prefix (including trailing dot if not empty)
- * @property {boolean} [skipKeys]
- * @property {CSN.Artifact} [_artifact]
+ * @property {string[]} [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
  */
 
-module.exports = { toCdsSourceCsn };
+module.exports = { csnToCdl };