@sap/cds-compiler 4.0.0 → 4.1.2

package/lib/compiler/resolve.js

@@ -62,7 +62,6 @@ const {
   testExpr,
   targetMaxNotOne,
   traverseQueryPost,
-  traverseExpr,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
@@ -87,14 +86,16 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    traverseExpr,
     createRemainingAnnotateStatements,
     effectiveType,
     getOrigin,
-    resolveType,
+    getInheritedProp,
     resolveTypeArgumentsUnchecked,
   } = model.$functions;
   Object.assign( model.$functions, {
     resolveExpr,
+    addForeignKeyNavigations,
   } );
 
   const ignoreSpecifiedElements
@@ -125,14 +126,21 @@ function resolve( model ) {
     // create “super” ANNOTATE statements for annotations on unknown artifacts:
     createRemainingAnnotateStatements();
     // report cyclic dependencies:
-    detectCycles( model.definitions, ( user, art, location ) => {
+    detectCycles( model.definitions, ( user, art, location, semanticLoc ) => {
       if (location) {
-        error( 'ref-cyclic', [ location, user ], { art }, {
+        model.$assert = null;
+        const msg = semanticLoc && 'target';
+        error( 'ref-cyclic', [ location, semanticLoc || user ], { art, '#': msg }, {
           std: 'Illegal circular reference to $(ART)',
           element: 'Illegal circular reference to element $(MEMBER) of $(ART)',
+          target: 'Illegal circular reference to target $(ART)',
         });
       }
     });
+    if (model.$assert) {
+      error( '$internal-expecting-cyclic', null, {},
+             'INTERNAL: the compiler should have issued an Error[ref-cyclic]' );
+    }
     return model;
   }
 
@@ -319,13 +327,32 @@ function resolve( model ) {
     const parent = art._parent;
     const allowedInMain = [ 'entity', 'aspect', 'event' ].includes( adHocOrMainKind( art ) );
     const isTopLevelElement = parent && (parent.kind !== 'element' || parent.targetAspect);
-    if (art.key?.val && !art.key.$inferred && !(allowedInMain && isTopLevelElement)) {
-      warning( 'unexpected-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',
-               });
+
+    // Check KEY (TODO: make this an extra function)
+    const { key } = art;
+    if (key?.val && !key.$inferred) {
+      // With unmanaged/composition as key, we complain at the `key` keyword, not
+      // the `on` condition / the aspect, because the easiest fix would be to
+      // simply remove the keyword.  Text and message-id are accordingly.
+      // This fits nicely with exposing unmanaged/composition with explicit `key`.
+      // We do not complain about unmanaged/composition inside struct keys.
+      // (Actually, aspect compositions are not supported as sub elements anyway.)
+      if (getInheritedProp( art, 'targetAspect' )) {
+        error( 'def-invalid-key', [ key.location, art ], { '#': 'composition' } );
+        // TODO: test with managed composition exposed with explicit KEY
+      }
+      else if (art.target && getInheritedProp( art, 'on' )) {
+        error( 'def-invalid-key', [ key.location, art ], { '#': 'unmanaged' } );
+      }
+      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',
+                 } );
+      }
     }
+
     if (art.targetAspect && !(allowedInMain && isTopLevelElement)) {
       message( 'type-managed-composition', [ art.targetAspect.location, art ],
                { '#': allowedInMain ? 'sub' : 'std' } );
@@ -426,14 +453,19 @@ function resolve( model ) {
       forEachGeneric( obj.targetAspect, 'elements', elem => dependsOnSilent( art, elem ) );
     }
     if (obj.foreignKeys) {       // silent dependencies
-      forEachGeneric( obj, 'foreignKeys', (elem) => {
-        dependsOnSilent( art, elem );
-      } );
+      // Avoid strange ref-cyclic if managed composition is key (check comes later)
+      // TODO: the following is already done by addimplicitforeignkeys()!
+      if (obj.$inferred !== 'aspect-composition') {
+        forEachGeneric( obj, 'foreignKeys', (elem) => {
+          dependsOnSilent( art, elem );
+        } );
+      }
       addForeignKeyNavigations( art );
     }
 
     resolveExpr( art.default, 'default', art );
-    resolveExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'expr'), art );
+    // TODO: distinguish not by $syntax (it is semantics), but whether in query
+    resolveExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
     if (art.type?.$inferred === 'cast')
       inferTypePropertiesFromCast( art );
     if (art.value) {
@@ -458,6 +490,8 @@ function resolve( model ) {
     /**
      * Check whether the signature of the specified element matches that of the inferred one.
      *
+     * TODO: resolveRefs() is already too long → do not add sub functions
+     *
      * TODO:
      *  - This function has a lot of quite similar code blocks; it should be refactored to
      *    combine them.
@@ -529,7 +563,7 @@ function resolve( model ) {
               iKeys = iKeys._origin;
           }
           iKeys = Object.keys(iKeys.foreignKeys || {});
-          if (sKeys.length !== iKeys.length || sKeys.some(key => !iKeys.includes(key))) {
+          if (sKeys.length !== iKeys.length || sKeys.some( fkey => !iKeys.includes(fkey))) {
             error('query-mismatched-element', [
               specifiedElement.foreignKeys.location || specifiedElement.location, user,
             ], {
@@ -609,27 +643,33 @@ function resolve( model ) {
           }
         }
 
-        if (specifiedElement.enum) {
-          const iEnum = inferredElement.enum || inferredElement.value?.enum;
-          forEachGeneric(specifiedElement, 'enum', (sVal, name) => {
-            const iVal = iEnum[name];
-            if (!iVal) {
+        if (specifiedElement.enum && !specifiedElement.$expand) {
+          // TODO: ".value" is necessary due to recompilation: The compiler does not copy
+          //       "enum" out of ".value", i.e. casts, only "type", changing the _effectiveType.
+          const iEnumValues = inferredElement.enum || inferredElement.value?.enum;
+          const sEnumValues = specifiedElement.enum;
+          for (const name in specifiedElement.enum) {
+            // TODO: See TODO above; issue is cast()
+            const sEnumEntry = sEnumValues[name];
+            const iEnumEntry = iEnumValues[name]?._effectiveType || iEnumValues[name];
+            if (!iEnumEntry) {
               error('query-mismatched-element', [ specifiedElement.location, user ], {
-                '#': 'std',
-                name: user.name.id,
-                prop: 'enum',
+                '#': 'enumExtra', name: user.name.id, id: name,
               });
+              break;
             }
-
-            // TODO: Get $expanded enum values
-            /* if (iVal.value?.val !== sVal.value?.val || iVal.value?.['#'] !== sVal.value?.['#']) {
-              error('query-mismatched-element', [ specifiedElement.location, user ], {
-                '#': 'std',
-                name: user.name.id,
-                prop: 'enum',
-              });
-            } */
-          });
+            else {
+              // We allow implicit `val: "<name>"`.
+              const iVal = iEnumEntry.value?.val || iEnumEntry.value?.['#'] || name;
+              const sVal = sEnumEntry.value?.val || sEnumEntry.value?.['#'] || name;
+              if (iVal !== sVal) {
+                error('query-mismatched-element', [ specifiedElement.location, user ], {
+                  '#': 'enumVal', name: user.name.id, id: name,
+                });
+                break;
+              }
+            }
+          }
         }
       }
 
@@ -793,7 +833,7 @@ function resolve( model ) {
     } );
     // if (!query.$inlines) console.log('RQ:',query)
     for (const col of query.$inlines)
-      resolveExpr( col.value, 'expr', col );
+      resolveExpr( col.value, 'column', col );
     // for (const col of query.$inlines)
     //   if (!col.value.path) throw new CompilerAssertion(col.name.element)
     if (query !== query._main._leadingQuery) // will be done later
@@ -801,17 +841,17 @@ function resolve( model ) {
     if (query.from)
       resolveJoinOn( query.from );
     if (query.where)
-      resolveExpr( query.where, 'expr', query ); // TODO: extra 'where'?
+      resolveExpr( query.where, 'where', query );
     if (query.groupBy)
-      resolveBy( query.groupBy, 'expr', 'expr' ); // TODO: extra 'groupBy'?
-    resolveExpr( query.having, 'expr', query );   // TODO: extra 'having' or 'where'?
+      resolveBy( query.groupBy, 'groupBy', 'groupBy' );
+    resolveExpr( query.having, 'having', query );
     if (query.$orderBy)       // ORDER BY from UNION:
       // TODO clarify: can I access the tab alias of outer queries?  If not:
       // 4th arg query._main instead query._parent.
-      resolveBy( query.$orderBy, 'order-by-set-ref', 'order-by-set-expr' );
+      resolveBy( query.$orderBy, 'orderBy-set-ref', 'orderBy-set-expr' );
     if (query.orderBy) {       // ORDER BY
     // search in `query.elements` after having checked table aliases of the current query
-      resolveBy( query.orderBy, 'order-by-ref', 'order-by-expr' );
+      resolveBy( query.orderBy, 'orderBy-ref', 'orderBy-expr' );
       // TODO: disallow resulting element ref if in expression!
       // Necessary to check it in the compiler as it might work with other semantics on DB!
       // (we could downgrade it to a warning if name is equal to unique source element name)
@@ -824,7 +864,7 @@ function resolve( model ) {
         for (const j of join.args)
           resolveJoinOn( j );
         if (join.on)
-          resolveExpr( join.on, 'joinOn', query );
+          resolveExpr( join.on, 'join-on', query );
           // TODO: check restrictions according to join "query"
       }
     }
@@ -1004,20 +1044,57 @@ function resolve( model ) {
         setArtifactLink( key.targetElement.path[0], elem );
         setLink( key, '_effectiveType', effectiveType(elem) );
         dependsOn(key, elem, location);
-        dependsOnSilent(art, key);
+        // TODO TMP: instead, make managed composition of aspects and unmanaged
+        // assocs not depend on their `on` condition (empty `_deps` after resolve)
+        if (art.$inferred !== 'aspect-composition')
+          dependsOnSilent( art, key );
       }
     });
     obj.foreignKeys[$inferred] = 'keys';
   }
 
-  function addForeignKeyNavigations( art ) {
+  /**
+   * Add reference tree from foreign key reference back to foreign key of association.
+   *
+   * For `type T: Association to Target { foo as bar, elem.sub }`, this function adds:
+   *
+   *   '$keysNavigation': {
+   *     foo: { _artifact: 'type:“T”/key:“bar”' },
+   *     elem: {
+   *       '$keysNavigation': { sub: { _artifact: 'type:“T”/key:“sub”' } }
+   *     }
+   *
+   * This function complains if two foreign keys point to the same target element
+   * (`Association to Target { foo as bar, foo }`) or overlapping target elements
+   * (`Association to Target { elem.sub, elem }`).  In `resolvePath`, the compiler
+   * already forbids to follow associations in foreign key refs.
+   *
+   * This ref tree could also be used in a core-compiler check which is now part
+   * of to.sql: refs in the `on` condition of unmanaged associations cannot follow
+   * associations other to foreign key refs.
+   *
+   * This ref tree is only created for originally defined managed associations
+   * (including those created by the compiler, like the `up_` association), not
+   * for derived association like for `type DerivedT: T`, or exposed ones.
+   */
+  function addForeignKeyNavigations( art, silent = false ) {
     art.$keysNavigation = Object.create(null);
+    const keys = [];
+    // Basically sort foreign keys according to length of target element ref.
+    // This way, we complain about ref to sub element (`elem.sub`) even if it
+    // comes earlier than the ref to structure element (`elem`).
     forEachGeneric( art, 'foreignKeys', ( key ) => {
-      if (!key.targetElement || !key.targetElement.path)
-        return;
+      const path = key.targetElement?.path;
+      if (path) {
+        const arr = keys[path.length] || (keys[path.length] = []);
+        arr.push( key );
+      }
+    });
+    for (const key of keys.flat()) {
       let dict = art.$keysNavigation;
-      const last = key.targetElement.path[key.targetElement.path.length - 1];
-      for (const item of key.targetElement.path) {
+      const { path } = key.targetElement;
+      const last = path[path.length - 1];
+      for (const item of path) {
         let nav = dict[item.id];
         if (!nav) {
           nav = {};
@@ -1028,13 +1105,21 @@ function resolve( model ) {
             nav.$keysNavigation = Object.create(null);
         }
         else if (item === last || nav._artifact) {
-          error( 'duplicate-key-ref', [ item.location, key ], {},
-                 'The same target reference has already been used in a key definition' );
-          return;
+          if (silent)
+            break;
+          const name = nav._artifact?.name.id;
+          const text = (item !== last) ? 'sub' : 'std';
+          error( 'duplicate-key-ref', [ item.location, key ], { '#': text, name }, {
+            std: 'Foreign key $(NAME) already refers to the same target element',
+            // eslint-disable-next-line max-len
+            sub: 'Foreign key $(NAME) already refers to the target element whose sub element is again referred to here',
+            // TODO: please add ideas for a better text, e.g. to (closed) PR #11325
+          } );
+          break;
         }
         dict = nav.$keysNavigation;
       }
-    } );
+    }
   }
 
   // TODO: add this somehow to tweak-assocs.js ?
@@ -1067,6 +1152,8 @@ function resolve( model ) {
       }
     }
     const origTarget = origType.target._artifact;
+    // console.log(require('../model/revealInternalProperties').ref(elem),
+    //             !!origTarget,!!origType._effectiveType,!!origType.target)
     if (!origTarget || !target)
       return;
 
@@ -1194,65 +1281,9 @@ function resolve( model ) {
 
   // Resolve the type and its arguments if applicable.
   function resolveTypeExpr( art, user ) {
-    const typeArt = resolveType( art.type, user );
-    if (typeArt) {
+    const typeArt = resolvePath( art.type, 'type', user );
+    if (typeArt)
       resolveTypeArgumentsUnchecked( art, typeArt, user );
-      checkTypeArguments( art, typeArt );
-    }
-  }
-
-  /**
-   * Check the type arguments on `artWithType`.
-   * If the effective type is an array or structured type, an error is emitted.
-   */
-  function checkTypeArguments( artWithType, typeArt ) {
-    // Note: `_effectiveType` point to `artWithType` itself, if it is an enum type,
-    //       descend to the origin in this case.
-    // TODO: this function is not complete(!): parallel `elements` and `length`, … - rework function
-    // TODO: check relationship with resolveTypeArgumentsUnchecked()
-    let effectiveTypeArt = effectiveType( typeArt );
-    while (effectiveTypeArt?.enum)
-      effectiveTypeArt = effectiveType( getOrigin( effectiveTypeArt ) );
-    if (!effectiveTypeArt)
-      return; // e.g. illegal definition references, cycles, ...
-
-    const params = effectiveTypeArt.parameters &&
-      effectiveTypeArt.parameters.map(p => p.name || p) || [];
-
-    for (const param of typeParameters.list) {
-      if (artWithType[param] !== undefined) {
-        if (!params.includes(param)) {
-          // Whether the type ref itself is a builtin or a custom type with a builtin as base.
-          const type = getOrigin(artWithType);
-
-          let variant;
-          if (type.builtin)
-            // `.type` is already a builtin: use a nicer message.
-            variant = 'builtin';
-          else if (effectiveTypeArt.builtin)
-            // base type is a builtin, i.e. a scalar
-            variant = 'type';
-          else
-            // effectiveType is not a builtin -> array or structured
-            variant = 'non-scalar';
-
-          // console.log(typeArt.name,artWithType.name,effectiveTypeArt.name)
-          error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
-            '#': variant, prop: param, art: artWithType.type, type: effectiveTypeArt,
-          });
-          break; // Avoid spam: Only emit the first error.
-        }
-        else if (!typeParameters.expectedLiteralsFor[param].includes(artWithType[param].literal)) {
-          error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
-            '#': 'incorrect-type',
-            prop: param,
-            code: artWithType[param].literal,
-            names: typeParameters.expectedLiteralsFor[param],
-          });
-          break; // Avoid spam: Only emit the first error.
-        }
-      }
-    }
   }
 
   function resolveExpr( expr, exprCtx, user ) {
@@ -1264,6 +1295,7 @@ function resolve( model ) {
       resolveTypeExpr( expr, user._user || user );
 
     if (expr.path) {
+      // TODO: re-think this $expected: 'exists' thing
       if (expr.$expected === 'exists') {
         error( 'expr-unexpected-exists', [ expr.location, user ], {},
                'An EXISTS predicate is not expected here' );
@@ -1317,7 +1349,7 @@ function resolve( model ) {
       if (expected === 'from')
         variant = 'from';
       // XSN TODO: filter$location including […]
-      message( 'expr-no-filter', [ location, user ], { '#': variant }, {
+      message( 'expr-unexpected-filter', [ location, user ], { '#': variant }, {
         std: 'A filter can only be provided when navigating along associations',
         // to help users for `… from E:toF { toF[…].x }`
         // eslint-disable-next-line max-len
@@ -1332,23 +1364,23 @@ function resolve( model ) {
       let first = dict[Object.keys(dict)[0]];
       if (Array.isArray(first))
         first = first[0];
-      message( 'args-no-params',
-               [ dict[$location] ||
-                 dictLocation( dict, first && first.name && first.name.location || stepLocation),
+      error( 'expr-unexpected-argument',
+             [ dict[$location] || dictLocation( dict, first?.name?.location || stepLocation ),
                user ],
-               { art, '#': (entity ? 'entity' : expected ) },
-               {
-                 std: 'Parameters can only be provided when navigating along associations',
-                 from: 'Parameters can only be provided for the source entity or associations',
-                 // or extra message id for entity?
-                 entity: 'Entity $(ART) has no parameters',
-               } );
+             { art, '#': (entity ? 'entity' : expected ) },
+             {
+               std: 'Parameters can only be provided when navigating along associations',
+               from: 'Parameters can only be provided for the source entity or associations',
+               // or extra message id for entity?
+               entity: 'Unexpected arguments for entity $(ART) without parameters',
+             } );
       return;
     }
-    const exp = (expected === 'from') ? 'expr' : expected;
+    const exp = (expected === 'from') ? 'from-args' : expected;
     if (Array.isArray(dict)) {
-      message( 'args-expected-named', [ dict[0] && dict[0].location || stepLocation, user ], {},
-               'Named parameters must be provided for the entity' );
+      const loc = [ dict[0] && dict[0].location || stepLocation, user ];
+      error( 'expr-expected-named-argument', loc, {},
+             'Expected named parameters for the entity' );
       for (const a of dict)
         resolveExpr( a, exp, user );
       return;
@@ -1360,11 +1392,10 @@ function resolve( model ) {
       for (const a of Array.isArray(arg) ? arg : [ arg ]) {
         setArtifactLink( a.name, param );
         if (!param) {
-          message( 'args-undefined-param', [ a.name.location, user ], { art, id: name },
-                   'Entity $(ART) has no parameter $(ID)' );
+          error( 'expr-undefined-param', [ a.name.location, user ], { art, id: name },
+                 'Entity $(ART) has no parameter $(ID)' );
         }
-        // TODO: Also for other parameters?
-        resolveExpr( a, (expected === 'from') ? 'param-only' : exp, user );
+        resolveExpr( a, exp, user );
       }
     }
   }