@sap/cds-compiler 6.1.0 → 6.3.0

package/lib/gen/Dictionary.json

@@ -808,7 +808,6 @@
       "Type": "Core.Tag"
     },
     "Common.IsTimezone": {
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"
@@ -1035,7 +1034,6 @@
       "Type": "Edm.DateTimeOffset"
     },
     "Common.Timezone": {
-      "$experimental": true,
       "AppliesTo": [
         "Property",
         "Parameter"
@@ -3506,6 +3504,7 @@
         "Label": "Edm.String",
         "Parameters": "Collection(Common.ValueListParameter)",
         "PresentationVariantQualifier": "Core.SimpleIdentifier",
+        "RelativeCollectionPath": "Edm.NavigationPropertyPath",
         "SearchSupported": "Edm.Boolean",
         "SelectionVariantQualifier": "Core.SimpleIdentifier"
       }

package/lib/gen/cdlKeywords.json

@@ -0,0 +1,26 @@
+{
+  "reserved": [
+    "ALL",
+    "ANY",
+    "AS",
+    "BY",
+    "CASE",
+    "CAST",
+    "DISTINCT",
+    "EXISTS",
+    "FALSE",
+    "FROM",
+    "IN",
+    "KEY",
+    "NOT",
+    "NULL",
+    "OF",
+    "ON",
+    "SELECT",
+    "SOME",
+    "TRUE",
+    "WHEN",
+    "WHERE",
+    "WITH"
+  ]
+}

package/lib/inspect/inspectPropagation.js

@@ -36,7 +36,7 @@ function inspectPropagation( xsn, options, artifactName ) {
 
   if (!artifactXsn) {
     error(null, null, { name: artifactName },
-          // eslint-disable-next-line @stylistic/js/max-len
+          // eslint-disable-next-line @stylistic/max-len
           'Artifact $(NAME) not found, only top-level artifacts and their elements are supported for now');
     return null;
   }

package/lib/json/from-csn.js

@@ -137,7 +137,7 @@ const typeProperties = [
   // do not include CSN v0.1.0 properties here:
   'target', 'elements', 'enum', 'items',
   'cardinality', // for association publishing in views
-  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
+  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull', 'default',
   'keys', 'on',                 // only with 'target'
 ];
 const exprProperties = [
@@ -1142,7 +1142,7 @@ function elementsDict( def, spec, xsn ) {
     return elements;
   warning( 'syntax-expecting-returns', elements[$location],
            { prop: 'elements', parentprop: 'returns' },
-           // eslint-disable-next-line @stylistic/js/max-len
+           // eslint-disable-next-line @stylistic/max-len
            'Expecting property $(PROP) to be put into an object for property $(PARENTPROP) when annotating action return structures' );
   xsn.returns = { kind: 'annotate', elements, location: elements[$location] };
   return undefined;

package/lib/json/to-csn.js

@@ -201,7 +201,7 @@ const propertyOrder = (function orderPositions() {
 const typeProperties = [
   'target', 'elements', 'enum', 'items',
   'cardinality', // for association publishing in views
-  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
+  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull', 'default',
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
   '$typeArgs', // for unresolved type arguments, e.g. through parseCql
 ];

package/lib/language/multiLineStringParser.js

@@ -77,7 +77,7 @@ class MultiLineStringParser {
     this.str = token.text; // Copy because .text is a getter
 
     if (this.str[0] !== '`' || this.str[this.str.length - 1] !== '`')
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line @stylistic/max-len
       throw new CompilerAssertion('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
 
     this.output = [];

package/lib/model/cloneCsn.js

@@ -39,6 +39,7 @@ const internalCsnProps = {
   $notNull: shallowCopy, // used for HANA CSN migrations
   $sqlService: shallowCopy,
   $dummyService: shallowCopy,
+  $dataProductService: shallowCopy,
 };
 const internalEnumerableCsnProps = {
   __proto__: null,

package/lib/model/csnRefs.js

@@ -250,10 +250,9 @@ function csnRefs( csn, universalReady ) {
   // const { definitions } = csn;
   const cache = new WeakMap();
   setCache( BUILTIN_TYPE, '_origin', null );
-  if (universalReady === 'init-all') {
-    for (const name of Object.keys( csn.definitions || {}))
-      initDefinition( name );
-  }
+  if (universalReady === 'init-all')
+    initAllDefinitions();
+
   // Functions which set the new `baseEnv`:
   resolveRef.expandInline = function resolveExpandInline( ref, ...args ) {
     return cached( ref, '_env', () => navigationEnv( resolveRef( ref, ...args ).art ) );
@@ -278,6 +277,7 @@ function csnRefs( csn, universalReady ) {
     getColumnName: col => getCache( col, '$as' ),
     $getQueries: def => getCache( def, '$queries' ), // unstable API
     initDefinition,
+    initAllDefinitions,
     dropDefinitionCache,
     targetAspect,
     msgLocations,
@@ -489,6 +489,11 @@ function csnRefs( csn, universalReady ) {
     return query && cache.get( query.projection || query );
   }
 
+  function initAllDefinitions() {
+    for (const name of Object.keys( csn.definitions || {}))
+      initDefinition( name );
+  }
+
   function initDefinition( main ) {
     const name = typeof main === 'string' && main;
     if (name) {

package/lib/model/csnUtils.js

@@ -64,6 +64,7 @@ function getUtils( model, universalReady ) {
     addStringAnnotationTo,
     getServiceName,
     getFinalTypeInfo,
+    resolvePath,
     get$combined,
     getQueryPrimarySource,
     ..._csnRefs,
@@ -448,6 +449,71 @@ function getUtils( model, universalReady ) {
       return target;
     }
   }
+
+
+  /**
+   * Resolve the type of an artifact
+   * If art is undefined, stop
+   * If art has elements or items.elements, stop
+   * If art has a type and the type is scalar, stop
+   * If art has a named type or a type ref, resolve it
+   */
+  function resolveType( art ) {
+    while (art &&
+      !((art.items && art.items.elements) || art.elements) &&
+      (art.type &&
+        ((!art.type.ref && !isBuiltinType(art.type)) || art.type.ref))) {
+      if (art.type.ref)
+        art = resolvePath(art.type);
+      else
+        art = model.definitions[art.type];
+    }
+    return art;
+  }
+
+  /**
+   * Path resolution, attach artifact to each path step, if found,
+   * Dereference types and follow associations.
+   *
+   * @param {any} path ref object
+   * @param {any} art start environment
+   * @returns {any} path with resolved artifacts or artifact
+   * (if called with simple ref paths)
+   */
+  function resolvePath( path, art = undefined ) {
+    let notFound = false;
+    for (let i = 0; i < path.ref.length && !notFound; i++) {
+      const ps = path.ref[i];
+      const id = ps.id || ps;
+      if (art) {
+        if (art.target)
+          art = model.definitions[art.target].elements[id];
+        else if (art.items && art.items.elements || art.elements)
+          art = (art.items && art.items.elements || art.elements)[id];
+
+        else
+          art = undefined;
+      }
+      else {
+        art = model.definitions[id];
+      }
+      art = resolveType(art);
+
+      // if path step has id, store art
+      if (ps.id && art)
+        ps._art = art;
+      notFound = !art;
+    }
+    // if resolve was called on constraint path, path has id.
+    // Store art and return path, if called recursively for model ref paths,
+    // return artifact only
+    if (path.ref[0].id) {
+      if (art)
+        path._art = art;
+      return path;
+    }
+    return art;
+  }
 }
 
 
@@ -1248,7 +1314,6 @@ function walkCsnPath( csn, path ) {
   for (const segment of path)
     obj = obj[segment];
 
-
   return obj;
 }
 
@@ -1356,7 +1421,7 @@ function functionList( functions, thisArg ) {
  * @returns {boolean}
  */
 function isDollarSelfOrProjectionOperand( arg ) {
-  return arg.ref && arg.ref.length === 1 &&
+  return arg.ref?.length === 1 &&
     (arg.ref[0] === '$self' || arg.ref[0] === '$projection');
 }
 

package/lib/optionProcessor.js

@@ -1,6 +1,6 @@
 // Compiler options
 
-/* eslint @stylistic/js/max-len: 0 */
+/* eslint @stylistic/max-len: 0 */
 
 // Remarks:
 // - The specification is client-tool centric (bin/cdsc.js):
@@ -169,7 +169,8 @@ optionProcessor
     Q, toSql [options] <files...>               Generate SQL DDL statements
     J, forJava [options] <files...>             Generate CSN for the Java Runtime
        toCsn [options] <files...>               (default) Generate original model as CSN
-       parseCdl [options] <file>                Generate a CSN that is close to the CDL source.
+       parse [options] <file>                   Parse the input file. For CDL input, generate a CSN that is
+                                                close to the CDL source.
        explain <message-id>                     Explain a compiler message.
        parseOnly [options] <files...>           (internal)  Stop compilation after parsing, write messages to <stderr>,
                                                 per default no output.
@@ -264,7 +265,7 @@ optionProcessor.command('O, toOdata')
   .option('    --odata-vocabularies <list>')
   .option('    --odata-no-creator')
   .option('    --draft-messages')
-  .option('    --add-annotation-AddressViaNavigationPath')
+  .option('    --draft-user-description')
   .option('-c, --csn')
   .option('-f, --odata-format <format>', { valid: [ 'flat', 'structured' ] })
   .option('-n, --sql-mapping <style>', { valid: [ 'plain', 'quoted', 'hdbcds' ], aliases: [ '--names' ] })
@@ -300,8 +301,7 @@ optionProcessor.command('O, toOdata')
                                    { prefix: { alias, ns, uri }, ... }
        --odata-no-creator          Omit creator identification in API
        --draft-messages            Add draft messages as part of the draft creation
-       --add-annotation-AddressViaNavigationPath Add annotation "@Common.AddressViaNavigationPath" to the services
-                                                 containing draft enabled entitties 
+       --draft-user-description    Add user description fields to the DraftAdministrativeData entity
        -n, --sql-mapping <style> Annotate artifacts and elements with "@cds.persistence.name", which is
                              the corresponding database name (see "--sql-mapping" for "toSql")
                                plain   : (default) Names in uppercase and flattened with underscores
@@ -534,15 +534,15 @@ optionProcessor.command('toCsn')
        --with-localized   Add localized convenience views to the CSN output.
 `);
 
-optionProcessor.command('parseCdl')
+optionProcessor.command('parse', { aliases: [ 'parseCdl' ] })
   .option('-h, --help')
   .positionalArgument('<file>')
   .option('    --with-locations')
   .help(`
-  Usage: cdsc parseCdl [options] <file>
+  Usage: cdsc parse [options] <file>
 
-  Only parse the CDL and output a CSN that is close to the source. Does not
-  resolve imports, apply extensions or expand any queries.
+  Only parse the input file. For CDL input, output a CSN that is close to the source.
+  Does not resolve imports, apply extensions or expand any queries.
 
   Options
        --with-locations   Add $location to CSN artifacts.

package/lib/parsers/AstBuildingParser.js

@@ -47,7 +47,10 @@ const extensionsCode = {
 const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
-  leanConditions = { afterBrace: true, atRightParen: true, fail: true };
+  leanConditions = {
+    afterBrace: true,
+    fail: true,
+  };
 
   constructor( lexer, keywords, table, options, messageFunctions ) {
     super( lexer, keywords, table ); // lexer has file
@@ -115,13 +118,16 @@ class AstBuildingParser extends BaseParser {
 
   // Guards, Prepare Commands and Lookahead Methods -----------------------------
 
-  tableWithoutAs() {            // not used in <guard=…>, only called by other guard
-    // TODO TOOL: if the tool properly creates `default: this.giR()`, this
-    // condition method is most likely not necessary
-    const { keyword } = this.la();
-    // TODO: if necessary, we could allow some keywords, and just make sure that
-    // all JOIN variants are still possible
-    return keyword && this.keywords[keyword] != null;
+  queryOnLeftSloppyAlias( _arg, mode ) {
+    if (mode === 'M' || this.isNoKeywordInRuleFollow( _arg, mode ))
+      return true;
+    // TODO TOOL: have a base parser method for the test
+    if (this.conditionTokenIdx === this.tokenIdx &&        // tested on same
+        this.conditionStackLength == null)                 // after error recovery
+      return false;
+    if (this.constructor.tracingParser)
+      this._traceSubPush( 'queryOnLeft' );
+    return this.queryOnLeft( 'table', mode );
   }
 
   /**
@@ -134,15 +140,9 @@ class AstBuildingParser extends BaseParser {
    * - <guard=queryOnLeft> tests whether the expression on the left is a query
    * - <guard=queryOnLeft, arg=‹SomeVal›>: tests whether the expression on the
    *   left is a query, then make the current context to be not a query anymore
-   * - <guard=queryOnLeft, arg=tableWithoutAs>: …after having checked
-   *   whether the next token is no (reserved or unreserved) keyword
    */
   queryOnLeft( arg, test ) {
-    if (arg === 'tableWithoutAs') {
-      if (this.tableWithoutAs())
-        return true;
-    }
-    else if (!arg && !test) {
+    if (!arg && !test) {
       // provide new dynamic parentheses context, except with direct
       // recursive call:
       if (this.inSameRule_( this.s, this.stack.at( -1 ).followState ))
@@ -202,6 +202,10 @@ class AstBuildingParser extends BaseParser {
   }
 
   addTokenToSet_( set, tokenName, val, collectKeywordsOnly ) {
+    if (!this.dynamic_.call) {
+      super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
+      return;
+    }
     const token = parserTokens[tokenName];
     // TODO: use lower-case in specialFunctions
     const realTokens = token && this.dynamic_.generic?.[token];
@@ -214,7 +218,7 @@ class AstBuildingParser extends BaseParser {
       // Works, since `DeleteStarFromSet` comes after `*` (length-sorted):
       delete set['*'];
     }
-    else {
+    else if (!token) {
       super.addTokenToSet_( set, tokenName, val, collectKeywordsOnly );
     }
   }
@@ -488,10 +492,6 @@ class AstBuildingParser extends BaseParser {
     // token is not on a new line?
   }
 
-  atRightParen() {
-    return this.l() !== ')';
-  }
-
   /**
    * For annotations at the beginning of columns outside parentheses
    */
@@ -570,7 +570,7 @@ class AstBuildingParser extends BaseParser {
     if (this.l() === ':') {
       this.warning( 'syntax-missing-parens', name,
                     { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
-                    // eslint-disable-next-line @stylistic/js/max-len
+                    // eslint-disable-next-line @stylistic/max-len
                     'When $(CODE) is followed by $(OP), use $(NEWCODE) for annotation assignments at this position' );
     }
   }
@@ -582,7 +582,7 @@ class AstBuildingParser extends BaseParser {
         // do not report error if the '@' is not correct:
         this.s !== null && this.tokenIdx > this.recoverTokenIdx) {
       this.warning( 'syntax-missing-semicolon', next, { code: ';' },
-                    // eslint-disable-next-line @stylistic/js/max-len
+                    // eslint-disable-next-line @stylistic/max-len
                     'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
     }
   }
@@ -737,7 +737,7 @@ class AstBuildingParser extends BaseParser {
       }
       else if (text.charAt(0) !== '!') {
         this.message( 'syntax-deprecated-ident', location, { delimited: id },
-                      // eslint-disable-next-line @stylistic/js/max-len
+                      // eslint-disable-next-line @stylistic/max-len
                       'Deprecated delimited identifier syntax, use $(DELIMITED) - strings are delimited by single quotes' );
       }
     }
@@ -948,7 +948,7 @@ class AstBuildingParser extends BaseParser {
                     {
                       std: 'Annotation number $(RAWVALUE) is put as $(VALUE) into the CSN',
                       rounded: 'Annotation number $(RAWVALUE) is rounded to $(VALUE)',
-                      // eslint-disable-next-line @stylistic/js/max-len
+                      // eslint-disable-next-line @stylistic/max-len
                       infinite: 'Annotation value $(RAWVALUE) is infinite as number and put as string into the CSN',
                     } );
     }
@@ -1000,7 +1000,7 @@ class AstBuildingParser extends BaseParser {
 
   // TODO: can we remove `;`/EOF from the expected-set for `annotate Foo with ⎀`?
   checkWith( keyword ) {
-    if (this.lb() !== keyword)
+    if (this.lb() !== keyword || ![ ';', '}', 'EOF' ].includes( this.l() ))
       return;
     const tok = this.la();
     const docTokenIndex = this.docCommentIndex &&
@@ -1012,7 +1012,7 @@ class AstBuildingParser extends BaseParser {
     const expecting = this.expectingArray().filter( t => t !== '<EOF>' && t !== '\'}\'' );
     const msg = this.warning( 'syntax-unexpected-semicolon', tok,
                               { offending: this.antlrName( tok ), expecting, keyword: 'with' },
-                              // eslint-disable-next-line @stylistic/js/max-len
+                              // eslint-disable-next-line @stylistic/max-len
                               'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
     msg.expectedTokens = expecting;
   }
@@ -1523,6 +1523,8 @@ class AstBuildingParser extends BaseParser {
   }
 }
 
+AstBuildingParser.prototype.queryOnLeftSloppyAlias.afterError = true;
+
 function addOneForDefinition( count, ext ) {
   return (ext.kind === 'extend') ? count : count + 1;
 }

package/lib/parsers/identifiers.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const cdlKeywords = require('../gen/cdlKeywords.json').reserved;
+
 /** RegEx identifying undelimited identifiers in CDL */
 const undelimitedIdentifierRegex = /^[$_\p{ID_Start}][$\p{ID_Continue}\u200C\u200D]*$/u;
 
@@ -13,36 +15,6 @@ const functionsWithoutParentheses = [
   'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
 ];
 
-// CDL reserved keywords, used for automatic quoting in 'toCdl' renderer
-// TODO: Use `parser.keywords` from our generated CdlParser.js (#13856)
-const cdlKeywords = [
-  'ALL',
-  'ANY',
-  'AS',
-  'BY',
-  'CASE',
-  'CAST',
-  'DISTINCT',
-  'EXISTS',
-  'EXTRACT',
-  'FALSE', // boolean
-  'FROM',
-  'IN',
-  'KEY',
-  'NEW',
-  'NOT',
-  'NULL',
-  'OF',
-  'ON',
-  'SELECT',
-  'SOME',
-  'TRIM',
-  'TRUE', // boolean
-  'WHEN',
-  'WHERE',
-  'WITH',
-];
-
 function isSimpleCdlIdentifier( id ) {
   if (undelimitedIdentifierRegex.test(id))
     return true;

package/lib/render/toCdl.js

@@ -796,10 +796,15 @@ class CsnToCdl {
     }
 
     // Top-level annotations of the artifact
-    let result = this.renderAnnotationAssignmentsAndDocComment(ext, env);
+    const topLevelAnnotations = this.renderAnnotationAssignmentsAndDocComment(ext, env.withIncreasedIndent());
+
     // 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) }`;
+    let result = `${ env.indent }annotate ${ this.renderArtifactName(ext.annotate, env) }`;
+
+    if (topLevelAnnotations)
+      result += ` with\n${ topLevelAnnotations }`;
+
 
     if (ext.params)
       result += this.renderAnnotateParamsInParentheses(ext, env);
@@ -1368,7 +1373,7 @@ class CsnToCdl {
   }
 
   /**
-   * Render the given columns.
+   * Render the given columns / select items.
    *
    * @param {CSN.Extension | CSN.QuerySelect} art
    * @param {object} elements
@@ -1439,7 +1444,7 @@ class CsnToCdl {
       if (col.cast.target && !col.cast.type)
         result += ` : ${ this.renderRedirectedTo(col.cast, env) }`;
       else
-        result += ` : ${ this.renderTypeReferenceAndProps(col.cast, env, { typeRefOnly: true, noAnnoCollect: true }) }`;
+        result += ` : ${ this.renderTypeReferenceAndProps(col.cast, env, { noAnnoCollect: true }) }`;
       env.path.length -= 1;
     }
     return result;
@@ -1459,6 +1464,7 @@ class CsnToCdl {
 
     const isAnonymousExpand = (obj.expand && !obj.ref);
 
+
     // s as alias { * }
     if (obj.as && !isAnonymousExpand)
       result += this.renderAlias(obj.as, env);
@@ -1483,7 +1489,7 @@ class CsnToCdl {
     const childEnv = env.withIncreasedIndent();
     const expandInline = obj.expand || obj.inline;
     result += expandInline //
-      .map(elm => this.renderAnnotationAssignmentsAndDocComment(elm, childEnv) + childEnv.indent + this.renderInlineExpand(elm, childEnv))
+      .map(elm => this.renderViewColumn(elm, childEnv))
       .join(',\n');
     result += `\n${ env.indent }}`;
 
@@ -1869,9 +1875,12 @@ class CsnToCdl {
       if (artifact.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 += ` ${ this.renderForeignKeys(artifact, env) }`;
+      // Foreign keys (if any, unless we also have an ON-condition (which means we have been transformed from managed to unmanaged)
+      if (artifact.keys && !artifact.on) {
+        const keys = this.renderForeignKeys(artifact, env, false);
+        if (keys)
+          result += ` ${ keys }`;
+      }
 
       if (!artifact.on) {
         // unmanaged associations can't be followed by "not null" or "default"
@@ -1923,10 +1932,14 @@ class CsnToCdl {
    */
   renderRedirectedTo( art, env ) {
     let result = `redirected to ${ this.renderDefinitionReference(art.target, env) }`;
-    if (art.on)
+    if (art.on) {
       result += ` on ${ this.exprRenderer.renderExpr(art.on, env.withSubPath([ 'on' ])) }`;
-    else if (art.keys)
-      result += ` ${ this.renderForeignKeys(art, env) }`;
+    }
+    else if (art.keys) {
+      const keys = this.renderForeignKeys(art, env, true);
+      if (keys)
+        result += ` ${ keys }`;
+    }
     return result;
   }
 
@@ -2274,13 +2287,16 @@ class CsnToCdl {
   }
 
   /**
-   * Render foreign keys.
+   * Render foreign keys.  We only render foreign keys if necessary or if we can't say for sure
+   * that the foreign keys would match the implicitly generated ones.
    *
    * @param {object} art
    * @param {CdlRenderEnvironment} env
+   * @param {boolean} alwaysRenderForeignKeys
+   *     If false, only render foreign keys if necessary (i.e. can't be inferred by compiler again).
    * @return {string}
    */
-  renderForeignKeys( art, env ) {
+  renderForeignKeys( art, env, alwaysRenderForeignKeys = false ) {
     const renderedKeys = [];
     let hasAnnotations = false;
     env = env.withSubPath([ 'keys', -1 ]);
@@ -2301,18 +2317,62 @@ class CsnToCdl {
       renderedKeys.push(`${ key }${ alias },`);
     }
 
+    // Annotations on foreign keys always require rendering of explicit keys.
+    // Otherwise, we'd have to use annotate statements here.
     if (hasAnnotations) {
       const sep = `\n${ env.indent }`;
       env.decreaseIndent();
       return `{${ sep }${ renderedKeys.join(sep) }\n${ env.indent }}`;
     }
 
+    if (!alwaysRenderForeignKeys && this.foreignKeysMatchImplicitOnes( art ))
+      return '';
+
     let result = renderedKeys.join(' ');
     if (result[result.length - 1] === ',') // remove trailing comma
       result = result.slice(0, -1);
     return `{ ${ result } }`;
   }
 
+  /**
+   * Returns true, if `to.cdl()` could leave out explicit foreign keys in the rendered output
+   * without changing recompilation.  We do so, because explicit foreign keys are not promoted
+   * on CAPire.
+   *
+   * @param {CSN.Artifact} art
+   * @returns {boolean}
+   */
+  foreignKeysMatchImplicitOnes( art ) {
+    if (art.cardinality && art.cardinality.max !== 1)
+      return false; // e.g. to-many assocs
+
+    const target = this.csn.definitions[art.target];
+    if (!art.keys?.length || !art.target || !target?.elements)
+      return false;
+
+    // We could improve to.cdl() to properly check if keys match, but then we'd have to look
+    // at sub-elements, structures, etc.;  for now, we only check “simple” foreign keys that
+    // don't have any alias.
+    const hasComplexKeys = art.keys.some(key => key.ref?.length !== 1 || key.as !== undefined);
+    if (hasComplexKeys)
+      return false;
+
+    const targetKeys = Object.keys(target.elements).filter(name => target.elements[name]?.key);
+    if (targetKeys.length === 0)
+      return false; // always require explicit keys if there are no target side keys
+
+    const foreignKeys = art.keys.map(key => key.ref[0]);
+    if (foreignKeys.length !== targetKeys.length)
+      return false;
+
+    // We require the _same_ order! Otherwise, recompilation would change the generated foreign key order!
+    for (let i = 0; i < foreignKeys.length; ++i) {
+      if (foreignKeys[i] !== targetKeys[i])
+        return false;
+    }
+    return true;
+  }
+
   /**
    * Render an explicit alias, e.g. for columns.
    *