@sap/cds-compiler 4.7.6 → 4.9.0

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');
@@ -25,12 +26,12 @@ const {
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { CompilerAssertion } = require('../base/error');
-const { CsnLocation } = require('./classes');
+const { Location } = require('../base/location');
 
 const $location = Symbol.for( 'cds.$location' );
 
 // attach stupid location - TODO: remove in v5
-const genLocation = new CsnLocation( '' );
+const genLocation = new Location( '' );
 
 const draftElements = [
   'IsActiveEntity',
@@ -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

@@ -30,7 +30,7 @@ const tweakAssocs = require('./tweak-assocs');
 const propagator = require('./propagator');
 const check = require('./checks');
 
-const { emptyWeakLocation } = require('../base/location');
+const { Location, emptyWeakLocation } = require('../base/location');
 const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
 const { checkRemovedDeprecatedFlags } = require('../base/model');
 const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
@@ -38,7 +38,7 @@ const { cdsFs } = require('../utils/file');
 
 const fs = require('fs');
 const path = require('path');
-const { CsnLocation, XsnSource } = require('./classes');
+const { XsnSource } = require('./xsn-model');
 
 const extensionParsers = {
   csn: parseCsn.parse,
@@ -56,7 +56,6 @@ class InvocationError extends Error {
     super( ...args );
     this.code = 'ERR_CDS_COMPILER_INVOCATION';
     this.errors = errs;
-    this.hasBeenReported = false;
   }
 }
 
@@ -93,7 +92,7 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
     return parser( source, filename, options, messageFunctions );
 
   const model = new XsnSource();
-  model.location = new CsnLocation( filename );
+  model.location = new Location( filename );
   messageFunctions.error( 'file-unknown-ext', emptyWeakLocation( filename ),
                           { file: ext, '#': !ext && 'none' }, {
                             std: 'Unknown file extension $(FILE)',
@@ -174,12 +173,12 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
       return [];                 // no further dependency processing
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in sources:
-    sources[filename] = { location: new CsnLocation( rel ) };
+    sources[filename] = { location: new Location( rel ) };
 
     const source = await cdsFs( fileCache, options.traceFs ).readFileAsync( filename, 'utf8' );
     const ast = parseX( source, rel, options, model.$messageFunctions );
     sources[filename] = ast;
-    ast.location = new CsnLocation( rel );
+    ast.location = new Location( rel );
     ast.dirname = path.dirname( filename );
     assertConsistency( ast, options );
 
@@ -293,7 +292,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
     }
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in a.sources:
-    a.sources[filename] = { location: new CsnLocation( rel ) };
+    a.sources[filename] = { location: new Location( rel ) };
 
     cdsFs( fileCache, options.traceFs ).readFileSync( filename, 'utf8', (err, source) => {
       if (err) {
@@ -303,7 +302,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
         try {
           const ast = parseX( source, rel, options, model.$messageFunctions );
           a.sources[filename] = ast;
-          ast.location = new CsnLocation( rel );
+          ast.location = new Location( rel );
           ast.dirname = path.dirname( filename );
           assertConsistency( ast, options );
           cb( null, ast );
@@ -374,7 +373,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     if (typeof source === 'string') {
       const ast = parseX( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = new CsnLocation( filename );
+      ast.location = new Location( filename );
       assertConsistency( ast, options );
     }
     else if (options.$xsnObjects) { // source is a XSN object with option $xsnObjects
@@ -383,7 +382,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     else {                      // source is a CSN object
       const ast = parseCsn.augment( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = new CsnLocation( filename );
+      ast.location = new Location( filename );
       assertConsistency( ast, options );
     }
 

package/lib/compiler/lsp-api.js

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

package/lib/compiler/populate.js

@@ -633,8 +633,14 @@ function populate( model ) {
   }
 
   function resolveExcluding( name, env, excludingDict, user ) {
-    if (env[name])
+    const found = env[name];
+    if (found) { // set links for LSP; if Array, then via multiple query sources ($navElement)
+      const art = (Array.isArray(found) && found.map(f => f._origin)) ||
+        (found.kind === '$navElement' && found._origin) ||
+        found;
+      setArtifactLink( excludingDict[name].name, art );
       return;
+    }
     /** @type {object} */
     // console.log(name,Object.keys(env),Object.keys(excludingDict))
     const compileMessageRef = info(
@@ -745,7 +751,6 @@ function populate( model ) {
         location: col.value.location || col.location,
         $inferred: '$internal',
       };
-      col.$inferred = '$internal';
       return col.name.id;
     }
     // invent a name for code completion in expression, see also #10596
@@ -880,9 +885,12 @@ function populate( model ) {
     if (envParent || query.kind !== 'select') {
       // already done in populateQuery (TODO: change that and check whether
       // `*` is allowed at all in definer)
-      const user = colParent || query;
-      for (const name in user.excludingDict)
-        resolveExcluding( name, env, excludingDict, query );
+      if (!colParent || colParent.value._artifact) {
+        // avoid "not found" messages if pathHead can't be found
+        const user = colParent || query;
+        for (const name in user.excludingDict)
+          resolveExcluding( name, env, excludingDict, query );
+      }
     }
   }
 

package/lib/compiler/propagator.js

@@ -13,36 +13,23 @@ const {
   forEachMember,
   forEachGeneric,
   isDeprecatedEnabled,
+  isBetaEnabled,
 } = require( '../base/model');
 const {
   setLink,
   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'
@@ -71,12 +58,24 @@ 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;
 
   forEachDefinition( model, run );
+  if (isBetaEnabled( model.options, 'v5preview' ))
+    forEachGeneric( model, 'vocabularies', run );
 
   // TODO: move 'virtual' handling/checks to resolver if
   //       'deprecated.oldVirtualNotNullPropagation' is gone
@@ -100,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) {
@@ -199,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)
@@ -267,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'
@@ -276,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) {
@@ -519,8 +526,6 @@ function resolve( model ) {
     if (art.value) {
       if (art.$syntax === 'calc')
         checkCalculatedElement( art );
-      else if (art.type && !art.$inferred)
-        checkColumnTypeCast( art );
     }
 
     resolveExprInAnnotations( art );
@@ -559,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',
@@ -570,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
@@ -849,21 +856,6 @@ function resolve( model ) {
     }
   }
 
-  function checkColumnTypeCast( art ) {
-    const elem = (art.value.op?.val === 'cast')
-      ? art.value.args[0]?._artifact
-      : art.value._artifact;
-    if (elem && art.type) { // has explicit type
-      if (art.type._artifact?.elements)
-        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'to-structure' } );
-      else if (elem.elements) // TODO: calc elements
-        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-structure' } );
-      else if (elem.target && !art.type._artifact?.target)
-        // allow cast to association -> that is already checked and denied elsewhere
-        error( 'type-invalid-cast', [ art.type.location, art ], { '#': 'from-assoc' } );
-    }
-  }
-
   /**
    * Return type containing the assoc spec (keys, on); note that no
    * propagation/rewrite has been done yet, cyclic dependency must have been
@@ -1223,8 +1215,9 @@ function resolve( model ) {
              'Only an association can be redirected' );
       return;
     }
-    else if ((elem.value || elem.expand) && elem.type && !elem.type.$inferred) {
-      error( 'ref-unexpected-assoc', [ elem.type.location, elem ], { '#': 'cast' } );
+    else if ((elem.value || elem.expand) && elem.type &&
+        (!elem.type.$inferred || elem.type.$inferred === 'cast')) {
+      error( 'type-invalid-cast', [ elem.type.location, elem ], { '#': 'assoc' } );
       return;
     }
     // console.log(message( null, elem.location, elem, {target,art:assoc}, 'Info','RE')
@@ -1364,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 );
@@ -1383,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 ) );
@@ -1393,30 +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) {
-      info( 'anno-experimental-expressions', [ expr.location ], {
-        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 ) {
@@ -1448,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;