@sap/cds-compiler 5.7.2 → 5.8.0

package/lib/compiler/resolve.js

@@ -46,7 +46,7 @@ const {
   isDeprecatedEnabled,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
-const { dictLocation, weakLocation } = require('../base/location');
+const { weakLocation } = require('../base/location');
 const { combinedLocation } = require('../base/location');
 const { typeParameters } = require('./builtins');
 
@@ -92,15 +92,16 @@ function resolve( model ) {
     resolveDefinitionName,
     attachAndEmitValidNames,
     traverseExpr,
+    traverseTypedExpr,
     effectiveType,
     getOrigin,
     getInheritedProp,
     resolveTypeArgumentsUnchecked,
   } = model.$functions;
   Object.assign( model.$functions, {
-    resolveExpr,
     addForeignKeyNavigations,
     redirectionChain,
+    resolveExprInAnnotations,
   } );
 
   const ignoreSpecifiedElements
@@ -260,6 +261,10 @@ function resolve( model ) {
   }
 
   function propagateKeyProps( view ) {
+    if (view.kind === 'type') {
+      // we don't propagate keys to type projections, see #13575
+      return;
+    }
     // Second argument true ensure that `key` is only propagated along simple
     // view, i.e. ref or subquery in FROM, not UNION or JOIN.
     traverseQueryPost( view.query, true, ( query ) => {
@@ -552,11 +557,11 @@ function resolve( model ) {
       addForeignKeyNavigations( art );
     }
 
-    resolveExprWithEnum( art.default, 'default', art );
+    resolveExpr( art.default, 'default', art, art );
 
     // TODO: distinguish not by $syntax (it is semantics), but whether in query
     const valueCtx = (art.$syntax === 'calc') ? 'calc' : 'column';
-    resolveExprWithEnum( art.value, valueCtx, art );
+    resolveExpr( art.value, valueCtx, art, art );
     if (art.type?.$inferred === 'cast')
       inferTypePropertiesFromCast( art );
     if (art.value) {
@@ -598,7 +603,7 @@ function resolve( model ) {
 
       // Check explicit types: If either side has one, so must the other.
       const sType = specifiedElement.type?._artifact;
-      const iTypeArt = getInferredPropFromOrigin( 'type' )?._artifact;
+      const iTypeArt = getInheritedProp( inferredElement, 'type' )?._artifact;
       const iType = iTypeArt || inferredElement;
       // FIXME: The coding above returns incorrect iType for expand on associations
 
@@ -678,7 +683,7 @@ function resolve( model ) {
         }
 
         if (specifiedElement.virtual) {
-          const iVirtual = getInferredPropFromOrigin( 'virtual' )?.val || false;
+          const iVirtual = getInheritedProp( inferredElement, 'virtual' )?.val || false;
           if (!specifiedElement.virtual.val !== !iVirtual) {
             error( 'query-mismatched-element', [
               specifiedElement.virtual.location || specifiedElement.location, user,
@@ -737,7 +742,7 @@ function resolve( model ) {
 
         if (specifiedElement.key) { // TODO: `|| inferredElement.key?.val`, once to.sql is fixed
           // TODO: Do not use _origin chain for key; has been propagated in propagateKeyProps().
-          const iKey = getInferredPropFromOrigin( 'key' )?.val;
+          const iKey = getInheritedProp( inferredElement, 'key' )?.val;
           // If "key" is specified or truthy in the inferred element, the values must match.
           if (!iKey !== !specifiedElement.key?.val) {
             error( 'query-mismatched-element', [
@@ -793,16 +798,6 @@ function resolve( model ) {
         return false;
       }
 
-      function getInferredPropFromOrigin( prop ) {
-        // Inferred property via _origin chain (0 === circular).
-        let element = inferredElement;
-        if (element._effectiveType !== 0) {
-          while (getOrigin( element ) && !element[prop])
-            element = getOrigin( element );
-        }
-        return element[prop];
-      }
-
       function getInferredCardinality() {
         let element = inferredElement;
         if (element._effectiveType !== 0) {
@@ -822,11 +817,19 @@ function resolve( model ) {
     // Set '@Core.Computed' in the Core Compiler to have it propagated...
     if (art.kind !== 'element' || art['@Core.Computed'])
       return;
+
+    // For events and types, elements can't be @Core.Computed, as values are only used
+    // to infer the element signature.  For virtual, we keep @Core.Computed, as it's
+    // always been that way, even before type projections.
+    const elementsCanBeComputed = art._main?.kind !== 'type' && art._main?.kind !== 'event';
+
     if (art.virtual?.val ||
-        art.value &&
+       elementsCanBeComputed && art.value &&
         (!art.value._artifact || !art.value.path || // in localization view: _artifact, but no path
           art.value.stored?.val || // calculated elements on-write are always computed
-          art.value._artifact.kind === 'builtin' || art.value._artifact.kind === 'param' )) {
+          art.value._artifact.kind === 'builtin' ||
+          art.value._artifact.kind === 'param' ||
+          art.value.scope === 'param' )) {
       art['@Core.Computed'] = {
         name: {
           path: [ { id: 'Core.Computed', location: art.location } ],
@@ -1067,10 +1070,11 @@ function resolve( model ) {
     traverseExpr( art.on, 'on-check', art, (expr) => {
       const { path } = expr;
       if (!expr?._artifact || path?.length < 2 || issue['#'])
-        return;                 // no path or with error or already found issue
+        return traverseExpr.SKIP; // no path or with error or already found issue
       const head = (path[0]._navigation?.kind === '$self') ? 1 : 0;
       if (path[head]._artifact === art)
         checkAutoRedirectedPathItem( path[head + 1], modelTarget, issue );
+      return traverseExpr.SKIP;
     } );
     // Check explicit+implicit foreign keys: no renamed target element
     const implicit = art.foreignKeys?.[$inferred];
@@ -1390,6 +1394,7 @@ function resolve( model ) {
     const typeArt = resolvePath( art.type, 'type', user );
     if (typeArt)
       resolveTypeArgumentsUnchecked( art, typeArt, user );
+    return typeArt;
   }
 
   function resolveExprInAnnotations( art ) {
@@ -1408,7 +1413,10 @@ function resolve( model ) {
     if (expr.$tokenTexts) {
       if (!anno.kind)
         initAnnotationForExpression( anno, art );
-      resolveExprWithEnum( expr, 'annotation', anno );
+      const type = anno === expr && anno.name;
+      // TODO: it might be best to set an _artifact link also for property values
+      // like in `@Anno: [ { foo: #EnumSymbol }]
+      resolveExpr( expr, 'annotation', anno, type );
     }
     else if (expr.literal === 'array') {
       expr.val.forEach( val => resolveAnnoExpr( val, art, anno ) );
@@ -1428,7 +1436,7 @@ function resolve( model ) {
     anno.kind = '$annotation';
     setLink( anno, '_outer', art );
     art.$contains ??= {};
-    art.$contains.$annotation = { // set in resolveExprItem
+    art.$contains.$annotation = { // set in resolveExprNode
       $path: false,
       $self: false,
     };
@@ -1436,157 +1444,180 @@ function resolve( model ) {
     // Might be useful for future recursive types.
   }
 
-  function resolveExprWithEnum( expr, exprCtx, art ) {
-    traverseExpr( expr, exprCtx, art, resolveExprItem );
-    const sym = expr?.sym;
-    const assignment = art;
-    // Check enum as top-level annotation value:
-    if (art?.kind === '$annotation')
-      art = art === expr && art.name._artifact;
-    if (!art)
-      return;
-    const symbols = effectiveType( art )?.enum;
-    if (!sym || !symbols)
-      return;
-    // TODO: or warning if enum symbol but non-enum type?
-    if (symbols[sym.id]) {
-      setLink( sym, '_artifact', symbols[sym.id] );
-    }
-    else {
-      let type = art._effectiveType;
-      // inferred enums can't be extended (yet): show underlying enum
-      while (type.enum[$inferred])
-        type = getOrigin( type );
-      const err = message( 'ref-undefined-enum', [ sym.location, assignment ],
-                           { id: sym.id, type } );
-      if (options.newParser)
-        attachAndEmitValidNames( err, symbols );
-    }
-  }
-
-  function resolveExpr( expr, exprCtx, user ) {
-    traverseExpr( expr, exprCtx, user, resolveExprItem );
+  function resolveExpr( expr, exprCtx, art, type = null ) {
+    traverseTypedExpr( expr, exprCtx, art, type, resolveExprNode );
   }
 
-  function resolveExprItem( expr, expected, user ) {
+  function resolveExprNode( expr, expected, user, type ) {
     if (expr.type) // e.g. cast( a as Integer )
-      resolveTypeExpr( expr, user._user || user );
+      type = resolveTypeExpr( expr, user._user || user );
 
     if (expr.path) {
-      // TODO: re-think this $expected: 'exists' thing
-      if (expr.$expected === 'exists') {
-        if (expected !== 'annotation') { // `exists e[…]` allowed in annotation expressions
-          error( 'expr-unexpected-exists', [ expr.location, user ], {},
-                 'An EXISTS predicate is not expected here' );
-        }
-        // We complain about the EXISTS before, as EXISTS subquery is also not supported
-        // TODO: location of EXISTS, TODO: really do this in define.js
-        expr.$expected = 'approved-exists'; // only complain once
-      }
-      resolvePath( expr, expected, user );
-
-      const last = expr.$expected !== 'approved-exists' && expr.path[expr.path.length - 1];
-      for (const step of expr.path) {
-        if (step && (step.args || step.where || step.cardinality) &&
-            step._artifact && !Array.isArray( step._artifact ) )
-          resolveParamsAndWhere( step, expected, user, step === last );
-        // TODO: delete 4th arg
-      }
-
-      if (expected === 'annotation') {
-        user._outer.$contains.$annotation.$path = true;
-        user._outer.$contains.$annotation.$self ||= expr.path[0]?._navigation?.kind === '$self';
-      }
+      type = resolveExprPath( expr, expected, user );
+    }
+    else if (expr.id) {
+      type = resolvePathItem( expr, expected, user );
+    }
+    else if (expr.sym) {
+      resolveEnumSymbol( expr, expected, user, type );
     }
     else if (expr.query) {
+      // No traversal into query, art.$queries set in define.js
+      // No subqueries for type projections, nor in annotation expressions.
       const { query } = expr;
-      if (query.kind || query._leadingQuery) { // UNION has _leadingQuery
-        // traverseQueryPost( query, false, resolveQuery );
+      if (query._main?.kind === 'type' ||
+         (!query.kind && !query._leadingQuery)) { // UNION has _leadingQuery
+        error( 'expr-no-subquery', [ expr.location, user ], {
+          '#': query._main?.kind === 'type' ? 'type' : 'std',
+        }, {
+          std: 'Subqueries are not supported here',
+          type: 'Subqueries are not supported in type projections',
+        } );
       }
-      else {
-        error( 'expr-no-subquery', [ expr.location, user ], {},
-               'Subqueries are not supported here' );
+      else if (query._main?.kind === 'event') {
+        warning( 'expr-no-event-subquery', [ expr.location, user ],
+                 'Subqueries are not supported in event projections' );
       }
     }
+    return type;
   }
 
-  function resolveParamsAndWhere( step, expected, user, isLast ) {
-    const alias = (step._navigation?.kind === '$tableAlias') ? step._navigation : null;
-    const type = alias || effectiveType( step._artifact );
-    const art = type?.target ? type.target._artifact : type;
-    if (!art)
-      return;
-    const entity = art.kind === 'entity' &&
-          (!isLast || user.expand || user.inline || expWithFilter.includes( expected )) &&
-          art;
-    if (step.args)
-      resolveParams( step.args, art, entity, expected, user, step.location );
-
-    // Publishing an association with filters is ok in columns and also ok in calculated elements.
-    const publishAssoc = art.kind === 'entity' && (expected === 'column' || expected === 'calc');
-
-    if (entity || publishAssoc) {
-      if (step.where) {
-        setLink( step, '_user', user._user || user );
-        const inCalc = (expected === 'calc' || expected === 'calc-filter');
-        resolveExpr( step.where, (inCalc ? 'calc-filter' : 'filter'), step );
+  function resolveExprPath( expr, expected, user ) {
+    // TODO: re-think this $expected: 'exists' thing
+    if (expr.$expected === 'exists') {
+      if (expected !== 'annotation') { // `exists e[…]` allowed in annotation expressions
+        error( 'expr-unexpected-exists', [ expr.location, user ], {},
+               'An EXISTS predicate is not expected here' );
       }
+      // We complain about the EXISTS before, as EXISTS subquery is also not supported
+      // TODO: location of EXISTS, TODO: really do this in define.js
+      expr.$expected = 'approved-exists'; // only complain once
+    }
+    const ref = resolvePath( expr, expected, user );
+
+    if (expected === 'annotation') {
+      user._outer.$contains.$annotation.$path = true;
+      user._outer.$contains.$annotation.$self ||= expr.path[0]?._navigation?.kind === '$self';
+    }
+
+    // check whether arguments and filters are allowed on last path item;
+    // references in those are to be resolved below even if not allowed
+    // (for code completion)
+    const last = expr.path[expr.path.length - 1];
+    if (!last || !(last.args || last.where || last.cardinality) ||
+        expr.$expected === 'approved-exists' ||
+        user.expand || user.inline ||
+        expWithFilter.includes( expected ) ||     // `from`, …
+        last._navigation?.kind === '$tableAlias') // error already reported
+      return ref;
+
+    const type = effectiveType( last._artifact );
+    const art = type && (type.kind === 'entity' ? type : type.target?._artifact);
+    if (!art)
+      return ref;               // error already reported via resolvePathItem()
+    const unexpectedFilter = expected !== 'column' && expected !== 'calc';
+    if (last.args || last.where || last.cardinality)
+      reportUnexpectedArgsAndFilter( last, expected, user, art, unexpectedFilter && 'std' );
+    // TODO: we should have different message-ids for the "last" stuff: adding
+    // `.item` likely corrects the ref, probably with location at end of ref
+    return ref;
+  }
+
+  function resolvePathItem( step, expected, user ) {
+    // In FROM ref, first item artifact might be array (duplicate in same
+    // `artifacts` dictionary)
+    if (!step._artifact || Array.isArray( step._artifact ))
+      return traverseExpr.SKIP; // cannot resolve filter refs for undef'd / duplicates
+
+    const isAlias = step._navigation?.kind === '$tableAlias';
+    if (isAlias)
+      return reportUnexpectedArgsAndFilter( step, expected, user, { params: {} }, 'tableAlias' );
+    const type = effectiveType( step._artifact );
+    const art = type && (type.kind === 'entity' ? type : type.target?._artifact);
+    if (!art) {
+      const exp = (expected === 'from') ? 'from' : 'std';
+      return (type && type.target)
+        ? traverseExpr.SKIP     // something wrong with the association
+        : reportUnexpectedArgsAndFilter( step, expected, user, { params: {} }, exp );
+    }
+    setLink( step, '_user', user._user || user );
+    const { args } = step;
+    if (!args)
+      return null;
+    if (Array.isArray( args )) {
+      const loc = [ args[0]?.location || step.location, user ];
+      error( 'expr-expected-named-argument', loc, {},
+             'Expected named parameters for the entity' );
+      // only via CSN input - TODO: or do in CSN parser?
+      return null;
     }
-    else if (step.where || step.cardinality) {
-      const location = combinedLocation( step.where, step.cardinality );
-      let variant = alias ? 'tableAlias' : 'std';
-      if (expected === 'from')
-        variant = 'from';
-      // XSN TODO: filter$location including […]
-      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 @stylistic/js/max-len
-        tableAlias: 'A filter can only be provided when navigating along associations, but found table alias',
-        from: 'A filter can only be provided for the source entity or associations',
-      } );
+    if (!art.params) {
+      // remark: from the location, this should be 'expr-unexpected-arguments',
+      // or probably better: use a text variant of expr-undefined-param
+      error( 'expr-unexpected-argument', [ args[$location] || step.location, user ],
+             { art, '#': 'no-params' } ); // TODO: own message-id ?
+      return null;
+    }
+
+    for (const id in args) {
+      const param = art.params[id];
+      const { name } = args[id];
+      setArtifactLink( name, param );
+      if (!param) {
+        error( 'expr-undefined-param', [ name.location, user ], { art, id },
+               'Entity $(ART) has no parameter $(ID)' );
+      }
+      // no need to do s/th special for duplicate arguments in args[id].$duplicates
     }
+    return null;
   }
 
-  function resolveParams( dict, art, entity, expected, user, stepLocation ) {
-    if (!entity || !entity.params) {
-      let first = dict[Object.keys( dict )[0]];
-      if (Array.isArray( first ))
-        first = first[0];
-      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: 'Unexpected arguments for entity $(ART) without parameters',
-             } );
+  function resolveEnumSymbol( expr, expected, user, type ) {
+    const { sym } = expr;
+    // CSN input with both '#'+val (recompilation) → do not resolve
+    if (!sym || expr.val !== undefined || !type)
       return;
+    // The parameter def for an argument, and the annotation def for an assignment
+    // is in `type._artifact`, it is not `type` itself:
+    type = effectiveType( type.id ? type._artifact : type );
+    // Remark: do not use `?.`, type could be 0 for cyclic parameter type
+    if (type && type.foreignKeys) {
+      const keys = Object.values( type.foreignKeys );
+      if (keys.length === 1) {
+        const elem = resolvePath( keys[0].targetElement, 'targetElement', keys[0] );
+        type = effectiveType( elem );
+      }
     }
-    const exp = (expected === 'from') ? 'from-args' : expected;
-    if (Array.isArray( dict )) {
-      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 );
+    const symbols = type && type.enum;
+    if (!symbols)
       return;
+
+    // TODO: or warning if enum symbol but non-enum type?
+    if (symbols[sym.id]) {
+      setLink( sym, '_artifact', symbols[sym.id] );
     }
-    // TODO: allow to specify expected for arguments in in specExpected
-    for (const name in dict) {
-      const param = art.params[name];
-      const arg = dict[name];
-      for (const a of Array.isArray( arg ) ? arg : [ arg ]) {
-        setArtifactLink( a.name, param );
-        if (!param) {
-          error( 'expr-undefined-param', [ a.name.location, user ], { art, id: name },
-                 'Entity $(ART) has no parameter $(ID)' );
-        }
-        resolveExpr( a, exp, user );
-      }
+    else {
+      // inferred enums can't be extended (yet): show underlying enum
+      while (type.enum[$inferred])
+        type = getOrigin( type );
+      const err = message( 'ref-undefined-enum', [ sym.location, user ],
+                           { id: sym.id, type } );
+      if (options.newParser || options.newparser)
+        attachAndEmitValidNames( err, symbols );
+    }
+  }
+
+  function reportUnexpectedArgsAndFilter( step, expected, user, art, variant ) {
+    if (step.args && art?.params) {
+      const loc = [ step.args[$location] || step.location, user ];
+      error( 'expr-unexpected-argument', loc, { '#': variant } );
+    }
+    if ((step.where || step.cardinality) && variant) {
+      const location = combinedLocation( step.where, step.cardinality );
+      // XSN TODO: filter$location including […]
+      message( 'expr-unexpected-filter', [ location, user ], { '#': variant } );
     }
+    return variant && traverseExpr.SKIP;
   }
 }