@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/render/toCdl.js

@@ -1,8 +1,7 @@
 'use strict';
 
 const keywords = require('../base/keywords');
-const { isBuiltinType, generatedByCompilerVersion, getNormalizedQuery } = require('../model/csnUtils');
-const { findElement, getExpressionRenderer } = require('./utils/common');
+const { findElement, createExpressionRenderer, withoutCast } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
@@ -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');
-  let _renderExpr = null;
 
-  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))})`;
@@ -635,7 +693,7 @@ function csnToCdl(csn, options) {
         result += renderJoinCardinality(source.cardinality);
         result += `join ${renderViewSource(source.args[i], env)}`;
         if (source.on)
-          result += ` on ${renderExpr(source.on, env, true, true)}`;
+          result += ` on ${exprRenderer.renderExpr(source.on, env)}`;
       }
       result += ')';
       return result;
@@ -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)
@@ -687,13 +744,13 @@ function csnToCdl(csn, options) {
 
     if (path.ref[0].where) {
       const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
-      const expr = renderExpr(path.ref[0].where, env, true, true);
+      const expr = exprRenderer.renderExpr(path.ref[0].where, env);
       result += `[${cardinality}${expr}]`;
     }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `:${renderExpr({ ref: path.ref.slice(1) }, env)}`;
+      result += `:${exprRenderer.renderExpr({ ref: path.ref.slice(1) }, env)}`;
 
     return result;
   }
@@ -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) {
@@ -755,17 +812,19 @@ function csnToCdl(csn, options) {
     result += env.indent;
 
     // only if column is virtual, keyword virtual was present in the source text
-    if (col.virtual)
-      result += 'virtual ';
+    result += col.virtual ? 'virtual ' : '';
+    result += col.key ? 'key ' : '';
 
-    const key = col.key ? 'key ' : '';
     // Use special rendering for .expand/.inline - renderExpr cannot easily handle some cases
-    result += key + ((col.expand || col.inline) ? renderInlineExpand(col, env) : renderExpr(col, env, true));
+    if (col.expand || col.inline)
+      result += renderInlineExpand(col, env);
+    else
+      result += exprRenderer.renderExpr(withoutCast(col), env);
 
     // Alias for inline/expand is already handled by renderInlineExpand
     // A new association (cast with `type` and `target`) uses `as` as its primary name, not alias.
-    const isNewAssociation = col.cast && col.cast.type && col.cast.target;
-    if (col.as && !col.inline && !col.expand && !isNewAssociation)
+    const isNewAssociation = col.cast?.type && col.cast.target;
+    if (!isNewAssociation && col.as && !col.inline && !col.expand)
       result += ` as ${quoteIdIfRequired(col.as)}`;
 
     // Explicit type provided for the view element?
@@ -787,9 +846,9 @@ 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) ? '' : renderExpr(obj, env);
+    let result = (obj.as && obj.expand && !obj.ref) ? '' : exprRenderer.renderExpr(withoutCast(obj), env);
 
     // s as alias { * }
     if (obj.as && (obj.ref || obj.xpr || obj.val !== undefined || obj.func !== undefined))
@@ -812,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
@@ -837,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
@@ -853,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)}`;
@@ -891,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();
@@ -937,13 +990,13 @@ function csnToCdl(csn, options) {
       result += renderActionsAndFunctions(query, env);
 
     if (select.where)
-      result += `${continueIndent(result, env)}where ${renderExpr(select.where, env, true, true)}`;
+      result += `${continueIndent(result, env)}where ${exprRenderer.renderExpr(select.where, env)}`;
 
     if (select.groupBy)
-      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => renderExpr(expr, env, true, false, true)).join(', ')}`;
+      result += `${continueIndent(result, env)}group by ${select.groupBy.map(expr => exprRenderer.renderExpr(expr, env)).join(', ')}`;
 
     if (select.having)
-      result += `${continueIndent(result, env)}having ${renderExpr(select.having, env, true, true)}`;
+      result += `${continueIndent(result, env)}having ${exprRenderer.renderExpr(select.having, env)}`;
 
     if (select.orderBy)
       result += `${continueIndent(result, env)}order by ${select.orderBy.map(entry => renderOrderByEntry(entry, env)).join(', ')}`;
@@ -960,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 ' ';
@@ -976,14 +1029,14 @@ 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 ${renderExpr(limit.rows, limitEnv)}`;
+        limitStr += `limit ${exprRenderer.renderExpr(limit.rows, limitEnv)}`;
 
       if (limit.offset !== undefined) {
         const offsetIndent = (limitStr === '') ? '' : `\n${increaseIndent(limitEnv).indent}`;
-        limitStr += `${offsetIndent}offset ${renderExpr(limit.offset, limitEnv)}`;
+        limitStr += `${offsetIndent}offset ${exprRenderer.renderExpr(limit.offset, limitEnv)}`;
       }
       return limitStr;
     }
@@ -1020,8 +1073,8 @@ function csnToCdl(csn, options) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderOrderByEntry(entry, env) {
-    let result = renderAnnotationAssignmentsAndDocComment(entry, env) + renderExpr(entry, env, true, false, true);
+  function renderOrderByEntry( entry, env ) {
+    let result = renderAnnotationAssignmentsAndDocComment(entry, env) + exprRenderer.renderExpr(entry, env);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1041,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)
@@ -1062,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);
@@ -1084,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)
@@ -1100,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)}`;
@@ -1117,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)
@@ -1142,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 ];
@@ -1195,8 +1248,7 @@ function csnToCdl(csn, options) {
 
       // ON-condition (if any)
       if (artifact.on)
-        result += ` on ${renderExpr(artifact.on, env, true, true)}`;
-
+        result += ` on ${exprRenderer.renderExpr(artifact.on, env)}`;
 
       // Foreign keys (if any, unless we also have an ON_condition (which means we have been transformed from managed to unmanaged)
       if (artifact.keys && !artifact.on)
@@ -1237,7 +1289,7 @@ function csnToCdl(csn, options) {
     if (!isTypeDef) // NOT NULL not possible for not-arrayed type definitions
       result += renderNullability(artifact);
     if (artifact.default)
-      result += ` default ${renderExpr(artifact.default, env)}`;
+      result += ` default ${exprRenderer.renderExpr(artifact.default, env)}`;
 
     return result;
   }
@@ -1249,10 +1301,10 @@ 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 ${renderExpr(art.on, env, true, true)}`;
+      result += ` on ${exprRenderer.renderExpr(art.on, env)}`;
     else if (art.keys)
       result += ` { ${Object.keys(art.keys).map(name => renderForeignKey(art.keys[name], env)).join(', ')} }`;
     return result;
@@ -1263,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);
@@ -1290,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 += ` = ${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)
@@ -1326,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.
@@ -1373,11 +1408,10 @@ function csnToCdl(csn, options) {
    *
    * @param {string|object} s
    * @param {number} idx
-   * @param {boolean} inline
    * @param {object} env
    * @returns {string}
    */
-  function renderPathStep(s, idx, inline, 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.
@@ -1405,7 +1439,7 @@ function csnToCdl(csn, options) {
       if (s.where) {
         // Filter, possibly with cardinality
         const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
-        const expr = renderExpr(s.where, env, inline, true);
+        const expr = exprRenderer.renderExpr(s.where, env);
         result += `[${cardinality}${expr}]`;
       }
 
@@ -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,11 +1511,13 @@ 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, `renderExpr()` will already add parentheses.
+    // For nested xpr, `exprRenderer.renderExpr()` will already add parentheses.
     env = { ...env, additionalKeywords };
-    return renderExpr(arg, env, true, !isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords), true);
+    if (isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords))
+      return exprRenderer.renderExpr(arg, env);
+    return exprRenderer.renderSubExpr(arg, env);
   }
 
   /**
@@ -1490,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);
@@ -1502,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;
@@ -1530,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 &&
@@ -1546,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;
@@ -1558,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 '';
@@ -1573,9 +1609,9 @@ 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 renderExpr(fKey, env) + alias;
+    return exprRenderer.renderExpr(fKey, env) + alias;
   }
 
   /**
@@ -1583,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 = [];
@@ -1612,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('@'))
@@ -1632,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('#');
@@ -1671,104 +1711,91 @@ 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 a function expression.
+   * 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 {object} obj Object with .func and optionally .args
-   * @param {CdlRenderEnvironment} env
-   * @returns {string}
+   * @param {string} name
+   * @return {string}
    */
-  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}(${renderArguments( obj, '=>', env )})`;
+  function renderDefinitionReference( name ) {
+    usings.addIfRequired(name);
+    return quotePathIfRequired(name);
   }
 
   /**
-   * Render an expression.
-   *
-   * @param {any} expr
-   * @param {CdlRenderEnvironment} exprEnv
-   * @param {boolean} [isInline]
-   * @param {boolean} [isNestedExpr]
-   * @param {boolean} [alwaysRenderCast]
-   * @returns {string}
+   * @param {string[]} includes
+   * @return {string}
    */
-  function renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast) {
-    if (!_renderExpr) {
-      _renderExpr = getExpressionRenderer({
-        finalize(x) {
-          return x;
-        },
-        explicitTypeCast(x, env) {
-          const typeRef = renderTypeReferenceAndProps(x.cast, env, { typeRefOnly: true, noAnnoCollect: true });
-          const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
-          return `cast(${renderArgument(arg, env)} as ${typeRef})`;
-        },
-        val(x, env) {
-          // Literal value, possibly with explicit 'literal' property
-          switch (x.literal || typeof x.val) {
-            case 'number':
-            case 'boolean':
-            case 'null':
-              return x.val;
-            case 'x':
-            case 'date':
-            case 'time':
-            case 'timestamp':
-              return `${x.literal}'${x.val}'`;
-            case 'string':
-              return renderString(x.val, env);
-            case 'object':
-              if (x.val === null)
-                return 'null';
-            // otherwise fall through to
-            default:
-              throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
-          }
-        },
-        aliasOnly(x, _env) {
-          return x.as;
-        },
-        enum(x) {
-          return `#${x['#']}`;
-        },
-        ref(x, env) {
-          const { inline } = this;
-          return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, inline, env)).join('.')}`;
-        },
-        windowFunction(x, env) {
-          const funcDef = renderFuncExpr(x, env);
-          const windowFunctionOperator = x.xpr.shift(); // OVER ...
-          return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
-        },
-        func(x, env) {
-          return renderFuncExpr(x, env);
-        },
-        xpr(x, env) {
-          if (this.nestedExpr && !x.cast || x.xpr.some(s => s === 'exists'))
-            return `(${renderExpr(x.xpr, env, this.inline, true)})`;
-          return renderExpr(x.xpr, env, this.inline, true);
-        },
-        // Sub-queries in expressions need to be in parentheses, otherwise
-        // left-associativity of UNIONS may result in different results.
-        // For example: `select from E where id in (select from E union select from E);`:
-        // Without parentheses, it would be different query.
-        SET(x, env) {
-          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
-        },
-        SELECT(x, env) {
-          return `(${renderQuery(x, false, 'view', increaseIndent(env))})`;
-        },
-      });
-    }
+  function renderIncludes( includes ) {
+    return ` : ${includes.map(name => renderDefinitionReference(name)).join(', ')}`;
+  }
 
-    return _renderExpr(expr, exprEnv, isInline, isNestedExpr, alwaysRenderCast);
+  function createCdlExpressionRenderer() {
+    return createExpressionRenderer({
+      finalize: x => x,
+      typeCast(x) {
+        const typeRef = renderTypeReferenceAndProps(x.cast, this.env, { typeRefOnly: true, noAnnoCollect: true });
+        const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
+        return `cast(${renderArgument(arg, this.env)} as ${typeRef})`;
+      },
+      val(x) {
+        // Literal value, possibly with explicit 'literal' property
+        switch (x.literal || typeof x.val) {
+          case 'number':
+          case 'boolean':
+          case 'null':
+            return x.val;
+          case 'x':
+          case 'date':
+          case 'time':
+          case 'timestamp':
+            return `${x.literal}'${x.val}'`;
+          case 'string':
+            return renderString(x.val, this.env);
+          case 'object':
+            if (x.val === null)
+              return 'null';
+            // otherwise fall through to
+          default:
+            throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+        }
+      },
+      aliasOnly: x => x.as,
+      enum: x => `#${x['#']}`,
+      ref(x) {
+        return `${(x.param || x.global) ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env)).join('.')}`;
+      },
+      windowFunction(x) {
+        const funcDef = this.func(x);
+        return `${funcDef} ${this.renderExpr(x.xpr)}`; // xpr[0] is 'over'
+      },
+      func(x) {
+        if (keywords.cdl_functions.includes(x.func.toUpperCase()))
+          return x.func;
+        const name = identifierRegex.test(x.func) ? x.func : quote(x.func);
+        return `${name}(${renderArguments( x, '=>', this.env )})`;
+      },
+      xpr(x) {
+        if (this.isNestedXpr && !x.cast || x.xpr.some(s => s === 'exists'))
+          return `(${this.renderExpr(x.xpr)})`;
+        return this.renderExpr(x.xpr);
+      },
+      // 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) {
+        return `(${renderQuery(x, false, 'view', increaseIndent(this.env))})`;
+      },
+      SELECT(x) {
+        return `(${renderQuery(x, false, 'view', increaseIndent(this.env))})`;
+      },
+    });
   }
 }
 
@@ -1776,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}  ` });
 }
 
@@ -1817,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('.');
 }
 
@@ -1832,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);
@@ -1848,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))}`;
@@ -1862,7 +1890,7 @@ function quoteAnnotationPathIfRequired(anno) {
  * @param id
  * @returns {string}
  */
-function quote(id) {
+function quote( id ) {
   return `![${id.replace(/]/g, ']]')}]`;
 }
 
@@ -1878,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()) ||
@@ -1887,16 +1915,16 @@ function requiresQuotingForCdl(id, additionalKeywords) {
 
 const functionExpressionOperatorsRequireParentheses = [
   // Antlr rule 'condition', 'conditionAnd'
-  'and', 'or',
+  'AND', 'OR',
 
   // Antlr rule 'conditionTerm'
   '=', '<>', '>', '>=', '<', '<=', '!=',
   // These are not forbidden, since they must be preceded by one of the comparators above.
   // 'any', 'some', 'all',
 
-  'is', 'in', 'not', 'null', 'exists',
+  'IS', 'IN', 'NOT', 'NULL', 'EXISTS',
   // Antlr rule 'predicate'
-  'between', 'like', 'escape',
+  'BETWEEN', 'LIKE', 'ESCAPE',
 ];
 
 /**
@@ -1921,10 +1949,10 @@ 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) ||
-        !functionExpressionOperatorsRequireParentheses.includes(val.toLowerCase())));
+      (additionalAllowedKeywords.includes(val.toUpperCase()) ||
+        !functionExpressionOperatorsRequireParentheses.includes(val.toUpperCase())));
 }
 
 /**
@@ -1938,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 [];
@@ -1952,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.
@@ -1968,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, '\'\'')}'`;
 
@@ -2013,7 +2033,7 @@ function renderString(str, env) {
 }
 
 /** @param {number} codePoint */
-function hexEscape(codePoint) {
+function hexEscape( codePoint ) {
   const hex = codePoint.toString(16);
   return `\\u{${hex}}`;
 }
@@ -2022,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,
@@ -2034,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 };