@sap/cds-compiler 5.8.2 → 5.9.0

package/lib/render/toCdl.js

@@ -1,133 +1,623 @@
 'use strict';
 
+// to.cdl() renderer
+//
+// This file contains the whole to.cdl(), which takes CSN and outputs CDL.
+// It used e.g. by `cds import`.
+//
+//
+// # Development Notes
+//
+// ## Abbreviations used
+//  - fqn : fully qualified name, i.e. a name that is a global definition reference
+//
+
+
 const keywords = require('../base/keywords');
 const { cdlNewLineRegEx } = require('../language/textUtils');
 const { findElement, createExpressionRenderer, withoutCast } = require('./utils/common');
 const { escapeString, hasUnpairedUnicodeSurrogate } = require('./utils/stringEscapes');
 const { checkCSNVersion } = require('../json/csnVersion');
-const { forEachDefinition, normalizeTypeRef } = require('../model/csnUtils');
+const { normalizeTypeRef, forEachDefinition } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
-const { ModelError } = require('../base/error');
+const { ModelError, CompilerAssertion } = require('../base/error');
 const { typeParameters, specialFunctions } = require('../compiler/builtins');
 const { isAnnotationExpression } = require('../base/builtins');
 const { forEach } = require('../utils/objectUtils');
-const {
-  getNormalizedQuery,
-} = require('../model/csnUtils');
 const { isBuiltinType } = require('../base/builtins');
 const { cloneFullCsn } = require('../model/cloneCsn');
-const { getKeysDict } = require('../model/csnRefs');
+const { getKeysDict, implicitAs } = require('../model/csnRefs');
 const { undelimitedIdentifierRegex } = require('../parsers/identifiers');
+const { getNormalizedQuery } = require('../model/csnUtils');
+const {
+  line,
+  pretty,
+  nestBy,
+  bracketBlock,
+  joinDocuments,
+} = require('./utils/pretty');
 
 const specialFunctionKeywords = Object.create(null);
 
+const MAX_LINE_WIDTH = 72;
+const INDENT_SIZE = 2;
+
+function format( document ) {
+  return pretty(document, MAX_LINE_WIDTH);
+}
+
 /**
- * Render the CSN model 'model' to CDS source text.
- * Returned object has the following properties:
- *  - `model`: CSN model rendered as CDL (string).
- *  - `namespace`: Namespace statement + `using from './model.cds'.
+ * @param {string} path
+ * @returns {string}
+ */
+function rootPathSegment( path ) {
+  // RegEx is at least twice as fast as .split()[0]
+  return path.match(/^[^.]+/)[0];
+}
+
+/**
+ * Path alias to be rendered as a USING statement.
+ */
+class UsingAlias {
+  path;
+  alias;
+
+  /**
+   * @param {string} path
+   * @param {string} alias
+   */
+  constructor(path, alias) {
+    this.path = path;
+    this.alias = alias;
+  }
+
+  requiresExplicitAlias() {
+    return this.alias && implicitAs(this.path) !== this.alias;
+  }
+}
+
+class NameScopeStack {
+  /** @type {DefinitionPathTree[]} */
+  #scopes = [];
+  /** @type {Record<string, UsingAlias>} */
+  #aliasToFqn = Object.create(null);
+  /** @type {Record<string, UsingAlias>} */
+  #fqnToAlias = Object.create(null);
+  /** @type {string|null} */
+  #namespaceAlias = null;
+
+  /**
+   @param {DefinitionPathTree} root
+   @param {CSN.Model} csn
+   */
+  setRootScope( root, csn ) {
+    root.availableRootPaths = Object.assign(Object.create(null), root.children);
+    this.#scopes = [ root ];
+
+    this.#prepareUniqueUsingsForRootPaths(csn);
+  }
+
+  /**
+   * @param {DefinitionPathTree} scope
+   */
+  pushNameEnv(scope) {
+    const outerScope = this.#scopes.at(-1);
+
+    const isNamespace = this.#scopes.length === 1 && !scope.definition;
+    if (isNamespace)
+      this.#namespaceAlias = implicitAs(scope.name);
+
+    // Own children are always available.
+    // Root paths of the outer scope are also available in the inner scope.
+    scope.availableRootPaths = Object.assign(Object.create(null), outerScope.availableRootPaths, scope.children);
+    this.#scopes.push(scope);
+  }
+
+  popNameEnv() {
+    const popped = this.#scopes.pop();
+    const wasNamespace = this.#scopes.length === 1 && !popped.definition;
+    if (wasNamespace)
+      this.#namespaceAlias = null;
+  }
+
+  /**
+   * To be able to refer to definitions outside the current scope, we need to have
+   * unique USING statements.  The most stable way is to create a USING statement for
+   * root path-segments on-demand and give it an alias by having it unique in the set
+   * of all path segments of all definitions.
+   *
+   * While this will still lead to some long paths here and there, it is the most
+   * secure way to avoid ambiguities due to shadowing names.
+   *
+   * @param {CSN.Model} csn
+   */
+  #prepareUniqueUsingsForRootPaths(csn) {
+    // We include vocabularies here, too, because their names are affected by a global "namespace".
+    const names = [
+      ...Object.keys(csn.definitions || {}),
+      ...Object.keys(csn.vocabularies || {}),
+      ...(csn.extensions || []).map(ext => ext.extend || ext.annotate || ''),
+    ];
+    const segmentedNames = names.map(name => name.split('.'));
+    this.nonRootSegments = new Set(segmentedNames.map(segments => segments.slice(1)).flat(1));
+    // Don't use `this.#scopes[0].availableRootPaths`, as that will contain unreachable paths,
+    // e.g. for a file that contains `namespace a.b`, `a` is not reachable.
+    this.rootSegments = new Set(segmentedNames.map(name => name[0]));
+    this.rootSegments.add('cds'); // builtin namespaces
+    this.rootSegments.add('hana');
+  }
+
+  /**
+   * @param {string} fqn Path for which we want to add an alias.
+   */
+  #addUsingAlias( fqn ) {
+    const segments = fqn.split('.');
+    let aliasName = segments.at(-1);
+    // An explicit alias only needs to be used if the implicit one has the possibility of
+    // being shadowed in any scope or if there is already an alias of that name.
+    if (this.nonRootSegments.has(aliasName) || this.#aliasToFqn[aliasName]) {
+      // There is a non-root segment of the same root name, hence the need for aliases.
+      let counter = 0;
+      aliasName += '_';
+      const baseAlias = aliasName;
+      while (this.nonRootSegments.has(aliasName) || this.rootSegments.has(aliasName) || this.#aliasToFqn[aliasName]) {
+        // Alias must be unique among _all_ segments and existing USINGs.
+        aliasName = `${baseAlias}${++counter}`;
+      }
+    }
+
+    // Always add an alias, even if unnecessary, as we'd otherwise try to create
+    // it in #useAliasForPath() again if the same rootName is seen again.
+    if (this.#aliasToFqn[aliasName])
+      throw new CompilerAssertion(`to.cdl: Alias "${aliasName}" already exists; collision for ${fqn} and ${this.#aliasToFqn[aliasName].path}`);
+    const alias = new UsingAlias(fqn, aliasName);
+    this.#aliasToFqn[aliasName] = alias;
+    this.#fqnToAlias[fqn] = alias;
+  }
+
+  /**
+   * We assume that definition names, when rendered, are always relative
+   * to the current name environment.
+   *
+   * This function must only be used for statements that _create_ definitions
+   * and not for references _to_ definitions.
+   *
+   * @param {string} fqn
+   * @returns {string}
+   */
+  definitionName(fqn) {
+    const leaf = this.#scopes.at(-1);
+    if (!leaf?.name)
+      return fqn;
+    if (isBuiltinType(fqn)) {
+      // For e.g. `annotate` statements:
+      // - `annotate String;` is invalid
+      // - `annotate cds.String;` works
+      return fqn;
+    }
+    if (fqn.startsWith(`${leaf.name }.`))
+      return fqn.substring(leaf.name.length + 1); // '+1' => also remove '.'
+    throw new CompilerAssertion('to.cdl: Definition to be rendered is not in current name scope!');
+  }
+
+  /**
+   * Get a relative reference to the given definition name in the current name environment.
+   *
+   * This function must only be used for references _to_ definitions and not
+   * for statements that _create_ definitions, i.e _introduce_ a new name.
+   *
+   * @param {string} fqn
+   * @returns {string}
+   */
+  definitionReference(fqn) {
+    if (isBuiltinType(fqn)) {
+      const ref = this.builtinShorthandReference(fqn);
+      if (ref !== null)
+        return ref;
+    }
+
+    const name = rootPathSegment(fqn);
+    // Go through all scopes except the root one, since in there, paths are always absolute.
+    for (let i = this.#scopes.length - 1; i >= 1; i--) {
+      const tree = this.#scopes[i];
+
+      if (tree.name && fqn.startsWith(`${tree.name }.`)) {
+        // FQN is in current scope.
+        const relativeName = fqn.substring(tree.name.length + 1);
+        const relativeRoot = rootPathSegment(relativeName);
+
+        // Since CDS requires root path segments to be _known within a CDL document_, we
+        // need to check if the root path is _known_.  If not, we need a USING statement.
+        // Example: `namespace ns; entity C : ns.D {};` -> must render alias, as 'D' would
+        // be invalid! Required for parseCdl.
+        if (!tree.children[relativeRoot])
+          return this.#useAliasForPathInScope(fqn, tree);
+
+        // Name can be used relative to scope 'tree'.  We now need to check if the relative
+        // name does not collide with more inner scopes by checking for direct children.
+        for (let j = this.#scopes.length - 1; j > i; j--) {
+          if (this.#scopes[j].children[relativeRoot]) {
+            // collision; requires alias
+            return this.#useAliasForPathInScope(fqn, tree);
+          }
+        }
+
+        return relativeName;
+      }
+      else if (name in tree.children) {
+        // Name is in current scope, but it is not the artifact we're looking for.
+        // Use a global alias to avoid confusing it.
+        return this.#useAliasForPathInScope(fqn, null);
+      }
+    }
+
+    // At this point, the path is unknown and outside any non-root scope.
+
+    if (this.#namespaceAlias && (name !== 'cds' || this.#namespaceAlias === 'cds')) {
+      // There is a namespace. We need a USING for all non-builtin paths, but also for
+      // builtins if the namespace alias collides. Builtin collision, e.g.
+      // `type my.cds.String : cds.String;` with common namespace "my.cds".
+      return this.#useAliasForPathInScope(fqn, null);
+    }
+    if (name !== 'cds' && !this.#scopes[0].availableRootPaths?.[name]) {
+      // In case the non-builtin path is unknown, add a using statement. Required for parseCdl.
+      // Completely unknown: -> alias
+      return this.#useAliasForPathInScope(fqn, null);
+    }
+    // Builtin or root path is known.
+    return fqn;
+  }
+
+  /**
+   * Adapt the FQN to use a global alias.  The alias is created for either
+   * the scope in which the FQN resides or the root path segment.
+   *
+   * @param {string} fqn
+   * @param {DefinitionPathTree} [scope]
+   * @returns {string}
+   */
+  #useAliasForPathInScope( fqn, scope ) {
+    const path = scope?.name ? scope.name : rootPathSegment(fqn);
+    if (!this.#fqnToAlias[path]?.path)
+      this.#addUsingAlias(path);
+
+    if (this.#fqnToAlias[path].alias === path)
+      return fqn; // shortcut to avoid substring()
+
+    return this.#fqnToAlias[path].alias + fqn.substring(path.length);
+  }
+
+  /**
+   * Returns a shorthand reference to the builtin type if possible or
+   * null otherwise, in which case the caller must ensure that the full type
+   * can be used.
+   *
+   * Example:
+   *   cds.Integer -> Integer
+   *   cds.hana.NCHAR -> hana.NCHAR
+   *
+   * @param {string} type
+   * @returns {string|null}
+   */
+  builtinShorthandReference(type) {
+    const shortHand = type.slice(4); // remove 'cds.'
+    const root = rootPathSegment(shortHand);
+    if (this.#scopes.at(-1).availableRootPaths[root])
+      return null; // there is already an artifact of the same name
+    if (this.#namespaceAlias === root)
+      return null; // alias collides with shorthand
+    return shortHand;
+  }
+
+  /**
+   * Get a list of objects meant to be rendered as USING statements.
+   *
+   * @returns {UsingAlias[]}
+   */
+  getUsings() {
+    const result = [];
+    for (const alias in this.#aliasToFqn)
+      result.push(this.#aliasToFqn[alias]);
+    return result;
+  }
+}
+
+/**
+ * @see createDefinitionPathTree()
+ */
+class DefinitionPathTree {
+  name = null;
+  /** @type {Record<string, DefinitionPathTree>} */
+  children = Object.create(null);
+  definition = null;
+  /** @type {Record<string, DefinitionPathTree>} */
+  availableRootPaths = null; // used in NameScopeStack
+
+  /**
+   * @param {string} fqn
+   */
+  constructor(fqn) {
+    this.name = fqn;
+  }
+}
+
+/**
+ * For a CSN model, constructs a tree of all path segments of all definitions, e.g.
+ * definitions `a.b.c.d` and `a.b.e.f` will end up in:
+ * ```
+ * a
+ * └─ b
+ *    ├─ c
+ *    │  └─ d (link to definition)
+ *    └─ e
+ *       └─ f (link to definition)
+ * ```
  *
  * @param {CSN.Model} csn
- * @param {CSN.Options} options
- * @param {object} msg Message Functions
+ * @param {CdlOptions} options
+ * @returns {DefinitionPathTree}
  */
-function csnToCdl( csn, options, msg ) {
-  const special$self = !csn?.definitions?.$self && '$self';
-  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 = cloneFullCsn(csn, options);
-    enrichUniversalCsn(csn, options);
+function createDefinitionPathTree( csn, options ) {
+  const tree = new DefinitionPathTree('');
+  if (!csn.definitions)
+    return tree;
+
+  const useNesting = options.renderCdlDefinitionNesting;
+
+  for (const defName in csn.definitions) {
+    const segments = defName.split('.');
+    if (!useNesting) {
+      // If we don't want nesting, don't do more work than necessary:
+      // only the first path step is relevant
+      segments.length = 1;
+    }
+    let leaf = tree;
+    for (let i = 0; i < segments.length; i++) {
+      const level = segments[i];
+      const fqn = segments.slice(0, i + 1).join('.');
+      leaf.children[level] ??= new DefinitionPathTree(fqn);
+      leaf = leaf.children[level];
+    }
+    leaf.definition = csn.definitions[defName];
   }
+  return tree;
+}
 
-  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 (name !== special$self && !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');
+class CsnToCdl {
+  /**
+   * @param {CSN.Model} csn
+   * @param {CdlOptions} options
+   * @param {object} msg
+   */
+  constructor(csn, options, msg) {
+    this.csn = csn;
+    this.options = options;
+    this.msg = msg;
+
+    if (this.options.csnFlavor === 'universal' && isBetaEnabled(this.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.
+      this.csn = cloneFullCsn(this.csn, this.options);
+      enrichUniversalCsn(this.csn, this.options);
+    }
 
-  const cdlResult = Object.create(null);
-  cdlResult.model = '';
+    checkCSNVersion(this.csn, this.options);
 
-  const subelementAnnotates = [];
+    this.exprRenderer = this.createCdlExpressionRenderer();
+    this.subelementAnnotates = [];
+  }
 
-  cdlResult.model += renderDefinitions();
-  // sub-element annotations that can't be written directly.
-  cdlResult.model += renderExtensions(subelementAnnotates, createEnv());
+  render() {
+    const cdlResult = Object.create(null);
+    cdlResult.model = '';
 
-  if (csn.vocabularies)
-    cdlResult.model += renderVocabularies(csn.vocabularies);
-  if (csn.extensions)
-    cdlResult.model += renderExtensions(csn.extensions, createEnv());
+    const env = createEnv();
 
-  if (csn.namespace) {
-    cdlResult.namespace = `namespace ${renderArtifactName(csn.namespace, createEnv())};\n`;
-    cdlResult.namespace += 'using from \'./model.cds\';';
+    const useNesting = !!this.options.renderCdlDefinitionNesting;
+    this.definitionTree = createDefinitionPathTree(this.csn, this.options);
+    this.commonNamespace = this.getCommonNamespace();
+
+    env.nameEnvStack.setRootScope(this.definitionTree, this.csn);
+
+    const useNamespace = this.commonNamespace !== this.definitionTree;
+    if (useNamespace)
+      env.nameEnvStack.pushNameEnv(this.commonNamespace);
+
+    cdlResult.model += useNesting
+      ? this.renderNestedDefinitions(env)
+      : this.renderDefinitions(env);
+    // sub-element annotations that can't be written directly.
+    cdlResult.model += this.renderExtensions(this.subelementAnnotates, env);
+
+    if (this.csn.vocabularies)
+      cdlResult.model += this.renderVocabularies(this.csn.vocabularies, env);
+    if (this.csn.extensions)
+      cdlResult.model += this.renderExtensions(this.csn.extensions, env);
+
+    if (useNamespace)
+      env.nameEnvStack.popNameEnv();
+
+    cdlResult.model = this.renderUsingAliases(env.nameEnvStack.getUsings(), env) + cdlResult.model;
+    if (this.csn.requires) {
+      let usingsStr = this.csn.requires.map(req => `using from '${req}';`).join('\n');
+      usingsStr += '\n\n';
+      cdlResult.model = usingsStr + cdlResult.model;
+    }
+
+    if (this.commonNamespace.name)
+      cdlResult.model = `namespace ${this.renderArtifactName(this.commonNamespace.name, env)};\n\n${cdlResult.model}`;
+
+    if (this.csn.namespace) {
+      cdlResult.namespace = `namespace ${this.renderArtifactName(this.csn.namespace, createEnv())};\n`;
+      cdlResult.namespace += 'using from \'./model.cds\';';
+    }
+
+    this.msg.throwWithError();
+    return cdlResult;
   }
 
-  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;
+  /**
+   * Determine a common namespace along all definitions.
+   * Returns this.definitionTree if there is no common namespace.
+   *
+   * @returns {DefinitionPathTree}
+   */
+  getCommonNamespace() {
+    let root = this.definitionTree;
+    if (!this.options.renderCdlDefinitionNesting || !this.options.renderCdlCommonNamespace)
+      return root; // User does not want common namespace.
+
+    if (this.csn.vocabularies) {
+      // TODO: With vocabularies, we don't search for a common namespace.
+      //   Reason being that `namespace` statements affect vocabularies, but
+      //   we don't create definition trees for them.
+      return root;
+    }
+    if (this.csn.extensions?.length > 0) {
+      // TODO: Check for the case of `entity Unknown.E {}; annotate Unknown;`
+      //   by going through all extensions.
+      return root;
+    }
+
+    while (root) {
+      const keys = Object.keys(root.children);
+      if (keys.length !== 1 || root.children[keys[0]].definition) {
+        // There is either more than one sibling path, or the path is a definition.
+        // We MUST NOT create a common namespace for `entity A {}; entity A.A {}`!
+        break;
+      }
+      if (keys[0] === 'cds') {
+        // Don't use 'cds' as common namespace _anywhere_, not even in `namespace foo.cds.bar;`
+        // While our code _does_ handle such cases, as it also needs to do so for `String`, etc.,
+        // it would make reading to.cdl() output worse.
+        return this.definitionTree;
+      }
+      root = root.children[keys[0]];
+    }
+
+    return root;
   }
 
-  msg.throwWithError();
-  return cdlResult;
+  /**
+   * @param {UsingAlias[]} aliases
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  renderUsingAliases(aliases, env) {
+    if (!this.options.renderCdlDefinitionNesting) {
+      // openAPI importer searches for a single USING statement and replaces it.
+      // Let's try to be backward compatible.
+      return aliases.length > 0 ? `using { ${aliases.map(entry => (entry.requiresExplicitAlias()
+        ? `${this.quotePathIfRequired(entry.path, env)} as ${this.quoteNonIdentifierOrKeyword(entry.alias, env)}`
+        : entry.path)).join(', ')} };\n\n` : '';
+    }
+
+    let result = '';
+    for (const entry of aliases) {
+      if (entry.requiresExplicitAlias())
+        result += `using { ${this.quotePathIfRequired(entry.path, env)} as ${this.quoteNonIdentifierOrKeyword(entry.alias, env)} };\n`;
+      else
+        result += `using { ${entry.path } };\n`;
+    }
+    return result !== '' ? `${ result }\n` : result;
+  }
 
   /**
-   * Render entries from the `csn.definitions` dictionary.
-   * Returns an empty string if nothing is rendered.
+   * Render definitions in a flat list, i.e. without nesting.
    *
-   * @return {string}
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
    */
-  function renderDefinitions() {
+  renderDefinitions(env) {
     let result = '';
-    const env = createEnv();
-    forEachDefinition(csn, (artifact, artifactName) => {
-      const sourceStr = renderDefinition(artifactName, artifact, env);
+    forEachDefinition(this.csn, (artifact, artifactName) => {
+      const sourceStr = this.renderDefinition(artifactName, artifact, env);
       if (sourceStr !== '')
         result += `${sourceStr}\n`;
     });
     return result;
   }
 
+  /**
+   * Render entries from the `csn.definitions` dictionary.
+   * Returns an empty string if nothing is rendered.
+   *
+   * @return {string}
+   */
+  renderNestedDefinitions(env) {
+    const that = this;
+    let result = '';
+    renderTree(this.definitionTree);
+    return result;
+
+    /**
+     * @param {DefinitionPathTree} tree
+     */
+    function renderTree( tree ) {
+      for (const name in tree.children) {
+        const entry = tree.children[name];
+        const def = entry.definition;
+
+        if (def?.kind === 'service' || def?.kind === 'context') {
+          // Render service/context with nested definitions.
+          env.path = [ 'definitions', entry.name ];
+          result += that.renderAnnotationAssignmentsAndDocComment(def, env);
+          result += `${env.indent}${def.kind} ${ that.renderArtifactName(entry.name, env) } {\n`;
+          env.increaseIndent();
+          env.nameEnvStack.pushNameEnv(entry);
+          if (entry.children)
+            renderTree(entry);
+          env.nameEnvStack.popNameEnv();
+          env.decreaseIndent();
+          if (result.at(-1) === '\n' && result.at(-2) === '\n')
+            result = result.substring(0, result.length - 1); // to get the closing brace on the next line after a definition, remove one linebreak
+          result += `${env.indent}};\n\n`;
+        }
+        else if (def) {
+          const sourceStr = that.renderDefinition(entry.name, def, env);
+          if (sourceStr !== '')
+            result += `${sourceStr}\n`;
+          if (entry.children)
+            renderTree(entry);
+        }
+        else if (entry.children) {
+          renderTree(entry);
+        }
+      }
+    }
+  }
+
   /**
    * Render annotation definitions, i.e. entries from csn.vocabularies.
    * Returns an empty string if there isn't anything to render.
    *
    * @param {object} vocabularies
+   * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderVocabularies( vocabularies ) {
+  renderVocabularies( vocabularies, env ) {
     let result = '';
-    forEach(vocabularies, renderVocabulariesEntry);
+    for (const key in vocabularies)
+      result += this.renderVocabulariesEntry(key, vocabularies[key], env);
     return result;
+  }
 
-    function renderVocabulariesEntry( name, anno ) {
-      if (!anno.$ignore) {
-        // This environment is passed down the call hierarchy, for dealing with
-        // indentation and name resolution issues
-        const env = createEnv({ path: [ 'vocabularies', name ] });
-        const sourceStr = renderArtifact(name, anno, env, 'annotation');
-        result += `${sourceStr}\n`;
-      }
-    }
+  /**
+   * @param {string} name
+   * @param anno
+   * @param {CdlRenderEnvironment} env
+   * @returns {string}
+   */
+  renderVocabulariesEntry( name, anno, env ) {
+    if (anno.$ignore)
+      return '';
+    // This environment is passed down the call hierarchy, for dealing with
+    // indentation and name resolution issues
+    env.path = [ 'vocabularies', name ];
+    const sourceStr = this.renderArtifact(name, anno, env, 'annotation');
+    return `${sourceStr}\n`;
   }
 
   /**
@@ -139,10 +629,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtensions( extensions, env ) {
+  renderExtensions( extensions, env ) {
     if (!env.path)
       env = env.cloneWith({ path: [ 'extensions' ] });
-    return extensions.map((ext, index) => renderExtension(ext, env.withSubPath([ index ]))).join('\n');
+    return extensions.map((ext, index) => this.renderExtension(ext, env.withSubPath([ index ]))).join('\n');
   }
 
   /**
@@ -152,10 +642,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtension( ext, env ) {
+  renderExtension( ext, env ) {
     if (ext.extend)
-      return renderExtendStatement(ext.extend, ext, env);
-    return renderAnnotateStatement(ext, env);
+      return this.renderExtendStatement(ext.extend, ext, env);
+    return this.renderAnnotateStatement(ext, env);
   }
 
   /**
@@ -168,21 +658,21 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtendStatement( extName, ext, env ) {
+  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, env) : renderDefinitionReference(extName, env);
+    let result = this.renderAnnotationAssignmentsAndDocComment(ext, env);
+    extName = this.renderArtifactName(extName, env);
 
     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, i) => renderDefinitionReference(inc, env.withSubPath([ 'includes', i ]))).join(', ');
+      const includes = ext.includes.map((inc, i) => this.renderDefinitionReference(inc, env.withSubPath([ 'includes', i ]))).join(', ');
       result += `${env.indent}extend ${affix}${extName} with ${includes};\n`;
       return result;
     }
 
-    const typeParams = renderTypeParameters(ext, true);
+    const typeParams = this.renderTypeParameters(ext, true);
     if (typeParams) {
       result += `${env.indent}extend ${extName} with ${typeParams};\n`;
       return result;
@@ -201,22 +691,22 @@ function csnToCdl( csn, options, msg ) {
     // If there are actions, check if there are also elements/columns, and if so, use the prefix notation.
     const usePrefixNotation = ext.actions && (ext.columns || ext.elements);
     if (usePrefixNotation)
-      result += `${env.indent}extend ${getExtendPrefixVariant(ext)} ${extName} with {\n`;
+      result += `${env.indent}extend ${this.getExtendPrefixVariant(ext)} ${extName} with {\n`;
     else
-      result += `${env.indent}extend ${extName} with ${getExtendPostfixVariant(ext)}{\n`;
+      result += `${env.indent}extend ${extName} with ${this.getExtendPostfixVariant(ext)}{\n`;
 
     if (ext.columns)
-      result += renderViewColumns(ext, env.withIncreasedIndent());
+      result += this.renderViewColumns(ext, env.withIncreasedIndent());
 
     else if (ext.elements || ext.enum)
-      result += renderExtendStatementElements(ext, env);
+      result += this.renderExtendStatementElements(ext, env);
 
     // Not part of if/else cascade, because it may be in postfix notation.
     if (ext.actions) {
       const childEnv = env.withIncreasedIndent();
       let actions = '';
       forEach(ext.actions, (actionName, action) => {
-        actions += renderActionOrFunction(actionName, action, childEnv.withSubPath([ 'actions', actionName ]));
+        actions += this.renderActionOrFunction(actionName, action, childEnv.withSubPath([ 'actions', actionName ]), true);
       });
       if (!usePrefixNotation)
         result += actions;
@@ -234,7 +724,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {object} ext
    * @return {string}
    */
-  function getExtendPrefixVariant( ext ) {
+  getExtendPrefixVariant( ext ) {
     if (ext.kind === 'extend')
       return 'element'; // element extensions inside an `extend`
     if (ext.columns)
@@ -250,7 +740,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Extension} ext
    * @return {string}
    */
-  function getExtendPostfixVariant( ext ) {
+  getExtendPostfixVariant( ext ) {
     if (ext.columns)
       return 'columns ';
     if (ext.actions)
@@ -274,17 +764,17 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderExtendStatementElements( ext, env ) {
+  renderExtendStatementElements( ext, env ) {
     let result = '';
     const prop = ext.elements ? 'elements' : 'enum';
     forEach(ext[prop] || {}, (elemName, element) => {
       const childEnv = env.withIncreasedIndent().withSubPath([ 'elements', elemName ]);
       if (element.kind === 'extend')
-        result += renderExtendStatement(elemName, element, childEnv);
+        result += this.renderExtendStatement(elemName, element, childEnv);
       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, childEnv.withSubPath([ prop, elemName ]));
+        result += this.renderElement(elemName, element, childEnv.withSubPath([ prop, elemName ]));
     });
     return result;
   }
@@ -296,7 +786,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateStatement( ext, env ) {
+  renderAnnotateStatement( ext, env ) {
     // Special case: Super annotate has both "returns" and "elements".
     // Render as separate `annotate`s, but keep the order.
     if (ext.elements && ext.returns) {
@@ -304,27 +794,27 @@ function csnToCdl( csn, options, msg ) {
 
       // The first of 'elements' or 'returns' gets all other properties as well.
       // The second only gets one property (itself).
-      let result = renderAnnotateStatement({ ...ext, [second]: undefined }, env);
-      result += renderAnnotateStatement({ annotate: ext.annotate, [second]: ext[second] }, env);
+      let result = this.renderAnnotateStatement({ ...ext, [second]: undefined }, env);
+      result += this.renderAnnotateStatement({ annotate: ext.annotate, [second]: ext[second] }, env);
 
       return result;
     }
 
     // Top-level annotations of the artifact
-    let result = renderAnnotationAssignmentsAndDocComment(ext, env);
+    let result = this.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, env)}`;
+    result += `${env.indent}annotate ${this.renderArtifactName(ext.annotate, env)}`;
 
     if (ext.params)
-      result += renderAnnotateParamsInParentheses(ext, env);
+      result += this.renderAnnotateParamsInParentheses(ext, env);
 
     // Element extensions and annotations (possibly nested)
     if (ext.elements || ext.enum)
-      result += ` ${renderAnnotateStatementElements(ext, env)}`;
+      result += ` ${this.renderAnnotateStatementElements(ext, env)}`;
 
     else if (ext.returns)
-      result += renderAnnotateReturns(ext, env);
+      result += this.renderAnnotateReturns(ext, env);
 
 
     if (ext.actions) { // Bound action annotations
@@ -334,12 +824,12 @@ function csnToCdl( csn, options, msg ) {
       for (const name in ext.actions) {
         env.path[env.path.length - 1] = name;
         const action = ext.actions[name];
-        result += renderAnnotationAssignmentsAndDocComment(action, env) + env.indent + quoteNonIdentifierOrKeyword(name, env);
+        result += this.renderAnnotationAssignmentsAndDocComment(action, env) + env.indent + this.quoteNonIdentifierOrKeyword(name, env);
         // Action parameter annotations
         if (action.params)
-          result += renderAnnotateParamsInParentheses(action, env);
+          result += this.renderAnnotateParamsInParentheses(action, env);
         if (action.returns)
-          result += renderAnnotateReturns(action, env);
+          result += this.renderAnnotateReturns(action, env);
 
         result = removeTrailingNewline(result);
         result += ';\n';
@@ -362,7 +852,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateStatementElements( ext, env ) {
+  renderAnnotateStatementElements( ext, env ) {
     const elements = ext.enum ? ext.enum : ext.elements;
     let result = '{\n';
     env.increaseIndent();
@@ -370,16 +860,16 @@ function csnToCdl( csn, options, msg ) {
     for (const name in elements) {
       env.path[env.path.length - 1] = name;
       const elem = elements[name];
-      result += renderAnnotationAssignmentsAndDocComment(elem, env);
-      result += env.indent + quoteNonIdentifierOrKeyword(name, env);
+      result += this.renderAnnotationAssignmentsAndDocComment(elem, env);
+      result += env.indent + this.quoteNonIdentifierOrKeyword(name, env);
       if (elem.elements) {
         env.path.push('elements');
-        result += ` ${renderAnnotateStatementElements(elem, env)}`;
+        result += ` ${this.renderAnnotateStatementElements(elem, env)}`;
         env.path.pop();
       }
       else if (elem.enum) {
         env.path.push('enum');
-        result += ` ${renderAnnotateStatementElements(elem, env)}`;
+        result += ` ${this.renderAnnotateStatementElements(elem, env)}`;
         env.path.pop();
       }
 
@@ -399,18 +889,18 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateReturns( ext, env ) {
+  renderAnnotateReturns( ext, env ) {
     env = env.withSubPath([ 'returns', 'elements' ]);
     let result = ' returns';
 
-    const returnAnnos = renderAnnotationAssignmentsAndDocComment(ext.returns, env.withIncreasedIndent());
+    const returnAnnos = this.renderAnnotationAssignmentsAndDocComment(ext.returns, env.withIncreasedIndent());
     if (returnAnnos)
       result += `\n${returnAnnos}`;
 
     if (ext.returns.elements) {
       // Annotations are on separate lines: Have it aligned nicely
       result += returnAnnos ? `${env.indent}` : ' ';
-      result += renderAnnotateStatementElements(ext.returns, env);
+      result += this.renderAnnotateStatementElements(ext.returns, env);
     }
     return result;
   }
@@ -422,13 +912,13 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotateParamsInParentheses( ext, env ) {
+  renderAnnotateParamsInParentheses( ext, env ) {
     const childEnv = env.withIncreasedIndent();
     let result = '(\n';
     const paramAnnotations = [];
     forEach(ext.params, (paramName, param) => {
-      const annos = renderAnnotationAssignmentsAndDocComment(param, childEnv);
-      const name = quoteNonIdentifierOrKeyword(paramName, childEnv);
+      const annos = this.renderAnnotationAssignmentsAndDocComment(param, childEnv);
+      const name = this.quoteNonIdentifierOrKeyword(paramName, childEnv);
       // Not supported, yet (#13052)
       // const sub = (param.elements || param.enum) ? ` ${renderAnnotateStatementElements(param, childEnv)}` : '';
       paramAnnotations.push( annos + childEnv.indent + name);
@@ -444,32 +934,32 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function renderDefinition( artifactName, art, env ) {
+  renderDefinition( artifactName, art, env ) {
     env = env.cloneWith({ path: [ 'definitions', artifactName ] });
 
     const kind = art.kind || 'type'; // the default kind is "type".
     switch (kind) {
       case 'entity':
         if (art.query || art.projection)
-          return renderView(artifactName, art, env);
-        return renderArtifact(artifactName, art, env);
+          return this.renderView(artifactName, art, env);
+        return this.renderArtifact(artifactName, art, env);
       case 'aspect':
-        return renderAspect(artifactName, art, env);
+        return this.renderAspect(artifactName, art, env);
 
       case 'context':
       case 'service':
-        return renderContextOrService(artifactName, art, env);
+        return this.renderContextOrService(artifactName, art, env);
 
       case 'annotation': // annotation in 'csn.definitions' for compiler v1 compatibility
-        return renderArtifact(artifactName, art, env, 'annotation');
+        return this.renderArtifact(artifactName, art, env, 'annotation');
 
       case 'action':
       case 'function':
-        return renderActionOrFunction(artifactName, art, env);
+        return this.renderActionOrFunction(artifactName, art, env, false);
 
       case 'type':
       case 'event':
-        return renderArtifact(artifactName, art, env);
+        return this.renderArtifact(artifactName, art, env);
 
       default:
         throw new ModelError(`to.cdl: Unknown artifact kind: '${art.kind}' at ${JSON.stringify(env.path)}`);
@@ -477,48 +967,49 @@ function csnToCdl( csn, options, msg ) {
   }
 
   /**
-   * TODO: Also use this function for other kinds such as entities, aspects and views.
-   *
    * @param {string} artifactName
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    * @param {string} [overrideKind] If set, override the artifact kind.
    */
-  function renderArtifact( artifactName, art, env, overrideKind ) {
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
+  renderArtifact( artifactName, art, env, overrideKind ) {
+    let result = this.renderAnnotationAssignmentsAndDocComment(art, env);
     let kind = overrideKind || art.$syntax === 'aspect' && 'aspect' || art.kind;
     if (art.abstract)
       kind = `abstract ${ kind }`;
-    const normalizedArtifactName = renderArtifactName(artifactName, env);
+    // Vocabularies are in a separate name environment. We can't shorten them.
+    const normalizedArtifactName = kind !== 'annotation'
+      ? this.renderArtifactName(artifactName, env)
+      : this.quotePathIfRequired(artifactName, env);
     result += `${env.indent}${kind} ${normalizedArtifactName}`;
 
     if (art.params)
-      result += renderParameters(art, env);
+      result += this.renderParameters(art, env);
 
     let isDirectStruct = false;
     const isQuery = art.query || art.projection;
     if (isQuery) {
       result += ' : ';
       // types/events (should) only support "projections"
-      result += renderQuery(getNormalizedQuery(art).query, true, 'projection',
-                            env.withSubPath([ art.projection ? 'projection' : 'query' ]));
+      result += this.renderQuery(getNormalizedQuery(art).query, true, 'projection',
+                                 env.withSubPath([ art.projection ? 'projection' : 'query' ]));
     }
     else {
-      const type = renderTypeReferenceAndProps(art, env);
+      const type = this.renderTypeReferenceAndProps(art, env);
       if (type) {
         isDirectStruct = type.startsWith('{');
 
         if (art.includes?.length && isDirectStruct) {
           // We can only render includes, if the type is directly structured. Otherwise, we would
           // render e.g. `type T : Include : T2;`, which is invalid.  We use `extend` in such cases.
-          result += renderIncludes(art.includes, env);
+          result += this.renderIncludes(art.includes, env);
         }
 
         // For nicer output, no colon if unnamed structure is used.
         result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
       }
       else {
-        msg.warning('syntax-missing-type', env.path, { '#': art.kind, name: artifactName }, {
+        this.msg.warning('syntax-missing-type', env.path, { '#': art.kind, name: artifactName }, {
           std: 'Missing type for definition $(NAME); can\'t be represented in CDL',
           entity: 'Missing elements for entity $(NAME); can\'t be represented in CDL',
         });
@@ -530,7 +1021,7 @@ function csnToCdl( csn, options, msg ) {
         // If there are no elements nor query, but actions, CDL syntax requires braces.
         result += ' { }';
       }
-      result += renderActionsAndFunctions(art, env);
+      result += this.renderBoundActionsAndFunctions(art, env);
     }
 
     result += ';\n';
@@ -538,7 +1029,7 @@ function csnToCdl( csn, options, msg ) {
     if (art.includes?.length && !isDirectStruct) {
       // If we're not a directly structured type, render the `includes` as `extend`
       // statements directly below the type definition.
-      result += renderExtendStatement(artifactName, { includes: art.includes }, env);
+      result += this.renderExtendStatement(artifactName, { includes: art.includes }, env);
     }
 
     return result;
@@ -550,9 +1041,9 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderContextOrService( artifactName, art, env ) {
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}${art.kind} ${renderArtifactName(artifactName, env)}`;
+  renderContextOrService( artifactName, art, env ) {
+    let result = this.renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent}${art.kind} ${this.renderArtifactName(artifactName, env)}`;
     return `${result} {};\n`;
   }
 
@@ -566,19 +1057,19 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAspect( artifactName, art, env ) {
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}aspect ${renderArtifactName(artifactName, env)}`;
+  renderAspect( artifactName, art, env ) {
+    let result = this.renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent}aspect ${this.renderArtifactName(artifactName, env)}`;
     if (art.includes)
-      result += renderIncludes(art.includes, env);
+      result += this.renderIncludes(art.includes, env);
 
     if (art.elements)
-      result += ` ${renderElements(art, env)}`;
+      result += ` ${this.renderElements(art, env)}`;
     else if (art.actions)
       // if there are no elements, but actions, CDL syntax requires braces.
       result += ' { }';
 
-    result += `${renderActionsAndFunctions(art, env)};\n`;
+    result += `${this.renderBoundActionsAndFunctions(art, env)};\n`;
     return result;
   }
 
@@ -589,11 +1080,11 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderElements( artifact, env ) {
+  renderElements( artifact, env ) {
     let elements = '';
     const childEnv = env.withIncreasedIndent();
     for (const name in artifact.elements)
-      elements += renderElement(name, artifact.elements[name], childEnv.withSubPath([ 'elements', name ]));
+      elements += this.renderElement(name, artifact.elements[name], childEnv.withSubPath([ 'elements', name ]));
 
     return (elements === '') ? '{ }' : `{\n${elements}${env.indent}}`;
   }
@@ -607,19 +1098,19 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Element} element
    * @param {CdlRenderEnvironment} env
    */
-  function renderElement( elementName, element, env ) {
+  renderElement( elementName, element, env ) {
     const isCalcElement = (element.value !== undefined);
-    let result = renderAnnotationAssignmentsAndDocComment(element, env);
+    let result = this.renderAnnotationAssignmentsAndDocComment(element, env);
     result += env.indent;
     result += element.virtual ? 'virtual ' : '';
     result += element.key ? 'key ' : '';
     result += element.masked ? 'masked ' : '';
-    result += quoteNonIdentifierOrKeyword(elementName, env);
+    result += this.quoteNonIdentifierOrKeyword(elementName, env);
     if (element['#'] !== undefined) { // enum symbol reference
       result += ` = #${element['#']}`;
     }
     else if (element.val !== undefined) { // enum value
-      result += ` = ${exprRenderer.renderExpr(element, env)}`;
+      result += ` = ${this.exprRenderer.renderExpr(element, env)}`;
     }
     else if (!isCalcElement || !isDirectAssocOrComp(element.type) && !element.$filtered && !element.$enclosed) {
       // If the element is a calculated element _and_ a direct association or
@@ -627,7 +1118,7 @@ function csnToCdl( csn, options, msg ) {
       // would alter the ON-condition.
       // If it is a calculated element _and_ an indirect association (via type chain),
       // we'd get a cast to an association.
-      const props = renderTypeReferenceAndProps(element, env);
+      const props = this.renderTypeReferenceAndProps(element, env);
       if (props !== '')
         result += ` : ${props}`;
     }
@@ -637,8 +1128,8 @@ function csnToCdl( csn, options, msg ) {
       env.path.push('value');
       const isSubExpr = (element.value.xpr && xprContainsCondition(element.value.xpr));
       result += isSubExpr
-        ? exprRenderer.renderSubExpr(element.value, env)
-        : exprRenderer.renderExpr(element.value, env);
+        ? this.exprRenderer.renderSubExpr(element.value, env)
+        : this.exprRenderer.renderExpr(element.value, env);
       if (element.value.stored === true)
         result += ' stored';
       env.path.length -= 1;
@@ -661,10 +1152,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderQueryElementAndEnumAnnotations( art, env ) {
-    const annotate = collectAnnotationsOfElementsAndEnum(art, env);
+  renderQueryElementAndEnumAnnotations( art, env ) {
+    const annotate = this.collectAnnotationsOfElementsAndEnum(art, env);
     if (annotate)
-      return renderExtensions([ annotate ], env);
+      return this.renderExtensions([ annotate ], env);
     return '';
   }
 
@@ -676,7 +1167,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {CSN.Extension|null}
    */
-  function collectAnnotationsOfElementsAndEnum( artifact, env ) {
+  collectAnnotationsOfElementsAndEnum( artifact, env ) {
     // Array, which may be annotated as well.
     if (artifact.items) {
       env = env.withSubPath([ 'items' ]);
@@ -763,13 +1254,13 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderViewSource( source, env ) {
+  renderViewSource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
       const subEnv = env.withIncreasedIndent();
-      let result = `(\n${subEnv.indent}${renderQuery(source, false, 'view', subEnv)}\n${env.indent})`;
+      let result = `(\n${subEnv.indent}${this.renderQuery(source, false, 'view', subEnv)}\n${env.indent})`;
       if (source.as)
-        result += renderAlias(source.as, env);
+        result += this.renderAlias(source.as, env);
 
       return result;
     }
@@ -777,17 +1268,17 @@ function csnToCdl( csn, options, msg ) {
     else if (source.join) {
       // One join operation, possibly with ON-condition
       env.path.push('args', 0);
-      let result = `(${renderViewSource(source.args[0], env)}`;
+      let result = `(${this.renderViewSource(source.args[0], env)}`;
       for (let i = 1; i < source.args.length; i++) {
         env.path[env.path.length - 1] = i;
         result += ` ${source.join} `;
-        result += renderJoinCardinality(source.cardinality);
-        result += `join ${renderViewSource(source.args[i], env)}`;
+        result += this.renderJoinCardinality(source.cardinality);
+        result += `join ${this.renderViewSource(source.args[i], env)}`;
       }
       env.path.length -= 2;
       if (source.on) {
         env.path.push('on');
-        result += ` on ${exprRenderer.renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
+        result += ` on ${this.exprRenderer.renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
         env.path.length -= 1;
       }
       result += ')';
@@ -795,10 +1286,10 @@ function csnToCdl( csn, options, msg ) {
     }
     // Ordinary path, possibly with an alias
 
-    return renderAbsolutePathWithAlias(source, env);
+    return this.renderAbsolutePathWithAlias(source, env);
   }
 
-  function renderJoinCardinality( card ) {
+  renderJoinCardinality( card ) {
     let result = '';
     if (card) {
       if (card.srcmin && card.srcmin === 1)
@@ -822,7 +1313,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAbsolutePath( path, env ) {
+  renderAbsolutePath( path, env ) {
     // Sanity checks
     if (!path.ref)
       throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
@@ -831,19 +1322,19 @@ function csnToCdl( csn, options, msg ) {
     const firstArtifactName = path.ref[0].id || path.ref[0];
 
     // Render the first path step (absolute name, with different quoting/naming ..)
-    let result = renderDefinitionReference(firstArtifactName, env);
+    let result = this.renderDefinitionReference(firstArtifactName, env);
 
     // Even the first step might have parameters and/or a filter
     env.path.push('ref', 0);
     if (path.ref[0].args)
-      result += `(${renderArguments(path.ref[0], ':', env)})`;
+      result += `(${this.renderArguments(path.ref[0], ':', env)})`;
     if (path.ref[0].where)
-      result += renderFilterAndCardinality(path.ref[0], env);
+      result += this.renderFilterAndCardinality(path.ref[0], env);
     env.path.length -= 2;
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
     if (path.ref.length > 1)
-      result += `:${exprRenderer.renderExpr({ ref: path.ref.slice(1) }, env)}`;
+      result += `:${this.exprRenderer.renderExpr({ ref: path.ref.slice(1) }, env)}`;
 
     return result;
   }
@@ -859,11 +1350,24 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAbsolutePathWithAlias( path, env ) {
-    let result = renderAbsolutePath(path, env);
+  renderAbsolutePathWithAlias( path, env ) {
+    // We may have changed the implicit alias due to renderAbsolutePath() and renderDefinitionReference()
+    // introducing USING statements. We need to ensure that the implicit alias stays the same.
+    const isElementRef = path.ref.length > 1;
+    const alias = path.as || implicitAs(path.ref);
+
+    let result = this.renderAbsolutePath(path, env);
     if (path.as) {
       // Source had an alias - render it
-      result += renderAlias(path.as, env);
+      result += this.renderAlias(path.as, env);
+    }
+    else if (!isElementRef) {
+      const defName = path.ref[0].id || path.ref[0];
+      const sourcePath = env.nameEnvStack.definitionReference(defName);
+      // Source did not have an alias, but we add one as we'd
+      // otherwise have a different implicit alias.
+      if (sourcePath.split('.').at(-1) !== alias)
+        result += this.renderAlias(alias, env);
     }
     return result;
   }
@@ -871,16 +1375,16 @@ function csnToCdl( csn, options, msg ) {
   /**
    * Render the given columns.
    *
-   * @param {CSN.Artifact} art
+   * @param {CSN.Extension | CSN.QuerySelect} art
    * @param {object} elements
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderViewColumns( art, env, elements = Object.create(null) ) {
+  renderViewColumns( art, env, elements = Object.create(null) ) {
     env.path.push( 'columns', -1 );
     const result = art.columns.map((col, i) => {
       env.path[env.path.length - 1] = i;
-      return renderViewColumn(col, env, findElement(elements, col));
+      return this.renderViewColumn(col, env, findElement(elements, col));
     }).join(',\n');
     env.path.length -= 2;
     return `${result}\n`;
@@ -895,15 +1399,15 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @param {CSN.Element} element Element corresponding to the column. Generated by the compiler.
    */
-  function renderViewColumn( col, env, element ) {
+  renderViewColumn( col, env, element ) {
     // Annotations and column
     let result = '';
     if (!col.doc) {
       // TODO: In contrast to annotations, we do not render the doc comment as part
       //       of an `annotate` statement.  That may change in the future.
-      result += renderDocComment(element, env);
+      result += this.renderDocComment(element, env);
     }
-    result += renderAnnotationAssignmentsAndDocComment(col, env);
+    result += this.renderAnnotationAssignmentsAndDocComment(col, env);
     result += env.indent;
 
     // only if column is virtual, keyword virtual was present in the source text
@@ -912,26 +1416,26 @@ function csnToCdl( csn, options, msg ) {
 
     // Use special rendering for .expand/.inline - renderExpr cannot easily handle some cases
     if (col.expand || col.inline)
-      result += renderInlineExpand(col, env);
+      result += this.renderInlineExpand(col, env);
     else if (col.xpr && xprContainsCondition(col.xpr))
-      result += exprRenderer.renderSubExpr(withoutCast(col), env);
+      result += this.exprRenderer.renderSubExpr(withoutCast(col), env);
     else
-      result += exprRenderer.renderExpr(withoutCast(col), env);
+      result += this.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?.type && col.cast.target;
     if (!isNewAssociation && col.as && !col.inline && !col.expand)
-      result += renderAlias(col.as, env);
+      result += this.renderAlias(col.as, env);
 
     // Explicit type provided for the view element?
     if (col.cast) {
       env.path.push('cast');
       // Special case: Explicit association type is actually a redirect
       if (col.cast.target && !col.cast.type)
-        result += ` : ${renderRedirectedTo(col.cast, env)}`;
+        result += ` : ${this.renderRedirectedTo(col.cast, env)}`;
       else
-        result += ` : ${renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true })}`;
+        result += ` : ${this.renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true })}`;
       env.path.length -= 1;
     }
     return result;
@@ -945,23 +1449,23 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderInlineExpand( obj, env ) {
+  renderInlineExpand( obj, env ) {
     // No expression to render for { * } as alias
-    let result = (obj.as && obj.expand && !obj.ref) ? '' : exprRenderer.renderExpr(withoutCast(obj), env);
+    let result = (obj.as && obj.expand && !obj.ref) ? '' : this.exprRenderer.renderExpr(withoutCast(obj), env);
 
     const isAnonymousExpand = (obj.expand && !obj.ref);
 
     // s as alias { * }
     if (obj.as && !isAnonymousExpand)
-      result += renderAlias(obj.as, env);
+      result += this.renderAlias(obj.as, env);
 
     // We found a leaf - no further drilling
     if (!obj.inline && !obj.expand) {
       env.path.push('cast');
       if (obj.cast && obj.cast.type)
-        result += ` : ${renderTypeReferenceAndProps(obj.cast, env, { noAnnoCollect: true })}`;
+        result += ` : ${this.renderTypeReferenceAndProps(obj.cast, env, { noAnnoCollect: true })}`;
       else if (obj.cast && obj.cast.target) // test tbd
-        result += ` : ${renderRedirectedTo(obj.cast, env)}`;
+        result += ` : ${this.renderRedirectedTo(obj.cast, env)}`;
       env.path.length -= 1;
       return result;
     }
@@ -975,7 +1479,7 @@ function csnToCdl( csn, options, msg ) {
     const childEnv = env.withIncreasedIndent();
     const expandInline = obj.expand || obj.inline;
     result += expandInline //
-      .map(elm => renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + renderInlineExpand(elm, childEnv))
+      .map(elm => this.renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + this.renderInlineExpand(elm, childEnv))
       .join(',\n');
     result += `\n${env.indent}}`;
 
@@ -985,7 +1489,7 @@ function csnToCdl( csn, options, msg ) {
 
     // { * } as expand
     if (obj.as && isAnonymousExpand)
-      result += renderAlias(obj.as, env);
+      result += this.renderAlias(obj.as, env);
 
     return result;
   }
@@ -997,7 +1501,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {String}
    */
-  function renderDocComment( obj, env ) {
+  renderDocComment( obj, env ) {
     if (!obj || obj && obj.doc === undefined)
       return '';
     else if (obj && obj.doc === null) // empty doc comment needs to be rendered
@@ -1012,7 +1516,7 @@ function csnToCdl( csn, options, msg ) {
     if (!obj.doc.includes('\n') && !/(^\s)|(\s$)/.test(obj.doc))
       return `${env.indent}/** ${doc} */\n`;
 
-    const comment = doc.split('\n').map(line => `${env.indent} * ${line}`).join('\n');
+    const comment = doc.split('\n').map(l => `${env.indent} * ${l}`).join('\n');
     return `${env.indent}/**\n${comment}\n${env.indent} */\n`;
   }
 
@@ -1021,20 +1525,20 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function renderView( artifactName, art, env ) {
+  renderView( artifactName, art, env ) {
     const syntax = (art.projection) ? 'projection' : 'entity';
-    let result = renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}entity ${renderArtifactName(artifactName, env)}`;
+    let result = this.renderAnnotationAssignmentsAndDocComment(art, env);
+    result += `${env.indent}entity ${this.renderArtifactName(artifactName, env)}`;
     if (art.params)
-      result += renderParameters(art, env);
+      result += this.renderParameters(art, env);
     result += ' as ';
-    result += renderQuery(getNormalizedQuery(art).query, true, syntax, env.withSubPath([ art.projection ? 'projection' : 'query' ]), art.elements);
+    result += this.renderQuery(getNormalizedQuery(art).query, true, syntax, env.withSubPath([ art.projection ? 'projection' : 'query' ]), art.elements);
     if (art.actions) // Views/Projections also allow actions. Just the VIEW keyword variant did not.
-      result += renderActionsAndFunctions(art, env);
+      result += this.renderBoundActionsAndFunctions(art, env);
     result += ';\n';
-    result += renderQueryElementAndEnumAnnotations(art, env);
+    result += this.renderQueryElementAndEnumAnnotations(art, env);
     if (art.includes)
-      result += renderExtension({ extend: artifactName, includes: art.includes }, env);
+      result += this.renderExtension({ extend: artifactName, includes: art.includes }, env);
     return result;
   }
 
@@ -1050,7 +1554,8 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @param {object} [elements]
    */
-  function renderQuery( query, isLeadingQuery, syntax, env, elements = query.elements || Object.create(null) ) {
+  renderQuery( query, isLeadingQuery, syntax, env, elements = query.elements || Object.create(null) ) {
+    const that = this;
     if (query.SET) {
       // Set operator, such as UNION, INTERSECT, or EXCEPT...
       return renderQuerySet();
@@ -1067,7 +1572,7 @@ function csnToCdl( csn, options, msg ) {
     result += (syntax === 'projection') ? 'projection on ' : 'select from ';
 
     env.path.push('from');
-    result += renderViewSource(select.from, env);
+    result += this.renderViewSource(select.from, env);
     env.path.length -= 1;
 
     if (select.mixin) {
@@ -1076,7 +1581,7 @@ function csnToCdl( csn, options, msg ) {
       env.increaseIndent();
       forEach(select.mixin, (name, mixin) => {
         env.path[env.path.length - 1] = name;
-        elems += renderElement(name, mixin, env);
+        elems += this.renderElement(name, mixin, env);
       });
       env.decreaseIndent();
       env.path.length -= 2;
@@ -1090,35 +1595,35 @@ function csnToCdl( csn, options, msg ) {
     if (select.columns) {
       result += ' {\n';
       env.increaseIndent();
-      result += renderViewColumns(select, env, elements);
+      result += this.renderViewColumns(select, env, elements);
       env.decreaseIndent();
       result += `${env.indent}}`;
     }
 
     const childEnv = env.withIncreasedIndent();
     if (select.excluding) {
-      const excludes = select.excluding.map(id => `${childEnv.indent}${quoteNonIdentifierOrKeyword(id, env)}`).join(',\n');
+      const excludes = select.excluding.map(id => `${childEnv.indent}${this.quoteNonIdentifierOrKeyword(id, env)}`).join(',\n');
       result += ` excluding {\n${excludes}\n`;
       result += `${env.indent}}`;
     }
 
     if (isLeadingQuery && query.actions)
-      result += renderActionsAndFunctions(query, env);
+      result += this.renderBoundActionsAndFunctions(query, env);
 
     if (select.where)
-      result += `${continueIndent(result, env)}where ${exprRenderer.renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
+      result += `${continueIndent(result, env)}where ${this.exprRenderer.renderExpr(select.where, env.withSubPath([ 'where' ]))}`;
 
     if (select.groupBy)
-      result += `${continueIndent(result, env)}group by ${select.groupBy.map((expr, i) => exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
+      result += `${continueIndent(result, env)}group by ${select.groupBy.map((expr, i) => this.exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
 
     if (select.having)
-      result += `${continueIndent(result, env)}having ${exprRenderer.renderExpr(select.having, env.withSubPath([ 'having' ]))}`;
+      result += `${continueIndent(result, env)}having ${this.exprRenderer.renderExpr(select.having, env.withSubPath([ 'having' ]))}`;
 
     if (select.orderBy)
-      result += `${continueIndent(result, env)}order by ${select.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
+      result += `${continueIndent(result, env)}order by ${select.orderBy.map((entry, i) => this.renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
 
     if (select.limit)
-      result += `${continueIndent(result, env)}${renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
+      result += `${continueIndent(result, env)}${this.renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
 
     return result;
 
@@ -1147,7 +1652,7 @@ function csnToCdl( csn, options, msg ) {
       const subQueries = query.SET.args.map((arg, i) => {
         // First arg may be leading query
         const subEnv = env.withSubPath([ 'SET', 'args', i ]);
-        const subQuery = renderQuery(arg, isLeadingQuery && (i === 0), 'view', subEnv, elements);
+        const subQuery = that.renderQuery(arg, isLeadingQuery && (i === 0), 'view', subEnv, elements);
         return `(${subQuery})`;
       });
 
@@ -1155,10 +1660,10 @@ function csnToCdl( csn, options, msg ) {
       // Set operation may also have an ORDER BY and LIMIT/OFFSET (in contrast to the ones belonging to
       // each SELECT)
       if (query.SET.orderBy)
-        setResult += `${continueIndent(setResult, env)}order by ${query.SET.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'SET', 'orderBy', i ]))).join(', ')}`;
+        setResult += `${continueIndent(setResult, env)}order by ${query.SET.orderBy.map((entry, i) => that.renderOrderByEntry(entry, env.withSubPath([ 'SET', 'orderBy', i ]))).join(', ')}`;
 
       if (query.SET.limit)
-        setResult += `${continueIndent(setResult, env)}${renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ]))}`;
+        setResult += `${continueIndent(setResult, env)}${that.renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ]))}`;
       return setResult;
     }
   }
@@ -1171,8 +1676,8 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderOrderByEntry( entry, env ) {
-    let result = renderAnnotationAssignmentsAndDocComment(entry, env) + exprRenderer.renderExpr(entry, env);
+  renderOrderByEntry( entry, env ) {
+    let result = this.renderAnnotationAssignmentsAndDocComment(entry, env) + this.exprRenderer.renderExpr(entry, env);
     if (entry.sort)
       result += ` ${entry.sort}`;
 
@@ -1189,14 +1694,14 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} limitEnv
    * @return {string}
    */
-  function renderLimit( limit, limitEnv ) {
+  renderLimit( limit, limitEnv ) {
     let limitStr = '';
     if (limit.rows !== undefined)
-      limitStr += `limit ${exprRenderer.renderExpr(limit.rows, limitEnv.withSubPath([ 'rows' ]))}`;
+      limitStr += `limit ${this.exprRenderer.renderExpr(limit.rows, limitEnv.withSubPath([ 'rows' ]))}`;
 
     if (limit.offset !== undefined) {
       const offsetIndent = (limitStr === '') ? '' : `\n${limitEnv.withIncreasedIndent().indent}`;
-      limitStr += `${offsetIndent}offset ${exprRenderer.renderExpr(limit.offset, limitEnv.withSubPath([ 'offset' ]))}`;
+      limitStr += `${offsetIndent}offset ${this.exprRenderer.renderExpr(limit.offset, limitEnv.withSubPath([ 'offset' ]))}`;
     }
     return limitStr;
   }
@@ -1211,12 +1716,12 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderActionsAndFunctions( art, env ) {
+  renderBoundActionsAndFunctions( art, env ) {
     let result = '';
     if (art.actions) {
       const childEnv = env.withIncreasedIndent();
       for (const name in art.actions)
-        result += renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]));
+        result += this.renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]), true);
       result = (result === '')
         ? ' actions { }'
         : ` actions {\n${result}${env.indent}}`;
@@ -1230,18 +1735,25 @@ function csnToCdl( csn, options, msg ) {
    * @param {string} actionName
    * @param {CSN.Action} act
    * @param {CdlRenderEnvironment} env
+   * @param {boolean} isBound
    * @return {string}
    */
-  function renderActionOrFunction( actionName, act, env ) {
-    let result = renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind;
-    result += ` ${renderArtifactName(actionName, env)}`;
-    result += renderParameters(act, env);
+  renderActionOrFunction( actionName, act, env, isBound ) {
+    let result = this.renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind;
+    if (isBound) {
+      // for bound actions, paths are not global
+      result += ` ${this.quotePathIfRequired(actionName, env)}`;
+    }
+    else {
+      result += ` ${this.renderArtifactName(actionName, env)}`;
+    }
+    result += this.renderParameters(act, env);
     if (act.returns) {
       let actEnv = env.withSubPath([ 'returns' ]);
-      const annos = renderAnnotationAssignmentsAndDocComment(act.returns, actEnv.withIncreasedIndent());
+      const annos = this.renderAnnotationAssignmentsAndDocComment(act.returns, actEnv.withIncreasedIndent());
       if (annos) // if `returns` has annotations, increase indent for nicer aligned output
         actEnv = actEnv.withIncreasedIndent();
-      const type = renderTypeReferenceAndProps(act.returns, actEnv);
+      const type = this.renderTypeReferenceAndProps(act.returns, actEnv);
       result += ` returns${annos ? '\n' : ' '}${annos}${annos ? actEnv.indent : ''}${type}`;
     }
 
@@ -1258,9 +1770,9 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderParameters( art, env ) {
+  renderParameters( art, env ) {
     const childEnv = env.withIncreasedIndent();
-    const parameters = Object.keys(art.params || {}).map(name => renderParameter(name, art.params[name], childEnv));
+    const parameters = Object.keys(art.params || {}).map(name => this.renderParameter(name, art.params[name], childEnv));
     if (parameters.length === 0)
       return '()';
     return `(\n${parameters.join(',\n')}\n${env.indent})`;
@@ -1274,10 +1786,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderParameter( parName, par, env ) {
+  renderParameter( parName, par, env ) {
     env = env.withSubPath( [ 'params', parName ]);
-    let result = `${renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
-    result += `${quoteNonIdentifierOrKeyword(parName, env)} : ${renderTypeReferenceAndProps(par, env)}`;
+    let result = `${this.renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
+    result += `${this.quoteNonIdentifierOrKeyword(parName, env)} : ${this.renderTypeReferenceAndProps(par, env)}`;
     return result;
   }
 
@@ -1293,7 +1805,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {boolean} [config.noAnnoCollect] Do not collect annotations of sub-elements.
    * @return {string}
    */
-  function renderTypeReferenceAndProps( artifact, env, config = {} ) {
+  renderTypeReferenceAndProps( artifact, env, config = {} ) {
     let result = '';
     const { typeRefOnly, noAnnoCollect } = config;
 
@@ -1307,7 +1819,7 @@ function csnToCdl( csn, options, msg ) {
     // "not null". Keep a reference to the outer artifact.
     const origArtifact = artifact;
     if (!artifact.type && artifact.items) {
-      checkArrayedArtifact(artifact, env);
+      this.checkArrayedArtifact(artifact, env);
       result += 'many '; // alternative: 'array of'; but not used
       artifact = artifact.items;
       env = env.withSubPath([ 'items' ]);
@@ -1316,8 +1828,8 @@ function csnToCdl( csn, options, msg ) {
     const type = normalizeTypeRef(artifact.type);
 
     if (!type && artifact.elements) {
-      result += renderElements(artifact, env);
-      result += renderNullability(artifact.notNull);
+      result += this.renderElements(artifact, env);
+      result += this.renderNullability(artifact.notNull);
       // structured default not possible at the moment
       return result;
     }
@@ -1330,7 +1842,7 @@ function csnToCdl( csn, options, msg ) {
       const isComp = type === 'cds.Composition';
       // Type, cardinality and target; CAPire uses CamelCase
       result += isComp ? 'Composition' : 'Association';
-      result += renderCardinality(artifact);
+      result += this.renderCardinality(artifact);
 
       // `targetAspect` may be set by the core compiler and refers to the original named or unnamed aspect.
       // In parseCdl, `target` may still be an object containing elements.  This would be replaced
@@ -1338,12 +1850,12 @@ function csnToCdl( csn, options, msg ) {
       // If a name exists (either in target or targetAspect), prefer it over rendering elements.
       const elements = artifact.target?.elements || artifact.targetAspect?.elements;
       if (typeof artifact.target === 'string' || typeof artifact.targetAspect === 'string') {
-        result += renderAbsolutePath({ ref: [ artifact.target || artifact.targetAspect ] },
-                                     { ...env, additionalKeywords: [ 'MANY', 'ONE' ] });
+        result += this.renderAbsolutePath({ ref: [ artifact.target || artifact.targetAspect ] },
+                                          { ...env, additionalKeywords: [ 'MANY', 'ONE' ] });
       }
       else if (elements) {
         // anonymous aspect, either parseCdl or client CSN.
-        result += renderElements({ elements }, env.withSubPath([ artifact.target?.elements ? 'target' : 'targetAspect' ]));
+        result += this.renderElements({ elements }, env.withSubPath([ artifact.target?.elements ? 'target' : 'targetAspect' ]));
       }
       else {
         throw new ModelError('Association/Composition is missing its target! Throwing exception to trigger recompilation.');
@@ -1351,16 +1863,16 @@ function csnToCdl( csn, options, msg ) {
 
       // ON-condition (if any)
       if (artifact.on)
-        result += ` on ${exprRenderer.renderExpr(artifact.on, env.withSubPath([ 'on' ]))}`;
+        result += ` on ${this.exprRenderer.renderExpr(artifact.on, env.withSubPath([ 'on' ]))}`;
 
       // 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)
-        result += ` ${ renderForeignKeys(artifact, env) }`;
+        result += ` ${ this.renderForeignKeys(artifact, env) }`;
 
       if (!artifact.on) {
         // unmanaged associations can't be followed by "not null" or "default"
-        result += renderNullability(notNull);
-        result += renderDefaultExpr(defaultValue, env.withSubPath([ 'default' ]));
+        result += this.renderNullability(notNull);
+        result += this.renderDefaultExpr(defaultValue, env.withSubPath([ 'default' ]));
       }
       return result;
     }
@@ -1372,28 +1884,28 @@ function csnToCdl( csn, options, msg ) {
     // We only extract annotations of enums, if "typeRefOnly" is true.  Otherwise, since
     // the full enum is rendered below, we would have unnecessary annotations.
     if (!noAnnoCollect && (!artifact.enum || typeRefOnly)) {
-      const annotate = collectAnnotationsOfElementsAndEnum(artifact, env);
+      const annotate = this.collectAnnotationsOfElementsAndEnum(artifact, env);
       if (annotate)
-        subelementAnnotates.push(annotate);
+        this.subelementAnnotates.push(annotate);
     }
 
     // Reference to another artifact
     if (typeof type === 'string') {
       // If we get here, it must be a named type
-      result += renderNamedTypeWithParameters(artifact, env);
+      result += this.renderNamedTypeWithParameters(artifact, env);
     }
     else if (type?.ref) {
-      result += renderAbsolutePath(artifact.type, env);
+      result += this.renderAbsolutePath(artifact.type, env);
     }
 
     if (artifact.enum && !typeRefOnly)
-      result += renderEnum(artifact.enum, env);
+      result += this.renderEnum(artifact.enum, env);
 
-    result += renderNullability(notNull);
+    result += this.renderNullability(notNull);
     // If there is a default value, and it's a calculated element, do not
     // render the default (because it's not supported for calc elements).
     if (defaultValue !== undefined && !artifact.value)
-      result += renderDefaultExpr(defaultValue, env.withSubPath([ 'default' ]));
+      result += this.renderDefaultExpr(defaultValue, env.withSubPath([ 'default' ]));
 
     return result;
   }
@@ -1405,12 +1917,12 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderRedirectedTo( art, env ) {
-    let result = `redirected to ${renderDefinitionReference(art.target, env)}`;
+  renderRedirectedTo( art, env ) {
+    let result = `redirected to ${this.renderDefinitionReference(art.target, env)}`;
     if (art.on)
-      result += ` on ${exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ]))}`;
+      result += ` on ${this.exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ]))}`;
     else if (art.keys)
-      result += ` ${ renderForeignKeys(art, env) }`;
+      result += ` ${ this.renderForeignKeys(art, env) }`;
     return result;
   }
 
@@ -1421,26 +1933,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderNamedTypeWithParameters( artWithType, env ) {
+  renderNamedTypeWithParameters( artWithType, env ) {
     const type = normalizeTypeRef(artWithType.type);
-    let result = '';
-
-    if (isBuiltinType(type)) {
-      // 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 = type.slice(4);
-      if (shortHand.startsWith('hana.') && hanaRequiresAbsolutePath)
-        result += type;
-      else if (usings.available.includes(shortHand))
-        result += type;
-      else
-        result += shortHand;
-    }
-    else {
-      result += renderDefinitionReference(type, env);
-    }
-
-    result += renderTypeParameters(artWithType);
+    let result = this.renderDefinitionReference(type, env);
+    result += this.renderTypeParameters(artWithType);
     return result;
   }
 
@@ -1452,11 +1948,11 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderEnum( enumPart, env ) {
+  renderEnum( enumPart, env ) {
     let result = ' enum {\n';
     const childEnv = env.withIncreasedIndent();
     for (const name in enumPart)
-      result += renderElement(name, enumPart[name], childEnv.withSubPath([ 'enum', name ]));
+      result += this.renderElement(name, enumPart[name], childEnv.withSubPath([ 'enum', name ]));
     result += `${env.indent}}`;
     return result;
   }
@@ -1469,14 +1965,14 @@ function csnToCdl( csn, options, msg ) {
    * @param {any} annoValue
    * @param {CdlRenderEnvironment} env
    */
-  function renderAnnotationValue( annoValue, env ) {
+  renderAnnotationValue( annoValue, env ) {
     if (isAnnotationExpression(annoValue)) {
       // Once inside an expression, we stay there.
-      const xpr = exprRenderer.renderExpr(annoValue, env);
+      const xpr = this.exprRenderer.renderExpr(annoValue, env);
       return `( ${xpr} )`;
     }
     else if (Array.isArray(annoValue)) {
-      return renderAnnotationArrayValue( annoValue, env );
+      return this.renderAnnotationArrayValue( annoValue, env );
     }
     else if (typeof annoValue === 'object' && annoValue !== null) {
       // Enum symbol
@@ -1486,26 +1982,24 @@ function csnToCdl( csn, options, msg ) {
       // Shorthand for absolute path (as string)
       else if (annoValue['='] !== undefined) {
         if (annoValue['='].startsWith('@'))
-          return quoteAnnotationPathIfRequired(annoValue['='], env);
-        return quotePathIfRequired(annoValue['='], env);
+          return this.quoteAnnotationPathIfRequired(annoValue['='], env);
+        return this.quotePathIfRequired(annoValue['='], env);
       }
       // Shorthand for ellipsis: `... up to <val>`
       else if (annoValue['...'] !== undefined) {
         if (annoValue['...'] === true)
           return '...';
-        return `... up to ${renderAnnotationValue(annoValue['...'], env)}`;
+        return `... up to ${this.renderAnnotationValue(annoValue['...'], env)}`;
       }
 
       // Struct value (can currently only occur within an array)
       // Render as one-liner if there is at most one key.  Render as multi-line
       // struct if there are more and use nicer indentation.
       const keys = Object.keys(annoValue);
-      const childEnv = keys.length <= 1 ? env : env.withIncreasedIndent();
-      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key, env)}: ${renderAnnotationValue(annoValue[key], childEnv.withSubPath([ key ]))}`);
-      if (values.length <= 1)
-        return `{ ${values.join(', ')} }`;
-      const valueList = values.join(`,\n${childEnv.indent}`);
-      return `{\n${childEnv.indent}${valueList}\n${env.indent}}`;
+      const childEnv = env.withIncreasedIndent();
+      const values = keys.map(key => `${this.quoteAnnotationPathIfRequired(key, env)}: ${this.renderAnnotationValue(annoValue[key], childEnv.withSubPath([ key ]))}`);
+      const result = joinDocuments(values, [ ',', line() ]);
+      return format(nestBy(env.indent.length, bracketBlock(INDENT_SIZE, '{', result, '}') ));
     }
     // Null
     else if (annoValue === null) {
@@ -1527,25 +2021,12 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAnnotationArrayValue( annoValue, env ) {
+  renderAnnotationArrayValue( annoValue, env ) {
     const childEnv = env.withIncreasedIndent();
     // Render array parts as values.
-    let length = 0;
-    let hasLineBreak = false;
-    const items = annoValue.map((item, i) => {
-      const result = renderAnnotationValue(item, childEnv.withSubPath([ i ]));
-      length += result.length + 2; // just a heuristic; add 2 for `, `.
-      if (!hasLineBreak && result.includes('\n'))
-        hasLineBreak = true;
-      return result;
-    });
-
-    if (!hasLineBreak && (length + env.indent.length) < 100) {
-      // Spaces required if last array value is a delimited identifier.
-      return `[ ${items.join(', ')} ]`;
-    }
-    const renderedItems = items.join(`,\n${childEnv.indent}`);
-    return `[\n${childEnv.indent}${renderedItems}\n${env.indent}]`;
+    const items = annoValue.map((item, i) => this.renderAnnotationValue(item, childEnv.withSubPath([ i ])));
+    const result = joinDocuments(items, [ ',', line() ]);
+    return format(nestBy(env.indent.length, bracketBlock(INDENT_SIZE, '[', result, ']')));
   }
 
   /**
@@ -1556,14 +2037,14 @@ function csnToCdl( csn, options, msg ) {
    * @param {object} env
    * @returns {string}
    */
-  function renderPathStep( s, idx, env ) {
+  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.
       // FIXME: We should rather explicitly recognize quoting somehow
       if (idx === 0 && s.startsWith('$'))
         return s;
-      return quoteNonIdentifierOrKeyword(s, env);
+      return this.quoteNonIdentifierOrKeyword(s, env);
     }
     // ID with filters or parameters
     else if (typeof s === 'object') {
@@ -1573,16 +2054,16 @@ function csnToCdl( csn, options, msg ) {
 
       // Not really a path step but an object-like function call
       if (s.func)
-        return `${s.func}(${renderArguments(s, '=>', env)})`;
+        return `${s.func}(${this.renderArguments(s, '=>', env)})`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${quoteNonIdentifierOrKeyword(s.id, env)}`;
+      let result = `${this.quoteNonIdentifierOrKeyword(s.id, env)}`;
       if (s.args) {
         // View parameters
-        result += `(${renderArguments(s, ':', env)})`;
+        result += `(${this.renderArguments(s, ':', env)})`;
       }
 
-      result += renderFilterAndCardinality(s, env);
+      result += this.renderFilterAndCardinality(s, env);
 
       return result;
     }
@@ -1599,13 +2080,13 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderArguments( node, sep, env ) {
+  renderArguments( node, sep, env ) {
     if (!node.args)
       return '';
     else if (Array.isArray(node.args))
-      return renderPositionalArguments(node, env);
+      return this.renderPositionalArguments(node, env);
     else if (typeof node.args === 'object')
-      return renderNamedArguments(node, sep, env);
+      return this.renderNamedArguments(node, sep, env);
     throw new ModelError(`Unknown args: ${JSON.stringify(node.args)}; expected array/object`);
   }
 
@@ -1618,9 +2099,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderNamedArguments( node, separator, env ) {
+  renderNamedArguments( node, separator, env ) {
+    const that = this;
     return Object.keys(node.args).map(function renderNamedArgument(key) {
-      return `${quoteNonIdentifierOrKeyword(key, env)} ${separator} ${renderArgument(node.args[key], env.withSubPath([ 'args', key ]))}`;
+      return `${that.quoteNonIdentifierOrKeyword(key, env)} ${separator} ${that.renderArgument(node.args[key], env.withSubPath([ 'args', key ]))}`;
     }).join(', ');
   }
 
@@ -1631,16 +2113,17 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function renderPositionalArguments( node, env ) {
+  renderPositionalArguments( node, env ) {
     if (!node.args)
       return '';
     const func = node.func?.toUpperCase();
+    const that = this;
     if (func) {
       return node.args.map(function renderFunctionArg(arg, i) {
-        return renderArgument(arg, env.withSubPath([ 'args', i ]), getKeywordsForSpecialFunctionArgument(func, i));
+        return that.renderArgument(arg, env.withSubPath([ 'args', i ]), getKeywordsForSpecialFunctionArgument(func, i));
       }).join(', ');
     }
-    return node.args.map((arg, i) => renderArgument(arg, env.withSubPath([ 'args', i ]))).join(', ');
+    return node.args.map((arg, i) => this.renderArgument(arg, env.withSubPath([ 'args', i ]))).join(', ');
   }
 
   /**
@@ -1652,13 +2135,13 @@ function csnToCdl( csn, options, msg ) {
    * @param {string[]} additionalKeywords
    * @return {string}
    */
-  function renderArgument( arg, env, additionalKeywords = [] ) {
+  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.cloneWith({ additionalKeywords });
     if (isSimpleFunctionExpression(arg && arg.xpr, additionalKeywords))
-      return exprRenderer.renderExpr(arg, env);
-    return exprRenderer.renderSubExpr(arg, env);
+      return this.exprRenderer.renderExpr(arg, env);
+    return this.exprRenderer.renderSubExpr(arg, env);
   }
 
   /**
@@ -1667,10 +2150,10 @@ function csnToCdl( csn, options, msg ) {
    * @param artifact
    * @returns {string}
    */
-  function renderCardinality( artifact ) {
-    if (isSimpleCardinality(artifact.cardinality))
-      return renderSimpleCardinality(artifact);
-    return renderBracketCardinality(artifact);
+  renderCardinality( artifact ) {
+    if (this.isSimpleCardinality(artifact.cardinality))
+      return this.renderSimpleCardinality(artifact);
+    return this.renderBracketCardinality(artifact);
   }
 
   /**
@@ -1679,7 +2162,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Artifact} art
    * @return {string}
    */
-  function renderBracketCardinality( art ) {
+  renderBracketCardinality( art ) {
     const isComp = normalizeTypeRef(art.type) === 'cds.Composition';
     const suffix = (isComp ? ' of ' : ' to ');
     const card = art.cardinality;
@@ -1705,7 +2188,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Cardinality} cardinality
    * @return {boolean}
    */
-  function isSimpleCardinality( cardinality ) {
+  isSimpleCardinality( cardinality ) {
     return !cardinality || (
       cardinality.min === undefined &&
       cardinality.src === undefined &&
@@ -1721,7 +2204,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Element} elem
    * @return {string}
    */
-  function renderSimpleCardinality( elem ) {
+  renderSimpleCardinality( elem ) {
     let result = (normalizeTypeRef(elem.type) === 'cds.Association' ? ' to ' : ' of ');
     if (!elem.cardinality)
       return result;
@@ -1732,24 +2215,23 @@ function csnToCdl( csn, options, msg ) {
     return result;
   }
 
-
-  function renderFilterAndCardinality( s, env ) {
+  renderFilterAndCardinality( s, env ) {
     let result = '';
     const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
     let filter = '';
 
     // TODO: Unify with other filter rendering for SELECT
     if (s.groupBy)
-      filter += ` group by ${s.groupBy.map((expr, i) => exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
+      filter += ` group by ${s.groupBy.map((expr, i) => this.exprRenderer.renderExpr(expr, env.withSubPath([ 'groupBy', i ]))).join(', ')}`;
     if (s.having)
-      filter += ` having ${exprRenderer.renderExpr(s.having, env.withSubPath([ 'having' ]))}`;
+      filter += ` having ${this.exprRenderer.renderExpr(s.having, env.withSubPath([ 'having' ]))}`;
     if (s.orderBy)
-      filter += ` order by ${s.orderBy.map((entry, i) => renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
+      filter += ` order by ${s.orderBy.map((entry, i) => this.renderOrderByEntry(entry, env.withSubPath([ 'orderBy', i ]))).join(', ')}`;
     if (s.limit)
-      filter += ` ${renderLimit(s.limit, env.withSubPath([ 'limit' ]))}`;
+      filter += ` ${this.renderLimit(s.limit, env.withSubPath([ 'limit' ]))}`;
 
     if (s.where) {
-      let where = exprRenderer.renderExpr(s.where, env.withSubPath([ 'where' ]));
+      let where = this.exprRenderer.renderExpr(s.where, env.withSubPath([ 'where' ]));
       // Special rules in CDS parser: If filter starts with one of these SQL keywords, WHERE is mandatory.
       if (filter || /^(?:group|having|order|limit)\s/i.test(where))
         where = ` where ${where}`;
@@ -1767,19 +2249,19 @@ function csnToCdl( csn, options, msg ) {
     return result;
   }
 
-  function renderDefaultExpr( defaultValue, env ) {
+  renderDefaultExpr( defaultValue, env ) {
     if (!defaultValue)
       return '';
     let result = ' default ';
     if (defaultValue.xpr && xprContainsCondition( defaultValue.xpr))
-      result += exprRenderer.renderSubExpr(withoutCast(defaultValue), env);
+      result += this.exprRenderer.renderSubExpr(withoutCast(defaultValue), env);
     else
-      result += exprRenderer.renderExpr(withoutCast(defaultValue), env);
+      result += this.exprRenderer.renderExpr(withoutCast(defaultValue), env);
     return result;
   }
 
   // Render the nullability of an element or parameter (can be unset, true, or false)
-  function renderNullability( notNull /* , env */) {
+  renderNullability( notNull /* , env */) {
     if (notNull === undefined) {
       // Attribute not set at all
       return '';
@@ -1794,7 +2276,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderForeignKeys( art, env ) {
+  renderForeignKeys( art, env ) {
     const renderedKeys = [];
     let hasAnnotations = false;
     env = env.withSubPath([ 'keys', -1 ]);
@@ -1804,14 +2286,14 @@ function csnToCdl( csn, options, msg ) {
       env.path[env.path.length - 1] = i;
       const fKey = art.keys[i];
 
-      const annos = renderAnnotationAssignmentsAndDocComment(fKey, env).trim();
+      const annos = this.renderAnnotationAssignmentsAndDocComment(fKey, env).trim();
       if (annos) {
         hasAnnotations = true;
         renderedKeys.push(annos);
       }
 
-      const alias = fKey.as ? renderAlias(fKey.as, env) : '';
-      const key = exprRenderer.renderExpr(fKey, env);
+      const alias = fKey.as ? this.renderAlias(fKey.as, env) : '';
+      const key = this.exprRenderer.renderExpr(fKey, env);
       renderedKeys.push(`${key}${alias},`);
     }
 
@@ -1834,8 +2316,8 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderAlias( alias, env ) {
-    return ` as ${quoteNonIdentifierOrKeyword(alias, env)}`;
+  renderAlias( alias, env ) {
+    return ` as ${this.quoteNonIdentifierOrKeyword(alias, env)}`;
   }
 
   /**
@@ -1847,7 +2329,7 @@ function csnToCdl( csn, options, msg ) {
    *                                 for length instead of `(length: 10)`.
    * @returns {string}
    */
-  function renderTypeParameters( artWithType, noShortVersion = false ) {
+  renderTypeParameters( artWithType, noShortVersion = false ) {
     const params = typeParameters.list.filter(param => artWithType[param] !== undefined);
     if (params.length === 0)
       return '';
@@ -1876,11 +2358,11 @@ function csnToCdl( csn, options, msg ) {
    * @param {{parentheses: boolean}} [config] Config for renderAnnotationAssignment()
    * @return {string}
    */
-  function renderAnnotationAssignmentsAndDocComment( obj, env, config ) {
-    let result = renderDocComment(obj, env);
+  renderAnnotationAssignmentsAndDocComment( obj, env, config ) {
+    let result = this.renderDocComment(obj, env);
     for (const name in obj) {
       if (name.startsWith('@'))
-        result += renderAnnotationAssignment(obj[name], name, env.withSubPath([ name ]), config);
+        result += this.renderAnnotationAssignment(obj[name], name, env.withSubPath([ name ]), config);
     }
     return result;
   }
@@ -1896,7 +2378,7 @@ function csnToCdl( csn, options, msg ) {
    * @param {object} [config] parentheses: 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 = { parentheses: false } ) {
+  renderAnnotationAssignment( anno, name, env, config = { parentheses: false } ) {
     name = name.substring(1);
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
@@ -1912,14 +2394,14 @@ function csnToCdl( csn, options, msg ) {
     if (variant === '')
       nameBeforeVariant += '#';
 
-    result += quoteAnnotationPathIfRequired(nameBeforeVariant, env);
+    result += this.quoteAnnotationPathIfRequired(nameBeforeVariant, env);
 
     if (variant !== undefined && variant !== '') {
       // Unfortunately, the compiler does not allow `.@` after the first variant identifier,
       // nor multiple `#`, so we're back at simple paths that are possibly quoted.
-      result += `#${quotePathIfRequired(variant, env)}`;
+      result += `#${this.quotePathIfRequired(variant, env)}`;
     }
-    result += ` : ${renderAnnotationValue(anno, env)}`;
+    result += ` : ${this.renderAnnotationValue(anno, env)}`;
 
     if (parentheses)
       result += ')';
@@ -1933,8 +2415,8 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string} Artifact name ready for rendering
    */
-  function renderArtifactName( artifactName, env ) {
-    return quotePathIfRequired(artifactName, env);
+  renderArtifactName( artifactName, env ) {
+    return this.quotePathIfRequired(env.nameEnvStack.definitionName(artifactName), env);
   }
 
   /**
@@ -1945,9 +2427,11 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderDefinitionReference( name, env ) {
-    usings.addIfRequired(name);
-    return quotePathIfRequired(name, env);
+  renderDefinitionReference( name, env ) {
+    if (name === '$self' && !this.csn.definitions.$self)
+      return '$self';
+    name = env.nameEnvStack.definitionReference(name);
+    return this.quotePathIfRequired(name, env);
   }
 
   /**
@@ -1955,17 +2439,18 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function renderIncludes( includes, env ) {
-    return ` : ${includes.map((name, i) => renderDefinitionReference(name, env.withSubPath([ 'includes', i ]))).join(', ')}`;
+  renderIncludes( includes, env ) {
+    return ` : ${includes.map((name, i) => this.renderDefinitionReference(name, env.withSubPath([ 'includes', i ]))).join(', ')}`;
   }
 
-  function createCdlExpressionRenderer() {
+  createCdlExpressionRenderer() {
+    const that = this;
     return createExpressionRenderer({
       finalize: x => x,
       typeCast(x) {
-        const typeRef = renderTypeReferenceAndProps(x.cast, this.env.withSubPath([ 'cast' ]), { typeRefOnly: true, noAnnoCollect: true });
+        const typeRef = that.renderTypeReferenceAndProps(x.cast, this.env.withSubPath([ 'cast' ]), { typeRefOnly: true, noAnnoCollect: true });
         const arg = { ...x, cast: null }; // "arg" without cast to avoid recursion.
-        return `cast(${renderArgument(arg, this.env)} as ${typeRef})`;
+        return `cast(${that.renderArgument(arg, this.env)} as ${typeRef})`;
       },
       val(x) {
         // Literal value, possibly with explicit 'literal' property
@@ -1992,7 +2477,7 @@ function csnToCdl( csn, options, msg ) {
       aliasOnly: x => x.as,
       enum: x => `#${x['#']}`,
       ref(x) {
-        return `${x.param ? ':' : ''}${x.ref.map((step, index) => renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
+        return `${x.param ? ':' : ''}${x.ref.map((step, index) => that.renderPathStep(step, index, this.env.withSubPath([ 'ref', index ]))).join('.')}`;
       },
       windowFunction(x) {
         const funcDef = this.func(x);
@@ -2001,10 +2486,10 @@ function csnToCdl( csn, options, msg ) {
       func(x) {
         if (keywords.cdl_functions.includes(x.func.toUpperCase()) && !x.args)
           return x.func;
-        const name = quoteFunctionIfRequired(x.func, this.env);
+        const name = that.quoteFunctionIfRequired(x.func, this.env);
         if (!x.args) // e.g. for methods without arguments, `args` is not set at all.
           return `${name}`;
-        return `${name}(${renderArguments( x, '=>', this.env )})`;
+        return `${name}(${that.renderArguments( x, '=>', this.env )})`;
       },
       xpr(x) {
         const xprEnv = this.env.withSubPath([ 'xpr' ]);
@@ -2017,10 +2502,10 @@ function csnToCdl( csn, options, msg ) {
       // 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', this.env.withIncreasedIndent())})`;
+        return `(${that.renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
       },
       SELECT(x) {
-        return `(${renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
+        return `(${that.renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
       },
     });
   }
@@ -2040,22 +2525,22 @@ function csnToCdl( csn, options, msg ) {
    * @param {CSN.Artifact} art
    * @param {CdlRenderEnvironment} env
    */
-  function checkArrayedArtifact( art, env ) {
+  checkArrayedArtifact( art, env ) {
     if (!art.items)
       return;
     if (art.notNull !== undefined) {
-      msg.warning('def-unexpected-nullability', env.path, { prop: 'not null', otherprop: 'items' },
-                  'Property $(PROP) not rendered, because it can only be rendered inside $(OTHERPROP) for arrayed artifacts');
+      this.msg.warning('def-unexpected-nullability', env.path, { prop: 'not null', otherprop: 'items' },
+                       'Property $(PROP) not rendered, because it can only be rendered inside $(OTHERPROP) for arrayed artifacts');
     }
 
     if (art.items.items && !art.items.type)
-      msg.message('type-invalid-items', [ ...env.path, 'items' ], { '#': 'nested', prop: 'items' } );
+      this.msg.message('type-invalid-items', [ ...env.path, 'items' ], { '#': 'nested', prop: 'items' } );
 
     const type = art.items.type && normalizeTypeRef(art.items.type);
     if (type === 'cds.Association' || type === 'cds.Composition') {
       // check for `art.items.target` not sufficient; could be indirect type reference
       const isComp = type === 'cds.Composition';
-      msg.message('type-invalid-items', [ ...env.path, 'items' ], { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
+      this.msg.message('type-invalid-items', [ ...env.path, 'items' ], { '#': isComp ? 'comp' : 'assoc', prop: 'items' });
     }
   }
 
@@ -2073,12 +2558,12 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function quotePathIfRequired( path, env ) {
+  quotePathIfRequired( path, env ) {
     return path.split('.').map((step, index) => {
       if (index === 0)
-        return quoteNonIdentifierOrKeyword(step, env);
+        return this.quoteNonIdentifierOrKeyword(step, env);
       else if (!undelimitedIdentifierRegex.test(step))
-        return delimitedId(step, env);
+        return this.delimitedId(step, env);
       return step;
     }).join('.');
   }
@@ -2095,10 +2580,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function quoteNonIdentifierOrKeyword( id, env ) {
+  quoteNonIdentifierOrKeyword( id, env ) {
     // Quote if required for CDL
     if (requiresQuotingForCdl(id, env?.additionalKeywords || []))
-      return delimitedId(id, env);
+      return this.delimitedId(id, env);
     return id;
   }
 
@@ -2114,9 +2599,9 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function quoteNonIdentifier( id, env ) {
+  quoteNonIdentifier( id, env ) {
     if (!undelimitedIdentifierRegex.test(id))
-      return delimitedId(id, env);
+      return this.delimitedId(id, env);
     return id;
   }
 
@@ -2127,10 +2612,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function quoteFunctionIfRequired( funcName, env ) {
+  quoteFunctionIfRequired( funcName, env ) {
     if (cdlNewLineRegEx.test(funcName)) {
-      msg.error('name-invalid-identifier', env.path, {},
-                'An identifier can\'t contain newline characters in CDL');
+      this.msg.error('name-invalid-identifier', env.path, {},
+                     'An identifier can\'t contain newline characters in CDL');
     }
     return apiSmartFunctionId(funcName);
   }
@@ -2145,11 +2630,11 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @returns {string}
    */
-  function quoteAnnotationPathIfRequired( anno, env ) {
+  quoteAnnotationPathIfRequired( anno, env ) {
     return anno.split('.').map((segment) => {
       if (segment.startsWith('@'))
-        return `@${quoteNonIdentifier(segment.slice(1), env)}`;
-      return quoteNonIdentifier(segment, env);
+        return `@${this.quoteNonIdentifier(segment.slice(1), env)}`;
+      return this.quoteNonIdentifier(segment, env);
     }).join('.');
   }
 
@@ -2161,10 +2646,10 @@ function csnToCdl( csn, options, msg ) {
    * @param {CdlRenderEnvironment} env
    * @return {string}
    */
-  function delimitedId( id, env ) {
+  delimitedId( id, env ) {
     if (cdlNewLineRegEx.test(id)) {
-      msg.error('name-invalid-identifier', env.path, {},
-                'An identifier can\'t contain newline characters in CDL');
+      this.msg.error('name-invalid-identifier', env.path, {},
+                     'An identifier can\'t contain newline characters in CDL');
     }
     return apiDelimitedId(id);
   }
@@ -2175,6 +2660,7 @@ class CdlRenderEnvironment {
   path = null;
   elementName = null;
   additionalKeywords = [];
+  nameEnvStack = new NameScopeStack();
 
   constructor(values) {
     Object.assign(this, values);
@@ -2184,10 +2670,11 @@ class CdlRenderEnvironment {
     this.indent = `  ${this.indent}`;
   }
   decreaseIndent() {
-    this.indent = this.indent.substring(0, this.indent.length - 2);
+    this.indent = this.indent.substring(0, this.indent.length - INDENT_SIZE);
   }
   withIncreasedIndent() {
-    return new CdlRenderEnvironment({ ...this, indent: `  ${this.indent}` });
+    const indent = ' '.repeat(this.indent.length + INDENT_SIZE);
+    return new CdlRenderEnvironment({ ...this, indent });
   }
   withSubPath(path) {
     return new CdlRenderEnvironment({ ...this, path: [ ...this.path, ...path ] });
@@ -2258,8 +2745,8 @@ const conditionOperators = [
   // Antlr rule 'condition', 'conditionAnd'
   'AND', 'OR',
 
-  // Antlr rule 'conditionTerm'
-  '=', '<>', '>', '>=', '<', '<=', '!=',
+  // redepage CdlGrammar.g4 rule 'expression'
+  '=', '<>', '>', '>=', '<', '<=', '==', '!=',
   // These are not forbidden, since they must be preceded by one of the comparators above.
   // 'any', 'some', 'all',
 
@@ -2435,20 +2922,6 @@ 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);
-}
-
 /**
  * Quotes the identifier using CDL-style ![]-quotes.
  *
@@ -2503,6 +2976,21 @@ function apiSmartFunctionId( funcName ) {
   return funcName;
 }
 
+/**
+ * Render the CSN model 'model' to CDS source text.
+ * Returned object has the following properties:
+ *  - `model`: CSN model rendered as CDL (string).
+ *  - `namespace`: Namespace statement + `using from './model.cds'.
+ *
+ * @param {CSN.Model} csn
+ * @param {CdlOptions} options
+ * @param {object} msg Message Functions
+ */
+function csnToCdl( csn, options, msg ) {
+  const renderer = new CsnToCdl(csn, options, msg);
+  return renderer.render();
+}
+
 
 module.exports = {
   csnToCdl,