@sap/cds-compiler 2.15.4 → 3.0.0

package/lib/render/toCdl.js

@@ -1,33 +1,32 @@
 'use strict';
 
 const keywords = require('../base/keywords');
-const { getLastPartOf } = require('../model/csnUtils');
 const { isBuiltinType, generatedByCompilerVersion, getNormalizedQuery } = require('../model/csnUtils');
-const { renderFunc, findElement, getExpressionRenderer } = require('./utils/common');
+const { findElement, getExpressionRenderer } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
-const { csnRefs } = require('../model/csnRefs');
 const { forEachDefinition } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
 const { ModelError } = require('../base/error');
-const { typeParameters } = require('../compiler/builtins');
+const { typeParameters, specialFunctions } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
 
+const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
+
 /**
  * Render the CSN model 'model' to CDS source text.
  * Returned object has the following properties:
  *  - `model`: CSN model rendered as CDL (string).
- *  - [csn.namespace]: Namespace statement + `using from './model.cds'.
+ *  - `namespace`: Namespace statement + `using from './model.cds'.
  *  - `unappliedExtensions`: Annotations / Extensions from the `csn.extensions` array.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} [options]
  */
-function toCdsSourceCsn(csn, options) {
+function csnToCdl(csn, options) {
   timetrace.start('CDL rendering');
-  const { artifactRef } = csnRefs(csn);
   let _renderExpr = null;
 
   if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
@@ -48,8 +47,8 @@ function toCdsSourceCsn(csn, options) {
     cdlResult.model += renderVocabularies(csn.vocabularies);
 
   if (csn.namespace) {
-    cdlResult[csn.namespace] = `namespace ${renderArtifactName(csn.namespace)};\n`;
-    cdlResult[csn.namespace] += 'using from \'./model.cds\';';
+    cdlResult.namespace = `namespace ${renderArtifactName(csn.namespace)};\n`;
+    cdlResult.namespace += 'using from \'./model.cds\';';
   }
 
   // If there are extensions, such as 'extend' and 'annotate' statements, render them separately.
@@ -93,7 +92,7 @@ function toCdsSourceCsn(csn, options) {
       if (!anno._ignore) {
         // This environment is passed down the call hierarchy, for dealing with
         // indentation and name resolution issues
-        const env = createEnv();
+        const env = envNewPath(createEnv(), [ 'vocabularies', name ]);
         const sourceStr = renderTypeOrAnnotation(name, anno, env, 'annotation');
         result += `${sourceStr}\n`;
       }
@@ -147,7 +146,7 @@ function toCdsSourceCsn(csn, options) {
       // 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`;
+        result += `${env.indent}extend ${affix}${extName} with ${quotePathIfRequired(id)};\n`;
       return result;
     }
 
@@ -293,7 +292,6 @@ function toCdsSourceCsn(csn, options) {
       result += `${env.indent}}`;
     }
 
-
     result += ';\n';
     return result;
   }
@@ -348,24 +346,22 @@ function toCdsSourceCsn(csn, options) {
    * @param {CdlRenderEnvironment} env
    */
   function renderArtifact(artifactName, art, env) {
-    // FIXME: Correctly build the paths during runtime to give better locations
-    env.path = [ 'definitions', artifactName ];
+    env = envNewPath(env, [ 'definitions', artifactName ]);
     env.artifactName = artifactName;
 
     switch (art.kind) {
       case 'entity':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
-
         return renderEntity(artifactName, art, env);
 
       case 'context':
       case 'service':
-        return renderContext(artifactName, art, env);
+        return renderContextOrService(artifactName, art, env);
       case 'type':
       case 'aspect':
-      case 'annotation':
-        return renderTypeOrAnnotation(artifactName, art, env, art.$syntax);
+      case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
+        return renderTypeOrAnnotation(artifactName, art, env);
       case 'action':
       case 'function':
         return renderActionOrFunction(artifactName, art, env);
@@ -389,16 +385,14 @@ function toCdsSourceCsn(csn, options) {
     if (art.includes)
       result += renderIncludes(art.includes);
     if (art.query || art.projection) {
-      env._artifact = art;
       result += ' : ';
       result += renderQuery(getNormalizedQuery(art).query, true, 'projection', env,
                             [ 'definitions', artifactName, 'query' ]);
       result += ';\n';
-      delete env._artifact;
     }
     else if (art.type) {
       // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env)};\n`;
+      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
     }
     else if (art.elements) {
       result += ' {\n';
@@ -411,18 +405,14 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * Render a context or service. Return the resulting source string.
-   *
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
+   * @returns {string}
    */
-  function renderContext(artifactName, art, env) {
+  function renderContextOrService(artifactName, art, env) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent + (art.abstract ? 'abstract ' : '') + art.kind} ${renderArtifactName(artifactName)}`;
-    if (art.includes)
-      result += renderIncludes(art.includes);
-
+    result += `${env.indent}${art.kind} ${renderArtifactName(artifactName)}`;
     return `${result} {};\n`;
   }
 
@@ -446,18 +436,6 @@ function toCdsSourceCsn(csn, options) {
     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({
-          annotate: artifactName,
-          elements: {
-            [name]: {
-              elements: element.elements,
-            },
-          },
-        });
-      }
       result += renderElement(name, element, childEnv);
     }
 
@@ -476,19 +454,15 @@ function toCdsSourceCsn(csn, options) {
    * @param {Boolean} [isSubElement]
    */
   function renderElement(elementName, elm, env, isSubElement) {
-    env.elementName = elementName;
+    env = envAddPath(env, [ 'elements', 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 ' : '') +
-                         quotedElementName} : ${
-      renderTypeReference(elm, env, undefined)
-    }${elm.on ? '' : renderNullability(elm)}`;
-    if (elm.default)
-      result += ` default ${renderExpr(elm.default, env)}`;
-
-    delete env.elementName;
+    result += env.indent;
+    result += elm.virtual ? 'virtual ' : '';
+    result += elm.key && !isSubElement ? 'key ' : '';
+    // TODO(v4): Remove once deprecated flag for `masked` is removed.
+    result += elm.masked ? 'masked ' : '';
+    result += `${quoteIdIfRequired(elementName)} : ${renderTypeReferenceAndProps(elm, env)}`;
+
     return `${result};\n`;
   }
 
@@ -529,7 +503,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderQueryElementAnnotations(artifactName, art, env) {
-    const annotate = collectAnnotationsOfElements(artifactName, art);
+    const annotate = collectAnnotationsOfElements(art, { artifactName, path: env.path });
     if (annotate)
       return renderExtensions([ annotate ], env);
     return '';
@@ -539,13 +513,40 @@ function toCdsSourceCsn(csn, options) {
    * 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
+   * @param {CdlRenderEnvironment} env
    * @return {CSN.Extension|null}
    */
-  function collectAnnotationsOfElements(artifactName, artWithElements) {
-    const annotate = { annotate: artifactName };
-    return collectAnnos(annotate, artWithElements) ? annotate : null;
+  function collectAnnotationsOfElements(artWithElements, env) {
+    // Array of structures, which may be annotated as well.
+    if (!artWithElements.elements && artWithElements.items) {
+      env = envAddPath(env, [ 'items' ]);
+      artWithElements = artWithElements.items;
+    }
+
+    const annotate = { annotate: env.path[1] };
+
+    // Based on the current path, create a correctly nested structure
+    // of elements for which we collect annotations.
+    // TODO: More properties?
+    let obj = annotate;
+    for (let i = 2; i < env.path.length; ++i) {
+      const key = env.path[i];
+      if (key === 'elements' || key === 'actions') {
+        obj[key] = Object.create(null);
+        const elem = env.path[i + 1];
+        obj[key][elem] = {};
+        obj = obj[key][elem];
+      }
+      else if (key === 'returns') {
+        obj.returns = {};
+        obj = obj.returns;
+      }
+      else {
+        // ignore others, e.g. 'items'
+      }
+    }
+    return collectAnnos(obj, artWithElements) ? annotate : null;
 
     /**
      * Recursive function to collect annotations. `annotateObj` will get an `elements`
@@ -749,7 +750,7 @@ function toCdsSourceCsn(csn, options) {
       if (col.cast.target && !col.cast.type)
         result += ` : ${renderRedirectedTo(col.cast, env)}`;
       else
-        result += ` : ${renderTypeReference(col.cast, env, true)}`;
+        result += ` : ${renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true })}`;
     }
     return result;
   }
@@ -758,58 +759,51 @@ function toCdsSourceCsn(csn, options) {
    * For the current column, render a (nested) inline/expand. If the current column
    * does not have an .expand/.inline, '' is returned
    *
-   * @param {object} col Thing with .expand or .inline
-   * @param {CdlRenderEnvironment} parentEnv
+   * @param {object} obj Thing with .expand or .inline
+   * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderInlineExpand(col, parentEnv) {
-    if (!col.inline && !col.expand)
-      return '';
-
-    return renderIX(col, parentEnv);
-
-    function renderIX(obj, env) {
-      // No expression to render for { * } as alias
-      let result = (obj.as && obj.expand && !obj.ref) ? '' : renderExpr(obj, env);
-
-      // s as alias { * }
-      if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
-        result += ` as ${obj.as}`;
-
-      // We found a leaf - no further drilling
-      if (!obj.inline && !obj.expand) {
-        if (obj.cast && obj.cast.type)
-          result += ` : ${renderTypeReference(obj.cast, createEnv())}`;
-        else if (obj.cast && obj.cast.target) // test tbd
-          result += ` : ${renderRedirectedTo(obj.cast, env)}`;
-        return result;
-      }
+  function renderInlineExpand(obj, env) {
+    // No expression to render for { * } as alias
+    let result = (obj.as && obj.expand && !obj.ref) ? '' : renderExpr(obj, env);
+
+    // s as alias { * }
+    if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
+      result += ` as ${obj.as}`;
+
+    // We found a leaf - no further drilling
+    if (!obj.inline && !obj.expand) {
+      if (obj.cast && obj.cast.type)
+        result += ` : ${renderTypeReferenceAndProps(obj.cast, createEnv(), { noAnnoCollect: true })}`;
+      else if (obj.cast && obj.cast.target) // test tbd
+        result += ` : ${renderRedirectedTo(obj.cast, env)}`;
+      return result;
+    }
 
-      if (obj.inline)
-        result += '.{\n';
-      else
-        result += result !== '' ? ' {\n' : '{\n';
+    if (obj.inline)
+      result += '.{\n';
+    else
+      result += result !== '' ? ' {\n' : '{\n';
 
-      // Drill down and render children of the expand/inline
-      const childEnv = increaseIndent(env);
-      const expandInline = obj.expand || obj.inline;
-      expandInline.forEach((elm, i) => {
-        result += `${childEnv.indent}${renderIX(elm, childEnv)}`;
-        if (i < expandInline.length - 1)
-          result += ',\n';
-      });
-      result += `\n${env.indent}}`;
+    // Drill down and render children of the expand/inline
+    const childEnv = increaseIndent(env);
+    const expandInline = obj.expand || obj.inline;
+    expandInline.forEach((elm, i) => {
+      result += `${childEnv.indent}${renderInlineExpand(elm, childEnv)}`;
+      if (i < expandInline.length - 1)
+        result += ',\n';
+    });
+    result += `\n${env.indent}}`;
 
-      // Don't forget about the .excluding
-      if (obj.excluding)
-        result += ` excluding { ${obj.excluding.join(',')} }`;
+    // Don't forget about the .excluding
+    if (obj.excluding)
+      result += ` excluding { ${obj.excluding.join(',')} }`;
 
-      // { * } as expand
-      if (!obj.ref && obj.as)
-        result += ` as ${obj.as}`;
+    // { * } as expand
+    if (!obj.ref && obj.as)
+      result += ` as ${obj.as}`;
 
-      return result;
-    }
+    return result;
   }
 
   /**
@@ -855,7 +849,6 @@ function toCdsSourceCsn(csn, options) {
     else {
       result += ' as ';
     }
-    env._artifact = art;
     result += renderQuery(getNormalizedQuery(art).query, true, syntax, env, [ 'definitions', artifactName, 'query' ], art.elements);
     result += ';\n';
     result += renderQueryElementAnnotations(artifactName, art, env);
@@ -955,7 +948,7 @@ function toCdsSourceCsn(csn, options) {
     }
 
     /**
-     * Render a query's LIMIT clause, which may have also have OFFSET.
+     * Render a query's LIMIT clause, which may also have OFFSET.
      *
      * @param {CSN.QueryLimit} limit
      * @param {CdlRenderEnvironment} limitEnv
@@ -1029,7 +1022,7 @@ function toCdsSourceCsn(csn, options) {
     let result = '';
     const childEnv = increaseIndent(env);
     for (const name in art.actions)
-      result += renderActionOrFunction(name, art.actions[name], childEnv);
+      result += renderActionOrFunction(name, art.actions[name], envAddPath(childEnv, [ 'actions', name ]));
 
     // Even if we have seen actions/functions, they might all have been ignored
     if (result !== '')
@@ -1052,19 +1045,8 @@ function toCdsSourceCsn(csn, options) {
     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) {
-        // 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)}`;
+      const actEnv = envAddPath(env, [ 'returns' ]);
+      result += ` returns ${renderTypeReferenceAndProps(act.returns, actEnv)}`;
     }
 
     result += ';\n';
@@ -1080,11 +1062,9 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderParameter(parName, par, env) {
-    let result = `${renderAnnotationAssignmentsAndDocComment(par, env) + env.indent + quoteIdIfRequired(parName)} : ${renderTypeReference(par, env)}`;
-    if (par.default)
-      result += ` default ${renderExpr(par.default, env)}`;
-
-    result += renderNullability(par);
+    env = envAddPath(env, [ 'params', parName ]);
+    let result = `${renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
+    result += `${quoteIdIfRequired(parName)} : ${renderTypeReferenceAndProps(par, env)}`;
     return result;
   }
 
@@ -1095,7 +1075,7 @@ function toCdsSourceCsn(csn, options) {
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
-   * @param {String} artType - used for rendering csn.vocabularies, as the annotations there do not have a kind. Only in toCdl mode
+   * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind. Only in toCdl mode
    * @return {string}
    */
   function renderTypeOrAnnotation(artifactName, art, env, artType) {
@@ -1104,96 +1084,71 @@ function toCdsSourceCsn(csn, options) {
     if (art.includes)
       result += renderIncludes(art.includes);
 
-    const childEnv = increaseIndent(env);
-    if (art.elements && !art.type) {
-      // Structured type or annotation with anonymous struct type
-      result += ' {\n';
-      for (const name in art.elements)
-        result += renderElement(name, art.elements[name], childEnv);
-
-      result += `${env.indent}};\n`;
-    }
-    else {
-      // Derived type or annotation with non-anonymous type
-      result += ` : ${renderTypeReference(art, env, false)}`;
-      if (art.default)
-        result += ` default ${renderExpr(art.default, env)}`;
-      result += ';\n';
-    }
+    if (!art.type && art.elements) // For nicer output, no colon if unnamed structure is used.
+      result += ` ${renderTypeReferenceAndProps(art, env)};\n`;
+    else
+      result += ` : ${renderTypeReferenceAndProps(art, env)};\n`;
     return result;
   }
 
   /**
-   * Render a reference to a type used by 'elm' (named or inline)
-   * Allow suppressing enum-rendering - used in columns for example
+   * Render a reference to a type used by 'artifact' (named or inline) and (element) properties
+   * such as `not null` and `default <xpr>`.
+   * Allow suppressing rendering of structs such as enums - used in columns for example.
    *
-   * @param {CSN.Element} elm
+   * @param {object} artifact
    * @param {CdlRenderEnvironment} env
-   * @param {boolean} [noEnum=false]
+   * @param {object} [config={}] - `typeRefOnly`   Whether to only render type defs, no arrayed/structured/enum.
+   *                             - `noAnnoCollect` Do not collect annotations of sub-elements.
    * @return {string}
    */
-  function renderTypeReference(elm, env, noEnum = false) {
+  function renderTypeReferenceAndProps(artifact, env, config = {}) {
     let result = '';
-
-    // Array type: Render items instead
-    if (elm.items && !elm.type) {
-      // HANA CDS does not support keyword many
-      let rc = `many ${renderTypeReference(elm.items, env)}`;
-      if (elm.items.notNull != null)
-        rc += elm.items.notNull ? ' not null' : ' null';
-      // many sub element annotates
-      // 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;
+    const { typeRefOnly, noAnnoCollect } = config;
+    let isTypeDef = env.path?.length === 2; // e.g [ 'definitions', typeDef ];
+
+    if (typeRefOnly && !artifact.type)
+      throw new ModelError(`Expected artifact to have a type; in: ${env.artifactName}`);
+
+    if (artifact.localized) // works even for type definitions
+      result += 'localized ';
+
+    if (!artifact.type && artifact.items) {
+      result += 'many '; // alternative: 'array of'; but not used
+      artifact = artifact.items;
+      env = envAddPath(env, 'items');
+      // element keywords allowed in MANY case; was an oversight when arrays were introduced.
+      isTypeDef = false;
+      // "many many" does not work in CDL, so we don't check for it.
     }
 
-    // FIXME: Is this a type attribute?
-    result += (elm.localized ? 'localized ' : '');
-
-    // Anonymous structured type
-    if (!elm.type) {
-      if (!elm.elements)
-        throw new ModelError(`Missing type of: ${JSON.stringify(elm)}`);
-
+    if (!artifact.type && artifact.elements) {
       result += '{\n';
-      const childEnv = increaseIndent(env);
-      for (const name in elm.elements)
-        result += renderElement(name, elm.elements[name], childEnv, null);
+      const childEnv = envAddPath(increaseIndent(env), 'items');
+      for (const name in artifact.elements)
+        result += renderElement(name, artifact.elements[name], childEnv, null);
 
       result += `${env.indent}}`;
+      if (!isTypeDef)
+        result += renderNullability(artifact);
+      // structured default not possible at the moment
       return result;
     }
 
-    const comp = 'cds.Composition';
     // Association type
-    if ([ 'cds.Association', comp ].includes(elm.type)) {
+    if (artifact.type === 'cds.Association' || artifact.type === 'cds.Composition') {
+      const isComp = artifact.type === 'cds.Composition';
       // Type, cardinality and target; CAPire uses CamelCase
-      result += (elm.type === comp) ? 'Composition' : 'Association';
-
-      if (isSimpleCardinality(elm.cardinality)) {
-        result += renderSimpleCardinality(elm);
-      }
-      else {
-        result += renderCardinality(elm.cardinality) +
-          ((elm.type === comp) ? ' of ' : ' to ');
-      }
+      result += isComp ? 'Composition' : 'Association';
+      result += renderCardinality(artifact);
 
       // `targetAspect` may be set by the core compiler and refers to the original named or unnamed aspect.
       // In parseCdl, `target` may still be an object containing elements.  This would be replaced
       // by targetAspect in client CSN, but we can't rely on that.
       // If a name exists (either in target or targetAspect), prefer it over rendering elements.
-      const elements = 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);
+      const elements = artifact.target && artifact.target.elements || artifact.targetAspect && artifact.targetAspect.elements;
+      if (typeof artifact.target === 'string' || typeof artifact.targetAspect === 'string') {
+        result += renderAbsolutePath({ ref: [ artifact.target || artifact.targetAspect ] }, env);
       }
       else if (elements) {
         // anonymous aspect, either parseCdl or client CSN.
@@ -1209,40 +1164,48 @@ function toCdsSourceCsn(csn, options) {
       }
 
       // ON-condition (if any)
-      if (elm.on)
-        result += ` on ${renderExpr(elm.on, env, true, true)}`;
+      if (artifact.on)
+        result += ` on ${renderExpr(artifact.on, env, true, true)}`;
 
 
       // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
-      if (elm.keys && !elm.on)
-        result += ` { ${Object.keys(elm.keys).map(name => renderForeignKey(elm.keys[name], env)).join(', ')} }`;
+      if (artifact.keys && !artifact.on)
+        result += ` { ${Object.keys(artifact.keys).map(name => renderForeignKey(artifact.keys[name], env)).join(', ')} }`;
+
+      if (!isTypeDef && !artifact.on) // unmanaged associations can't be followed by "not null"
+        result += renderNullability(artifact);
+      // DEFAULT not possible here.
 
       return result;
     }
 
-    // Reference to another element
-    if (elm.type.ref) {
-      if (elm.enum) {
-        const source = artifactRef(elm.type);
-        if (!source.enum) {
-          // enum was defined at this element and not at the referenced one
-          result += renderAbsolutePath(elm.type, env) + renderEnum(elm.enum, env);
-        }
-        else {
-          result += renderAbsolutePath(elm.type, env);
-        }
-      }
-      else {
-        result += renderAbsolutePath(elm.type, env);
-      }
-      return result;
+    // At this point, we will render a named type.
+
+    // If we have a type and elements, we may have sub-structure annotates that would
+    // get lost if we only render the type name.
+    // TODO: Can we annotate elements of targetAspect?
+    //       If so, move this block before the composition rendering.
+    if (!noAnnoCollect && (artifact.elements || artifact.items?.elements)) {
+      const annotate = collectAnnotationsOfElements(artifact, env);
+      if (annotate)
+        subelementAnnotates.push(annotate);
     }
 
-    // If we get here, it must be a named type
-    result += renderNamedTypeWithParameters(elm);
+    // Reference to another artifact
+    if (typeof artifact.type === 'string') {
+      // If we get here, it must be a named type
+      result += renderNamedTypeWithParameters(artifact);
+    }
+    else if (artifact.type?.ref) {
+      result += renderAbsolutePath(artifact.type, env);
+    }
 
-    if (elm.enum && !noEnum)
-      result += renderEnum(elm.enum, env);
+    if (artifact.enum && !typeRefOnly)
+      result += renderEnum(artifact.enum, env);
+    if (!isTypeDef) // NOT NULL not possible for not-arrayed type definitions
+      result += renderNullability(artifact);
+    if (artifact.default)
+      result += ` default ${renderExpr(artifact.default, env)}`;
 
     return result;
   }
@@ -1255,7 +1218,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderRedirectedTo(art, env) {
-    let result = `redirected to ${quoteIdIfRequired(art.target)}`;
+    let result = `redirected to ${quotePathIfRequired(art.target)}`;
     if (art.on)
       result += ` on ${renderExpr(art.on, env, true, true)}`;
     else if (art.keys)
@@ -1280,8 +1243,6 @@ function toCdsSourceCsn(csn, options) {
         result += artWithType.type.slice(4);
     }
     else {
-      // Simple absolute name
-      // Type names are never flattened (derived types are unraveled in HANA)
       result += renderArtifactName(artWithType.type);
     }
 
@@ -1346,7 +1307,7 @@ function toCdsSourceCsn(csn, options) {
       }
       // Shorthand for absolute path (as string)
       else if (x['=']) {
-        return quotePathString(x['=']);
+        return quotePathIfRequired(x['=']);
       }
       // Shorthand for ellipsis: `... up to <val>`
       else if (x['...']) {
@@ -1355,11 +1316,15 @@ function toCdsSourceCsn(csn, options) {
         return `... up to ${renderAnnotationValue(x['...'], env)}`;
       }
 
-      // Struct value (can actually only occur within an array)
-
-      // Note that we have to quote the struct keys here manually and not use quoteIdIfRequired, because they may even contain dots (yuc!)
-      // FIXME: Should that really be allowed?
-      return `{${Object.keys(x).map(key => `![${key}]: ${renderAnnotationValue(x[key], env)}`).join(', ')}}`;
+      // Struct value (can currently only occur within an array)
+      // Render as one-liner if there is at most one key.  Render as multi-line
+      // struct if there are more and use nicer indentation.
+      const keys = Object.keys(x);
+      const childEnv = keys.length <= 1 ? env : increaseIndent(env);
+      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key)}: ${renderAnnotationValue(x[key], childEnv)}`);
+      if (values.length <= 1)
+        return `{ ${values.join(', ')} }`;
+      return `{\n${childEnv.indent}${values.join(`,\n${childEnv.indent}`)}\n${env.indent}}`;
     }
     // Null
     else if (x === null) {
@@ -1430,12 +1395,18 @@ function toCdsSourceCsn(csn, options) {
     const args = node.args || [];
 
     // Positional arguments
-    if (Array.isArray(args))
+    if (Array.isArray(args)) {
+      const func = node.func?.toUpperCase();
+      if (func)
+        return args.map((arg, i) => renderArgument(arg, env, getKeywordsForSpecialFunctionArgument(func, i))).join(', ');
+
       return args.map(arg => renderArgument(arg, env)).join(', ');
+    }
 
     // Named arguments (object/dict)
-    else if (typeof args === 'object')
+    else if (typeof args === 'object') {
       return Object.keys(args).map(key => `${quoteIdIfRequired(key)} ${sep} ${renderArgument(args[key], env)}`).join(', ');
+    }
 
     throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
   }
@@ -1446,23 +1417,40 @@ function toCdsSourceCsn(csn, options) {
    *
    * @param {any} arg
    * @param {CdlRenderEnvironment} env
+   * @param {string[]} additionalAllowedKeywords
    * @return {string}
    */
-  function renderArgument(arg, env) {
+  function renderArgument(arg, env, additionalAllowedKeywords = []) {
     // If the argument is a xpr with e.g. `=`, it may require parentheses.
     // For nested xpr, `renderExpr()` will already add parentheses.
-    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr), true);
+    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalAllowedKeywords), true);
+  }
+
+  /**
+   * Render an artifact's cardinality.
+   *
+   * @param artifact
+   * @returns {string}
+   */
+  function renderCardinality(artifact) {
+    if (isSimpleCardinality(artifact.cardinality))
+      return renderSimpleCardinality(artifact);
+    return renderBracketCardinality(artifact);
   }
 
   /**
    * Render a cardinality (only those parts that were actually provided)
    *
-   * @param {CSN.Cardinality} card
+   * @param {CSN.Artifact} art
    * @return {string}
    */
-  function renderCardinality(card) {
+  function renderBracketCardinality(art) {
+    const isComp = art.type === 'cds.Composition';
+    const suffix = (isComp ? ' of ' : ' to ');
+    const card = art.cardinality;
+
     if (!card)
-      return '';
+      return suffix;
 
     let result = '[';
     if (card.src !== undefined)
@@ -1474,7 +1462,7 @@ function toCdsSourceCsn(csn, options) {
     if (card.max !== undefined)
       result += card.max;
 
-    return `${result}]`;
+    return `${result}]${suffix}`;
   }
 
   /**
@@ -1543,12 +1531,6 @@ function toCdsSourceCsn(csn, options) {
     if (params.length === 0)
       return '';
 
-    // 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})`;
-
     // Special cases for 1 or 2 arguments.
     if (params.length === 1 && artWithType.length !== undefined)
       return `(${artWithType.length})`;
@@ -1603,6 +1585,7 @@ function toCdsSourceCsn(csn, options) {
     // We expand this pattern to also include dots after the first character.
     // If the annotation does not follow this pattern `ident(.@ident)*`, it must be quoted:
     // `@identifier@identifier` must be quoted but `@identifier.@identifier` should not.
+    // TODO: Use quoteAnnotationPathIfRequired()
     const annoRequiresQuoting = !/^[$_a-zA-Z][$_a-zA-Z0-9.]*(?:\.@[$_a-zA-Z][$_a-zA-Z0-9.]*)*$/.test(nameBeforeVariant);
     // Unfortunately, the compiler does not allow `.` after the first variant identifier,
     // even though that is the result after flattening.
@@ -1624,77 +1607,47 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * Render the name of an artifact, using the current name prefix from 'env'
-   * and the real name of the artifact. In case of plain names, this
-   * is equivalent to simply flattening and uppercasing the whole name.
-   *
-   * In cdlMode, the prefix is extended to handle cases like an entity shadowing the prefix
-   * of another entity -> Service.E and Service.E.Sub
-   *
-   * To handle such cases for hdbcds in quoted/hdbcds, we:
-   * - Find the part of the name that is no longer prefix (context/service)
-   * - For Service.E -> E, for Service.E.Sub -> E.Sub
-   * - Replace all dots in this "real name" with underscores
-   * - Join with the env prefix
+   * Render the name of an artifact, quote path steps if necessary.
    *
    * @param {string} artifactName Artifact name to render
    * @return {string} Artifact name ready for rendering
    */
   function renderArtifactName(artifactName) {
-    const realname = getRealName(artifactName);
-    const prefix = (realname !== artifactName) ? artifactName.slice(0, artifactName.length - realname.length - 1) : '';
-    return prefix ? `${quoteIdIfRequired(prefix)}.${realname.split('.').map(quoteIdIfRequired).join('.')}` : realname.split('.').map(quoteIdIfRequired).join('.');
+    return quotePathIfRequired(artifactName);
   }
 
   /**
-   * Get the part that is really the name of this artifact and not just prefix caused by a context/service
+   * Render a function expression.
    *
-   * @param {String} artifactName Artifact name to use
-   * @returns {String} non-prefix part of the artifact name
+   * @param {object} obj Object with .func and optionally .args
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
    */
-  function getRealName(artifactName) {
-    const parts = artifactName.split('.');
-    // Length of 1 -> There can be no prefix
-    if (parts.length === 1)
-      return artifactName;
-
-
-    let seen = '';
-    for (let i = 0; i < parts.length; i++) {
-      if (seen !== '')
-        seen = `${seen}.${parts[i]}`;
-      else
-        seen = parts[i];
-
-
-      const art = csn.definitions[seen];
-      if (!art || (art.kind !== 'service' && art.kind !== 'context')) {
-        // We found a case where the prefix ended
-        // Return everything following
-        return parts.slice(i).join('.');
-      }
-    }
-
-    // we seem to have a normal case - just return the last part
-    return getLastPartOf(artifactName);
+  function renderFuncExpr( obj, env ) {
+    if (keywords.cdl_functions.includes(obj.func.toUpperCase()))
+      return obj.func;
+    const name = identifierRegex.test(obj.func) ? obj.func : quote(obj.func);
+    return `${name}(${renderArgs( obj, '=>', env )})`;
   }
 
   /**
    * Render an expression.
    *
    * @param {any} expr
-   * @param {CdlRenderEnvironment} env
-   * @param {boolean} [inline]
-   * @param {boolean} [nestedExpr]
+   * @param {CdlRenderEnvironment} exprEnv
+   * @param {boolean} [isInline]
+   * @param {boolean} [isNestedExpr]
    * @param {boolean} [alwaysRenderCast]
    * @returns {string}
    */
-  function renderExpr(expr, env, inline, nestedExpr, alwaysRenderCast) {
+  function renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast) {
     if (!_renderExpr) {
       _renderExpr = getExpressionRenderer({
-        finalize: x => x,
-        explicitTypeCast: (x, env) => {
-          const typeRef = renderTypeReference(x.cast, env, true);
+        finalize(x) {
+          return x;
+        },
+        explicitTypeCast(x, env) {
+          const typeRef = renderTypeReferenceAndProps(x.cast, env, { typeRefOnly: true, noAnnoCollect: true });
           const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
           return `cast(${renderArgument(arg, env)} as ${typeRef})`;
         },
@@ -1723,42 +1676,40 @@ function toCdsSourceCsn(csn, options) {
         aliasOnly(x, _env) {
           return x.as;
         },
-        enum: x => `#${x['#']}`,
+        enum(x) {
+          return `#${x['#']}`;
+        },
         ref(x, env) {
           const { inline } = this;
           return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, inline, env)).join('.')}`;
         },
-        windowFunction: (x, env) => {
-          const funcDef = renderFunc(x.func, x, null, a => renderArgs(a, '=>', env));
+        windowFunction(x, env) {
+          const funcDef = renderFuncExpr(x, env);
           const windowFunctionOperator = x.xpr.shift(); // OVER ...
           return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
         },
-        func: (x, env) => {
-          // 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));
+        func(x, env) {
+          return renderFuncExpr(x, env);
         },
         xpr(x, env) {
           if (this.nestedExpr && !x.cast || x.xpr.some(s => s === 'exists'))
             return `(${renderExpr(x.xpr, env, this.inline, true)})`;
-
           return renderExpr(x.xpr, env, this.inline, true);
         },
         // Sub-queries in expressions need to be in parentheses, otherwise
         // left-associativity of UNIONS may result in different results.
         // For example: `select from E where id in (select from E union select from E);`:
         // Without parentheses, it would be different query.
-        SET: (x, env) => `(${renderQuery(x, false, 'view', increaseIndent(env))})`,
-        SELECT: (x, env) => `(${renderQuery(x, false, 'view', increaseIndent(env))})`,
+        SET(x, env) {
+          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
+        },
+        SELECT(x, env) {
+          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
+        },
       });
     }
-    return _renderExpr(expr, env, inline, nestedExpr, alwaysRenderCast);
+
+    return _renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast);
   }
 }
 
@@ -1772,15 +1723,19 @@ 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: '',
+    path: null,
     artifactName: '',
     elementName: '',
   };
 }
 
+function envAddPath(env, path) {
+  return Object.assign({}, env, { path: [ ...env.path, ...path ] } );
+}
+function envNewPath(env, path) {
+  return Object.assign({}, env, { path: [ ...path ] } );
+}
+
 /**
  * Returns a copy of 'env' with increased indentation (and reset name prefix)
  *
@@ -1788,22 +1743,25 @@ function createEnv() {
  * @returns {CdlRenderEnvironment}
  */
 function increaseIndent(env) {
-  return Object.assign({}, env, { namePrefix: '', indent: `${env.indent}  ` });
+  return Object.assign({}, env, { indent: `${env.indent}  ` });
 }
 
 /**
- * Return a path string 'path' with appropriate "-quotes.
+ * Quote the path steps with `![]` if necessary. For simple ids such as
+ * `elem` use `quoteIdIfRequired` instead.
  *
  * @param {string} path
  * @returns {string}
+ *
+ * @todo For paths such as `E.key`, `key` does not have to be in quotes.
  */
-function quotePathString(path) {
-  // "foo"."bar"."wiz"."blub"
+function quotePathIfRequired(path) {
   return path.split('.').map(quoteIdIfRequired).join('.');
 }
 
 /**
- * Return an id 'id' with appropriate "-quotes
+ * Quote the id with `![]` if necessary. For paths such as `E.key` use
+ * `quotePathIfRequired` instead.
  *
  * @param {string} id
  * @return {string}
@@ -1816,6 +1774,23 @@ function quoteIdIfRequired(id) {
   return id;
 }
 
+/**
+ * Quote an annotation path, e.g. `@My.@Anno.Description` if necessary.
+ * `anno` can start with `@` but is not required to be.
+ * Example of an annotation path that needs to be quoted:
+ * `@![ spaces in path ].@!["double quotes"]`.
+ *
+ * @param {string} anno
+ * @returns {string}
+ */
+function quoteAnnotationPathIfRequired(anno) {
+  return anno.split('.').map((segment) => {
+    if (segment.startsWith('@'))
+      return `@${quoteIdIfRequired(segment.slice(1))}`;
+    return quoteIdIfRequired(segment);
+  }).join('.');
+}
+
 /**
  * Quotes the identifier using CDL-style ![]-quotes.
  *
@@ -1828,20 +1803,14 @@ function quote(id) {
 
 /**
  * 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, ...)
+ * does not match the first part of the `Identifier` rule of `language.g4`
+ * or if 'id' is a reserved keyword.
  *
  * @param {string} id
  * @return {boolean}
  */
 function requiresQuotingForCdl(id) {
-  return /^\d/.test(id) ||
-    /\W/g.test(id.replace(/\./g, '')) ||
+  return !identifierRegex.test(id) ||
     keywords.cdl.includes(id.toUpperCase()) ||
     keywords.cdl_functions.includes(id.toUpperCase());
 }
@@ -1865,18 +1834,52 @@ const functionExpressionOperatorsRequireParentheses = [
  * in a `fct(<xpr>)` expression such as `cast(<xpr> as Type)`.  We only need to
  * look at the first nesting level.  Otherwise, `renderExpr()` will already add parentheses.
  *
- * The list was created by looking at the `expression` Antlr rule.
+ * The list of `functionExpressionOperatorsRequireParentheses` was created by looking at
+ * the `expression` Antlr rule.
+ * Because of token-rewrites, there are functions that allow operators/tokens that would
+ * require parentheses in other functions.  For example *regex functions allow `IN` but
+ * if `IN` is used in other functions, it requires parentheses.  To allow for that case,
+ * you can set `additionalAllowedKeywords` to list of tokens that are allowed.
  *
- * This is more of a heuristic for "nicer" CDL output.  For example the
+ * Note that this is more of a heuristic for "nicer" CDL output.  For example the
  * following snippet is parsable without parentheses:
  *   `cast( case when int > 1 then int else 0 end as Integer ),`
- * However, because it is a flat xpr-array, we see `>` and assume that it is not a simple expression.
+ * However, because it is a flat xpr-array, we see `>` and assume that it is not
+ * a simple expression.
  *
  * @param {any[]} xpr
+ * @param {string[]} additionalAllowedKeywords
  * @return {boolean}
  */
-function isSimpleFunctionExpression(xpr) {
-  return !xpr || xpr.every(val => typeof val !== 'string' || !functionExpressionOperatorsRequireParentheses.includes(val.toLowerCase()));
+function isSimpleFunctionExpression(xpr, additionalAllowedKeywords = []) {
+  return !xpr || xpr.every(val => typeof val !== 'string' ||
+      (additionalAllowedKeywords.includes(val) ||
+        !functionExpressionOperatorsRequireParentheses.includes(val.toLowerCase())));
+}
+
+/**
+ * Special functions may have special parser rules, such as SAP HANA RegEx functions.
+ * They allow certain keywords in their arguments.
+ *
+ * This function is used to determine if arguments need to be put in parentheses or not.
+ * See {@link isSimpleFunctionExpression}.
+ *
+ * @param {string} funcName
+ * @param {number} argumentIndex
+ * @returns {string[]}
+ */
+function getKeywordsForSpecialFunctionArgument(funcName, argumentIndex) {
+  const f = specialFunctions[funcName] && specialFunctions[funcName][argumentIndex];
+  if (!f)
+    return [];
+  const additionalKeywords = [];
+  if (f.intro)
+    additionalKeywords.push(...f.intro);
+  if (f.expr)
+    additionalKeywords.push(...f.expr);
+  if (f.separator)
+    additionalKeywords.push(...f.separator);
+  return additionalKeywords;
 }
 
 /**
@@ -1884,7 +1887,7 @@ function isSimpleFunctionExpression(xpr) {
  * @return {string}
  */
 function renderIncludes(includes) {
-  return ` : ${includes.map(name => quoteIdIfRequired(name)).join(', ')}`;
+  return ` : ${includes.map(name => quotePathIfRequired(name)).join(', ')}`;
 }
 
 /**
@@ -1965,17 +1968,9 @@ function isSimpleString(str) {
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
  * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
- * @property {CSN.Path} [path] CSN path to the current artifact
+ * @property {string[]} [path] CSN path to the current artifact
  * @property {string}   [artifactName] Name of the artifact - set in renderArtifact
  * @property {string}   [elementName] Name of the element being rendered - set in renderElement
- * @property {{[name: string]: {
-      quotedName: string,
-      quotedAlias: string
-    }}} topLevelAliases Dictionary of aliases for used artifact names
- *
- * @property {string} [namePrefix] Current name prefix (including trailing dot if not empty)
- * @property {boolean} [skipKeys]
- * @property {CSN.Artifact} [_artifact]
  */
 
-module.exports = { toCdsSourceCsn };
+module.exports = { csnToCdl };