@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/render/toCdl.js

@@ -1,29 +1,26 @@
 '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 { getLastPartOf } = require('../model/csnUtils');
+const { isBuiltinType, generatedByCompilerVersion, getNormalizedQuery } = require('../model/csnUtils');
+const { renderFunc, 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/universalCsnEnricher');
+const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
+const { ModelError } = require('../base/error');
+const { typeParameters } = require('../compiler/builtins');
+const { forEach } = require('../utils/objectUtils');
 
 /**
- * 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).
+ *  - [csn.namespace]: Namespace statement + `using from './model.cds'.
+ *  - `unappliedExtensions`: Annotations / Extensions from the `csn.extensions` array.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} [options]
@@ -31,9 +28,7 @@ const { isBetaEnabled } = require('../base/model');
 function toCdsSourceCsn(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);
@@ -41,177 +36,285 @@ function toCdsSourceCsn(csn, options) {
   checkCSNVersion(csn, options);
 
   const cdlResult = Object.create(null);
+  cdlResult.model = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
+
+  const subelementAnnotates = [];
 
-  const main = 'model';
+  cdlResult.model += renderDefinitions();
+  // sub-element annotations that can't be written directly.
+  cdlResult.model += renderExtensions(subelementAnnotates, createEnv());
 
-  cdlResult[main] = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
+  if (csn.vocabularies)
+    cdlResult.model += renderVocabularies(csn.vocabularies);
 
-  const subelementAnnotates = [];
+  if (csn.namespace) {
+    cdlResult[csn.namespace] = `namespace ${renderArtifactName(csn.namespace)};\n`;
+    cdlResult[csn.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); // Must come first because it populates 'env.topLevelAliases'
-    if (sourceStr !== '')
-      cdlResult[main] += `${sourceStr}\n`;
-  });
+    forEachDefinition(csn, (artifact, artifactName) => {
+      const sourceStr = renderArtifact(artifactName, artifact, env);
+      if (sourceStr !== '')
+        result += `${sourceStr}\n`;
+    });
+    return result;
+  }
+
+  /**
+   * 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;
 
-  // 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`;
+    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 = createEnv();
+        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 ${quoteIdIfRequired(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 = renderUsings('', env) + 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';
     }
@@ -219,6 +322,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.
    *
@@ -233,7 +354,6 @@ function toCdsSourceCsn(csn, options) {
 
     switch (art.kind) {
       case 'entity':
-      case 'view':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
 
@@ -242,8 +362,6 @@ function toCdsSourceCsn(csn, options) {
       case 'context':
       case 'service':
         return renderContext(artifactName, art, env);
-      case 'namespace':
-        return renderNamespace(artifactName, art, env);
       case 'type':
       case 'aspect':
       case 'annotation':
@@ -252,9 +370,9 @@ function toCdsSourceCsn(csn, options) {
       case 'function':
         return renderActionOrFunction(artifactName, art, env);
       case 'event':
-        return renderEventIfCDLMode(artifactName, art, env);
+        return renderEvent(artifactName, art, env);
       default:
-        throw new Error(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -263,15 +381,13 @@ 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 += ' : ';
@@ -294,80 +410,6 @@ function toCdsSourceCsn(csn, options) {
     return result;
   }
 
-  /**
-   * Return a dictionary with the direct sub-artifacts of the artifact with name 'artifactName' in the csn
-   *
-   * @param {string} artifactName
-   * @return {object}
-   */
-  function getSubArtifacts(artifactName) {
-    const prefix = `${artifactName}.`;
-    const result = Object.create(null);
-    for (const name in csn.definitions) {
-      // We have a direct child if its name starts with prefix and contains no more dots
-      if (name.startsWith(prefix) && !name.substring(prefix.length).includes('.')) {
-        result[getLastPartOf(name)] = csn.definitions[name];
-      }
-      else if (name.startsWith(prefix)) {
-        const prefixPlusNextPart = name.substring(0, name.substring(prefix.length).indexOf('.') + prefix.length);
-        if (csn.definitions[prefixPlusNextPart]) {
-          const art = csn.definitions[prefixPlusNextPart];
-          if (![ 'service', 'context', 'namespace' ].includes(art.kind)) {
-            const nameWithoutPrefix = name.substring(prefix.length);
-            result[nameWithoutPrefix] = csn.definitions[name];
-          }
-        }
-        else {
-          result[name.substring(prefix.length)] = csn.definitions[name];
-        }
-      }
-    }
-    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.
    *
@@ -376,44 +418,12 @@ function toCdsSourceCsn(csn, options) {
    * @param {CdlRenderEnvironment} env
    */
   function renderContext(artifactName, art, env) {
-    let result = renderDocComment(art, env) + renderAnnotationAssignments(art, env);
+    let result = renderAnnotationAssignmentsAndDocComment(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(', ')}`;
-    }
-    return `${result} {};\n`;
-  }
+    if (art.includes)
+      result += renderIncludes(art.includes);
 
-  function updatePrefixForDottedName(env, name) {
-    let innerEnv = env;
-    if (name.indexOf('.') !== -1) {
-      const parts = name.split('.');
-      for (let i = 0; i < parts.length - 1; i++)
-        innerEnv = addNamePrefix(innerEnv, parts[i]);
-    }
-
-    return innerEnv;
-  }
-
-  /**
-   * Render a namespace. Return the resulting source string.
-   *
-   * @param {string} artifactName
-   * @param {CSN.Artifact} art
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderNamespace(artifactName, art, env) {
-    // We currently do not render anything for a namespace, we just append its id to
-    // the environment's current name prefix and descend into its children
-    let result = renderDocComment(art, env);
-    const childEnv = addNamePrefix(env, getLastPartOf(artifactName));
-    const subArtifacts = getSubArtifacts(artifactName);
-    for (const name in subArtifacts)
-      result += renderArtifact(`${artifactName}.${name}`, subArtifacts[name], updatePrefixForDottedName(childEnv, name));
-
-    return result;
+    return `${result} {};\n`;
   }
 
   /**
@@ -425,105 +435,37 @@ 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 ]);
+      if (element.type && element.elements) {
+        subelementAnnotates.push({
+          annotate: artifactName,
+          elements: {
+            [name]: {
+              elements: element.elements,
+            },
+          },
+        });
+      }
       result += renderElement(name, element, childEnv);
     }
 
     result += `${env.indent}}`;
-    result += `${renderActionsAndFunctions(art, env) + renderTechnicalConfiguration(art.technicalConfig, env)};\n`;
+    result += `${renderActionsAndFunctions(art, env)};\n`;
     return result;
   }
 
-  // Render the 'technical configuration { ... }' section 'tc' of an entity.
-  // Return the resulting source string.
-  function renderTechnicalConfiguration(tc, env) {
-    let result = renderDocComment(tc, env);
-    const childEnv = increaseIndent(env);
-
-    if (!tc)
-      return result;
-
-
-    // FIXME: How to deal with non-HANA technical configurations? We should probably just iterate all entries
-    // in 'tc' that we find and render them all (is it syntactically allowed yet to have more than one?)
-    tc = tc.hana;
-    if (!tc)
-      throw new Error('Expecting a HANA technical configuration');
-
-    result += `\n${env.indent}technical ${tc.calculated ? '' : 'hana '}configuration {\n`;
-
-    // Store type (must be separate because SQL wants it between 'CREATE' and 'TABLE')
-    if (tc.storeType)
-      result += `${tc.storeType} store;\n`;
-
-    // Fixed parts belonging to the table (includes migration, unload prio, extended storage,
-    // auto merge, partitioning, ...)
-    if (tc.tableSuffix) {
-      // Unlike SQL, CDL and HANA CDS require a semicolon after each table-suffix part
-      // (e.g. `migration enabled; row store; ...`). In order to keep both
-      // the simplicity of "the whole bandwurm is just one expression that can be
-      // rendered to SQL without further knowledge" and at the same time telling
-      // CDS about the boundaries, the compactor has put each part into its own `xpr`
-      // object. Semantically equivalent because a "trivial" SQL renderer would just
-      // concatenate them.
-      for (const xpr of tc.tableSuffix)
-        result += `${childEnv.indent + renderExpr(xpr, childEnv)};\n`;
-    }
-
-    // Indices and full-text indices
-    for (const idxName in tc.indexes || {}) {
-      if (Array.isArray(tc.indexes[idxName][0])) {
-        // FIXME: Should we allow multiple indices with the same name at all?
-        for (const index of tc.indexes[idxName])
-          result += `${childEnv.indent + renderExpr(index, childEnv)};\n`;
-      }
-      else {
-        result += `${childEnv.indent + renderExpr(tc.indexes[idxName], childEnv)};\n`;
-      }
-    }
-    // Fuzzy search indices
-    for (const columnName in tc.fzindexes || {}) {
-      if (Array.isArray(tc.fzindexes[columnName][0])) {
-        // FIXME: Should we allow multiple fuzzy search indices on the same column at all?
-        // And if not, why do we wrap this into an array?
-        for (const index of tc.fzindexes[columnName])
-          result += `${childEnv.indent + renderExpr(fixFuzzyIndex(index, columnName), childEnv)};\n`;
-      }
-      else {
-        result += `${childEnv.indent + renderExpr(fixFuzzyIndex(tc.fzindexes[columnName], columnName), childEnv)};\n`;
-      }
-    }
-    result += `${env.indent}}`;
-    return result;
-
-    // Fuzzy indices are stored in compact CSN as they would appear in SQL after the column name,
-    // i.e. the whole line in SQL looks somewhat like this:
-    //   s nvarchar(10) FUZZY SEARCH INDEX ON FUZZY SEARCH MODE 'ALPHANUM'
-    // But in CDL, we don't write fuzzy search indices together with the table column, so we need
-    // to insert the name of the column after 'ON' in CDS syntax, making it look like this:
-    //   fuzzy search mode on (s) search mode 'ALPHANUM'
-    // This function expects an array with the original expression and returns an array with the modified expression
-    function fixFuzzyIndex(fuzzyIndex, columnName) {
-      return fuzzyIndex.map(token => (token === 'on' ? { xpr: [ 'on', '(', { ref: columnName.split('.') }, ')' ] } : token));
-    }
-  }
-
   /**
    * Render an element (of an entity, type or annotation, not a projection or view).
    * Return the resulting source string.
@@ -535,8 +477,8 @@ function toCdsSourceCsn(csn, options) {
    */
   function renderElement(elementName, elm, env, isSubElement) {
     env.elementName = elementName;
-    let result = renderDocComment(elm, env) + renderAnnotationAssignments(elm, env);
-    const quotedElementName = quoteOrUppercaseId(elementName);
+    let result = renderAnnotationAssignmentsAndDocComment(elm, env);
+    const quotedElementName = quoteIdIfRequired(elementName);
     result += `${env.indent + (elm.virtual ? 'virtual ' : '') +
                          (elm.key && !isSubElement ? 'key ' : '') +
                          ((elm.masked && !elm._ignoreMasked) ? 'masked ' : '') +
@@ -550,22 +492,6 @@ function toCdsSourceCsn(csn, options) {
     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 Error(`Expecting set with args in query: ${JSON.stringify(query)}`);
-
-    return leadingQuerySelect(query.SET.args[0]);
-  }
-
   /**
    * Render a query's actions and functions (if any) separately as extend-statements, so that actions
    * work not only for projections but also for views, which have no syntax (yet) to directly specify
@@ -589,9 +515,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
@@ -599,43 +529,61 @@ 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;
-    }
-    // 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 = renderAnnotationValue(elem[name], childEnv);
-        // Skip annotation if column has the same
-        if (columnMap[elemName] && columnMap[elemName][name] &&
-            renderAnnotationValue(columnMap[elemName][name], childEnv) === annotationValue)
-          continue;
-
-        // Annotation names are never flattened
-        elemAnnotations += `${childEnv.indent}${`@${renderAbsoluteNameWithQuotes(name.substring(1))}`} : ${annotationValue}\n`;
-      }
-      if (elemAnnotations !== '')
-        result += `${elemAnnotations}${childEnv.indent}${quoteOrUppercaseId(elemName)};\n`;
-    }
-    if (result !== '')
-      result = `${env.indent}annotate ${renderArtifactName(artifactName)} with {\n${result}${env.indent}};\n`;
+    const annotate = collectAnnotationsOfElements(artifactName, art);
+    if (annotate)
+      return renderExtensions([ annotate ], env);
+    return '';
+  }
 
-    return result;
+  /**
+   * Create an "annotate" statement as a CSN extension for all annotations of (sub-)elements.
+   * If no annotation was found, we return `null`.
+   *
+   * @param {string} artifactName
+   * @param {CSN.Artifact} artWithElements
+   * @return {CSN.Extension|null}
+   */
+  function collectAnnotationsOfElements(artifactName, artWithElements) {
+    const annotate = { annotate: artifactName };
+    return collectAnnos(annotate, artWithElements) ? annotate : null;
+
+    /**
+     * 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;
+    }
   }
 
   /**
@@ -650,25 +598,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
@@ -703,15 +650,14 @@ function toCdsSourceCsn(csn, options) {
   function renderAbsolutePath(path, env) {
     // Sanity checks
     if (!path.ref)
-      throw new Error(`Expecting ref in path: ${JSON.stringify(path)}`);
+      throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
 
 
     // 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)
@@ -742,11 +688,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.
@@ -758,7 +719,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
@@ -769,22 +737,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 {
+      if (col.cast.target && !col.cast.type)
+        result += ` : ${renderRedirectedTo(col.cast, env)}`;
+      else
         result += ` : ${renderTypeReference(col.cast, env, true)}`;
-      }
     }
     return result;
   }
@@ -813,16 +778,10 @@ function toCdsSourceCsn(csn, options) {
 
       // We found a leaf - no further drilling
       if (!obj.inline && !obj.expand) {
-        if (obj.cast && obj.cast.type) {
+        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(', ')} }`;
-        }
+        else if (obj.cast && obj.cast.target) // test tbd
+          result += ` : ${renderRedirectedTo(obj.cast, env)}`;
         return result;
       }
 
@@ -857,7 +816,7 @@ function toCdsSourceCsn(csn, options) {
    * 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) {
@@ -866,7 +825,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`;
   }
 
   /**
@@ -880,7 +845,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);
@@ -909,50 +874,31 @@ function toCdsSourceCsn(csn, options) {
    * @param {string} syntax The query syntax, either "projection", "entity" or "view"
    * @param {CdlRenderEnvironment} env
    * @param {CSN.Path} [path=[]]
+   * @param {object} [elements]
    */
   function renderQuery(query, isLeadingQuery, syntax, env, path = [], elements = query.elements || Object.create(null)) {
-    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) {
-      throw new Error(`Unexpected query operation ${JSON.stringify(query)}`);
+      // ...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 Error(`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;
@@ -962,13 +908,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
@@ -980,7 +925,7 @@ function toCdsSourceCsn(csn, options) {
       result += `${continueIndent(result, env)}where ${renderExpr(select.where, env, true, true)}`;
 
     if (select.groupBy)
-      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env)).join(', ')}`;
+      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env, true, false, true)).join(', ')}`;
 
     if (select.having)
       result += `${continueIndent(result, env)}having ${renderExpr(select.having, env, true, true)}`;
@@ -1026,6 +971,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;
+    }
   }
 
   /**
@@ -1037,7 +1005,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderDocComment(entry, env) + renderExpr(entry, env);
+    let result = renderAnnotationAssignmentsAndDocComment(entry, env) + renderExpr(entry, env, true, false, true);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1061,7 +1029,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], childEnv);
 
     // Even if we have seen actions/functions, they might all have been ignored
     if (result !== '')
@@ -1079,13 +1047,23 @@ 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' ]);
+      if (act.returns.type && act.returns.elements) {
+        // Annotation in action returns' structure.  Render it as an annotate statement.
+        const isBoundAction = (env.artifactName !== actionName);
+        const anno = {
+          annotate: env.artifactName || actionName,
+        };
+        if (isBoundAction)
+          anno.actions = { [actionName]: { returns: { elements: act.returns.elements } } };
+        else
+          anno.returns = { elements: act.returns.elements };
+        subelementAnnotates.push(anno);
+      }
       result += ` returns ${renderTypeReference(act.returns, env)}${renderNullability(act.returns)}`;
     }
 
@@ -1102,7 +1080,7 @@ 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)}`;
+    let result = `${renderAnnotationAssignmentsAndDocComment(par, env) + env.indent + quoteIdIfRequired(parName)} : ${renderTypeReference(par, env)}`;
     if (par.default)
       result += ` default ${renderExpr(par.default, env)}`;
 
@@ -1121,14 +1099,11 @@ function toCdsSourceCsn(csn, options) {
    * @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(', ')}`;
-    }
+    let result = renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName)}`;
+    if (art.includes)
+      result += renderIncludes(art.includes);
+
     const childEnv = increaseIndent(env);
     if (art.elements && !art.type) {
       // Structured type or annotation with anonymous struct type
@@ -1140,7 +1115,10 @@ function toCdsSourceCsn(csn, options) {
     }
     else {
       // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env, false)};\n`;
+      result += ` : ${renderTypeReference(art, env, false)}`;
+      if (art.default)
+        result += ` default ${renderExpr(art.default, env)}`;
+      result += ';\n';
     }
     return result;
   }
@@ -1164,8 +1142,16 @@ function toCdsSourceCsn(csn, options) {
       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 ]);
+      // TODO(andre): This does handle deeply nested elements because we take the full `elements`.
+      //              But when is env.elementName set and when not?
+      if (elm.items.type && elm.items.elements && env.artifactName) {
+        const annotate = { annotate: env.artifactName };
+        if (env.elementName)
+          annotate.elements = { [env.elementName]: elm.items };
+        else
+          annotate.elements = elm.items.elements;
+        subelementAnnotates.push(annotate);
+      }
 
       return rc;
     }
@@ -1176,7 +1162,7 @@ function toCdsSourceCsn(csn, options) {
     // Anonymous structured type
     if (!elm.type) {
       if (!elm.elements)
-        throw new Error(`Missing type of: ${JSON.stringify(elm)}`);
+        throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
 
       result += '{\n';
       const childEnv = increaseIndent(env);
@@ -1201,23 +1187,27 @@ function toCdsSourceCsn(csn, options) {
           ((elm.type === comp) ? ' of ' : ' to ');
       }
 
-      // normal target or named aspect
-      if (elm.target || elm.targetAspect && typeof elm.targetAspect === 'string') {
+      // `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 = elm.target && elm.target.elements || elm.targetAspect && elm.targetAspect.elements;
+      if (typeof elm.target === 'string' || typeof elm.targetAspect === 'string') {
         result += renderAbsolutePath({ ref: [ elm.target || elm.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}}`;
       }
       else {
-        throw new Error('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
+        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)}`;
@@ -1249,14 +1239,8 @@ function toCdsSourceCsn(csn, options) {
     }
 
     // If we get here, it must be a named type
-    if (isBuiltinType(elm.type)) {
-      result += renderBuiltinType(elm);
-    }
-    else {
-      // Simple absolute name
-      // Type names are never flattened (derived types are unraveled in HANA)
-      result += getResultingName(elm.type);
-    }
+    result += renderNamedTypeWithParameters(elm);
+
     if (elm.enum && !noEnum)
       result += renderEnum(elm.enum, env);
 
@@ -1264,18 +1248,48 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * @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 ${quoteIdIfRequired(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;
+  }
+
+  /**
+   * Render the named type with optional parameters, e.g. `MyString(length: 10)`.
+   * @param {CSN.Artifact} artWithType
+   * @return {string}
+   */
+  function renderNamedTypeWithParameters(artWithType) {
+    let result = '';
 
-    return elm.type.slice(4) + renderTypeParameters(elm);
+    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 {
+      // Simple absolute name
+      // Type names are never flattened (derived types are unraveled in HANA)
+      result += renderArtifactName(artWithType.type);
+    }
+
+    result += renderTypeParameters(artWithType);
+    return result;
   }
 
+
   /**
    * Render the 'enum { ... } part of a type declaration
    *
@@ -1286,21 +1300,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)
@@ -1310,17 +1335,25 @@ 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['='])
+      else if (x['=']) {
         return quotePathString(x['=']);
+      }
+      // Shorthand for ellipsis: `... up to <val>`
+      else if (x['...']) {
+        if (x['...'] === true)
+          return '...';
+        return `... up to ${renderAnnotationValue(x['...'], env)}`;
+      }
 
       // Struct value (can actually only occur within an array)
 
@@ -1339,170 +1372,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 {string|object} s
+   * @param {number} idx
+   * @returns {string}
    */
-  function renderExpr(x, env, inline = true, inExpr = 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 && 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;
-
-
-    /**
-     * 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 Error(`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)})`;
+  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
 
-        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 Error(`Unknown expression: ${JSON.stringify(x)}`);
-      }
-    }
+      if (idx === 0 &&
+              s.startsWith('$'))
+        return 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})`;
+      return quoteIdIfRequired(s);
     }
-
-    /**
-     * 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 Error(`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 Error(`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
@@ -1510,17 +1427,31 @@ 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)).join(', ');
+      return args.map(arg => renderArgument(arg, env)).join(', ');
 
     // Named arguments (object/dict)
     else if (typeof args === 'object')
-      return Object.keys(args).map(key => `${quoteOrUppercaseId(key)} ${sep} ${renderExpr(args[key], env)}`).join(', ');
+      return Object.keys(args).map(key => `${quoteIdIfRequired(key)} ${sep} ${renderArgument(args[key], env)}`).join(', ');
 
+    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
+  }
 
-    throw new Error(`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
+   * @return {string}
+   */
+  function renderArgument(arg, env) {
+    // 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), true);
   }
 
   /**
@@ -1601,28 +1532,35 @@ 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);
+  function renderTypeParameters(artWithType) {
+    const params = typeParameters.list.filter(param => artWithType[param] !== undefined);
+    if (params.length === 0)
+      return '';
 
-    if (elm.precision !== undefined)
-      params.push(elm.precision);
+    // TODO(v3): Remove special handling of srid
+    // For backwards compatibility, do not render srid as a named argument for POINT/GEOMETRY builtins.
+    if (artWithType.srid !== undefined &&
+       (artWithType.type === 'cds.hana.ST_POINT' || artWithType.type === 'cds.hana.ST_GEOMETRY'))
+      return `(${artWithType.srid})`;
 
-    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(', ')})`;
   }
 
   /**
@@ -1630,13 +1568,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;
   }
@@ -1649,14 +1588,16 @@ 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.
@@ -1667,151 +1608,21 @@ function toCdsSourceCsn(csn, options) {
     // 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;
-  }
-
-  /**
-   * Render appropriate USING directives for all artifacts used by artifact 'artifactName' in 'env'.
-   *
-   * @param {string} artifactName
-   * @param {CdlRenderEnvironment} env
-   * @return {string}
-   */
-  function renderUsings(artifactName, env) {
-    const distinct = {};
-    Object.keys(env.topLevelAliases)
-      .forEach((name) => {
-        distinct[`using ${env.topLevelAliases[name].quotedName} as ${env.topLevelAliases[name].quotedAlias};\n`] = '';
-      });
-
-    return Object.keys(distinct).join('');
-  }
-
-  /**
-   * 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: '',
-      // 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,
-    };
-  }
-
-  /**
-   * Returns a copy of 'env' with (quoted) name prefix 'id' and a dot appended to the current name prefix
-   *
-   * @param {CdlRenderEnvironment} env
-   * @param {string} id
-   * @returns {CdlRenderEnvironment}
-   */
-  function addNamePrefix(env, id) {
-    return Object.assign({}, env, { namePrefix: `${env.namePrefix + quoteIdIfRequired(id)}.` });
-  }
-
-  /**
-   * Returns a copy of 'env' with increased indentation (and resetted name prefix)
-   *
-   * @param {CdlRenderEnvironment} env
-   * @returns {CdlRenderEnvironment}
-   */
-  function increaseIndent(env) {
-    return Object.assign({}, env, { namePrefix: '', indent: `${env.indent}  ` });
-  }
-
-  /**
-   * Return a path string 'path' with appropriate "-quotes.
-   *
-   * @param {string} path
-   * @returns {string}
-   */
-  function quotePathString(path) {
-    // "foo"."bar"."wiz"."blub"
-    return path.split('.').map(quoteIdIfRequired).join('.');
-  }
-
-  /**
-   * 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);
-
-    return id;
-  }
-
-  /**
-   * 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'
-   *  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 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);
-  }
-
   /**
    * 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
@@ -1821,12 +1632,11 @@ function toCdsSourceCsn(csn, options) {
    * 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/namespace)
+   * - 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
    */
@@ -1837,25 +1647,14 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * 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);
-  }
-
-  /**
-   * Get the part that is really the name of this artifact and not just prefix caused by a context/service/namespace
+   * 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('.');
-    // Lenght of 1 -> There can be no prefix
+    // Length of 1 -> There can be no prefix
     if (parts.length === 1)
       return artifactName;
 
@@ -1869,7 +1668,7 @@ function toCdsSourceCsn(csn, options) {
 
 
       const art = csn.definitions[seen];
-      if (!art || ![ 'service', 'context', 'namespace' ].includes(art.kind)) {
+      if (!art || (art.kind !== 'service' && art.kind !== 'context')) {
         // We found a case where the prefix ended
         // Return everything following
         return parts.slice(i).join('.');
@@ -1879,15 +1678,218 @@ function toCdsSourceCsn(csn, options) {
     // we seem to have a normal case - just return the last part
     return getLastPartOf(artifactName);
   }
+
+  /**
+   * Render an expression.
+   *
+   * @param {any} expr
+   * @param {CdlRenderEnvironment} env
+   * @param {boolean} [inline]
+   * @param {boolean} [nestedExpr]
+   * @param {boolean} [alwaysRenderCast]
+   * @returns {string}
+   */
+  function renderExpr(expr, env, inline, nestedExpr, alwaysRenderCast) {
+    if (!_renderExpr) {
+      _renderExpr = getExpressionRenderer({
+        finalize: x => x,
+        explicitTypeCast: (x, env) => {
+          const typeRef = renderTypeReference(x.cast, env, 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 => `#${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 = renderFunc(x.func, x, null, a => renderArgs(a, '=>', env));
+          const windowFunctionOperator = x.xpr.shift(); // OVER ...
+          return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
+        },
+        func: (x, env) => {
+          // FIXME: Why care about HANA identifier?
+          // 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 = /^[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));
+        },
+        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) => `(${renderQuery(x, false, 'view', increaseIndent(env))})`,
+        SELECT: (x, env) => `(${renderQuery(x, false, 'view', increaseIndent(env))})`,
+      });
+    }
+    return _renderExpr(expr, env, inline, nestedExpr, alwaysRenderCast);
+  }
+}
+
+/**
+ * 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: '',
+    // 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: '',
+    elementName: '',
+  };
+}
+
+/**
+ * Returns a copy of 'env' with increased indentation (and reset name prefix)
+ *
+ * @param {CdlRenderEnvironment} env
+ * @returns {CdlRenderEnvironment}
+ */
+function increaseIndent(env) {
+  return Object.assign({}, env, { namePrefix: '', indent: `${env.indent}  ` });
+}
+
+/**
+ * Return a path string 'path' with appropriate "-quotes.
+ *
+ * @param {string} path
+ * @returns {string}
+ */
+function quotePathString(path) {
+  // "foo"."bar"."wiz"."blub"
+  return path.split('.').map(quoteIdIfRequired).join('.');
+}
+
+/**
+ * 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);
+
+  return id;
 }
 
-const controlCharacters = /[\u{0000}-\u{0009}\u{000B}\u{001F}]/u;
-const highSurrogate = /[\u{D800}-\u{DBFF}]/u;
-const lowSurrogate = /[\u{DC00}-\u{DFFF}]/u;
+/**
+ * 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'
+ *  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());
+}
+
+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',
+
+  'is', 'in', 'not', 'null', 'exists',
+  // Antlr rule 'predicate'
+  'between', 'like', 'escape',
+];
+
+/**
+ * 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 was created by looking at the `expression` Antlr rule.
+ *
+ * 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
+ * @return {boolean}
+ */
+function isSimpleFunctionExpression(xpr) {
+  return !xpr || xpr.every(val => typeof val !== 'string' || !functionExpressionOperatorsRequireParentheses.includes(val.toLowerCase()));
+}
+
+/**
+ * @param {string[]} includes
+ * @return {string}
+ */
+function renderIncludes(includes) {
+  return ` : ${includes.map(name => quoteIdIfRequired(name)).join(', ')}`;
+}
 
 /**
  * Render the given string.  Uses back-tick strings.
- * env is used for indentation for three-back-tick strings.
+ * env is used for indentation of three-back-tick strings.
  *
  * @param str
  * @param env
@@ -1897,90 +1899,33 @@ function renderString(str, env) {
   if (isSimpleString(str))
     return `'${str.replace(/'/g, '\'\'')}'`;
 
-  const output = [];
-
   // We try to work similar to how JavaScript implements JSON.stringify.
-  // JSON.stringify, however, checks for unpaired unicode surrogates (see §25.5.2.2,
-  // <https://tc39.es/ecma262/#sec-quotejsonstring>), which we do not do here.
-
-  for (let i = 0; i < str.length; ++i) {
-    const char = str[i];
-
-    switch (char) {
-      case '$':
-        output.push('\\$');
-        break;
-      case '`':
-        output.push('\\`');
-        break;
-      case '\\':
-        output.push('\\\\');
-        break;
-        // Replace commonly known escape sequences for control characters
-        // See lib/language/multiLineStringParser.js
-      case '\f':
-        output.push('\\f');
-        break;
-      case '\v':
-        output.push('\\v');
-        break;
-      case '\t':
-        output.push('\\t');
-        break;
-      case '\b':
-        output.push('\\b');
-        break;
-      // If CR, LS, or PS appear, they have been encoded explicitly.  If we don't escape
-      // them, a recompilation may yield different results because of newline normalization.
-      case '\r':
-        output.push('\\r');
-        break;
-      case '\u{2028}':
-        output.push('\\u{2028}');
-        break;
-      case '\u{2029}':
-        output.push('\\u{2029}');
-        break;
-      default: {
-        // Control Characters: C0
-        // See <https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Basic_ASCII_control_codes>
-        //
-        // JSON.stringify is not required to escape all control characters, but if used, files may
-        // be interpreted as binary.  Therefore, we replace them.
-        //
-        // We exclude LF from this list (\u000A). Characters with "nice" escapes have been replaced above.
-        if (controlCharacters.test(char)) {
-          const hex = char.codePointAt(0).toString(16);
-          output.push(`\\u{${hex}}`);
-          break;
-        }
+  // JSON.stringify() also checks for unpaired unicode surrogates (see §25.5.2.2,
+  // <https://tc39.es/ecma262/#sec-quotejsonstring>).
+  str = escapeString(str, {
+    $: '\\$',
+    '`': '\\`',
+    '\\': '\\\\',
+    // Replace commonly known escape sequences for control characters
+    // See lib/language/multiLineStringParser.js
+    '\f': '\\f',
+    '\v': '\\v',
+    '\t': '\\t',
+    '\b': '\\b',
+    // If CR, LS, or PS appear, they have been encoded explicitly.  If we don't escape
+    // them, a recompilation may yield different results because of newline normalization.
+    '\r': '\\r',
+    '\u{2028}': '\\u{2028}',
+    '\u{2029}': '\\u{2029}',
+    // Don't encode LF
+    '\n': '\n',
+    // JSON.stringify() is not required to escape all control characters, but if used, files may
+    // be interpreted as binary.  Therefore, we replace them.
+    // We exclude LF from this list (\n). Characters with "nice" escapes have been replaced above.
+    control: hexEscape,
+    unpairedSurrogate: hexEscape,
+  });
 
-        // Unicode Surrogates
-        // These characters appear in _pairs_.  A high surrogate must be followed by a low surrogate.
-        // If this is not the case, either needs to be encoded.  This is also done by JSON.
-        // See also <https://docs.microsoft.com/en-us/globalization/encoding/surrogate-pairs>
-        if (highSurrogate.test(char)) {
-          if (i + 1 >= str.length || !lowSurrogate.test(str[i + 1])) {
-            const hex = char.codePointAt(0).toString(16);
-            output.push(`\\u{${hex}}`);
-          }
-          else {
-            output.push(char);
-            ++i;
-            output.push(str[i]);
-          }
-        }
-        else if (lowSurrogate.test(char)) {
-          const hex = char.codePointAt(0).toString(16);
-          output.push(`\\u{${hex}}`);
-        }
-        else {
-          output.push(char);
-        }
-      }
-    }
-  }
-  str = output.join('');
   // Note: String is normalized, only \n is the line separator.
   const lines = str.split('\n');
   // We don't know whether a text block was used or not.  But if there
@@ -1994,6 +1939,12 @@ function renderString(str, env) {
   return `\`${str}\``;
 }
 
+/** @param {number} codePoint */
+function hexEscape(codePoint) {
+  const hex = codePoint.toString(16);
+  return `\\u{${hex}}`;
+}
+
 /**
  * Returns true if the given string can be represented by using single quotes.
  * @param {string} str
@@ -2001,14 +1952,13 @@ function renderString(str, env) {
 function isSimpleString(str) {
   // A single-line string allows everything except certain line separators/breaks.
   // See ANTLR grammar for specifics.
-  // Furthermore, if control characters \u{0000}-\u{001F} are used, we escape them,
+  // Furthermore, if control characters are used, we escape them,
   // as these are explicitly mentioned in the JSON spec (§9):
   // <https://www.ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf>
-  // On top, as (invalid) surrogate pairs need to be handled, we check for them as well.
+  // On top, because (invalid) surrogate pairs need to be handled, we check for them as well.
   // v3: Not a simple string if ' (\u0027) is in string.
   return str === '' || (/^[^\u{0000}-\u{001F}\u2028\u2029]+$/u.test(str) &&
-    !highSurrogate.test(str) &&
-    !lowSurrogate.test(str));
+    !hasUnpairedUnicodeSurrogate(str));
 }
 
 /**
@@ -2016,14 +1966,14 @@ function isSimpleString(str) {
  *
  * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
  * @property {CSN.Path} [path] CSN path to the current artifact
- * @property {string}   artifactName Name of the artifact - set in renderArtifact
- * @property {string}   elementName Name of the element being rendered - set in renderElement
+ * @property {string}   [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 {string} [namePrefix] Current name prefix (including trailing dot if not empty)
  * @property {boolean} [skipKeys]
  * @property {CSN.Artifact} [_artifact]
  */