@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/render/toCdl.js

@@ -9,6 +9,7 @@ const { forEachDefinition, normalizeTypeRef } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsn/universalCsnEnricher');
 const { isBetaEnabled } = require('../base/model');
 const { ModelError } = require('../base/error');
+const { makeMessageFunction } = require('../base/messages.js');
 const { typeParameters, specialFunctions } = require('../compiler/builtins');
 const { forEach } = require('../utils/objectUtils');
 const {
@@ -34,6 +35,8 @@ function csnToCdl( csn, options ) {
   const special$self = !csn?.definitions?.$self && '$self';
   timetrace.start('CDL rendering');
 
+  const msg = makeMessageFunction(csn, options, 'to.cdl');
+
   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.
@@ -214,7 +217,6 @@ function csnToCdl( csn, options ) {
 
     // Not part of if/else cascade, because it may be in postfix notation.
     if (ext.actions) {
-      // TODO: Merge with renderActionsAndFunctions() -> requires removal of static `with actions`
       const childEnv = increaseIndent(env);
       let actions = '';
       forEach(ext.actions, (actionName, action) => {
@@ -260,8 +262,6 @@ function csnToCdl( csn, options ) {
     if (ext.enum)
       return 'enum ';
     if (ext.elements) { // enum/elements ambiguity -> look into elements
-      // TODO: Check for `type` as well once this is supported by the parser (and identified as elements):
-      //       `extend E with { a = 'string'; b: String }`
       const isLikelyElement = Object.keys(ext.elements)
         .find(name => ext.elements[name].value !== undefined);
       if (isLikelyElement)
@@ -326,7 +326,7 @@ function csnToCdl( csn, options ) {
       const childEnv = increaseIndent(env);
       for (const name in ext.actions) {
         const action = ext.actions[name];
-        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteIdIfRequired(name);
+        result += renderAnnotationAssignmentsAndDocComment(action, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(name);
         // Action parameter annotations
         if (action.params)
           result += renderAnnotateParamsInParentheses(action.params, childEnv);
@@ -361,7 +361,7 @@ function csnToCdl( csn, options ) {
     for (const name in elements) {
       const elem = elements[name];
       result += renderAnnotationAssignmentsAndDocComment(elem, childEnv);
-      result += childEnv.indent + quoteIdIfRequired(name);
+      result += childEnv.indent + quoteNonIdentifierOrKeyword(name);
       if (elem.elements)
         result += renderAnnotateStatementElements(elem.elements, childEnv);
       if (elem.enum)
@@ -385,7 +385,7 @@ function csnToCdl( csn, options ) {
     let result = '(\n';
     const paramAnnotations = [];
     forEach(params, (paramName, param) => {
-      paramAnnotations.push( renderAnnotationAssignmentsAndDocComment(param, childEnv) + childEnv.indent + quoteIdIfRequired(paramName) );
+      paramAnnotations.push( renderAnnotationAssignmentsAndDocComment(param, childEnv) + childEnv.indent + quoteNonIdentifierOrKeyword(paramName) );
     });
     result += `${paramAnnotations.join(',\n')}\n${env.indent})`;
     return result;
@@ -541,37 +541,32 @@ function csnToCdl( csn, options ) {
    * Returns the resulting source string.
    *
    * @param {string} elementName
-   * @param {CSN.Element|CSN.Enum} elm
+   * @param {CSN.Element|CSN.Enum} element
    * @param {CdlRenderEnvironment} env
    */
-  function renderElement( elementName, elm, env ) {
+  function renderElement( elementName, element, env ) {
     env = envAddPath(env, [ 'elements', elementName ]);
-    let result = renderAnnotationAssignmentsAndDocComment(elm, env);
+    let result = renderAnnotationAssignmentsAndDocComment(element, env);
     result += env.indent;
-    result += elm.virtual ? 'virtual ' : '';
-    result += elm.key ? 'key ' : '';
+    result += element.virtual ? 'virtual ' : '';
+    result += element.key ? 'key ' : '';
     // TODO(v4): Remove once deprecated flag for `masked` is removed.
-    result += elm.masked ? 'masked ' : '';
-    result += quoteIdIfRequired(elementName);
-    if (elm.val !== undefined) { // enum value
-      result += ` = ${exprRenderer.renderExpr(elm, env)}`;
+    result += element.masked ? 'masked ' : '';
+    result += quoteNonIdentifierOrKeyword(elementName);
+    if (element.val !== undefined) { // enum value
+      result += ` = ${exprRenderer.renderExpr(element, env)}`;
     }
-    else if (elm['#'] !== undefined) { // enum symbol reference
-      result += ` = #${elm['#']}`;
+    else if (element['#'] !== undefined) { // enum symbol reference
+      result += ` = #${element['#']}`;
     }
     else {
-      // TODO: Maybe push the .value check into renderTypeReferenceAndProps?
-      const type = normalizeTypeRef(elm.items?.type || elm.type);
-      const isAssoc = type === 'cds.Association' || type === 'cds.Composition';
-      if (!isAssoc || elm.value === undefined) {
-        const props = renderTypeReferenceAndProps(elm, env);
-        if (props !== '')
-          result += ` : ${props}`;
-      }
+      const props = renderTypeReferenceAndProps(element, env);
+      if (props !== '')
+        result += ` : ${props}`;
     }
 
-    if (elm.value !== undefined) { // calculated element // @ts-ignore
-      result += ` = ${exprRenderer.renderExpr(elm.value, env)}`;
+    if (element.value !== undefined) { // calculated element // @ts-ignore
+      result += ` = ${exprRenderer.renderExpr(element.value, env)}`;
     }
 
     return `${result};\n`;
@@ -697,7 +692,8 @@ function csnToCdl( csn, options ) {
   function renderViewSource( source, env ) {
     // Sub-SELECT
     if (source.SELECT || source.SET) {
-      let result = `(${renderQuery(source, false, 'view', increaseIndent(env))})`;
+      const subEnv = increaseIndent(env);
+      let result = `(\n${subEnv.indent}${renderQuery(source, false, 'view', subEnv)}\n${env.indent})`;
       if (source.as)
         result += renderAlias(source.as);
 
@@ -762,9 +758,13 @@ function csnToCdl( csn, options ) {
       result += `(${renderArguments(path.ref[0], ':', env)})`;
 
     if (path.ref[0].where) {
+      // TODO: Unify with other filter rendering
       const cardinality = path.ref[0].cardinality ? (`${path.ref[0].cardinality.max}: `) : '';
       const expr = exprRenderer.renderExpr(path.ref[0].where, env);
-      result += `[${cardinality}${expr}]`;
+      if (expr.endsWith(']')) // for cases such as [… ![id] ]
+        result += `[ ${cardinality}${expr} ]`;
+      else
+        result += `[${cardinality}${expr}]`;
     }
 
     // Add any path steps (possibly with parameters and filters) that may follow after that
@@ -827,7 +827,7 @@ function csnToCdl( csn, options ) {
       result += renderDocComment(element, env);
     }
     // Note: parentheses are a workaround for #9015
-    result += renderAnnotationAssignmentsAndDocComment(col, env, { parens: true });
+    result += renderAnnotationAssignmentsAndDocComment(col, env, { parentheses: true });
     result += env.indent;
 
     // only if column is virtual, keyword virtual was present in the source text
@@ -1004,7 +1004,8 @@ function csnToCdl( csn, options ) {
     }
 
     if (select.excluding) {
-      result += ` excluding {\n${select.excluding.map(id => `${childEnv.indent}${quoteIdIfRequired(id)}`).join(',\n')}\n`;
+      const excludes = select.excluding.map(id => `${childEnv.indent}${quoteNonIdentifierOrKeyword(id)}`).join(',\n');
+      result += ` excluding {\n${excludes}\n`;
       result += `${env.indent}}`;
     }
 
@@ -1178,7 +1179,7 @@ function csnToCdl( csn, options ) {
   function renderParameter( parName, par, env ) {
     env = envAddPath(env, [ 'params', parName ]);
     let result = `${renderAnnotationAssignmentsAndDocComment(par, env)}${env.indent}`;
-    result += `${quoteIdIfRequired(parName)} : ${renderTypeReferenceAndProps(par, env)}`;
+    result += `${quoteNonIdentifierOrKeyword(parName)} : ${renderTypeReferenceAndProps(par, env)}`;
     return result;
   }
 
@@ -1211,7 +1212,7 @@ function csnToCdl( csn, options ) {
    * such as `not null` and `default <xpr>`.
    * Allow suppressing rendering of structs such as enums - used in columns for example.
    *
-   * @param {object} artifact
+   * @param {CSN.Artifact} artifact
    * @param {CdlRenderEnvironment} env
    * @param {object} [config={}] - `typeRefOnly`   Whether to only render type defs, no arrayed/structured/enum.
    *                             - `noAnnoCollect` Do not collect annotations of sub-elements.
@@ -1220,7 +1221,6 @@ function csnToCdl( csn, options ) {
   function renderTypeReferenceAndProps( artifact, env, config = {} ) {
     let result = '';
     const { typeRefOnly, noAnnoCollect } = config;
-    let isTypeDef = env.path?.length === 2; // e.g [ 'definitions', typeDef ];
 
     if (typeRefOnly && !artifact.type)
       throw new ModelError(`Expected artifact to have a type; in: ${env.artifactName}`);
@@ -1229,20 +1229,16 @@ function csnToCdl( csn, options ) {
       result += 'localized ';
 
     if (!artifact.type && artifact.items) {
+      checkArrayedArtifact(artifact, env);
       result += 'many '; // alternative: 'array of'; but not used
-      artifact = artifact.items;
-      env = envAddPath(env, 'items');
-      // element keywords allowed in MANY case; was an oversight when arrays were introduced.
-      isTypeDef = false;
-      // "many many" does not work in CDL, so we don't check for it.
+      ({ art: artifact, env } = checkInnerMostArray(artifact, env));
     }
 
     const type = normalizeTypeRef(artifact.type);
 
     if (!type && artifact.elements) {
       result += renderElements(artifact, env);
-      if (!isTypeDef)
-        result += renderNullability(artifact);
+      result += renderNullability(artifact);
       // structured default not possible at the moment
       return result;
     }
@@ -1278,7 +1274,7 @@ function csnToCdl( csn, options ) {
       if (artifact.keys && !artifact.on)
         result += ` { ${Object.keys(artifact.keys).map(name => renderForeignKey(artifact.keys[name], env)).join(', ')} }`;
 
-      if (!isTypeDef && !artifact.on) // unmanaged associations can't be followed by "not null"
+      if (artifact.notNull !== undefined && !artifact.on) // unmanaged associations can't be followed by "not null"
         result += renderNullability(artifact);
       // DEFAULT not possible here.
 
@@ -1291,8 +1287,6 @@ function csnToCdl( csn, options ) {
     // get lost if we only render the type name.
     // We only extract annotations of enums, if "typeRefOnly" is true.  Otherwise, since
     // the full enum is rendered below, we would have unnecessary annotations.
-    // TODO: Can we annotate elements of targetAspect?
-    //       If so, move this block before the composition rendering.
     if (!noAnnoCollect && (!artifact.enum || typeRefOnly)) {
       const annotate = collectAnnotationsOfElementsAndEnum(artifact, env);
       if (annotate)
@@ -1310,9 +1304,9 @@ function csnToCdl( csn, options ) {
 
     if (artifact.enum && !typeRefOnly)
       result += renderEnum(artifact.enum, env);
-    if (!isTypeDef) // NOT NULL not possible for not-arrayed type definitions
+    if (artifact.notNull !== undefined)
       result += renderNullability(artifact);
-    if (artifact.default)
+    if (artifact.default !== undefined)
       result += ` default ${exprRenderer.renderExpr(artifact.default, env)}`;
 
     return result;
@@ -1380,53 +1374,94 @@ function csnToCdl( csn, options ) {
   }
 
   /**
-   * Render an annotation value (somewhat like a simplified expression, with slightly different
-   * representation)
+   * Render an annotation value, which is either
+   *  - a normal expressions
+   *  - a somewhat simplified expression, with slightly different representation
    *
-   * @param {any} x
+   * @param {any} annoValue
    * @param {CdlRenderEnvironment} env
    */
-  function renderAnnotationValue( x, env ) {
-    if (Array.isArray(x)) {
-      // Render array parts as values. Spaces required if last array value is
-      // a delimited identifier.
-      return `[ ${x.map(item => renderAnnotationValue(item, env)).join(', ')} ]`;
+  function renderAnnotationValue( annoValue, env ) {
+    // TODO: There must be at least one known expression property, otherwise
+    //       it could be `type: 'unchecked'`.
+    const isXpr = annoValue?.['='] !== undefined && (Object.keys(annoValue).length > 1) &&
+        isBetaEnabled(options, 'annotationExpressions');
+    if (isXpr) {
+      // Once inside an expression, we stay there.
+      const xpr = exprRenderer.renderExpr(annoValue, env);
+      return `( ${xpr} )`;
     }
-    else if (typeof x === 'object' && x !== null) {
+    else if (Array.isArray(annoValue)) {
+      return renderAnnotationArrayValue( annoValue, env );
+    }
+    else if (typeof annoValue === 'object' && annoValue !== null) {
       // Enum symbol
-      if (x['#']) {
-        return `#${x['#']}`;
+      if (annoValue['#']) {
+        return `#${annoValue['#']}`;
       }
       // Shorthand for absolute path (as string)
-      else if (x['=']) {
-        return quotePathIfRequired(x['=']);
+      else if (annoValue['=']) {
+        if (annoValue['='].startsWith('@'))
+          return quoteAnnotationPathIfRequired(annoValue['=']);
+        return quotePathIfRequired(annoValue['=']);
       }
       // Shorthand for ellipsis: `... up to <val>`
-      else if (x['...']) {
-        if (x['...'] === true)
+      else if (annoValue['...']) {
+        if (annoValue['...'] === true)
           return '...';
-        return `... up to ${renderAnnotationValue(x['...'], env)}`;
+        return `... up to ${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(x);
+      const keys = Object.keys(annoValue);
       const childEnv = keys.length <= 1 ? env : increaseIndent(env);
-      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key)}: ${renderAnnotationValue(x[key], childEnv)}`);
+      const values = keys.map(key => `${quoteAnnotationPathIfRequired(key)}: ${renderAnnotationValue(annoValue[key], childEnv)}`);
       if (values.length <= 1)
         return `{ ${values.join(', ')} }`;
       const valueList = values.join(`,\n${childEnv.indent}`);
       return `{\n${childEnv.indent}${valueList}\n${env.indent}}`;
     }
     // Null
-    else if (x === null) {
+    else if (annoValue === null) {
       return 'null';
     }
     // Primitive: string, number, boolean
 
     // Quote strings, leave all others as they are
-    return (typeof x === 'string') ? renderString(x, env) : x;
+    return (typeof annoValue === 'string') ? renderString(annoValue, env) : String(annoValue);
+  }
+
+  /**
+   * Renders an array annotation value.  Uses a heuristic to put each element on its own line
+   * if a single-line becomes longer than 100 characters or if any sub-expression already
+   * contains a line break.  The latter checks makes nested arrays with structures more
+   * readable.
+   *
+   * @param {any[]} annoValue
+   * @param {CdlRenderEnvironment} env
+   * @return {string}
+   */
+  function renderAnnotationArrayValue( annoValue, env ) {
+    const childEnv = increaseIndent(env);
+    // Render array parts as values.
+    let length = 0;
+    let hasLineBreak = false;
+    const items = annoValue.map((item) => {
+      const result = renderAnnotationValue(item, childEnv);
+      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}]`;
   }
 
   /**
@@ -1444,7 +1479,7 @@ function csnToCdl( csn, options ) {
       // FIXME: We should rather explicitly recognize quoting somehow
       if (idx === 0 && s.startsWith('$'))
         return s;
-      return quoteIdIfRequired(s, env.additionalKeywords);
+      return quoteNonIdentifierOrKeyword(s, env.additionalKeywords);
     }
     // ID with filters or parameters
     else if (typeof s === 'object') {
@@ -1457,7 +1492,7 @@ function csnToCdl( csn, options ) {
         return `${s.func}(${renderArguments(s, '=>', env)})`;
 
       // Path step, possibly with view parameters and/or filters
-      let result = `${quoteIdIfRequired(s.id, env.additionalKeywords)}`;
+      let result = `${quoteNonIdentifierOrKeyword(s.id, env.additionalKeywords)}`;
       if (s.args) {
         // View parameters
         result += `(${renderArguments(s, ':', env)})`;
@@ -1466,7 +1501,10 @@ function csnToCdl( csn, options ) {
         // Filter, possibly with cardinality
         const cardinality = s.cardinality ? (`${s.cardinality.max}: `) : '';
         const expr = exprRenderer.renderExpr(s.where, env);
-        result += `[${cardinality}${expr}]`;
+        if (expr.endsWith(']')) // for cases such as [… ![id] ]
+          result += `[ ${cardinality}${expr} ]`;
+        else
+          result += `[${cardinality}${expr}]`;
       }
 
       return result;
@@ -1505,7 +1543,7 @@ function csnToCdl( csn, options ) {
    */
   function renderNamedArguments( node, separator, env ) {
     return Object.keys(node.args).map(function renderNamedArgument(key) {
-      return `${quoteIdIfRequired(key, env.additionalKeywords)} ${separator} ${renderArgument(node.args[key], env)}`;
+      return `${quoteNonIdentifierOrKeyword(key, env.additionalKeywords)} ${separator} ${renderArgument(node.args[key], env)}`;
     }).join(', ');
   }
 
@@ -1647,7 +1685,7 @@ function csnToCdl( csn, options ) {
    * @return {string}
    */
   function renderAlias( alias ) {
-    return ` as ${quoteIdIfRequired(alias)}`;
+    return ` as ${quoteNonIdentifierOrKeyword(alias)}`;
   }
 
   /**
@@ -1685,7 +1723,7 @@ function csnToCdl( csn, options ) {
    *
    * @param {object} obj Object that has annotations
    * @param {CdlRenderEnvironment} env
-   * @param {{parens: boolean}} [config] Config for renderAnnotationAssignment()
+   * @param {{parentheses: boolean}} [config] Config for renderAnnotationAssignment()
    * @return {string}
    */
   function renderAnnotationAssignmentsAndDocComment( obj, env, config ) {
@@ -1705,38 +1743,29 @@ function csnToCdl( csn, options ) {
    * @param {any} anno Annotation value
    * @param {string} name Annotation name, e.g. `@A.B.C#foo.C`
    * @param {CdlRenderEnvironment} env
-   * @param {object} [config] parens: Whether the annotation assignment must be surrounded by parentheses.
+   * @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 = { parens: false } ) {
+  function renderAnnotationAssignment( anno, name, env, config = { parentheses: false } ) {
     name = name.substring(1);
     // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
     const parts = name.split('#');
     const nameBeforeVariant = parts[0];
     const variant = parts[1];
-    const { parens } = config;
-
-    // Identifier according to our grammar: /[$_a-zA-Z][$_a-zA-Z0-9]*/
-    // We expand this pattern to also include dots after the first character.
-    // If the annotation does not follow this pattern `ident(.@ident)*`, it must be quoted:
-    // `@identifier@identifier` must be quoted but `@identifier.@identifier` should not.
-    // TODO: Use quoteAnnotationPathIfRequired()
-    const annoRequiresQuoting = !/^[$_a-zA-Z][$_a-zA-Z0-9.]*(?:\.@[$_a-zA-Z][$_a-zA-Z0-9.]*)*$/.test(nameBeforeVariant);
-    // Unfortunately, the compiler does not allow `.` after the first variant identifier,
-    // even though that is the result after flattening.
-    const variantRequiresQuoting = variant && !/^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(variant);
+    const { parentheses } = config;
 
     let result = `${env.indent}@`;
-    if (parens)
+    if (parentheses)
       result += '(';
 
-    if (annoRequiresQuoting || variantRequiresQuoting)
-      result += delimitedId(name);
-    else
-      result += name;
-
+    result += quoteAnnotationPathIfRequired(nameBeforeVariant);
+    if (variant !== undefined)
+      // Unfortunately, the compiler does not allow `.@` after the first variant identifier,
+      // so we're back at simple paths.
+      result += `#${quotePathIfRequired(variant)}`;
     result += ` : ${renderAnnotationValue(anno, env)}`;
-    if (parens)
+
+    if (parentheses)
       result += ')';
     return `${result}\n`;
   }
@@ -1753,7 +1782,7 @@ function csnToCdl( csn, options ) {
 
   /**
    * Render the name of a definition.  Ensures the first segment of the name
-   * is available in the rendered CDL.  Otherwise a USING is added.
+   * is available in the rendered CDL.  Otherwise, a USING is added.
    *
    * @param {string} name
    * @return {string}
@@ -1814,6 +1843,8 @@ function csnToCdl( csn, options ) {
         if (keywords.cdl_functions.includes(x.func.toUpperCase()) && !x.args)
           return x.func;
         const name = smartFunctionId(x.func);
+        if (!x.args) // e.g. for methods without arguments, `args` is not set at all.
+          return `${name}`;
         return `${name}(${renderArguments( x, '=>', this.env )})`;
       },
       xpr(x) {
@@ -1833,6 +1864,62 @@ function csnToCdl( csn, options ) {
       },
     });
   }
+
+  // checks -------------------------------------------------------------------
+  // The CDL backend has very few checks, but we need to tell the user if
+  // something can't be rendered.
+
+  /**
+   * to.cdl() can only render one nesting level of `items`.  `items` inside `items, etc.
+   * can't be represented in CDL, hence can't be rendered.
+   * However, it's possible that due to CSN expansion because of type-ofs, we have
+   * nested `.items` with a `.type` next to it.  In that case, return the node with `.type`.
+   *
+   * Returns the most deeply nested `.items`.  Upper bound are 100 nesting levels.
+   *
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   * @return {{art: CSN.Artifact, env: CdlRenderEnvironment}} `art` and new `env` with adapted `env.path`.
+   */
+  function checkInnerMostArray( art, env ) {
+    env = envNewPath(env, env.path); // copy path, so we can modify it directly
+
+    let nesting = 0;
+    while (art.items && nesting < 100) {
+      art = art.items;
+      env.path.push( 'items');
+      ++nesting;
+      if (art.type)
+        break; // after first `.items`, break at nesting level that has a type.
+    }
+
+    if (nesting >= 100) {
+      msg.error('def-invalid-nesting', env.path, { count: nesting, prop: 'items' },
+                'Property $(PROP) is nested more than $(COUNT) levels and can\'t be rendered');
+    }
+    else if (nesting > 1) {
+      msg.warning('def-unexpected-nesting', env.path, { prop: 'items' },
+                  'Property $(PROP) is nested more than one level; only rendering deepest level');
+    }
+    return { art, env };
+  }
+
+  /**
+   * If an artifact is an array via `.items`, some properties on `art` can't be rendered,
+   * for example "not null", because there is no CDL representation for it.  Only "not null"
+   * on `.items` can be rendered.
+   *
+   * @param {CSN.Artifact} art
+   * @param {CdlRenderEnvironment} env
+   */
+  function 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');
+    }
+  }
 }
 
 /**
@@ -1870,24 +1957,32 @@ function increaseIndent( env ) {
 }
 
 /**
- * Quote the path steps with `![]` if necessary. For simple ids such as
- * `elem` use `quoteIdIfRequired` instead.
+ * Quote simple path steps with `![]` if necessary. For simple ids such as
+ * `elem` use `quoteNonIdentifierOrKeyword` instead.
  *
- * In contrast to quoteIdIfRequired, does not handle additional keywords,
+ * In contrast to quoteNonIdentifierOrKeyword, does not handle additional keywords,
  * because it was not required, yet.
  *
+ * Due to token rewrite, all keywords after a dot (`.`) are rewritten to
+ * identifiers, i.e. we only need to check for the identifier RegEx.
+ *
  * @param {string} path
  * @returns {string}
- *
- * @todo For paths such as `E.key`, `key` does not have to be in quotes.
  */
 function quotePathIfRequired( path ) {
-  return path.split('.').map(step => quoteIdIfRequired(step)).join('.');
+  return path.split('.').map((step, index) => {
+    if (index === 0)
+      return quoteNonIdentifierOrKeyword(step);
+    else if (!identifierRegex.test(step))
+      return delimitedId(step);
+    return step;
+  }).join('.');
 }
 
 /**
  * Quote the id with `![]` if necessary. For paths such as `E.key` use
  * `quotePathIfRequired` instead.
+ * See quoteNonIdentifier() if you want to ignore keywords.
  *
  * Set additionalKeywords to an array of UPPERCASE keywords
  * that also need quoting, e.g. in special functions.
@@ -1896,13 +1991,30 @@ function quotePathIfRequired( path ) {
  * @param {string[]} [additionalKeywords]
  * @return {string}
  */
-function quoteIdIfRequired( id, additionalKeywords ) {
+function quoteNonIdentifierOrKeyword( id, additionalKeywords ) {
   // Quote if required for CDL
   if (requiresQuotingForCdl(id, additionalKeywords || []))
     return delimitedId(id);
   return id;
 }
 
+/**
+ * Quote the id with `![]` if necessary. For paths such as `E.key` use
+ * `quotePathIfRequired` instead.
+ * See quoteNonIdentifierOrKeyword() if you want to quote identifiers
+ * that are keywords as well.
+ *
+ * Does not quote the given id if it is a keyword.
+ *
+ * @param {string} id
+ * @return {string}
+ */
+function quoteNonIdentifier( id ) {
+  if (!identifierRegex.test(id))
+    return delimitedId(id);
+  return id;
+}
+
 /**
  * Quote an annotation path, e.g. `@My.@Anno.Description` if necessary.
  * `anno` can start with `@` but is not required to be.
@@ -1915,8 +2027,8 @@ function quoteIdIfRequired( id, additionalKeywords ) {
 function quoteAnnotationPathIfRequired( anno ) {
   return anno.split('.').map((segment) => {
     if (segment.startsWith('@'))
-      return `@${quoteIdIfRequired(segment.slice(1))}`;
-    return quoteIdIfRequired(segment);
+      return `@${quoteNonIdentifier(segment.slice(1))}`;
+    return quoteNonIdentifier(segment);
   }).join('.');
 }
 
@@ -2141,8 +2253,8 @@ function availableFirstPathSteps( csn ) {
 function smartId( id, insideFunction = null ) {
   insideFunction = insideFunction?.toUpperCase();
   if (!insideFunction || !specialFunctions[insideFunction])
-    return quoteIdIfRequired(id);
-  return quoteIdIfRequired(id, getAllKeywordsForSpecialFunction(insideFunction));
+    return quoteNonIdentifierOrKeyword(id);
+  return quoteNonIdentifierOrKeyword(id, getAllKeywordsForSpecialFunction(insideFunction));
 }
 
 /**

package/lib/render/toHdbcds.js

@@ -632,7 +632,6 @@ function toHdbcdsSource( csn, options ) {
       let result = `(${renderQuery(source, false, increaseIndent(env))})`;
       if (source.as)
         result += ` as ${formatIdentifier(source.as)}`;
-
       return result;
     }
     // JOIN
@@ -1684,25 +1683,19 @@ function toHdbcdsSource( csn, options ) {
   }
 
   /**
-   * Return an id 'id' with appropriate "-quotes
+   * Return an id 'id' with appropriate double-quotes
    *
    * @param {string} id Identifier to quote
    * @returns {string} Properly quoted identifier
    */
   function quoteId( id ) {
-    // Should only ever be called for real IDs (i.e. no dots inside)
-    if (id.indexOf('.') !== -1)
-      throw new ModelError(`HDBCDS: Tried to quote id with dot: ${id}`);
-
-
     switch (options.sqlMapping) {
       case 'plain':
         return smartId(id, 'hdbcds');
       case 'quoted':
       case 'hdbcds':
-        return delimitedId(id, 'hdbcds');
       default:
-        return null;
+        return delimitedId(id, 'hdbcds');
     }
   }