@sap/cds-compiler 4.8.0 → 4.9.0

package/lib/compiler/checks.js

@@ -19,6 +19,7 @@ const {
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('./builtins');
+const { propagationRules } = require('../base/builtins');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -69,6 +70,13 @@ function check( model ) {
     } );
   }
 
+  function* iterateAnnotations( art ) {
+    for (const prop in art) {
+      if (prop.charAt(0) === '@')
+        yield prop;
+    }
+  }
+
   function checkGenericConstruct( art ) {
     checkName( art );
     checkTypeArguments( art );
@@ -76,11 +84,9 @@ function check( model ) {
     if (art.value && !art.$calcDepElement && art.type)
       checkTypeCast( art.value, art );
 
-    if (model.vocabularies) {
-      Object.keys( art )
-        .filter( a => a.startsWith( '@' ) )
-        .forEach( a => checkAnnotationAssignment1( art, art[a] ) );
-    }
+    for (const anno of iterateAnnotations( art ))
+      checkAnnotationAssignment1( art, art[anno] );
+
     checkTypeStructure( art );
     checkAssociation( art ); // type def could be assoc
     if (art.kind === 'enum')
@@ -236,6 +242,8 @@ function check( model ) {
       ? xpr.args[0]?._artifact
       : xpr._artifact;
     const type = isCast ? xpr.type : user.type;
+    if (!isCast && type.$inferred)
+      return; // e.g. $inferred:'generated'
     if (elem && type) { // has explicit type
       if (type._artifact?.elements)
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'to-structure' } );
@@ -264,9 +272,11 @@ function check( model ) {
     // "key" keyword at localized element in SELECT list.
     // TODO: not in inferred elements, but also inside aspects
     if (elem.key?.val && elem._main?.query) {
+      // either the element was casted to localized (no `_origin`) or
       // original element is localized but not key, as that would have
       // already resulted in a warning by localized.js
-      if (elem._origin?.localized?.val && !elem._origin.key?.val) {
+      if ((!elem._origin && elem.localized?.val) ||
+        (elem._origin?.localized?.val && !elem._origin.key?.val)) {
         warning( 'def-ignoring-localized', [ elem.key.location, elem ], { keyword: 'localized' },
                  'Keyword $(KEYWORD) is ignored for primary keys' );
       }
@@ -860,21 +870,37 @@ function check( model ) {
     return false;
   }
 
+  /**
+   * Returns true if the given annotation accepts expressions as values.
+   *
+   * @param {object} anno
+   * @param {XSN.Artifact} art
+   * @returns {boolean}
+   */
+  function checkAnnotationAcceptsExpressions( anno, art ) {
+    const name = anno.name?.id;
+    if (!name)
+      return true;
+    if (!propagationRules[`@${ name }`])
+      return true;
+    error( 'anno-unexpected-expr', [ anno.location, art ], { anno: name },
+           'Unexpected expression as value for $(ANNO)' );
+    return false;
+  }
 
-  // Former checkAnnotationAssignments.js ------------------------------------
-
-  // Check the annotation assignments (if any) of 'annotatable', possibly using annotation
-  // definitions from 'model'. Report errors on 'options.messages.
-  //
-  // TODO: rework completely!
-  // TODO: if we have such a check, consider #variant, anno.@anno, anno@anno
-
-  // Has been slightly adapted for model.vocabularies but comments need to be
-  // adapted, etc.
   function checkAnnotationAssignment1( art, anno ) {
-    if (art.$contains?.$annotation)
-      checkAnnotationExpressions( anno, art );
+    if (art.$contains?.$annotation && anno.kind === '$annotation') {
+      if (checkAnnotationAcceptsExpressions( anno, art ))
+        checkAnnotationExpressions( anno, art );
+    }
+
+    if (!model.vocabularies)
+      return;
 
+    // Has been slightly adapted for model.vocabularies but comments need to be
+    // adapted, etc.
+    // TODO: rework completely!
+    // TODO: if we have such a check, consider #variant, anno.@anno, anno@anno
     // Sanity checks (ignore broken assignments)
     if (!anno.name?.id)
       return;

package/lib/compiler/define.js

@@ -213,6 +213,12 @@ function define( model ) {
     dictForEach( model.$collectedExtensions, e => e._extensions.forEach( initExtension ) );
 
     addI18nBlocks();
+
+    const { $self } = model.definitions;
+    if ($self) {
+      message( 'name-deprecated-$self', [ $self.location, $self ], { name: '$self' },
+               'Do not use $(NAME) as name for an artifact definition' );
+    }
   }
 
   // Phase 1: ----------------------------------------------------------------
@@ -228,14 +234,15 @@ function define( model ) {
     if (!src.kind)
       src.kind = 'source';
 
-    let { namespace } = src;
+    let namespace = src.namespace?.name;
     let prefix = '';
     if (namespace?.path && !namespace.path.broken) {
       namespace.id = pathName( namespace.path );
       prefix = `${ namespace.id }.`;
     }
     if (isInReservedNamespace( prefix )) {
-      error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], { name: 'cds' },
+      error( 'reserved-namespace-cds', [ src.namespace.name.location, src.namespace.name ],
+             { name: 'cds' },
              'The namespace $(NAME) is reserved for CDS builtins' );
       namespace = null;
     }
@@ -523,7 +530,7 @@ function define( model ) {
     if (src.$frontend && src.$frontend !== 'cdl')
       return;
     if (src.namespace) {
-      const decl = src.namespace;
+      const decl = src.namespace.name;
       if (!decl.id)             // parsing may have failed
         return;
       if (!model.definitions[decl.id]) {
@@ -562,8 +569,8 @@ function define( model ) {
       initArtifactParentLink( art, model.definitions );
     const block = art._block;
     checkRedefinition( art );
-    initMembers( art, art, block );
     initDollarSelf( art );      // $self
+    initMembers( art, art, block );
     if (art.params)
       initDollarParameters( art ); // $parameters
 
@@ -636,6 +643,7 @@ function define( model ) {
       name: { id: '$parameters' },
       kind: '$parameters',
       location: art.location,
+      deprecated: true, // hide in code completion
     };
     setLink( parameters, '_parent', art );
     setLink( parameters, '_main', art );
@@ -679,8 +687,14 @@ function define( model ) {
         setLink( self, '_origin', query );
         setLink( self, '_parent', query );
         setLink( self, '_main', query._main );
+
+        const projection = { ...self, deprecated: true }; // hide in code completion
+        setLink( projection, '_origin', query );
+        setLink( projection, '_parent', query );
+        setLink( projection, '_main', query._main );
+
         query.$tableAliases.$self = self;
-        query.$tableAliases.$projection = self;
+        query.$tableAliases.$projection = projection;
       }
       initSubQuery( query );    // check for SELECT clauses after from / mixin
     }
@@ -858,12 +872,13 @@ function define( model ) {
   }
 
   function initMixins( query, art ) {
-    // TODO: re-check if mixins have already duplicates
-    for (const name in query.mixin) {
-      const mixin = query.mixin[name];
+    forEachInOrder( query, 'mixin', initMixin );
+
+    function initMixin( mixin, name ) {
+      setLink( mixin, '_block', art._block );
+      setMemberParent( mixin, name, query );
+      checkRedefinition( mixin );
       if (!(mixin.$duplicates)) {
-        setMemberParent( mixin, name, query );
-        setLink( mixin, '_block', art._block );
         // TODO: do some initMembers() ?  If people had annotation
         // assignments on the mixin... (also for future mixin definitions
         // with generated values)
@@ -924,14 +939,14 @@ function define( model ) {
           setLink( col, '_block', parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
-            warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
+            message( 'syntax-ignoring-anno', [ col.doc.location, col ],
                      { '#': 'doc', code: '.{ ‹inline› }' } );
           }
           // col.$annotations no available for CSN input, have to search.
-          // Warning about first annotation should be enough to avoid spam.
+          // Message about first annotation should be enough to avoid spam.
           const firstAnno = Object.keys( col ).find( key => key.startsWith( '@' ) );
           if (firstAnno) {
-            warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
+            message( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
                      { code: '.{ ‹inline› }' } );
           }
         }
@@ -1151,7 +1166,7 @@ function define( model ) {
       checkRedefinition( elem );
       initMembers( elem, elem, bl, initExtensions );
       if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
-        initBoundSelfParam( elem.params );
+        initBoundSelfParam( elem.params, elem._main );
 
       // for a correct home path, setMemberParent needed to be called
 
@@ -1177,27 +1192,24 @@ function define( model ) {
     }
   }
 
-  function initBoundSelfParam( params ) {
+  function initBoundSelfParam( params, main ) {
     if (!params)
       return;
     if (boundSelfParamType === true) { // first try
       const def = model.definitions.$self;
       if (def) {
-        // TODO v5: bring this always, probably even as error
-        warning( 'name-deprecated-for-artifacts', [ def.location, def ], { name: '$self' },
-                 'Do not use $(NAME) as name for an artifact definition' );
         boundSelfParamType = false;
         return;
       }
-      const location = { file: '' };
-      boundSelfParamType = { name: { id: '$self', location }, location };
+      boundSelfParamType = '$self';
     }
     const first = params[Object.keys( params )[0] || ''];
     const type = first?.type || first?.items?.type; // this sequence = no derived type
     const path = type?.path;
     if (path?.length === 1 && path[0]?.id === '$self') { // TODO: no where: ?
-      setLink( type, '_artifact', boundSelfParamType );
-      setLink( path[0], '_artifact', boundSelfParamType );
+      const { $self } = main.$tableAliases;
+      setLink( type, '_artifact', $self );
+      setLink( path[0], '_artifact', $self );
     }
   }
 

package/lib/compiler/extend.js

@@ -9,6 +9,7 @@ const {
   forEachDefinition,
   forEachMember,
   isDeprecatedEnabled,
+  isBetaEnabled,
 } = require('../base/model');
 const { dictAdd, pushToDict } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
@@ -71,6 +72,7 @@ function extend( model ) {
   } );
 
   const includesNonShadowedFirst = isDeprecatedEnabled( model.options, 'includesNonShadowedFirst' );
+  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
 
   sortModelSources();
   const extensionsDict = Object.create( null ); // TODO TMP
@@ -222,6 +224,7 @@ function extend( model ) {
             code: 'extend … with definitions',
             keyword: 'extend service',
           };
+          // TODO(v5): Discuss: make this an error?
           warning( 'ext-invalid-kind', [ loc, ext ], msgArgs, {
             std: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) instead',
             annotate: 'There is no artifact $(ART), use $(CODE) instead',
@@ -818,7 +821,7 @@ function extend( model ) {
             annotate[prop] = art[prop];
         }
       }
-      if (extensions.length === 1) { // i.e. no proper location if from more than one extensions
+      if (extensions.length === 1) { // i.e. no proper location if from more than one extension
         annotate.location = extensions[0].location;
         annotate.name.location = extensions[0].name.location;
       }
@@ -829,18 +832,38 @@ function extend( model ) {
   }
 
   function checkRemainingMainExtensions( art, ext, localized ) {
-    if (localized)              // TODO v5: ignore only for annotate
+    if (localized) {
+      if (isV5preview && ext.kind === 'extend') {
+        // In v5, reject any `extend` on localized.
+        error( 'ref-undefined-art', [ ext.location || ext.name.location, ext ],
+               { '#': 'localized', keyword: 'annotate' } );
+      }
       return;
+    }
+
     if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
       return;
-    if (art?.kind === 'namespace') {
-      // TODO: not at all different to having no definition
-      info( 'anno-namespace', [ ext.name.location, ext ], {}, // TODO: better location?
-            'Namespaces can\'t be annotated' );
-    }
-    else if (art?.builtin) {
-      info( 'anno-builtin', [ ext.name.location, ext ], {}, // TODO: better location?
-            'Builtin types should not be annotated. Use custom type instead' );
+
+    if (art?.builtin) {
+      info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
+    }
+    else if (art?.kind === 'namespace') {
+      const hasAnnotations = Object.keys(ext).find(a => a.charAt(0) === '@');
+      const firstAnno = ext[hasAnnotations];
+      // In v5, extending namespaces is only allowed for `extend with definitions`.
+      // Neither annotations nor other extensions are allowed.
+      // Non-artifact extensions are reported in resolvePath() already (for v5).
+      if ((hasAnnotations || !ext.artifacts) ) {
+        if (isV5preview) {
+          error( 'ref-undefined-art', [ (firstAnno?.name || ext.name).location, ext ], {
+            '#': 'namespace', art: ext,
+          } );
+        }
+        else {
+          info( 'anno-namespace', [ (firstAnno?.name || ext.name).location, ext ], {},
+                'Namespaces can\'t be annotated nor extended' );
+        }
+      }
     }
   }
 

package/lib/compiler/index.js

@@ -56,7 +56,6 @@ class InvocationError extends Error {
     super( ...args );
     this.code = 'ERR_CDS_COMPILER_INVOCATION';
     this.errors = errs;
-    this.hasBeenReported = false;
   }
 }
 

package/lib/compiler/lsp-api.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// Placeholder for future LSP API.
+
+module.exports = {};

package/lib/compiler/propagator.js

@@ -20,30 +20,16 @@ const {
   linkToOrigin,
   withAssociation,
   viewFromPrimary,
+  copyExpr,
 } = require('./utils');
+const { propagationRules } = require('../base/builtins');
 const $inferred = Symbol.for( 'cds.$inferred' );
+const { xprRewriteFns } = require('./xpr-rewrite');
 // const { ref } = require( '../model/revealInternalProperties' )
 
 // Note that propagation here is also used for deep-copying (function `onlyViaParent`)
 function propagate( model ) {
   const props = {
-    '@com.sap.gtt.core.CoreModel.Indexable': never,
-    '@cds.persistence.exists': never, // also copied in generate.js
-    '@cds.persistence.table': never,
-    '@cds.persistence.calcview': never,
-    '@cds.persistence.udf': never,
-    '@cds.persistence.skip': notWithPersistenceTable, // also copied in generate.js
-    // '@cds.tenant.independent' is propagated as normal, but also copied in generate.js
-    '@sql.append': never,
-    '@sql.prepend': never,
-    '@sql.replace': never,
-    '@Analytics.hidden': never,
-    '@Analytics.visible': never,
-    '@cds.autoexpose': onlyViaArtifact,
-    '@cds.autoexposed': never,  // in case people set it themselves
-    '@cds.external': never,
-    '@cds.redirection.target': never,
-    '@fiori.draft.enabled': onlyViaArtifact,
     '@': annotation,            // always except in 'items' (and parameters for entity return types)
     doc: annotation,            // always except in 'items' (and parameters for entity return types)
     default: withKind,          // always except in 'items'
@@ -72,7 +58,17 @@ function propagate( model ) {
     returns,
     $filtered: annotation,
   };
+  const ruleToFunction = {
+    __proto__: null,
+    never,
+    onlyViaArtifact,
+    notWithPersistenceTable,
+  };
+  for (const rule in propagationRules)
+    props[rule] = ruleToFunction[propagationRules[rule]];
+
   const { options } = model;
+  const { rewriteAnnotationsRefs } = xprRewriteFns( model );
   // eslint-disable-next-line max-len
   const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, '_oldVirtualNotNullPropagation' );
   const { warning, throwWithError } = model.$messageFunctions;
@@ -103,7 +99,7 @@ function propagate( model ) {
       const news = [];
       for (const target of targets) {
         const origin = getOrigin( target );
-        if (origin) {
+        if (origin && origin.kind !== '$self') {
           // Calculated elements that are simple references: `calc = field;`.
           // Respect sibling properties in inheritance.
           if (target._calcOrigin?._origin && target.value?._artifact) {
@@ -202,6 +198,10 @@ function propagate( model ) {
       target[prop] = [ ...val ];
       target[prop].$inferred = 'prop';
     }
+    else if (prop.charAt(0) === '@' && val?.kind === '$annotation') {
+      target[prop] = Object.assign( copyExpr( val ), { $inferred: 'prop' } );
+      rewriteAnnotationsRefs( target, source, prop );
+    }
     else {
       target[prop] = Object.assign( {}, val, { $inferred: 'prop' } );
       if (val._artifact !== undefined)
@@ -270,6 +270,7 @@ function propagate( model ) {
     target[prop][$inferred] = 'prop';
   }
 
+  // Only propagate if parent object (which is not necessarily `_parent`) was propagated.
   function onlyViaParent( prop, target, source ) {
     if (target.$inferred === 'proxy' || target.$inferred === 'expanded')
       // assocs and enums do not have 'include'
@@ -279,6 +280,8 @@ function propagate( model ) {
   function targetAspect( prop, target, source ) {
     if (target.targetAspect)
       return;
+    if (target.type?._artifact === model.definitions['cds.Association'])
+      return; // don't propagate targetAspect to associations (e.g. via $filtered)
     const ta = source.targetAspect;
     if (!ta.elements && !ta._origin) { // _origin set for elements in source
       notWithExpand( prop, target, source );

package/lib/compiler/resolve.js

@@ -44,7 +44,6 @@ const {
   forEachGeneric,
   forEachInOrder,
   isDeprecatedEnabled,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictAdd } = require('../base/dictionaries');
 const { dictLocation, weakLocation } = require('../base/location');
@@ -126,6 +125,11 @@ function resolve( model ) {
     // Phase 4: resolve all artifacts:
     forEachDefinition( model, resolveRefs );
     forEachGeneric( model, 'vocabularies', resolveRefs );
+    if (model.options.lspMode) {
+      for (const name in model.sources)
+        resolveDefinitionName( model.sources[name].namespace );
+    }
+
     // create “super” ANNOTATE statements for annotations on unknown artifacts:
     createRemainingAnnotateStatements();
     // report cyclic dependencies:
@@ -363,6 +367,9 @@ function resolve( model ) {
     const allowedInMain = [ 'entity', 'aspect', 'event' ].includes( adHocOrMainKind( art ) );
     const isTopLevelElement = parent && (parent.kind !== 'element' || parent.targetAspect);
 
+    if (model.options.lspMode && art.name && !art._main)
+      resolveDefinitionName( art );
+
     // Check KEY (TODO: make this an extra function)
     const { key } = art;
     if (key?.val && !key.$inferred) {
@@ -557,10 +564,12 @@ function resolve( model ) {
       const sType = specifiedElement.type?._artifact;
       const iTypeArt = getInferredPropFromOrigin( 'type' )?._artifact;
       const iType = iTypeArt || inferredElement;
-
-      // xor: could be missing a type;
       // FIXME: The coding above returns incorrect iType for expand on associations
 
+      // $filtered may change composition to association; we allow that change here.
+      const compToAssoc = sType === model.definitions['cds.Association'] && inferredElement.target;
+
+      // xor: could be missing a type;
       if (!specifiedElement.type && inferredElement.type) {
         error( 'query-mismatched-element', [ specifiedElement.location, user ], {
           '#': !specifiedElement.type ? 'missing' : 'extra', name: user.name.id, prop: 'type',
@@ -568,7 +577,7 @@ function resolve( model ) {
         return;
       }
       // If specified type is `null`, type could not be resolved.
-      else if (sType && sType !== iType &&
+      else if (!compToAssoc && sType && sType !== iType &&
         // Special case for $recompilation: allow one level of type indirection. See #12113.
         (!model.options.$recompile || sType !== iType.type?._artifact)) {
         const typeName = !iTypeArt && 'typeExtra' ||  // no inferred type prop
@@ -1348,6 +1357,19 @@ function resolve( model ) {
   // General resolver functions
   //--------------------------------------------------------------------------
 
+  // Resolve the n-1 path steps before the definition name for LSP.
+  function resolveDefinitionName( art ) {
+    const path = art?.name?.path;
+    if (!art || art._main || !path || path.length <= 1)
+      return;
+
+    let name = art.name.id;
+    for (let i = path.length - 1; i > 0; --i) {
+      name = name.substring(0, name.length - path[i].id.length - 1);
+      setArtifactLink( path[i - 1], model.definitions[name] || false );
+    }
+  }
+
   // Resolve the type and its arguments if applicable.
   function resolveTypeExpr( art, user ) {
     const typeArt = resolvePath( art.type, 'type', user );
@@ -1367,7 +1389,6 @@ function resolve( model ) {
       if (!anno.kind)
         initAnnotationForExpression( anno, art );
       resolveExpr( expr, 'annotation', anno );
-      reportUnsupportedAnnoExpr( expr );
     }
     else if (expr.literal === 'array') {
       expr.val.forEach( val => resolveAnnoExpr( val, art, anno ) );
@@ -1377,32 +1398,22 @@ function resolve( model ) {
     }
   }
 
-  function reportUnsupportedAnnoExpr( expr ) {
-    if (isBetaEnabled( model.options, 'annotationExpressions' ))
-      return;
-    const alreadyReported = model.$messageFunctions.messages
-      .find(msg => msg.messageId === 'anno-experimental-expressions');
-    if (!alreadyReported) {
-      // due to test mode and shuffling, we would get a different location on each compilation.
-      const loc = model.options.testMode ? null : [ expr.location ];
-      info( 'anno-experimental-expressions', loc, {
-        option: 'annotationExpressions',
-        // eslint-disable-next-line max-len
-      }, 'Expressions in annotation values are a beta feature. Use at your own risk. (This message can be suppressed with beta flag $(OPTION))' );
-    }
-  }
-
-  // for faster processing, mark artifacts and annotations which contain anno expressions
+  /**
+   * For faster processing, mark artifacts and annotations which contain anno expressions
+   *
+   * @param {object} anno
+   * @param {XSN.Artifact} art
+   */
   function initAnnotationForExpression( anno, art ) {
     anno.kind = '$annotation';
     setLink( anno, '_outer', art );
-    while (!art.$contains?.$annotation) {
-      art.$contains ??= {};
-      art.$contains.$annotation = true; // TODO: extra values for elem and $self refs
-      if (!art._main)
-        break;
-      art = art._parent;        // TODO: really go up?
-    }
+    art.$contains ??= {};
+    art.$contains.$annotation = { // set in resolveExprItem
+      $path: false,
+      $self: false,
+    };
+    // Think about tagging parents too (like before #12636).
+    // Might be useful for future recursive types.
   }
 
   function resolveExpr( expr, exprCtx, user ) {
@@ -1434,6 +1445,11 @@ function resolve( model ) {
           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';
+      }
     }
     else if (expr.query) {
       const { query } = expr;