@sap/cds-compiler 2.11.4 → 2.13.8

package/lib/render/toCdl.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  getTopLevelArtifactNameOf, getLastPartOf,
+  getLastPartOf,
   getLastPartOfRef,
 } = require('../model/csnUtils');
 const {
@@ -9,12 +9,14 @@ const {
 } = require('../model/csnUtils');
 const keywords = require('../base/keywords');
 const { renderFunc, beautifyExprArray, findElement } = 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');
 
 /**
  * Render the CSN model 'model' to CDS source text. One source is created per
@@ -40,19 +42,19 @@ function toCdsSourceCsn(csn, options) {
 
   checkCSNVersion(csn, options);
 
-  const result = Object.create(null);
+  const cdlResult = Object.create(null);
 
   const main = 'model';
 
-  result[main] = `${options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`}`;
+  cdlResult[main] = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
 
   const subelementAnnotates = [];
 
   forEachDefinition(csn, (artifact, artifactName) => {
     const env = createEnv();
-    const sourceStr = renderArtifact(artifactName, artifact, env); // Must come first because it populates 'env.topLevelAliases'
+    const sourceStr = renderArtifact(artifactName, artifact, env);
     if (sourceStr !== '')
-      result[main] += `${sourceStr}\n`;
+      cdlResult[main] += `${sourceStr}\n`;
   });
 
   // Apply possible subelement/action return annotations with an "annotate X with"
@@ -70,7 +72,7 @@ function toCdsSourceCsn(csn, options) {
         if (elementName) // action returns do not have element name - we need less {} there
           sourceStr += '  }\n';
         sourceStr += '}\n';
-        result[main] += `${sourceStr}\n`;
+        cdlResult[main] += `${sourceStr}\n`;
       }
     }
   }
@@ -117,13 +119,13 @@ function toCdsSourceCsn(csn, options) {
         sourceStr = renderTypeOrAnnotation(annotationName, anno, env, 'annotation');
 
       if (sourceStr !== '')
-        result[main] += `${sourceStr}\n`;
+        cdlResult[main] += `${sourceStr}\n`;
     }
   }
 
   if (csn.namespace) {
-    result[csn.namespace] = `namespace ${renderArtifactName(csn.namespace)};\n`;
-    result[csn.namespace] += `using from './${main}.cds';`;
+    cdlResult[csn.namespace] = `namespace ${renderArtifactName(csn.namespace)};\n`;
+    cdlResult[csn.namespace] += `using from './${main}.cds';`;
   }
 
 
@@ -132,11 +134,11 @@ function toCdsSourceCsn(csn, options) {
   if (csn.extensions) {
     const env = createEnv();
     const sourceStr = renderUnappliedExtensions(csn.extensions, env);
-    result.unappliedExtensions = renderUsings('', env) + sourceStr;
+    cdlResult.unappliedExtensions = sourceStr;
   }
 
   timetrace.stop();
-  return result;
+  return cdlResult;
 
   /**
    * Render unapplied 'extend' and 'annotate' statements from the 'extensions array'
@@ -233,7 +235,6 @@ function toCdsSourceCsn(csn, options) {
 
     switch (art.kind) {
       case 'entity':
-      case 'view':
         if (art.query || art.projection)
           return renderView(artifactName, art, env);
 
@@ -242,8 +243,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':
@@ -254,7 +253,7 @@ function toCdsSourceCsn(csn, options) {
       case 'event':
         return renderEventIfCDLMode(artifactName, art, env);
       default:
-        throw new Error(`Unknown artifact kind: ${art.kind}`);
+        throw new ModelError(`Unknown artifact kind: ${art.kind}`);
     }
   }
 
@@ -294,37 +293,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
@@ -385,37 +353,6 @@ function toCdsSourceCsn(csn, options) {
     return `${result} {};\n`;
   }
 
-  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;
-  }
-
   /**
    * Render a (non-projection, non-view) entity. Return the resulting source string.
    *
@@ -446,84 +383,10 @@ function toCdsSourceCsn(csn, options) {
     }
 
     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.
@@ -561,7 +424,7 @@ function toCdsSourceCsn(csn, options) {
 
     // Sanity checks
     if (!query.SET || !query.SET.args || !query.SET.args[0])
-      throw new Error(`Expecting set with args in query: ${JSON.stringify(query)}`);
+      throw new ModelError(`Expecting set with args in query: ${JSON.stringify(query)}`);
 
     return leadingQuerySelect(query.SET.args[0]);
   }
@@ -620,14 +483,14 @@ function toCdsSourceCsn(csn, options) {
         if (!name.startsWith('@'))
           continue;
 
-        const annotationValue = renderAnnotationValue(elem[name], childEnv);
+        const annotationValue = renderAnnotationAssignment(elem[name], name, childEnv);
         // Skip annotation if column has the same
         if (columnMap[elemName] && columnMap[elemName][name] &&
-            renderAnnotationValue(columnMap[elemName][name], childEnv) === annotationValue)
+          renderAnnotationAssignment(columnMap[elemName][name], name, childEnv) === annotationValue)
           continue;
 
         // Annotation names are never flattened
-        elemAnnotations += `${childEnv.indent}${`@${renderAbsoluteNameWithQuotes(name.substring(1))}`} : ${annotationValue}\n`;
+        elemAnnotations += annotationValue;
       }
       if (elemAnnotations !== '')
         result += `${elemAnnotations}${childEnv.indent}${quoteOrUppercaseId(elemName)};\n`;
@@ -703,7 +566,7 @@ 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)
@@ -909,6 +772,7 @@ 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);
@@ -935,7 +799,7 @@ function toCdsSourceCsn(csn, options) {
     }
     // Otherwise must have a SELECT
     else if (!query.SELECT) {
-      throw new Error(`Unexpected query operation ${JSON.stringify(query)}`);
+      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
     }
     const select = query.SELECT;
     const childEnv = increaseIndent(env);
@@ -945,7 +809,7 @@ function toCdsSourceCsn(csn, options) {
     else if (syntax === 'view' || syntax === 'entity')
       result += `select from ${renderViewSource(select.from, env)}`;
     else
-      throw new Error(`Unknown query syntax: ${syntax}`);
+      throw new ModelError(`Unknown query syntax: ${syntax}`);
 
     if (select.mixin) {
       let elems = '';
@@ -980,7 +844,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)}`;
@@ -996,35 +860,35 @@ function toCdsSourceCsn(csn, options) {
     /**
      * Utility function to make sure that we continue with the same indentation in WHERE, GROUP BY, ... after a closing curly brace and beyond
      *
-     * @param {string} result
-     * @param {CdlRenderEnvironment} env
+     * @param {string} str
+     * @param {CdlRenderEnvironment} indentEnv
      * @return {string}
      */
-    function continueIndent(result, env) {
-      if (result.endsWith('}') || result.endsWith('})')) {
+    function continueIndent(str, indentEnv) {
+      if (str.endsWith('}') || str.endsWith('})')) {
         // The preceding clause ended with '}', just append after that
         return ' ';
       }
       // Otherwise, start new line and indent normally
-      return `\n${increaseIndent(env).indent}`;
+      return `\n${increaseIndent(indentEnv).indent}`;
     }
 
     /**
      * Render a query's LIMIT clause, which may have also have OFFSET.
      *
      * @param {CSN.QueryLimit} limit
-     * @param {CdlRenderEnvironment} env
+     * @param {CdlRenderEnvironment} limitEnv
      * @return {string}
      */
-    function renderLimit(limit, env) {
-      let result = '';
+    function renderLimit(limit, limitEnv) {
+      let limitStr = '';
       if (limit.rows !== undefined)
-        result += `limit ${renderExpr(limit.rows, env)}`;
+        limitStr += `limit ${renderExpr(limit.rows, limitEnv)}`;
 
       if (limit.offset !== undefined)
-        result += `${result !== '' ? `\n${increaseIndent(env).indent}` : ''}offset ${renderExpr(limit.offset, env)}`;
+        limitStr += `${limitStr !== '' ? `\n${increaseIndent(limitEnv).indent}` : ''}offset ${renderExpr(limit.offset, limitEnv)}`;
 
-      return result;
+      return limitStr;
     }
   }
 
@@ -1037,7 +901,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderOrderByEntry(entry, env) {
-    let result = renderDocComment(entry, env) + renderExpr(entry, env);
+    let result = renderDocComment(entry, env) + renderExpr(entry, env, true, false, true);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1140,7 +1004,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;
   }
@@ -1176,7 +1043,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);
@@ -1214,7 +1081,7 @@ function toCdsSourceCsn(csn, options) {
         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.');
       }
 
 
@@ -1335,7 +1202,7 @@ function toCdsSourceCsn(csn, options) {
     // Primitive: string, number, boolean
 
     // Quote strings, leave all others as they are
-    return (typeof x === 'string') ? `'${x.replace(/'/g, '\'\'')}'` : x;
+    return (typeof x === 'string') ? renderString(x, env) : x;
   }
 
   /**
@@ -1346,14 +1213,16 @@ function toCdsSourceCsn(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @param {boolean} [inline=true]
    * @param {boolean} [inExpr=false] Whether the expression is already inside another expression
+   * @param {boolean} [alwaysRenderCast=false] Whether to _always_ render SQL-style casts, even if `inExpr === false`
+   *                                           Note: This is a hack for casts() inside groupBy.
    */
-  function renderExpr(x, env, inline = true, inExpr = false) {
+  function renderExpr(x, env, inline = true, inExpr = false, alwaysRenderCast = false) {
     // Compound expression
     if (Array.isArray(x))
       return beautifyExprArray(x.map(item => renderExpr(item, env, inline, inExpr)));
 
     if (typeof x === 'object' && x !== null) {
-      if (inExpr && x.cast && x.cast.type)
+      if ((inExpr || alwaysRenderCast) && x.cast && x.cast.type)
         return renderExplicitTypeCast(renderExprObject());
       return renderExprObject();
     }
@@ -1385,14 +1254,14 @@ function toCdsSourceCsn(csn, options) {
           case 'timestamp':
             return `${x.literal}'${x.val}'`;
           case 'string':
-            return `'${x.val.replace(/'/g, '\'\'')}'`;
+            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)}`);
+            throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
         }
       }
       // Enum symbol
@@ -1439,7 +1308,7 @@ function toCdsSourceCsn(csn, options) {
         return `${renderQuery(x, false, 'view', increaseIndent(env))}`;
       }
       else {
-        throw new Error(`Unknown expression: ${JSON.stringify(x)}`);
+        throw new ModelError(`Unknown expression: ${JSON.stringify(x)}`);
       }
     }
 
@@ -1476,7 +1345,7 @@ function toCdsSourceCsn(csn, options) {
       else if (typeof s === 'object') {
         // Sanity check
         if (!s.func && !s.id)
-          throw new Error(`Unknown path step object: ${JSON.stringify(s)}`);
+          throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
 
         // Not really a path step but an object-like function call
         if (s.func)
@@ -1496,7 +1365,7 @@ function toCdsSourceCsn(csn, options) {
         return result;
       }
 
-      throw new Error(`Unknown path step: ${JSON.stringify(s)}`);
+      throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
     }
   }
 
@@ -1513,14 +1382,14 @@ function toCdsSourceCsn(csn, options) {
     const args = node.args ? node.args : {};
     // Positional arguments
     if (Array.isArray(args))
-      return args.map(arg => renderExpr(arg, env)).join(', ');
+      return args.map(arg => renderExpr(arg, env, true, false, true)).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 => `${quoteOrUppercaseId(key)} ${sep} ${renderExpr(args[key], env, true, false, true)}`).join(', ');
 
 
-    throw new Error(`Unknown args: ${JSON.stringify(args)}`);
+    throw new ModelError(`Unknown args: ${JSON.stringify(args)}`);
   }
 
   /**
@@ -1642,66 +1511,38 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * Render a single annotation assignment 'ann' with fully qualified name 'name' (no trailing LF).
-   * We might see variants like 'A.B.C#foo' or even 'A.B#foo.C'. In both cases, the #foo must be ignored
-   * when resolving the name, but must stay in the rendered output (quoted as necessary).
+   * Render a single annotation assignment 'anno' with fully qualified name 'name' (no trailing LF).
+   * We might see variants like 'A.B.C#foo' or even 'A.B#foo.C'. The latter needs to be quoted as
+   * dots in the variant are not recognized by the compiler.
    *
-   * @param {any} ann Annotation value
+   * @param {any} anno Annotation value
    * @param {string} name Annotation name, e.g. `@A.B.C#foo.C`
    * @param {CdlRenderEnvironment} env
-   * @return {string}
+   * @return {string} Rendered annotation, possibly quoted: `@![A.B.C#foo.C]: value`
    */
-  function renderAnnotationAssignment(ann, name, env) {
-    // Take the annotation assignment apart into <nameBeforeVariant>[#<variant>[.<nameAfterVariant>]]
-    //                      @1111111  3333333   5555
-    const parts = name.match(/@([^#]+)(#([^.]+)(\.(.+))?)?/);
-    const nameBeforeVariant = parts[1];
-    const variant = parts[3];
-    const nameAfterVariant = parts[5];
-    const topLevelName = getTopLevelArtifactNameOf(nameBeforeVariant, csn);
-    let result = `${env.indent}@`;
-    if (topLevelName) {
-      // Checked annotation, with declaration - must render top-level absolute name with proper using and alias
-      // Annotation names are never flattened
-      result += renderAbsoluteNameWithQuotes(topLevelName);
-      if (topLevelName !== nameBeforeVariant)
-        result += `.${quotePathString(nameBeforeVariant.substring(topLevelName.length + 1))}`;
-    }
-    else {
-      // Unchecked annotation, just render the name as it is
-      result += nameBeforeVariant;
-    }
-    // Append '#'-variant if any
-    if (variant) {
-      // FIXME: Unfortunately, the compiler does not yet understand an inner variant with proper quoting,
-      // i.e. like "__A"."B"#"foo"."C". As a workaround, we present the '#'-variant as a quoted part of the
-      // previous path step, i.e as "__A"."B#foo"."C" (which yields the same result). This hack is only necessary
-      // for inner '#'-variants, i.e. for those followed by a <nameAfterVariant>.
-      // FIXME: Won't work for inner variants on the top-level artifact, because the USING no longer matches
-      // for something like "__A#foo"."B"."C"
-      if (nameAfterVariant) {
-        const resultSteps = result.split('.');
-        // Take all paths steps from the result (which is now essentially 'nameBeforeVariant' with USING
-        // adaptations) except the last step
-        result = resultSteps.slice(0, -1).join('.');
-        // Append a combination of last path step and '#'-variant (quoted)
-        let lastStep = resultSteps[resultSteps.length - 1];
-        if (lastStep.includes('"')) {
-          // Last step was already quoted - strip off the existing quotes
-          lastStep = lastStep.slice(1, -1);
-        }
-        result += `.${quoteIdIfRequired(`${lastStep}#${variant}`)}`;
-      }
-      else {
-        // No hack required for trailing '#'-variant
-        result += `#${quoteIdIfRequired(variant)}`;
-      }
-    }
-    // Append anything that might have come after the variant
-    if (nameAfterVariant)
-      result += `.${quotePathString(nameAfterVariant)}`;
+  function renderAnnotationAssignment(anno, name, env) {
+    name = name.substring(1);
+    // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
+    const parts = name.split('#');
+    const nameBeforeVariant = parts[0];
+    const variant = parts[1];
+
+    // Identifier according to our grammar: /[$_a-zA-Z][$_a-zA-Z0-9]*/
+    // We expand this pattern to also include dots after the first character.
+    // If the annotation does not follow this pattern `ident(.@ident)*`, it must be quoted:
+    // `@identifier@identifier` must be quoted but `@identifier.@identifier` should not.
+    const annoRequiresQuoting = !/^[$_a-zA-Z][$_a-zA-Z0-9.]*(?:\.@[$_a-zA-Z][$_a-zA-Z0-9.]*)*$/.test(nameBeforeVariant);
+    // Unfortunately, the compiler does not allow `.` after the first variant identifier,
+    // even though that is the result after flattening.
+    const variantRequiresQuoting = variant && !/^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(variant);
+
+    let result;
+    if (annoRequiresQuoting || variantRequiresQuoting)
+      result = `${env.indent}@${quote(name)}`;
+    else
+      result = `${env.indent}@${name}`;
 
-    result += ` : ${renderAnnotationValue(ann, env)}`;
+    result += ` : ${renderAnnotationValue(anno, env)}`;
     return `${result}\n`;
   }
 
@@ -1717,23 +1558,6 @@ function toCdsSourceCsn(csn, options) {
     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.
@@ -1748,20 +1572,11 @@ function toCdsSourceCsn(csn, options) {
       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)
    *
@@ -1792,11 +1607,21 @@ function toCdsSourceCsn(csn, options) {
   function quoteIdIfRequired(id) {
     // Quote if required for CDL
     if (requiresQuotingForCdl(id))
-      return `![${id.replace(/]/g, ']]')}]`;
+      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
@@ -1837,7 +1662,7 @@ 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
@@ -1864,14 +1689,14 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * 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;
 
@@ -1885,7 +1710,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('.');
@@ -1897,6 +1722,80 @@ function toCdsSourceCsn(csn, options) {
   }
 }
 
+/**
+ * Render the given string.  Uses back-tick strings.
+ * env is used for indentation of three-back-tick strings.
+ *
+ * @param str
+ * @param env
+ * @returns {string}
+ */
+function renderString(str, env) {
+  if (isSimpleString(str))
+    return `'${str.replace(/'/g, '\'\'')}'`;
+
+  // We try to work similar to how JavaScript implements JSON.stringify.
+  // 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,
+  });
+
+  // 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
+  // are more than three lines, text blocks with indentation "look nicer".
+  // This value was chosen by personal taste.
+  if (lines.length > 3) {
+    str = lines.join(`\n${env.indent}`);
+    return `\`\`\`\n${env.indent}${str}\n${env.indent}\`\`\``;
+  }
+
+  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
+ */
+function isSimpleString(str) {
+  // A single-line string allows everything except certain line separators/breaks.
+  // See ANTLR grammar for specifics.
+  // 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, 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) &&
+    !hasUnpairedUnicodeSurrogate(str));
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *