@sap/cds-compiler 5.9.4 → 6.0.10

package/lib/render/toCdl.js

@@ -163,14 +163,14 @@ class NameScopeStack {
       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}`;
+        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}`);
+      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;
@@ -196,7 +196,7 @@ class NameScopeStack {
       // - `annotate cds.String;` works
       return fqn;
     }
-    if (fqn.startsWith(`${leaf.name }.`))
+    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!');
   }
@@ -222,7 +222,7 @@ class NameScopeStack {
     for (let i = this.#scopes.length - 1; i >= 1; i--) {
       const tree = this.#scopes[i];
 
-      if (tree.name && fqn.startsWith(`${tree.name }.`)) {
+      if (tree.name && fqn.startsWith(`${ tree.name }.`)) {
         // FQN is in current scope.
         const relativeName = fqn.substring(tree.name.length + 1);
         const relativeRoot = rootPathSegment(relativeName);
@@ -363,7 +363,7 @@ function createDefinitionPathTree( csn, options ) {
   if (!csn.definitions)
     return tree;
 
-  const useNesting = options.renderCdlDefinitionNesting;
+  const useNesting = options.renderCdlDefinitionNesting !== false;
 
   for (const defName in csn.definitions) {
     const segments = defName.split('.');
@@ -415,7 +415,7 @@ class CsnToCdl {
 
     const env = createEnv();
 
-    const useNesting = !!this.options.renderCdlDefinitionNesting;
+    const useNesting = this.options.renderCdlDefinitionNesting !== false;
     this.definitionTree = createDefinitionPathTree(this.csn, this.options);
     this.commonNamespace = this.getCommonNamespace();
 
@@ -441,18 +441,13 @@ class CsnToCdl {
 
     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');
+      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\';';
-    }
+      cdlResult.model = `namespace ${ this.renderArtifactName(this.commonNamespace.name, env) };\n\n${ cdlResult.model }`;
 
     this.msg.throwWithError();
     return cdlResult;
@@ -466,7 +461,7 @@ class CsnToCdl {
    */
   getCommonNamespace() {
     let root = this.definitionTree;
-    if (!this.options.renderCdlDefinitionNesting || !this.options.renderCdlCommonNamespace)
+    if (this.options.renderCdlDefinitionNesting === false || this.options.renderCdlCommonNamespace === false)
       return root; // User does not want common namespace.
 
     if (this.csn.vocabularies) {
@@ -506,20 +501,20 @@ class CsnToCdl {
    * @returns {string}
    */
   renderUsingAliases(aliases, env) {
-    if (!this.options.renderCdlDefinitionNesting) {
+    if (this.options.renderCdlDefinitionNesting !== false) {
       // 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` : '';
+      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`;
+        result += `using { ${ this.quotePathIfRequired(entry.path, env) } as ${ this.quoteNonIdentifierOrKeyword(entry.alias, env) } };\n`;
       else
-        result += `using { ${entry.path } };\n`;
+        result += `using { ${ entry.path } };\n`;
     }
     return result !== '' ? `${ result }\n` : result;
   }
@@ -535,7 +530,7 @@ class CsnToCdl {
     forEachDefinition(this.csn, (artifact, artifactName) => {
       const sourceStr = this.renderDefinition(artifactName, artifact, env);
       if (sourceStr !== '')
-        result += `${sourceStr}\n`;
+        result += `${ sourceStr }\n`;
     });
     return result;
   }
@@ -564,7 +559,7 @@ class CsnToCdl {
           // 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`;
+          result += `${ env.indent }${ def.kind } ${ that.renderArtifactName(entry.name, env) } {\n`;
           env.increaseIndent();
           env.nameEnvStack.pushNameEnv(entry);
           if (entry.children)
@@ -573,12 +568,12 @@ class CsnToCdl {
           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`;
+          result += `${ env.indent }};\n\n`;
         }
         else if (def) {
           const sourceStr = that.renderDefinition(entry.name, def, env);
           if (sourceStr !== '')
-            result += `${sourceStr}\n`;
+            result += `${ sourceStr }\n`;
           if (entry.children)
             renderTree(entry);
         }
@@ -617,7 +612,7 @@ class CsnToCdl {
     // indentation and name resolution issues
     env.path = [ 'vocabularies', name ];
     const sourceStr = this.renderArtifact(name, anno, env, 'annotation');
-    return `${sourceStr}\n`;
+    return `${ sourceStr }\n`;
   }
 
   /**
@@ -668,20 +663,20 @@ class CsnToCdl {
       // Includes can't be combined with anything in braces {}.
       const affix = isElementExtend ? 'element ' : '';
       const includes = ext.includes.map((inc, i) => this.renderDefinitionReference(inc, env.withSubPath([ 'includes', i ]))).join(', ');
-      result += `${env.indent}extend ${affix}${extName} with ${includes};\n`;
+      result += `${ env.indent }extend ${ affix }${ extName } with ${ includes };\n`;
       return result;
     }
 
     const typeParams = this.renderTypeParameters(ext, true);
     if (typeParams) {
-      result += `${env.indent}extend ${extName} with ${typeParams};\n`;
+      result += `${ env.indent }extend ${ extName } with ${ typeParams };\n`;
       return result;
     }
 
     // If there is nothing to extend, e.g. only annotations, don't render an
     // empty element list.  This would end up in diffs with parseCdl CSN.
     if (!ext.elements && !ext.columns && !ext.actions && !ext.enum) {
-      result += `${env.indent}extend ${extName};\n`;
+      result += `${ env.indent }extend ${ extName };\n`;
       return result;
     }
 
@@ -691,9 +686,9 @@ class CsnToCdl {
     // 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 ${this.getExtendPrefixVariant(ext)} ${extName} with {\n`;
+      result += `${ env.indent }extend ${ this.getExtendPrefixVariant(ext) } ${ extName } with {\n`;
     else
-      result += `${env.indent}extend ${extName} with ${this.getExtendPostfixVariant(ext)}{\n`;
+      result += `${ env.indent }extend ${ extName } with ${ this.getExtendPostfixVariant(ext) }{\n`;
 
     if (ext.columns)
       result += this.renderViewColumns(ext, env.withIncreasedIndent());
@@ -711,10 +706,10 @@ class CsnToCdl {
       if (!usePrefixNotation)
         result += actions;
       else if (actions !== '')
-        result += `${env.indent}} actions {\n${actions}`;
+        result += `${ env.indent }} actions {\n${ actions }`;
     }
 
-    result += `${env.indent}};\n`;
+    result += `${ env.indent }};\n`;
     return result;
   }
 
@@ -804,14 +799,14 @@ class CsnToCdl {
     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 ${this.renderArtifactName(ext.annotate, env)}`;
+    result += `${ env.indent }annotate ${ this.renderArtifactName(ext.annotate, env) }`;
 
     if (ext.params)
       result += this.renderAnnotateParamsInParentheses(ext, env);
 
     // Element extensions and annotations (possibly nested)
     if (ext.elements || ext.enum)
-      result += ` ${this.renderAnnotateStatementElements(ext, env)}`;
+      result += ` ${ this.renderAnnotateStatementElements(ext, env) }`;
 
     else if (ext.returns)
       result += this.renderAnnotateReturns(ext, env);
@@ -835,7 +830,7 @@ class CsnToCdl {
         result += ';\n';
       }
       env.decreaseIndent();
-      result += `${env.indent}}`;
+      result += `${ env.indent }}`;
     }
 
     result = removeTrailingNewline(result);
@@ -864,12 +859,12 @@ class CsnToCdl {
       result += env.indent + this.quoteNonIdentifierOrKeyword(name, env);
       if (elem.elements) {
         env.path.push('elements');
-        result += ` ${this.renderAnnotateStatementElements(elem, env)}`;
+        result += ` ${ this.renderAnnotateStatementElements(elem, env) }`;
         env.path.pop();
       }
       else if (elem.enum) {
         env.path.push('enum');
-        result += ` ${this.renderAnnotateStatementElements(elem, env)}`;
+        result += ` ${ this.renderAnnotateStatementElements(elem, env) }`;
         env.path.pop();
       }
 
@@ -877,7 +872,7 @@ class CsnToCdl {
     }
     env.path.length -= 2;
     env.decreaseIndent();
-    result += `${env.indent}}`;
+    result += `${ env.indent }}`;
     return result;
   }
 
@@ -895,11 +890,11 @@ class CsnToCdl {
 
     const returnAnnos = this.renderAnnotationAssignmentsAndDocComment(ext.returns, env.withIncreasedIndent());
     if (returnAnnos)
-      result += `\n${returnAnnos}`;
+      result += `\n${ returnAnnos }`;
 
     if (ext.returns.elements) {
       // Annotations are on separate lines: Have it aligned nicely
-      result += returnAnnos ? `${env.indent}` : ' ';
+      result += returnAnnos ? `${ env.indent }` : ' ';
       result += this.renderAnnotateStatementElements(ext.returns, env);
     }
     return result;
@@ -923,7 +918,7 @@ class CsnToCdl {
       // const sub = (param.elements || param.enum) ? ` ${renderAnnotateStatementElements(param, childEnv)}` : '';
       paramAnnotations.push( annos + childEnv.indent + name);
     });
-    result += `${paramAnnotations.join(',\n')}\n${env.indent})`;
+    result += `${ paramAnnotations.join(',\n') }\n${ env.indent })`;
     return result;
   }
 
@@ -962,7 +957,7 @@ class CsnToCdl {
         return this.renderArtifact(artifactName, art, env);
 
       default:
-        throw new ModelError(`to.cdl: Unknown artifact kind: '${art.kind}' at ${JSON.stringify(env.path)}`);
+        throw new ModelError(`to.cdl: Unknown artifact kind: '${ art.kind }' at ${ JSON.stringify(env.path) }`);
     }
   }
 
@@ -981,7 +976,7 @@ class CsnToCdl {
     const normalizedArtifactName = kind !== 'annotation'
       ? this.renderArtifactName(artifactName, env)
       : this.quotePathIfRequired(artifactName, env);
-    result += `${env.indent}${kind} ${normalizedArtifactName}`;
+    result += `${ env.indent }${ kind } ${ normalizedArtifactName }`;
 
     if (art.params)
       result += this.renderParameters(art, env);
@@ -1006,7 +1001,7 @@ class CsnToCdl {
         }
 
         // For nicer output, no colon if unnamed structure is used.
-        result += (!art.type && art.elements) ? ` ${type}` : ` : ${type}`;
+        result += (!art.type && art.elements) ? ` ${ type }` : ` : ${ type }`;
       }
       else {
         this.msg.warning('syntax-missing-type', env.path, { '#': art.kind, name: artifactName }, {
@@ -1043,8 +1038,8 @@ class CsnToCdl {
    */
   renderContextOrService( artifactName, art, env ) {
     let result = this.renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}${art.kind} ${this.renderArtifactName(artifactName, env)}`;
-    return `${result} {};\n`;
+    result += `${ env.indent }${ art.kind } ${ this.renderArtifactName(artifactName, env) }`;
+    return `${ result } {};\n`;
   }
 
   /**
@@ -1059,17 +1054,17 @@ class CsnToCdl {
    */
   renderAspect( artifactName, art, env ) {
     let result = this.renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}aspect ${this.renderArtifactName(artifactName, env)}`;
+    result += `${ env.indent }aspect ${ this.renderArtifactName(artifactName, env) }`;
     if (art.includes)
       result += this.renderIncludes(art.includes, env);
 
     if (art.elements)
-      result += ` ${this.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 += `${this.renderBoundActionsAndFunctions(art, env)};\n`;
+    result += `${ this.renderBoundActionsAndFunctions(art, env) };\n`;
     return result;
   }
 
@@ -1086,7 +1081,7 @@ class CsnToCdl {
     for (const name in artifact.elements)
       elements += this.renderElement(name, artifact.elements[name], childEnv.withSubPath([ 'elements', name ]));
 
-    return (elements === '') ? '{ }' : `{\n${elements}${env.indent}}`;
+    return (elements === '') ? '{ }' : `{\n${ elements }${ env.indent }}`;
   }
 
   /**
@@ -1107,10 +1102,10 @@ class CsnToCdl {
     result += element.masked ? 'masked ' : '';
     result += this.quoteNonIdentifierOrKeyword(elementName, env);
     if (element['#'] !== undefined) { // enum symbol reference
-      result += ` = #${element['#']}`;
+      result += ` = #${ element['#'] }`;
     }
     else if (element.val !== undefined) { // enum value
-      result += ` = ${this.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
@@ -1120,7 +1115,7 @@ class CsnToCdl {
       // we'd get a cast to an association.
       const props = this.renderTypeReferenceAndProps(element, env);
       if (props !== '')
-        result += ` : ${props}`;
+        result += ` : ${ props }`;
     }
 
     if (isCalcElement) { // calculated element // @ts-ignore
@@ -1135,7 +1130,7 @@ class CsnToCdl {
       env.path.length -= 1;
     }
 
-    return `${result};\n`;
+    return `${ result };\n`;
   }
 
   /**
@@ -1258,7 +1253,7 @@ class CsnToCdl {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
       const subEnv = env.withIncreasedIndent();
-      let result = `(\n${subEnv.indent}${this.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 += this.renderAlias(source.as, env);
 
@@ -1268,17 +1263,17 @@ class CsnToCdl {
     else if (source.join) {
       // One join operation, possibly with ON-condition
       env.path.push('args', 0);
-      let result = `(${this.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 += ` ${ source.join } `;
         result += this.renderJoinCardinality(source.cardinality);
-        result += `join ${this.renderViewSource(source.args[i], env)}`;
+        result += `join ${ this.renderViewSource(source.args[i], env) }`;
       }
       env.path.length -= 2;
       if (source.on) {
         env.path.push('on');
-        result += ` on ${this.exprRenderer.renderExpr(source.on, env.withSubPath([ 'on' ]))}`;
+        result += ` on ${ this.exprRenderer.renderExpr(source.on, env.withSubPath([ 'on' ])) }`;
         env.path.length -= 1;
       }
       result += ')';
@@ -1316,7 +1311,7 @@ class CsnToCdl {
   renderAbsolutePath( path, env ) {
     // Sanity checks
     if (!path.ref)
-      throw new ModelError(`Expecting ref in path: ${JSON.stringify(path)}`);
+      throw new ModelError(`Expecting ref in path: ${ JSON.stringify(path) }`);
 
     // Determine the absolute name of the first artifact on the path (before any associations or element traversals)
     const firstArtifactName = path.ref[0].id || path.ref[0];
@@ -1327,14 +1322,14 @@ class CsnToCdl {
     // Even the first step might have parameters and/or a filter
     env.path.push('ref', 0);
     if (path.ref[0].args)
-      result += `(${this.renderArguments(path.ref[0], ':', env)})`;
+      result += `(${ this.renderArguments(path.ref[0], ':', env) })`;
     if (path.ref[0].where)
       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 += `:${this.exprRenderer.renderExpr({ ref: path.ref.slice(1) }, env)}`;
+      result += `:${ this.exprRenderer.renderExpr({ ref: path.ref.slice(1) }, env) }`;
 
     return result;
   }
@@ -1387,7 +1382,7 @@ class CsnToCdl {
       return this.renderViewColumn(col, env, findElement(elements, col));
     }).join(',\n');
     env.path.length -= 2;
-    return `${result}\n`;
+    return `${ result }\n`;
   }
 
   /**
@@ -1414,28 +1409,37 @@ class CsnToCdl {
     result += col.virtual ? 'virtual ' : '';
     result += col.key ? 'key ' : '';
 
+    let exprResult;
     // Use special rendering for .expand/.inline - renderExpr cannot easily handle some cases
     if (col.expand || col.inline)
-      result += this.renderInlineExpand(col, env);
+      exprResult = this.renderInlineExpand(col, env);
     else if (col.xpr && xprContainsCondition(col.xpr))
-      result += this.exprRenderer.renderSubExpr(withoutCast(col), env);
+      exprResult = this.exprRenderer.renderSubExpr(withoutCast(col), env);
     else
-      result += this.exprRenderer.renderExpr(withoutCast(col), env);
+      exprResult = this.exprRenderer.renderExpr(withoutCast(col), env);
+
+    result += exprResult;
 
-    // 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)
+    // The same for `virtual <name>`, which is a new element definition instead of a reference.
+    const isNewElementDefinition = exprResult === '';
+    if (isNewElementDefinition && col.as) {
+      result += this.quoteNonIdentifierOrKeyword(col.as, env);
+    }
+    else if (col.as && !col.inline && !col.expand) {
+      // Alias for inline/expand is already handled by renderInlineExpand
       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 += ` : ${this.renderRedirectedTo(col.cast, env)}`;
+        result += ` : ${ this.renderRedirectedTo(col.cast, env) }`;
       else
-        result += ` : ${this.renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true })}`;
+        result += ` : ${ this.renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true }) }`;
       env.path.length -= 1;
     }
     return result;
@@ -1463,9 +1467,9 @@ class CsnToCdl {
     if (!obj.inline && !obj.expand) {
       env.path.push('cast');
       if (obj.cast && obj.cast.type)
-        result += ` : ${this.renderTypeReferenceAndProps(obj.cast, env, { noAnnoCollect: true })}`;
+        result += ` : ${ this.renderTypeReferenceAndProps(obj.cast, env, { noAnnoCollect: true }) }`;
       else if (obj.cast && obj.cast.target) // test tbd
-        result += ` : ${this.renderRedirectedTo(obj.cast, env)}`;
+        result += ` : ${ this.renderRedirectedTo(obj.cast, env) }`;
       env.path.length -= 1;
       return result;
     }
@@ -1481,11 +1485,11 @@ class CsnToCdl {
     result += expandInline //
       .map(elm => this.renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + this.renderInlineExpand(elm, childEnv))
       .join(',\n');
-    result += `\n${env.indent}}`;
+    result += `\n${ env.indent }}`;
 
     // Don't forget about the .excluding
     if (obj.excluding)
-      result += ` excluding { ${obj.excluding.join(',')} }`;
+      result += ` excluding { ${ obj.excluding.join(',') } }`;
 
     // { * } as expand
     if (obj.as && isAnonymousExpand)
@@ -1505,7 +1509,7 @@ class CsnToCdl {
     if (!obj || obj && obj.doc === undefined)
       return '';
     else if (obj && obj.doc === null) // empty doc comment needs to be rendered
-      return `\n${env.indent}/** */\n`;
+      return `\n${ env.indent }/** */\n`;
 
     let { doc } = obj;
     if (/[*]\//.test(doc)) // only escape sequence allowed in CDL for doc comments
@@ -1514,10 +1518,10 @@ class CsnToCdl {
     // Smaller comment for single-line comments.  If the comment starts or ends with whitespace
     // we must use a block comment, or it will be lost when compiling the source again.
     if (!obj.doc.includes('\n') && !/(^\s)|(\s$)/.test(obj.doc))
-      return `${env.indent}/** ${doc} */\n`;
+      return `${ env.indent }/** ${ doc } */\n`;
 
-    const comment = doc.split('\n').map(l => `${env.indent} * ${l}`).join('\n');
-    return `${env.indent}/**\n${comment}\n${env.indent} */\n`;
+    const comment = doc.split('\n').map(l => `${ env.indent } * ${ l }`).join('\n');
+    return `${ env.indent }/**\n${ comment }\n${ env.indent } */\n`;
   }
 
   /**
@@ -1528,7 +1532,7 @@ class CsnToCdl {
   renderView( artifactName, art, env ) {
     const syntax = (art.projection) ? 'projection' : 'entity';
     let result = this.renderAnnotationAssignmentsAndDocComment(art, env);
-    result += `${env.indent}entity ${this.renderArtifactName(artifactName, env)}`;
+    result += `${ env.indent }entity ${ this.renderArtifactName(artifactName, env) }`;
     if (art.params)
       result += this.renderParameters(art, env);
     result += ' as ';
@@ -1562,7 +1566,7 @@ class CsnToCdl {
     }
     else if (!query.SELECT) {
       // ...otherwise must have a SELECT
-      throw new ModelError(`Unexpected query operation ${JSON.stringify(query)}`);
+      throw new ModelError(`Unexpected query operation ${ JSON.stringify(query) }`);
     }
 
     let result = '';
@@ -1588,7 +1592,7 @@ class CsnToCdl {
       if (elems) {
         result += ' mixin {\n';
         result += elems;
-        result += `${env.indent}} into`;
+        result += `${ env.indent }} into`;
       }
     }
     result += select.distinct ? ' distinct' : '';
@@ -1597,33 +1601,33 @@ class CsnToCdl {
       env.increaseIndent();
       result += this.renderViewColumns(select, env, elements);
       env.decreaseIndent();
-      result += `${env.indent}}`;
+      result += `${ env.indent }}`;
     }
 
     const childEnv = env.withIncreasedIndent();
     if (select.excluding) {
-      const excludes = select.excluding.map(id => `${childEnv.indent}${this.quoteNonIdentifierOrKeyword(id, env)}`).join(',\n');
-      result += ` excluding {\n${excludes}\n`;
-      result += `${env.indent}}`;
+      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 += this.renderBoundActionsAndFunctions(query, env);
 
     if (select.where)
-      result += `${continueIndent(result, env)}where ${this.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) => this.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 ${this.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) => this.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)}${this.renderLimit(select.limit, env.withSubPath([ 'limit' ]))}`;
+      result += `${ continueIndent(result, env) }${ this.renderLimit(select.limit, env.withSubPath([ 'limit' ])) }`;
 
     return result;
 
@@ -1640,7 +1644,7 @@ class CsnToCdl {
         return ' ';
       }
       // Otherwise, start new line and indent normally
-      return `\n${indentEnv.withIncreasedIndent().indent}`;
+      return `\n${ indentEnv.withIncreasedIndent().indent }`;
     }
 
     /**
@@ -1653,17 +1657,17 @@ class CsnToCdl {
         // First arg may be leading query
         const subEnv = env.withSubPath([ 'SET', 'args', i ]);
         const subQuery = that.renderQuery(arg, isLeadingQuery && (i === 0), 'view', subEnv, elements);
-        return `(${subQuery})`;
+        return `(${ subQuery })`;
       });
 
-      let setResult = subQueries.join(`\n${env.indent}${query.SET.op}${query.SET.all ? ' all' : ''} `);
+      let setResult = subQueries.join(`\n${ env.indent }${ query.SET.op }${ query.SET.all ? ' all' : '' } `);
       // 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) => that.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)}${that.renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ]))}`;
+        setResult += `${ continueIndent(setResult, env) }${ that.renderLimit(query.SET.limit, env.withSubPath([ 'SET', 'limit' ])) }`;
       return setResult;
     }
   }
@@ -1679,10 +1683,10 @@ class CsnToCdl {
   renderOrderByEntry( entry, env ) {
     let result = this.renderAnnotationAssignmentsAndDocComment(entry, env) + this.exprRenderer.renderExpr(entry, env);
     if (entry.sort)
-      result += ` ${entry.sort}`;
+      result += ` ${ entry.sort }`;
 
     if (entry.nulls)
-      result += ` nulls ${entry.nulls}`;
+      result += ` nulls ${ entry.nulls }`;
 
     return result;
   }
@@ -1697,11 +1701,11 @@ class CsnToCdl {
   renderLimit( limit, limitEnv ) {
     let limitStr = '';
     if (limit.rows !== undefined)
-      limitStr += `limit ${this.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 ${this.exprRenderer.renderExpr(limit.offset, limitEnv.withSubPath([ 'offset' ]))}`;
+      const offsetIndent = (limitStr === '') ? '' : `\n${ limitEnv.withIncreasedIndent().indent }`;
+      limitStr += `${ offsetIndent }offset ${ this.exprRenderer.renderExpr(limit.offset, limitEnv.withSubPath([ 'offset' ])) }`;
     }
     return limitStr;
   }
@@ -1724,7 +1728,7 @@ class CsnToCdl {
         result += this.renderActionOrFunction(name, art.actions[name], childEnv.withSubPath([ 'actions', name ]), true);
       result = (result === '')
         ? ' actions { }'
-        : ` actions {\n${result}${env.indent}}`;
+        : ` actions {\n${ result }${ env.indent }}`;
     }
     return result;
   }
@@ -1742,10 +1746,10 @@ class CsnToCdl {
     let result = this.renderAnnotationAssignmentsAndDocComment(act, env) + env.indent + act.kind;
     if (isBound) {
       // for bound actions, paths are not global
-      result += ` ${this.quotePathIfRequired(actionName, env)}`;
+      result += ` ${ this.quotePathIfRequired(actionName, env) }`;
     }
     else {
-      result += ` ${this.renderArtifactName(actionName, env)}`;
+      result += ` ${ this.renderArtifactName(actionName, env) }`;
     }
     result += this.renderParameters(act, env);
     if (act.returns) {
@@ -1754,7 +1758,7 @@ class CsnToCdl {
       if (annos) // if `returns` has annotations, increase indent for nicer aligned output
         actEnv = actEnv.withIncreasedIndent();
       const type = this.renderTypeReferenceAndProps(act.returns, actEnv);
-      result += ` returns${annos ? '\n' : ' '}${annos}${annos ? actEnv.indent : ''}${type}`;
+      result += ` returns${ annos ? '\n' : ' ' }${ annos }${ annos ? actEnv.indent : '' }${ type }`;
     }
 
     result += ';\n';
@@ -1775,7 +1779,7 @@ class CsnToCdl {
     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})`;
+    return `(\n${ parameters.join(',\n') }\n${ env.indent })`;
   }
 
   /**
@@ -1788,8 +1792,8 @@ class CsnToCdl {
    */
   renderParameter( parName, par, env ) {
     env = env.withSubPath( [ 'params', parName ]);
-    let result = `${this.renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
-    result += `${this.quoteNonIdentifierOrKeyword(parName, env)} : ${this.renderTypeReferenceAndProps(par, env)}`;
+    let result = `${ this.renderAnnotationAssignmentsAndDocComment(par, env) }${ env.indent }`;
+    result += `${ this.quoteNonIdentifierOrKeyword(parName, env) } : ${ this.renderTypeReferenceAndProps(par, env) }`;
     return result;
   }
 
@@ -1810,7 +1814,7 @@ class CsnToCdl {
     const { typeRefOnly, noAnnoCollect } = config;
 
     if (typeRefOnly && !artifact.type)
-      throw new ModelError(`Expected artifact to have a type; in: ${JSON.stringify(env.path)}`);
+      throw new ModelError(`Expected artifact to have a type; in: ${ JSON.stringify(env.path) }`);
 
     if (artifact.localized) // works even for type definitions
       result += 'localized ';
@@ -1863,7 +1867,7 @@ class CsnToCdl {
 
       // ON-condition (if any)
       if (artifact.on)
-        result += ` on ${this.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)
@@ -1918,9 +1922,9 @@ class CsnToCdl {
    * @return {string}
    */
   renderRedirectedTo( art, env ) {
-    let result = `redirected to ${this.renderDefinitionReference(art.target, env)}`;
+    let result = `redirected to ${ this.renderDefinitionReference(art.target, env) }`;
     if (art.on)
-      result += ` on ${this.exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ]))}`;
+      result += ` on ${ this.exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ])) }`;
     else if (art.keys)
       result += ` ${ this.renderForeignKeys(art, env) }`;
     return result;
@@ -1953,7 +1957,7 @@ class CsnToCdl {
     const childEnv = env.withIncreasedIndent();
     for (const name in enumPart)
       result += this.renderElement(name, enumPart[name], childEnv.withSubPath([ 'enum', name ]));
-    result += `${env.indent}}`;
+    result += `${ env.indent }}`;
     return result;
   }
 
@@ -1969,7 +1973,7 @@ class CsnToCdl {
     if (isAnnotationExpression(annoValue)) {
       // Once inside an expression, we stay there.
       const xpr = this.exprRenderer.renderExpr(annoValue, env);
-      return `( ${xpr} )`;
+      return `( ${ xpr } )`;
     }
     else if (Array.isArray(annoValue)) {
       return this.renderAnnotationArrayValue( annoValue, env );
@@ -1977,7 +1981,7 @@ class CsnToCdl {
     else if (typeof annoValue === 'object' && annoValue !== null) {
       // Enum symbol
       if (annoValue['#'] !== undefined) {
-        return `#${annoValue['#']}`;
+        return `#${ annoValue['#'] }`;
       }
       // Shorthand for absolute path (as string)
       else if (annoValue['='] !== undefined) {
@@ -1989,7 +1993,7 @@ class CsnToCdl {
       else if (annoValue['...'] !== undefined) {
         if (annoValue['...'] === true)
           return '...';
-        return `... up to ${this.renderAnnotationValue(annoValue['...'], env)}`;
+        return `... up to ${ this.renderAnnotationValue(annoValue['...'], env) }`;
       }
 
       // Struct value (can currently only occur within an array)
@@ -1997,7 +2001,7 @@ class CsnToCdl {
       // struct if there are more and use nicer indentation.
       const keys = Object.keys(annoValue);
       const childEnv = env.withIncreasedIndent();
-      const values = keys.map(key => `${this.quoteAnnotationPathIfRequired(key, env)}: ${this.renderAnnotationValue(annoValue[key], childEnv.withSubPath([ key ]))}`);
+      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, '}') ));
     }
@@ -2050,17 +2054,17 @@ class CsnToCdl {
     else if (typeof s === 'object') {
       // Sanity check
       if (!s.func && !s.id)
-        throw new ModelError(`Unknown path step object: ${JSON.stringify(s)}`);
+        throw new ModelError(`Unknown path step object: ${ JSON.stringify(s) }`);
 
       // Not really a path step but an object-like function call
       if (s.func)
-        return `${s.func}(${this.renderArguments(s, '=>', env)})`;
+        return `${ s.func }(${ this.renderArguments(s, '=>', env) })`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${this.quoteNonIdentifierOrKeyword(s.id, env)}`;
+      let result = `${ this.quoteNonIdentifierOrKeyword(s.id, env) }`;
       if (s.args) {
         // View parameters
-        result += `(${this.renderArguments(s, ':', env)})`;
+        result += `(${ this.renderArguments(s, ':', env) })`;
       }
 
       result += this.renderFilterAndCardinality(s, env);
@@ -2068,7 +2072,7 @@ class CsnToCdl {
       return result;
     }
 
-    throw new ModelError(`Unknown path step: ${JSON.stringify(s)}`);
+    throw new ModelError(`Unknown path step: ${ JSON.stringify(s) }`);
   }
 
   /**
@@ -2087,7 +2091,7 @@ class CsnToCdl {
       return this.renderPositionalArguments(node, env);
     else if (typeof node.args === 'object')
       return this.renderNamedArguments(node, sep, env);
-    throw new ModelError(`Unknown args: ${JSON.stringify(node.args)}; expected array/object`);
+    throw new ModelError(`Unknown args: ${ JSON.stringify(node.args) }; expected array/object`);
   }
 
   /**
@@ -2102,7 +2106,7 @@ class CsnToCdl {
   renderNamedArguments( node, separator, env ) {
     const that = this;
     return Object.keys(node.args).map(function renderNamedArgument(key) {
-      return `${that.quoteNonIdentifierOrKeyword(key, env)} ${separator} ${that.renderArgument(node.args[key], env.withSubPath([ 'args', key ]))}`;
+      return `${ that.quoteNonIdentifierOrKeyword(key, env) } ${ separator } ${ that.renderArgument(node.args[key], env.withSubPath([ 'args', key ])) }`;
     }).join(', ');
   }
 
@@ -2172,13 +2176,13 @@ class CsnToCdl {
 
     let result = '[';
     if (card.src !== undefined)
-      result += `${card.src}, `;
+      result += `${ card.src }, `;
     if (card.min !== undefined)
-      result += `${card.min}..`;
+      result += `${ card.min }..`;
     if (card.max !== undefined)
       result += card.max;
     // srcmin can't be represented in CDL
-    return `${result}]${suffix}`;
+    return `${ result }]${ suffix }`;
   }
 
   /**
@@ -2217,34 +2221,34 @@ class CsnToCdl {
 
   renderFilterAndCardinality( s, env ) {
     let result = '';
-    const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
+    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) => this.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 ${this.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) => this.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 += ` ${this.renderLimit(s.limit, env.withSubPath([ 'limit' ]))}`;
+      filter += ` ${ this.renderLimit(s.limit, env.withSubPath([ 'limit' ])) }`;
 
     if (s.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}`;
-      filter = `${where} ${filter}`;
+        where = ` where ${ where }`;
+      filter = `${ where } ${ filter }`;
     }
 
     filter = filter.trim();
 
     if (cardinality || filter) {
       if (filter.endsWith(']')) // for cases such as [… ![id] ]
-        result += `[ ${cardinality}${filter} ]`;
+        result += `[ ${ cardinality }${ filter } ]`;
       else
-        result += `[${cardinality}${filter}]`;
+        result += `[${ cardinality }${ filter }]`;
     }
     return result;
   }
@@ -2294,13 +2298,13 @@ class CsnToCdl {
 
       const alias = fKey.as ? this.renderAlias(fKey.as, env) : '';
       const key = this.exprRenderer.renderExpr(fKey, env);
-      renderedKeys.push(`${key}${alias},`);
+      renderedKeys.push(`${ key }${ alias },`);
     }
 
     if (hasAnnotations) {
-      const sep = `\n${env.indent}`;
+      const sep = `\n${ env.indent }`;
       env.decreaseIndent();
-      return `{${sep}${renderedKeys.join(sep)}\n${env.indent}}`;
+      return `{${ sep }${ renderedKeys.join(sep) }\n${ env.indent }}`;
     }
 
     let result = renderedKeys.join(' ');
@@ -2317,7 +2321,7 @@ class CsnToCdl {
    * @return {string}
    */
   renderAlias( alias, env ) {
-    return ` as ${this.quoteNonIdentifierOrKeyword(alias, env)}`;
+    return ` as ${ this.quoteNonIdentifierOrKeyword(alias, env) }`;
   }
 
   /**
@@ -2337,17 +2341,17 @@ class CsnToCdl {
     if (!noShortVersion) {
     // Special cases for 1 or 2 arguments.
       if (params.length === 1 && artWithType.length !== undefined)
-        return `(${artWithType.length})`;
+        return `(${ artWithType.length })`;
       if (params.length === 2 && artWithType.precision !== undefined && artWithType.scale !== undefined)
-        return `(${artWithType.precision}, ${artWithType.scale})`;
+        return `(${ artWithType.precision }, ${ artWithType.scale })`;
     }
 
     // Render named params
     const renderedParams = [];
     for (const param of params)
-      renderedParams.push(`${param}: ${artWithType[param]}`);
+      renderedParams.push(`${ param }: ${ artWithType[param] }`);
 
-    return `(${renderedParams.join(', ')})`;
+    return `(${ renderedParams.join(', ') })`;
   }
 
   /**
@@ -2386,7 +2390,7 @@ class CsnToCdl {
     const variant = parts.length > 1 ? parts.slice(1).join('#') : undefined;
     const { parentheses } = config;
 
-    let result = `${env.indent}@`;
+    let result = `${ env.indent }@`;
     if (parentheses)
       result += '(';
 
@@ -2399,13 +2403,13 @@ class CsnToCdl {
     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 += `#${this.quotePathIfRequired(variant, env)}`;
+      result += `#${ this.quotePathIfRequired(variant, env) }`;
     }
-    result += ` : ${this.renderAnnotationValue(anno, env)}`;
+    result += ` : ${ this.renderAnnotationValue(anno, env) }`;
 
     if (parentheses)
       result += ')';
-    return `${result}\n`;
+    return `${ result }\n`;
   }
 
   /**
@@ -2440,7 +2444,7 @@ class CsnToCdl {
    * @return {string}
    */
   renderIncludes( includes, env ) {
-    return ` : ${includes.map((name, i) => this.renderDefinitionReference(name, env.withSubPath([ 'includes', i ]))).join(', ')}`;
+    return ` : ${ includes.map((name, i) => this.renderDefinitionReference(name, env.withSubPath([ 'includes', i ]))).join(', ') }`;
   }
 
   createCdlExpressionRenderer() {
@@ -2450,7 +2454,7 @@ class CsnToCdl {
       typeCast(x) {
         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(${that.renderArgument(arg, this.env)} as ${typeRef})`;
+        return `cast(${ that.renderArgument(arg, this.env) } as ${ typeRef })`;
       },
       val(x) {
         // Literal value, possibly with explicit 'literal' property
@@ -2463,7 +2467,7 @@ class CsnToCdl {
           case 'date':
           case 'time':
           case 'timestamp':
-            return `${x.literal}'${x.val}'`;
+            return `${ x.literal }'${ x.val }'`;
           case 'string':
             return renderString(x.val, this.env);
           case 'object':
@@ -2471,30 +2475,29 @@ class CsnToCdl {
               return 'null';
             // otherwise fall through to
           default:
-            throw new ModelError(`Unknown literal or type: ${JSON.stringify(x)}`);
+            throw new ModelError(`Unknown literal or type: ${ JSON.stringify(x) }`);
         }
       },
-      aliasOnly: x => x.as,
-      enum: x => `#${x['#']}`,
+      enum: x => `#${ x['#'] }`,
       ref(x) {
-        return `${x.param ? ':' : ''}${x.ref.map((step, index) => that.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);
-        return `${funcDef} ${this.renderExpr(x.xpr, this.env.withSubPath([ 'xpr' ]))}`; // xpr[0] is 'over'
+        return `${ funcDef } ${ this.renderExpr(x.xpr, this.env.withSubPath([ 'xpr' ])) }`; // xpr[0] is 'over'
       },
       func(x) {
         if (keywords.cdl_functions.includes(x.func.toUpperCase()) && !x.args)
           return x.func;
         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}(${that.renderArguments( x, '=>', this.env )})`;
+          return `${ name }`;
+        return `${ name }(${ that.renderArguments( x, '=>', this.env ) })`;
       },
       xpr(x) {
         const xprEnv = this.env.withSubPath([ 'xpr' ]);
         if (this.isNestedXpr && !x.cast)
-          return `(${this.renderExpr(x.xpr, xprEnv)})`;
+          return `(${ this.renderExpr(x.xpr, xprEnv) })`;
         return this.renderExpr(x.xpr, xprEnv);
       },
       // Sub-queries in expressions need to be in parentheses, otherwise
@@ -2502,10 +2505,10 @@ class CsnToCdl {
       // 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 `(${that.renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
+        return `(${ that.renderQuery(x, false, 'view', this.env.withIncreasedIndent()) })`;
       },
       SELECT(x) {
-        return `(${that.renderQuery(x, false, 'view', this.env.withIncreasedIndent())})`;
+        return `(${ that.renderQuery(x, false, 'view', this.env.withIncreasedIndent()) })`;
       },
     });
   }
@@ -2633,7 +2636,7 @@ class CsnToCdl {
   quoteAnnotationPathIfRequired( anno, env ) {
     return anno.split('.').map((segment) => {
       if (segment.startsWith('@'))
-        return `@${this.quoteNonIdentifier(segment.slice(1), env)}`;
+        return `@${ this.quoteNonIdentifier(segment.slice(1), env) }`;
       return this.quoteNonIdentifier(segment, env);
     }).join('.');
   }
@@ -2667,7 +2670,7 @@ class CdlRenderEnvironment {
   }
 
   increaseIndent() {
-    this.indent = `  ${this.indent}`;
+    this.indent = `  ${ this.indent }`;
   }
   decreaseIndent() {
     this.indent = this.indent.substring(0, this.indent.length - INDENT_SIZE);
@@ -2711,7 +2714,7 @@ function removeTrailingNewline( str ) {
 
 /**
  * Returns true if 'id' requires quotes for CDL, i.e. if 'id'
- * does not match the first part of the `Identifier` rule of `language.g4`
+ * does not match the first part of the `ident` rule of `lib/parsers/Lexer.js`
  * or if 'id' is a reserved keyword.
  *
  * Set additionalKeywords to an array of UPPERCASE keywords
@@ -2857,7 +2860,7 @@ function getAllKeywordsForSpecialFunction( funcName ) {
  */
 function renderString( str, env ) {
   if (isSimpleString(str))
-    return `'${str.replace(/'/g, '\'\'')}'`;
+    return `'${ str.replace(/'/g, '\'\'') }'`;
 
   // We try to work similar to how JavaScript implements JSON.stringify.
   // JSON.stringify() also checks for unpaired unicode surrogates (see §25.5.2.2,
@@ -2892,17 +2895,17 @@ function renderString( str, env ) {
   // are more than three lines, text blocks with indentation "look nicer".
   // This value was chosen by personal taste.
   if (lines.length > 3) {
-    str = lines.join(`\n${env.indent}`);
-    return `\`\`\`\n${env.indent}${str}\n${env.indent}\`\`\``;
+    str = lines.join(`\n${ env.indent }`);
+    return `\`\`\`\n${ env.indent }${ str }\n${ env.indent }\`\`\``;
   }
 
-  return `\`${str}\``;
+  return `\`${ str }\``;
 }
 
 /** @param {number} codePoint */
 function hexEscape( codePoint ) {
   const hex = codePoint.toString(16);
-  return `\\u{${hex}}`;
+  return `\\u{${ hex }}`;
 }
 
 /**
@@ -2933,7 +2936,7 @@ function isSimpleString( str ) {
  * @returns {string}
  */
 function apiDelimitedId( id ) {
-  return `![${id.replace(/]/g, ']]')}]`;
+  return `![${ id.replace(/]/g, ']]') }]`;
 }
 
 /**