@sap/cds-compiler 3.4.4 → 3.5.2

package/lib/render/toCdl.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const keywords = require('../base/keywords');
-const { isBuiltinType, generatedByCompilerVersion, getNormalizedQuery } = require('../model/csnUtils');
 const { findElement, createExpressionRenderer, withoutCast } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
@@ -12,6 +11,12 @@ const { isBetaEnabled } = require('../base/model');
 const { ModelError } = require('../base/error');
 const { typeParameters, specialFunctions } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
+const {
+  isBuiltinType,
+  generatedByCompilerVersion,
+  getNormalizedQuery,
+  cloneCsnNonDict,
+} = require('../model/csnUtils');
 
 const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
 
@@ -24,15 +29,36 @@ const identifierRegex = /^[$_a-zA-Z][$_a-zA-Z0-9]*$/;
  * @param {CSN.Model} csn
  * @param {CSN.Options} [options]
  */
-function csnToCdl(csn, options) {
+function csnToCdl( csn, options ) {
   timetrace.start('CDL rendering');
-  const exprRenderer = createCdlExpressionRenderer();
 
-  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn'))
+  if (options.csnFlavor === 'universal' && isBetaEnabled(options, 'enableUniversalCsn')) {
+    // Since the expander modifies the CSN, we need to clone it first or
+    // toCdl can't guarantee that the input CSN is not modified.
+    csn = cloneCsnNonDict(csn, options);
     enrichUniversalCsn(csn, options);
+  }
 
   checkCSNVersion(csn, options);
 
+  const exprRenderer = createCdlExpressionRenderer();
+  const usings = {
+    list: [],
+    available: availableFirstPathSteps(csn),
+    addIfRequired(name) {
+      // RegEx is at least twice as fast as .split()[0]
+      const first = name.match(/^[^.]+/)[0];
+      if (!this.available.includes(first) && !this.list.includes(first))
+        this.list.push(first);
+    },
+    renderUsings() {
+      if (this.list.length === 0)
+        return '';
+      return `using { ${this.list.join(', ')} };\n\n`;
+    },
+  };
+  const hanaRequiresAbsolutePath = usings.available.includes('hana');
+
   const cdlResult = Object.create(null);
   cdlResult.model = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
 
@@ -52,7 +78,14 @@ function csnToCdl(csn, options) {
     cdlResult.namespace += 'using from \'./model.cds\';';
   }
 
-  timetrace.stop();
+  cdlResult.model = usings.renderUsings() + cdlResult.model;
+  if (csn.requires) {
+    let usingsStr = csn.requires.map(req => `using from '${req}';`).join('\n');
+    usingsStr += '\n\n';
+    cdlResult.model = usingsStr + cdlResult.model;
+  }
+
+  timetrace.stop('CDL rendering');
   return cdlResult;
 
   /**
@@ -79,12 +112,12 @@ function csnToCdl(csn, options) {
    * @param {object} vocabularies
    * @return {string}
    */
-  function renderVocabularies(vocabularies) {
+  function renderVocabularies( vocabularies ) {
     let result = '';
     forEach(vocabularies, renderVocabulariesEntry);
     return result;
 
-    function renderVocabulariesEntry(name, anno) {
+    function renderVocabulariesEntry( name, anno ) {
       if (!anno._ignore) {
         // This environment is passed down the call hierarchy, for dealing with
         // indentation and name resolution issues
@@ -104,7 +137,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtensions(extensions, env) {
+  function renderExtensions( extensions, env ) {
     if (!env.path)
       env = envNewPath(env, [ 'extensions' ]);
     return extensions.map((ext, index) => renderExtension(ext, envAddPath(env, [ index ]))).join('\n');
@@ -117,7 +150,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtension(ext, env) {
+  function renderExtension( ext, env ) {
     if (ext.extend)
       return renderExtendStatement(ext.extend, ext, env);
     return renderAnnotateStatement(ext, env);
@@ -133,20 +166,33 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtendStatement(extName, ext, env) {
-    extName = renderArtifactName(extName);
-    // Element extensions have `kind` set.
-    const isElementExtend = (ext.kind === 'extend');
+  function renderExtendStatement( extName, ext, env ) {
+    // Element extensions have `kind` set. Don't use for enum extension.
+    const isElementExtend = (ext.kind === 'extend' && !ext.enum);
     let result = renderAnnotationAssignmentsAndDocComment(ext, env);
+    extName = isElementExtend ? renderArtifactName(extName) : renderDefinitionReference(extName);
 
     if (ext.includes && ext.includes.length > 0) {
       // Includes can't be combined with anything in braces {}.
       const affix = isElementExtend ? 'element ' : '';
-      const includes = ext.includes.map(inc => quotePathIfRequired(inc)).join(', ');
+      const includes = ext.includes.map(inc => renderDefinitionReference(inc)).join(', ');
       result += `${env.indent}extend ${affix}${extName} with ${includes};\n`;
       return result;
     }
 
+    const typeParams = renderTypeParameters(ext, true);
+    if (typeParams) {
+      result += `${env.indent}extend ${extName} with ${typeParams};\n`;
+      return result;
+    }
+
+    // If there is nothing to extend, e.g. only annotations, don't render an
+    // empty element list.  This would end up in diffs with parseCdl CSN.
+    if (!ext.elements && !ext.columns && !ext.actions && !ext.enum) {
+      result += `${env.indent}extend ${extName};\n`;
+      return result;
+    }
+
     // 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.
@@ -157,18 +203,12 @@ function csnToCdl(csn, options) {
     else
       result += `${env.indent}extend ${extName} with ${getExtendPostfixVariant(ext)} {\n`;
 
-    if (ext.columns) {
+    if (ext.columns)
       result += renderViewColumns(ext.columns, increaseIndent(env));
-    }
-    else if (ext.elements) {
+
+    else if (ext.elements || ext.enum)
       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) {
@@ -194,7 +234,7 @@ function csnToCdl(csn, options) {
    * @param {object} ext
    * @return {string}
    */
-  function getExtendPrefixVariant(ext) {
+  function getExtendPrefixVariant( ext ) {
     if (ext.kind === 'extend')
       return 'element'; // element extensions inside an `extend`
     if (ext.columns)
@@ -210,7 +250,7 @@ function csnToCdl(csn, options) {
    * @param {CSN.Extension} ext
    * @return {string}
    */
-  function getExtendPostfixVariant(ext) {
+  function getExtendPostfixVariant( ext ) {
     if (ext.columns)
       return 'columns';
     if (ext.actions)
@@ -229,15 +269,15 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtendStatementElements(ext, env) {
+  function renderExtendStatementElements( ext, env ) {
     let result = '';
-    forEach(ext.elements || {}, (elemName, element) => {
+    forEach(ext.elements || ext.enum || {}, (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);
+        result += renderElement(elemName, element, increaseIndent(env));
     });
     return result;
   }
@@ -249,9 +289,11 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateStatement(ext, env) {
+  function renderAnnotateStatement( ext, env ) {
     // Top-level annotations of the artifact
     let result = renderAnnotationAssignmentsAndDocComment(ext, env);
+    // Note: Not renderDefinitionReference, because we don't care if there
+    //       are annotations to unknown things. That's allowed!
     result += `${env.indent}annotate ${renderArtifactName(ext.annotate)}`;
 
     if (ext.params)
@@ -260,6 +302,8 @@ function csnToCdl(csn, options) {
     // Element extensions and annotations (possibly nested)
     if (ext.elements)
       result += renderAnnotateStatementElements(ext.elements, env);
+    if (ext.enum)
+      result += renderAnnotateStatementElements(ext.enum, env);
 
     // Returns annotations
     if (ext.returns) {
@@ -298,18 +342,21 @@ function csnToCdl(csn, options) {
    * 'elements' (assuming that the surrounding parent has just been rendered, without trailing newline).
    * Returns the resulting source string, ending without a trailing newline.
    *
-   * @param {CSN.Elements} elements
+   * @param {object} elements
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateStatementElements(elements, env) {
+  function renderAnnotateStatementElements( elements, env ) {
     let result = ' {\n';
     const childEnv = increaseIndent(env);
     for (const name in elements) {
       const elem = elements[name];
-      result += renderAnnotationAssignmentsAndDocComment(elem, childEnv) + childEnv.indent + quoteIdIfRequired(name);
+      result += renderAnnotationAssignmentsAndDocComment(elem, childEnv);
+      result += childEnv.indent + quoteIdIfRequired(name);
       if (elem.elements)
         result += renderAnnotateStatementElements(elem.elements, childEnv);
+      if (elem.enum)
+        result += renderAnnotateStatementElements(elem.enum, childEnv);
 
       result += ';\n';
     }
@@ -324,7 +371,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateParamsInParentheses(params, env) {
+  function renderAnnotateParamsInParentheses( params, env ) {
     const childEnv = increaseIndent(env);
     let result = '(\n';
     const paramAnnotations = [];
@@ -342,7 +389,7 @@ function csnToCdl(csn, options) {
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function renderArtifact(artifactName, art, env) {
+  function renderArtifact( artifactName, art, env ) {
     env = envNewPath(env, [ 'definitions', artifactName ]);
     env.artifactName = artifactName;
 
@@ -379,7 +426,7 @@ function csnToCdl(csn, options) {
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function renderEvent(artifactName, art, env) {
+  function renderEvent( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     const normalizedArtifactName = renderArtifactName(artifactName);
     result += `${env.indent}event ${normalizedArtifactName}`;
@@ -407,7 +454,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderContextOrService(artifactName, art, env) {
+  function renderContextOrService( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent}${art.kind} ${renderArtifactName(artifactName)}`;
     return `${result} {};\n`;
@@ -421,7 +468,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderEntity(artifactName, art, env) {
+  function renderEntity( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += env.indent + (art.abstract ? 'abstract ' : '');
     result += `entity ${renderArtifactName(artifactName)}`;
@@ -445,7 +492,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAspect(artifactName, art, env) {
+  function renderAspect( artifactName, art, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent}aspect ${renderArtifactName(artifactName)}`;
     if (art.includes)
@@ -468,11 +515,11 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderElements(artifact, env) {
+  function renderElements( artifact, env ) {
     let elements = '';
     const childEnv = increaseIndent(env);
     for (const name in artifact.elements)
-      elements += renderElement(name, artifact.elements[name], childEnv, null);
+      elements += renderElement(name, artifact.elements[name], childEnv);
 
     if (elements === '')
       return '{ }';
@@ -480,23 +527,34 @@ function csnToCdl(csn, options) {
   }
 
   /**
-   * Render an element (of an entity, type or annotation, not a projection or view).
-   * Return the resulting source string.
+   * Render an element (of an entity, type or annotation, not a projection or view)
+   * or an enum symbol.
+   * Returns the resulting source string.
    *
    * @param {string} elementName
-   * @param {CSN.Element} elm
+   * @param {CSN.Element|CSN.Enum} elm
    * @param {CdlRenderEnvironment} env
-   * @param {Boolean} [isSubElement]
    */
-  function renderElement(elementName, elm, env, isSubElement) {
+  function renderElement( elementName, elm, env ) {
     env = envAddPath(env, [ 'elements', elementName ]);
     let result = renderAnnotationAssignmentsAndDocComment(elm, env);
     result += env.indent;
     result += elm.virtual ? 'virtual ' : '';
-    result += elm.key && !isSubElement ? 'key ' : '';
+    result += elm.key ? 'key ' : '';
     // TODO(v4): Remove once deprecated flag for `masked` is removed.
     result += elm.masked ? 'masked ' : '';
-    result += `${quoteIdIfRequired(elementName)} : ${renderTypeReferenceAndProps(elm, env)}`;
+    result += quoteIdIfRequired(elementName);
+    if (elm.val !== undefined) {
+      result += ` = ${exprRenderer.renderExpr(elm, env)}`;
+    }
+    else if (elm['#'] !== undefined) {
+      result += ` = #${elm['#']}`;
+    }
+    else {
+      const props = renderTypeReferenceAndProps(elm, env);
+      if (props !== '')
+        result += ` : ${props}`;
+    }
 
     return `${result};\n`;
   }
@@ -516,8 +574,8 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderQueryElementAndEnumAnnotations(artifactName, art, env) {
-    const annotate = collectAnnotationsOfElementsAndEnum(art, { artifactName, path: env.path });
+  function renderQueryElementAndEnumAnnotations( artifactName, art, env ) {
+    const annotate = collectAnnotationsOfElementsAndEnum(art, createEnv({ artifactName, path: env.path }));
     if (annotate)
       return renderExtensions([ annotate ], env);
     return '';
@@ -531,7 +589,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {CSN.Extension|null}
    */
-  function collectAnnotationsOfElementsAndEnum(artifact, env) {
+  function collectAnnotationsOfElementsAndEnum( artifact, env ) {
     // Array, which may be annotated as well.
     if (artifact.items) {
       env = envAddPath(env, [ 'items' ]);
@@ -573,7 +631,7 @@ function csnToCdl(csn, options) {
      *
      * @return {boolean} True, if there were annotations, false otherwise.
      */
-    function collectAnnos(annotateObj, art) {
+    function collectAnnos( annotateObj, art ) {
       if (!art.elements && !art.enum)
         return false;
 
@@ -617,7 +675,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderViewSource(source, env) {
+  function renderViewSource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
       let result = `(${renderQuery(source, false, 'view', increaseIndent(env))})`;
@@ -645,7 +703,7 @@ function csnToCdl(csn, options) {
     return renderAbsolutePathWithAlias(source, env);
   }
 
-  function renderJoinCardinality(card) {
+  function renderJoinCardinality( card ) {
     let result = '';
     if (card) {
       if (card.srcmin && card.srcmin === 1)
@@ -669,17 +727,16 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAbsolutePath(path, env) {
+  function renderAbsolutePath( path, env ) {
     // Sanity checks
     if (!path.ref)
       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];
 
     // Render the first path step (absolute name, with different quoting/naming ..)
-    let result = renderArtifactName(firstArtifactName);
+    let result = renderDefinitionReference(firstArtifactName);
 
     // Even the first step might have parameters and/or a filter
     if (path.ref[0].args)
@@ -709,7 +766,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAbsolutePathWithAlias(path, env) {
+  function renderAbsolutePathWithAlias( path, env ) {
     let result = renderAbsolutePath(path, env);
     if (path.as) {
       // Source had an alias - render it
@@ -726,7 +783,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderViewColumns(columns, env, elements = Object.create(null)) {
+  function renderViewColumns( columns, env, elements = Object.create(null) ) {
     const result = columns.map(col => renderViewColumn(col, env, findElement(elements, col)))
       .filter(s => s !== '')
       .join(',\n');
@@ -742,7 +799,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @param {CSN.Element} element Element corresponding to the column. Generated by the compiler.
    */
-  function renderViewColumn(col, env, element) {
+  function renderViewColumn( col, env, element ) {
     // Annotations and column
     let result = '';
     if (!col.doc) {
@@ -789,7 +846,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderInlineExpand(obj, env) {
+  function renderInlineExpand( obj, env ) {
     // No expression to render for { * } as alias
     let result = (obj.as && obj.expand && !obj.ref) ? '' : exprRenderer.renderExpr(withoutCast(obj), env);
 
@@ -814,11 +871,9 @@ function csnToCdl(csn, options) {
     // 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 += expandInline //
+      .map(elm => renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + renderInlineExpand(elm, childEnv))
+      .join(',\n');
     result += `\n${env.indent}}`;
 
     // Don't forget about the .excluding
@@ -839,7 +894,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {String}
    */
-  function renderDocComment(obj, env) {
+  function renderDocComment( obj, env ) {
     if (!obj || obj && obj.doc === undefined)
       return '';
     else if (obj && obj.doc === null) // empty doc comment needs to be rendered
@@ -855,15 +910,11 @@ function csnToCdl(csn, options) {
   }
 
   /**
-   * Render a view. If '$syntax' is set (to 'projection', 'view', 'entity'),
-   * the view query is rendered in the requested syntax style, otherwise it
-   * is rendered as a view.
-   *
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function renderView(artifactName, art, env) {
+  function renderView( artifactName, art, env ) {
     const syntax = (art.projection) ? 'projection' : 'entity';
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent}entity ${renderArtifactName(artifactName)}`;
@@ -893,7 +944,7 @@ function csnToCdl(csn, options) {
    * @param {CSN.Path} [path=[]]
    * @param {object} [elements]
    */
-  function renderQuery(query, isLeadingQuery, syntax, env, path = [], elements = query.elements || Object.create(null)) {
+  function renderQuery( query, isLeadingQuery, syntax, env, path = [], elements = query.elements || Object.create(null) ) {
     if (query.SET) {
       // Set operator, such as UNION, INTERSECT, or EXCEPT...
       return renderQuerySet();
@@ -962,7 +1013,7 @@ function csnToCdl(csn, options) {
      * @param {CdlRenderEnvironment} indentEnv
      * @return {string}
      */
-    function continueIndent(str, indentEnv) {
+    function continueIndent( str, indentEnv ) {
       if (str.endsWith('}') || str.endsWith('})')) {
         // The preceding clause ended with '}', just append after that
         return ' ';
@@ -978,7 +1029,7 @@ function csnToCdl(csn, options) {
      * @param {CdlRenderEnvironment} limitEnv
      * @return {string}
      */
-    function renderLimit(limit, limitEnv) {
+    function renderLimit( limit, limitEnv ) {
       let limitStr = '';
       if (limit.rows !== undefined)
         limitStr += `limit ${exprRenderer.renderExpr(limit.rows, limitEnv)}`;
@@ -1022,7 +1073,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderOrderByEntry(entry, env) {
+  function renderOrderByEntry( entry, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(entry, env) + exprRenderer.renderExpr(entry, env);
     if (entry.sort)
       result += ` ${entry.sort}`;
@@ -1043,7 +1094,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderActionsAndFunctions(art, env) {
+  function renderActionsAndFunctions( art, env ) {
     let result = '';
     const childEnv = increaseIndent(env);
     for (const name in art.actions)
@@ -1064,7 +1115,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderActionOrFunction(actionName, act, env) {
+  function renderActionOrFunction( actionName, act, env ) {
     let result = renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind;
     result += ` ${renderArtifactName(actionName)}`;
     result += renderParameters(act, env);
@@ -1086,7 +1137,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderParameters(art, env) {
+  function renderParameters( art, env ) {
     const childEnv = increaseIndent(env);
     const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv));
     if (parameters.length === 0)
@@ -1102,7 +1153,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderParameter(parName, par, env) {
+  function renderParameter( parName, par, env ) {
     env = envAddPath(env, [ 'params', parName ]);
     let result = `${renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
     result += `${quoteIdIfRequired(parName)} : ${renderTypeReferenceAndProps(par, env)}`;
@@ -1119,7 +1170,7 @@ function csnToCdl(csn, options) {
    * @param {String} [artType] - used for rendering csn.vocabularies, as the annotations there do not have a kind.
    * @return {string}
    */
-  function renderTypeOrAnnotation(artifactName, art, env, artType) {
+  function renderTypeOrAnnotation( artifactName, art, env, artType ) {
     let result = renderAnnotationAssignmentsAndDocComment(art, env);
     result += `${env.indent + (artType || art.$syntax || art.kind )} ${renderArtifactName(artifactName)}`;
     if (art.includes)
@@ -1144,7 +1195,7 @@ function csnToCdl(csn, options) {
    *                             - `noAnnoCollect` Do not collect annotations of sub-elements.
    * @return {string}
    */
-  function renderTypeReferenceAndProps(artifact, env, config = {}) {
+  function renderTypeReferenceAndProps( artifact, env, config = {} ) {
     let result = '';
     const { typeRefOnly, noAnnoCollect } = config;
     let isTypeDef = env.path?.length === 2; // e.g [ 'definitions', typeDef ];
@@ -1250,8 +1301,8 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderRedirectedTo(art, env) {
-    let result = `redirected to ${quotePathIfRequired(art.target)}`;
+  function renderRedirectedTo( art, env ) {
+    let result = `redirected to ${renderDefinitionReference(art.target)}`;
     if (art.on)
       result += ` on ${exprRenderer.renderExpr(art.on, env)}`;
     else if (art.keys)
@@ -1264,19 +1315,22 @@ function csnToCdl(csn, options) {
    * @param {CSN.Artifact} artWithType
    * @return {string}
    */
-  function renderNamedTypeWithParameters(artWithType) {
+  function renderNamedTypeWithParameters( artWithType ) {
     let result = '';
 
     if (isBuiltinType(artWithType.type)) {
-      // If there is a user-defined type with the same short name (cds.Integer -> Integer),
-      // we render the full name, including the leading "cds."
-      if (csn.definitions[artWithType.type.slice(4)])
+      // If there is a user-defined type that starts with the same short name
+      // (cds.Integer -> Integer), we render the full name, including the leading "cds."
+      const shortHand = artWithType.type.slice(4);
+      if (shortHand.startsWith('hana.') && hanaRequiresAbsolutePath)
+        result += artWithType.type;
+      else if (usings.available.includes(shortHand))
         result += artWithType.type;
       else
-        result += artWithType.type.slice(4);
+        result += shortHand;
     }
     else {
-      result += renderArtifactName(artWithType.type);
+      result += renderDefinitionReference(artWithType.type);
     }
 
     result += renderTypeParameters(artWithType);
@@ -1291,35 +1345,15 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderEnum(enumPart, env) {
+  function renderEnum( enumPart, env ) {
     let result = ' enum {\n';
     const childEnv = increaseIndent(env);
     for (const name in enumPart)
-      result += renderEnumElement(name, enumPart[name], childEnv);
+      result += renderElement(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 += ` = ${exprRenderer.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)
@@ -1327,7 +1361,7 @@ function csnToCdl(csn, options) {
    * @param {any} x
    * @param {CdlRenderEnvironment} env
    */
-  function renderAnnotationValue(x, env) {
+  function renderAnnotationValue( x, env ) {
     if (Array.isArray(x)) {
       // Render array parts as values. Spaces required if last array value is
       // a delimited identifier.
@@ -1377,7 +1411,7 @@ function csnToCdl(csn, options) {
    * @param {object} env
    * @returns {string}
    */
-  function renderPathStep(s, idx, env) {
+  function renderPathStep( s, idx, 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.
@@ -1424,7 +1458,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderArguments(node, sep, env) {
+  function renderArguments( node, sep, env ) {
     if (!node.args)
       return '';
     else if (Array.isArray(node.args))
@@ -1443,7 +1477,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderNamedArguments(node, separator, env) {
+  function renderNamedArguments( node, separator, env ) {
     return Object.keys(node.args).map(function renderNamedArgument(key) {
       return `${quoteIdIfRequired(key, env.additionalKeywords)} ${separator} ${renderArgument(node.args[key], env)}`;
     }).join(', ');
@@ -1456,7 +1490,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderPositionalArguments(node, env) {
+  function renderPositionalArguments( node, env ) {
     if (!node.args)
       return '';
     const func = node.func?.toUpperCase();
@@ -1477,7 +1511,7 @@ function csnToCdl(csn, options) {
    * @param {string[]} additionalKeywords
    * @return {string}
    */
-  function renderArgument(arg, env, additionalKeywords = []) {
+  function renderArgument( arg, env, additionalKeywords = [] ) {
     // If the argument is a xpr with e.g. `=`, it may require parentheses.
     // For nested xpr, `exprRenderer.renderExpr()` will already add parentheses.
     env = { ...env, additionalKeywords };
@@ -1492,7 +1526,7 @@ function csnToCdl(csn, options) {
    * @param artifact
    * @returns {string}
    */
-  function renderCardinality(artifact) {
+  function renderCardinality( artifact ) {
     if (isSimpleCardinality(artifact.cardinality))
       return renderSimpleCardinality(artifact);
     return renderBracketCardinality(artifact);
@@ -1504,7 +1538,7 @@ function csnToCdl(csn, options) {
    * @param {CSN.Artifact} art
    * @return {string}
    */
-  function renderBracketCardinality(art) {
+  function renderBracketCardinality( art ) {
     const isComp = art.type === 'cds.Composition';
     const suffix = (isComp ? ' of ' : ' to ');
     const card = art.cardinality;
@@ -1532,7 +1566,7 @@ function csnToCdl(csn, options) {
    * @param {CSN.Cardinality} cardinality
    * @return {boolean}
    */
-  function isSimpleCardinality(cardinality) {
+  function isSimpleCardinality( cardinality ) {
     return !cardinality || (
       cardinality.min === undefined &&
       cardinality.src === undefined &&
@@ -1548,7 +1582,7 @@ function csnToCdl(csn, options) {
    * @param {CSN.Element} elem
    * @return {string}
    */
-  function renderSimpleCardinality(elem) {
+  function renderSimpleCardinality( elem ) {
     let result = (elem.type === 'cds.Association' ? ' to ' : ' of ');
     if (!elem.cardinality)
       return result;
@@ -1560,7 +1594,7 @@ function csnToCdl(csn, options) {
   }
 
   // Render the nullability of an element or parameter (can be unset, true, or false)
-  function renderNullability(obj /* , env */) {
+  function renderNullability( obj /* , env */) {
     if (obj.notNull === undefined) {
       // Attribute not set at all
       return '';
@@ -1575,7 +1609,7 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderForeignKey(fKey, env) {
+  function renderForeignKey( fKey, env ) {
     const alias = fKey.as ? (` as ${fKey.as}`) : '';
     return exprRenderer.renderExpr(fKey, env) + alias;
   }
@@ -1585,18 +1619,22 @@ function csnToCdl(csn, options) {
    * length, precision and scale (even if incomplete), plus any other unknown ones.
    *
    * @param {CSN.Artifact} artWithType
+   * @param {boolean} noShortVersion If true, parameters will not be shortened, e.g. `(10)`
+   *                                 for length instead of `(length: 10)`.
    * @returns {string}
    */
-  function renderTypeParameters(artWithType) {
+  function renderTypeParameters( artWithType, noShortVersion = false ) {
     const params = typeParameters.list.filter(param => artWithType[param] !== undefined);
     if (params.length === 0)
       return '';
 
+    if (!noShortVersion) {
     // 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 (params.length === 1 && artWithType.length !== undefined)
+        return `(${artWithType.length})`;
+      if (params.length === 2 && artWithType.precision !== undefined && artWithType.scale !== undefined)
+        return `(${artWithType.precision}, ${artWithType.scale})`;
+    }
 
     // Render named params
     const renderedParams = [];
@@ -1614,7 +1652,7 @@ function csnToCdl(csn, options) {
    * @param {{parens: boolean}} [config] Config for renderAnnotationAssignment()
    * @return {string}
    */
-  function renderAnnotationAssignmentsAndDocComment(obj, env, config) {
+  function renderAnnotationAssignmentsAndDocComment( obj, env, config ) {
     let result = renderDocComment(obj, env);
     for (const name in obj) {
       if (name.startsWith('@'))
@@ -1634,7 +1672,7 @@ function csnToCdl(csn, options) {
    * @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, config = { parens: false }) {
+  function renderAnnotationAssignment( anno, name, env, config = { parens: false } ) {
     name = name.substring(1);
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
@@ -1673,10 +1711,30 @@ function csnToCdl(csn, options) {
    * @param {string} artifactName Artifact name to render
    * @return {string} Artifact name ready for rendering
    */
-  function renderArtifactName(artifactName) {
+  function renderArtifactName( artifactName ) {
     return quotePathIfRequired(artifactName);
   }
 
+  /**
+   * Render the name of a definition.  Ensures the first segment of the name
+   * is available in the rendered CDL.  Otherwise a USING is added.
+   *
+   * @param {string} name
+   * @return {string}
+   */
+  function renderDefinitionReference( name ) {
+    usings.addIfRequired(name);
+    return quotePathIfRequired(name);
+  }
+
+  /**
+   * @param {string[]} includes
+   * @return {string}
+   */
+  function renderIncludes( includes ) {
+    return ` : ${includes.map(name => renderDefinitionReference(name)).join(', ')}`;
+  }
+
   function createCdlExpressionRenderer() {
     return createExpressionRenderer({
       finalize: x => x,
@@ -1745,32 +1803,33 @@ function csnToCdl(csn, options) {
  * Returns a newly created default environment (which keeps track of indentation, required USING
  * declarations and name prefixes.
  *
+ * @param {object} [values]
  * @return {CdlRenderEnvironment}
  */
-function createEnv() {
-  return {
+function createEnv( values = {} ) {
+  return Object.assign({
     // Current indentation string
     indent: '',
     path: null,
     artifactName: '',
     elementName: '',
-  };
+  }, values);
 }
 
-function envAddPath(env, path) {
+function envAddPath( env, path ) {
   return Object.assign({}, env, { path: [ ...env.path, ...path ] } );
 }
-function envNewPath(env, path) {
+function envNewPath( env, path ) {
   return Object.assign({}, env, { path: [ ...path ] } );
 }
 
 /**
  * Returns a copy of 'env' with increased indentation (and reset name prefix)
  *
- * @param {CdlRenderEnvironment} env
- * @returns {CdlRenderEnvironment}
+ * @param {object} env
+ * @returns {object}
  */
-function increaseIndent(env) {
+function increaseIndent( env ) {
   return Object.assign({}, env, { indent: `${env.indent}  ` });
 }
 
@@ -1786,7 +1845,7 @@ function increaseIndent(env) {
  *
  * @todo For paths such as `E.key`, `key` does not have to be in quotes.
  */
-function quotePathIfRequired(path) {
+function quotePathIfRequired( path ) {
   return path.split('.').map(step => quoteIdIfRequired(step)).join('.');
 }
 
@@ -1801,7 +1860,7 @@ function quotePathIfRequired(path) {
  * @param {string[]} [additionalKeywords]
  * @return {string}
  */
-function quoteIdIfRequired(id, additionalKeywords) {
+function quoteIdIfRequired( id, additionalKeywords ) {
   // Quote if required for CDL
   if (requiresQuotingForCdl(id, additionalKeywords || []))
     return quote(id);
@@ -1817,7 +1876,7 @@ function quoteIdIfRequired(id, additionalKeywords) {
  * @param {string} anno
  * @returns {string}
  */
-function quoteAnnotationPathIfRequired(anno) {
+function quoteAnnotationPathIfRequired( anno ) {
   return anno.split('.').map((segment) => {
     if (segment.startsWith('@'))
       return `@${quoteIdIfRequired(segment.slice(1))}`;
@@ -1831,7 +1890,7 @@ function quoteAnnotationPathIfRequired(anno) {
  * @param id
  * @returns {string}
  */
-function quote(id) {
+function quote( id ) {
   return `![${id.replace(/]/g, ']]')}]`;
 }
 
@@ -1847,7 +1906,7 @@ function quote(id) {
  * @param {string[]} [additionalKeywords]
  * @return {boolean}
  */
-function requiresQuotingForCdl(id, additionalKeywords) {
+function requiresQuotingForCdl( id, additionalKeywords ) {
   return !identifierRegex.test(id) ||
     keywords.cdl.includes(id.toUpperCase()) ||
     keywords.cdl_functions.includes(id.toUpperCase()) ||
@@ -1890,7 +1949,7 @@ const functionExpressionOperatorsRequireParentheses = [
  * @param {string[]} additionalAllowedKeywords
  * @return {boolean}
  */
-function isSimpleFunctionExpression(xpr, additionalAllowedKeywords = []) {
+function isSimpleFunctionExpression( xpr, additionalAllowedKeywords = [] ) {
   return !xpr || xpr.every(val => typeof val !== 'string' ||
       (additionalAllowedKeywords.includes(val.toUpperCase()) ||
         !functionExpressionOperatorsRequireParentheses.includes(val.toUpperCase())));
@@ -1907,7 +1966,7 @@ function isSimpleFunctionExpression(xpr, additionalAllowedKeywords = []) {
  * @param {number} argumentIndex
  * @returns {string[]}
  */
-function getKeywordsForSpecialFunctionArgument(funcName, argumentIndex) {
+function getKeywordsForSpecialFunctionArgument( funcName, argumentIndex ) {
   const f = specialFunctions[funcName] && specialFunctions[funcName][argumentIndex];
   if (!f)
     return [];
@@ -1921,14 +1980,6 @@ function getKeywordsForSpecialFunctionArgument(funcName, argumentIndex) {
   return additionalKeywords;
 }
 
-/**
- * @param {string[]} includes
- * @return {string}
- */
-function renderIncludes(includes) {
-  return ` : ${includes.map(name => quotePathIfRequired(name)).join(', ')}`;
-}
-
 /**
  * Render the given string.  Uses back-tick strings.
  * env is used for indentation of three-back-tick strings.
@@ -1937,7 +1988,7 @@ function renderIncludes(includes) {
  * @param env
  * @returns {string}
  */
-function renderString(str, env) {
+function renderString( str, env ) {
   if (isSimpleString(str))
     return `'${str.replace(/'/g, '\'\'')}'`;
 
@@ -1982,7 +2033,7 @@ function renderString(str, env) {
 }
 
 /** @param {number} codePoint */
-function hexEscape(codePoint) {
+function hexEscape( codePoint ) {
   const hex = codePoint.toString(16);
   return `\\u{${hex}}`;
 }
@@ -1991,7 +2042,7 @@ function hexEscape(codePoint) {
  * Returns true if the given string can be represented by using single quotes.
  * @param {string} str
  */
-function isSimpleString(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,
@@ -2003,13 +2054,28 @@ function isSimpleString(str) {
     !hasUnpairedUnicodeSurrogate(str));
 }
 
+/**
+ * Get a list of top-level artifact names, which are not in contexts/usings/, i.e. those
+ * before the first dot ('.').  For example for `S.E.F`, `S` is used.
+ *
+ * @param {CSN.Model} csn
+ * @return {string[]}
+ */
+function availableFirstPathSteps( csn ) {
+  if (!csn.definitions)
+    return [];
+  const unique = new Set(Object.keys(csn.definitions).map(name => name.split('.')[0]));
+  return Array.from(unique);
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *
  * @property {string}   indent Current indentation as a string, e.g. '  ' for two spaces.
- * @property {string[]} [path] CSN path to the current artifact
+ * @property {CSN.Path} [path] CSN path to the current artifact
  * @property {string}   [artifactName] Name of the artifact - set in renderArtifact
  * @property {string}   [elementName] Name of the element being rendered - set in renderElement
+ * @property {string[]} [additionalKeywords] For function rendering: Words that are also keywords.
  */
 
 module.exports = { csnToCdl };