@sap/cds-compiler 6.2.2 → 6.3.0

package/lib/compiler/checks.js

@@ -116,13 +116,21 @@ function check( model ) {
       return;
 
     const isVirtual = parentProps.virtual?.val || elem.virtual?.val;
+    const typeName = elem._effectiveType?.name?.id;
     if (isVirtual) {
       error( 'def-unexpected-key', [ (parentProps.key || elem.key).location, elem ],
-             { '#': 'virtual', prop: 'key' } );
+             { '#': 'virtual', keyword: 'key' } );
     }
-    else if (elem._effectiveType?.name?.id === 'cds.Map') {
+    else if (typeName === 'cds.Map') {
       error( 'def-unexpected-key', [ elem.type?.location || elem.location, elem ],
-             { '#': 'invalidType', prop: 'key', type: 'cds.Map' } );
+             { '#': 'invalidType', keyword: 'key', type: typeName } );
+    }
+    else if (typeName === 'cds.LargeString' ||
+        typeName === 'cds.Vector' ||
+        typeName === 'cds.hana.CLOB' ||
+        typeName === 'cds.LargeBinary') {
+      warning( 'def-unsupported-key', [ elem.type?.location || elem.location, elem ],
+               { '#': 'type', keyword: 'key', type: typeName } );
     }
   }
 
@@ -704,12 +712,15 @@ function check( model ) {
    *
    * @param {any} xpr The expression to check
    * @param {XSN.Artifact} user User for semantic location
+   * @param {any} _parentExpr
    * @param {string} [context] where the expression is used, e.g. 'anno'
    */
-  function checkGenericExpression( xpr, user, context ) {
+  function checkGenericExpression( xpr, user, _parentExpr, context ) {
     if (context !== 'anno')
       checkExpressionNotVirtual( xpr, user );
-    checkExpressionAssociationUsage( xpr, user, false );
+    checkExpressionAssociationUsage( xpr, user, {
+      context, rejectManaged: context === 'anno', rejectUnmanaged: true,
+    } );
     if (xpr.op?.val === 'cast') {
       requireExplicitTypeInSqlCast( xpr, user );
       checkTypeCast( xpr, user );
@@ -730,7 +741,7 @@ function check( model ) {
 
     visitExpression( elem.on, elem, (xpr, user) => {
       checkExpressionNotVirtual( xpr, user );
-      checkExpressionAssociationUsage( xpr, user, true );
+      checkExpressionAssociationUsage( xpr, user, null );
 
       if (xpr._artifact?._effectiveType?.name.id === 'cds.Map') {
         error( 'ref-unexpected-map', [ xpr.location, user ], { '#': 'onCond', type: 'cds.Map' } );
@@ -744,7 +755,9 @@ function check( model ) {
   }
 
   function checkSelectItemValue( elem ) {
-    checkExpressionAssociationUsage( elem.value, elem, false );
+    checkExpressionAssociationUsage( elem.value, elem, {
+      context: 'query', rejectManaged: false, rejectUnmanaged: true,
+    } );
     checkVirtualSelectItemChangeForV6( elem );
     // To avoid duplicate messages, only run this check if the type wasn't inferred from
     // the cast, as otherwise we will check it twice (once here, once via element).
@@ -753,8 +766,8 @@ function check( model ) {
       checkTypeCast( elem.value, elem );
       checkTypeArguments( elem.value, elem );
     }
-    visitSubExpression( elem.value, elem, (xpr) => {
-      checkGenericExpression( xpr, elem );
+    visitSubExpression( elem.value, elem, (xpr, user, parentExpr) => {
+      checkGenericExpression( xpr, elem, parentExpr, 'query' );
     } );
   }
 
@@ -811,7 +824,8 @@ function check( model ) {
         // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
         // And users can't change structured to non-structured elements.
         if (!elem.$inferred && xpr._artifact._effectiveType?.elements) {
-          error( 'ref-unexpected-structured', [ sourceLoc, elem ], { '#': 'expr' } );
+          error( 'ref-unexpected-structured', [ sourceLoc, elem ],
+                 { '#': 'struct-expr', elemref: xpr } );
         }
         else if (xpr._artifact.target !== undefined && (!lastStep.where || isStored)) {
           // Allow using an association _with filter_, but only for on-read calculated elements.
@@ -884,10 +898,11 @@ function check( model ) {
    *
    * @param {any} xpr The expression to check
    * @param {XSN.Artifact} user
-   * @param {boolean} allowAssocTail
+   * @param {{context: string, rejectUnmanaged, rejectManaged}|null} [rejectAssocTail]
+   *        Context where association tails are not allowed.
    * @returns {void}
    */
-  function checkExpressionAssociationUsage( xpr, user, allowAssocTail ) {
+  function checkExpressionAssociationUsage( xpr, user, rejectAssocTail = null ) {
     if (!xpr.args)
       return;
 
@@ -902,12 +917,18 @@ function check( model ) {
       const op = getBinaryOp( xpr );
       for (const arg of args) {
         if (arg && !(op?.val !== '=' && isDollarSelfOrProjectionOperand( arg )))
-          checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail );
+          checkExpressionIsNotAssocOrSelf( arg, user, rejectAssocTail );
       }
     }
   }
 
-  function checkExpressionIsNotAssocOrSelf( arg, user, allowAssocTail ) {
+  /**
+   * @param arg
+   * @param {XSN.Artifact} user
+   * @param {{context: string, rejectUnmanaged, rejectManaged}|null} [rejectAssocTail]
+   *        Context where association tails are not allowed.
+   */
+  function checkExpressionIsNotAssocOrSelf( arg, user, rejectAssocTail ) {
     // Arg must not be an association and not $self
     // Only if path is not approved exists path (that is non-query position)
     if (arg.path && arg.$expected !== undefined) { // not 'approved-exists'
@@ -916,9 +937,17 @@ function check( model ) {
         error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
       }
     }
-    else if (!allowAssocTail && isAssociationOperand( arg )) {
-      const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
-      error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': variant } );
+    else if (rejectAssocTail && isAssociationOperand( arg )) {
+      if (rejectAssocTail.rejectManaged && rejectAssocTail.rejectUnmanaged ||
+          rejectAssocTail.rejectManaged && arg._artifact.keys ||
+          rejectAssocTail.rejectUnmanaged && arg._artifact.on) {
+        // only a few contexts have special message
+        const context = rejectAssocTail.context === 'query' && 'query-' ||
+          rejectAssocTail.context === 'anno' && 'anno-' ||
+          '';
+        const variant = isComposition( model, arg._artifact ) ? 'expr-comp' : 'expr';
+        error( 'ref-unexpected-assoc', [ arg.location, user ], { '#': `${ context }${ variant }` } );
+      }
     }
   }
 
@@ -1105,7 +1134,7 @@ function check( model ) {
    */
   function checkAnnotationExpressions( anno, art ) {
     if (anno.$tokenTexts) {
-      checkGenericExpression( anno, art, 'anno' );
+      checkGenericExpression( anno, art, null, 'anno' );
     }
     else if (anno.literal === 'array') {
       anno.val.forEach( val => checkAnnotationExpressions( val, art ) );

package/lib/compiler/index.js

@@ -183,7 +183,7 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   return all.then( () => {
     options.abortSignal?.throwIfAborted();
     moduleLayers.setLayers( input.sources );
-    return compileDoX( model );
+    return compileDoX( model ); // also async
   } );
 
   // Read file `filename` and parse its content, return messages
@@ -303,7 +303,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   }
 
   moduleLayers.setLayers( a.sources );
-  return compileDoX( model );
+  return compileDoXSync( model );
 
   // Read file `filename` and parse its content, return messages
   function readAndParseSync( filename, cb ) {
@@ -423,7 +423,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
   }
   moduleLayers.setLayers( sources );
 
-  return compileDoX( model );
+  return compileDoXSync( model );
 }
 
 /**
@@ -457,8 +457,8 @@ function recompileX( csn, options ) {
 
   sources[file] = parseCsn.augment( csn, file, options, model.$messageFunctions );
   moduleLayers.setLayers( sources );
-  const compiled = compileDoX( model ); // calls throwWithError()
-  if (options.messages)         // does not help with exception in compileDoX()
+  const compiled = compileDoXSync( model ); // calls throwWithError()
+  if (options.messages)         // does not help with exception in compileDoXSync()
     deduplicateMessages( options.messages ); // TODO: do better
   return compiled;
 }
@@ -467,10 +467,12 @@ function recompileX( csn, options ) {
  * On the given model (AST like CSN) run the definer, resolver as well as semantic checks.
  * Creates an augmented CSN (XSN) and returns it.
  *
+ * This is the non-interruptible version of `compileDoX()` and can be used in non-`async` functions.
+ *
  * @param {object} model AST like CSN generated e.g. by `parsers.parseCdl()`
  * @returns {XSN.Model} Augmented CSN (XSN)
  */
-function compileDoX( model ) {
+function compileDoXSync( model ) {
   const { options } = model;
   const { throwWithError } = model.$messageFunctions;
   if (!options.testMode)
@@ -512,6 +514,61 @@ function compileDoX( model ) {
   return propagator.propagate( model );
 }
 
+/**
+ * On the given model (AST like CSN) run the definer, resolver as well as semantic checks.
+ * Creates an augmented CSN (XSN) and returns it.
+ *
+ * @param {object} model AST like CSN generated e.g. by `parsers.parseCdl()`
+ * @returns {XSN.Model} Augmented CSN (XSN)
+ */
+async function compileDoX( model ) {
+  const { options } = model;
+  const { throwWithError } = model.$messageFunctions;
+  if (!options.testMode)
+    model.meta = {}; // provide initial central meta object
+
+  checkRemovedDeprecatedFlags( options, model.$messageFunctions );
+
+  if (options.parseOnly) {
+    throwWithError();
+    return model;
+  }
+  model.$functions = {};
+  fns( model );                 // attach (mostly) paths functions
+  define( model );
+  await checkAsyncAbortFlag( options.abortSignal );
+
+  // do not run the resolver in parse-cdl mode or we get duplicate annotations, etc.
+  // TODO: do not use this function for parseCdl anyway…
+  if (options.parseCdl) {
+    finalizeParseCdl( model );
+    throwWithError();
+    return model;
+  }
+
+  for (const phase of [ extend, generate, kickStart, populate ]) {
+    phase( model );
+    // eslint-disable-next-line no-await-in-loop
+    await checkAsyncAbortFlag( options.abortSignal );
+  }
+
+  model.definitions = model.$functions.shuffleDict( model.definitions );
+  // Shuffling extensions is more difficult due to intra-file extensions of same artifact
+  // TODO: think about making this work
+
+  for (const phase of [ resolve, tweakAssocs, assertConsistency, check ]) {
+    phase( model );
+    // eslint-disable-next-line no-await-in-loop
+    await checkAsyncAbortFlag( options.abortSignal );
+  }
+
+  throwWithError();
+  if (options.lintMode)
+    return model;
+
+  return propagator.propagate( model );
+}
+
 /**
  * Process an array of `filenames`.  Returns an object with properties:
  *  - `sources`: dictionary which has a filename as key (value is irrelevant)
@@ -595,6 +652,31 @@ function createSourcesDict( filenames, filenameMap, dir ) {
   return { sources, files, repeated };
 }
 
+/**
+ * An `await`able function to fake a real asynchronous event.
+ *
+ * @returns {Promise<unknown>}
+ */
+async function waitForNextEventLoopIteration() {
+  return new Promise( ( r ) => {
+    setTimeout( r, 0 );
+  });
+}
+
+/**
+ * An actual async function that uses `setTimeout()` to allow the Node event loop to
+ * start its next iteration, but only if the `abortSignal` is defined.
+ *
+ * @param {AbortSignal?} abortSignal
+ * @returns {Promise<void>}
+ */
+async function checkAsyncAbortFlag( abortSignal ) {
+  if (!abortSignal)
+    return;
+  await waitForNextEventLoopIteration();
+  abortSignal.throwIfAborted();
+}
+
 module.exports = {
   parseX,
   compileX,

package/lib/compiler/resolve.js

@@ -430,10 +430,7 @@ function resolve( model ) {
       }
       else if (!allowedInMain || !isTopLevelElement) {
         warning( 'def-unsupported-key', [ art.key.location, art ],
-                 { '#': allowedInMain ? 'sub' : 'std', keyword: 'key' }, {
-                   std: '$(KEYWORD) is only supported for elements in an entity or an aspect',
-                   sub: '$(KEYWORD) is only supported for top-level elements',
-                 } );
+                 { '#': allowedInMain ? 'sub' : 'kind', keyword: 'key' } );
       }
     }
 
@@ -905,10 +902,13 @@ function resolve( model ) {
     }
     else if (effectiveType( art )?.elements && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.
-      if (art.type)
+      if (art.type) {
         error( 'type-unexpected-structure', [ art.type.location, art ], { '#': 'calc' } );
-      else
-        error( 'ref-unexpected-structured', [ art.value.location, art ], { '#': 'expr' } );
+      }
+      else {
+        error( 'ref-unexpected-structured', [ art.value.location, art ],
+               { '#': 'struct-expr', elemref: art.value } );
+      }
     }
     else if (effectiveType( art )?.items && !art.$inferred) {
       // For inferred (e.g. included) calc elements, this error is already emitted at the origin.

package/lib/compiler/tweak-assocs.js

@@ -349,42 +349,46 @@ function tweakAssocs( model ) {
       setLink( fk, '_effectiveType', fk );
       fk.targetElement = copyExpr( orig.targetElement, location );
       if (elem._redirected)
-        rewriteKey( elem, fk.targetElement );
+        rewriteKey( elem, fk );
     } );
     if (elem.foreignKeys) // Possibly no fk was set
       elem.foreignKeys[$inferred] = 'rewrite';
   }
 
-  function rewriteKey( elem, targetElement ) {
+  function rewriteKey( elem, fk ) {
+    const { targetElement } = fk;
     let projectedKey = null;
     // rewrite along redirection chain
     for (const alias of elem._redirected) {
-      if (alias.kind !== '$tableAlias')
-        continue;
-
-      projectedKey = firstProjectionForPath( targetElement.path, 0, alias, null );
-      if (projectedKey.elem) {
-        const item = targetElement.path[projectedKey.index];
-        item.id = projectedKey.elem.name.id;
-        if (projectedKey.index > 0)
-          targetElement.path.splice(0, projectedKey.index);
-      }
-      else {
-        setArtifactLink( targetElement.path[0], null );
-        setArtifactLink( targetElement, null );
+      if (alias.kind === '$tableAlias') {
+        projectedKey = firstProjectionForPath( targetElement.path, 0, alias, null );
+        if (projectedKey.elem) {
+          const item = targetElement.path[projectedKey.index];
+          item.id = projectedKey.elem.name.id;
+          if (projectedKey.index > 0)
+            targetElement.path.splice(0, projectedKey.index);
+        }
+        else {
+          setArtifactLink( targetElement.path[0], null );
+          setArtifactLink( targetElement, null );
 
-        const culprit = !elem.target.$inferred && elem.target ||
+          const culprit = !elem.target.$inferred && elem.target ||
           elem.value?.path?.[elem.value.path.length - 1] ||
           elem;
-        // TODO: probably better to collect the non-projected foreign keys
-        // and have one message for all
-        error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
-          '#': 'std',
-          id: targetElement.path.map(p => p.id).join('.'),
-          target: alias._main,
-          name: elem.name.id,
-        });
-        return null;
+          // TODO: probably better to collect the non-projected foreign keys
+          // and have one message for all
+          error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
+            '#': 'std',
+            id: targetElement.path.map(p => p.id).join('.'),
+            target: alias._main,
+            name: elem.name.id,
+          });
+          return null;
+        }
+      }
+      else {
+        // e.g. redirection target is entity that includes original target
+        projectedKey = { elem: findTargetElement( alias, targetElement ) };
       }
     }
 
@@ -397,6 +401,24 @@ function tweakAssocs( model ) {
     return null;
   }
 
+  /**
+   * Find the target element in the given redirection target.
+   * Used to find the target element in entities that include the original
+   * target entity.
+   *
+   * @param redirected
+   * @param targetElement
+   * @returns {*|null}
+   */
+  function findTargetElement( redirected, targetElement ) {
+    for (const step of targetElement.path) {
+      redirected = redirected.elements?.[step.id];
+      if (!redirected)
+        return null;
+    }
+    return redirected;
+  }
+
   // TODO: there is no need to rewrite the on condition of non-leading queries,
   // i.e. we could just have on = {…}
   // TODO: re-check $self rewrite (with managed composition of aspects),

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.2.7
+// Base class for generated parser, for redepage v0.3.0
 
 'use strict';
 

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-7489417512fa82b33fb6799686ce2917
+1f3bba2acb882f5120a55a01eb9a7bdc