@sap/cds-compiler 4.9.6 → 5.1.0

package/lib/compiler/define.js

@@ -216,7 +216,7 @@ function define( model ) {
 
     const { $self } = model.definitions;
     if ($self) {
-      message( 'name-deprecated-$self', [ $self.location, $self ], { name: '$self' },
+      message( 'name-deprecated-$self', [ $self.name.location, $self ], { name: '$self' },
                'Do not use $(NAME) as name for an artifact definition' );
     }
   }
@@ -364,7 +364,7 @@ function define( model ) {
   // must be called after addUsing().
   function addNamespace( namespace, src ) {
     // create using for own namespace:
-    // TODO: should we really do that in v5? See also initNamespaceAndUsing().
+    // TODO: should we really do that (in v6)?  See also initNamespaceAndUsing().
     const last = namespace.path[namespace.path.length - 1];
     const { id } = last;
     if (src.artifacts[id] || last.id.includes( '.' ))
@@ -507,9 +507,10 @@ function define( model ) {
   // TODO: message ids
   function checkRedefinition( art ) {
     if (!art.$duplicates || !art.name.id ||
-        art.$errorReported === 'syntax-duplicate-extend' ||
-        art.$errorReported === 'syntax-duplicate-annotate')
+        art.$errorReported === 'syntax-duplicate-extend')
       return;
+    if (art.kind === 'annotate' || art.kind === 'extend')
+      return; // extensions are merged into a super-annotate; $duplicates are only kept for LSP
     if (art._main) {
       error( 'duplicate-definition', [ art.name.location, art ], {
         name: art.name.id,
@@ -637,7 +638,6 @@ function define( model ) {
   }
 
   function initDollarParameters( art ) {
-    // TODO: remove $parameters in v5?
     // TODO: use setMemberParent() ?
     const parameters = {
       name: { id: '$parameters' },
@@ -939,14 +939,14 @@ function define( model ) {
           setLink( col, '_block', parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
-            message( 'syntax-ignoring-anno', [ col.doc.location, col ],
+            message( 'syntax-unexpected-anno', [ col.doc.location, col ],
                      { '#': 'doc', code: '.{ ‹inline› }' } );
           }
           // col.$annotations no available for CSN input, have to search.
           // Message about first annotation should be enough to avoid spam.
           const firstAnno = Object.keys( col ).find( key => key.startsWith( '@' ) );
           if (firstAnno) {
-            message( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
+            message( 'syntax-unexpected-anno', [ col[firstAnno].name.location, col ],
                      { code: '.{ ‹inline› }' } );
           }
         }
@@ -1083,7 +1083,7 @@ function define( model ) {
           hasElement = true;    // warning with CDL input or `name: {}` in CSN input
       }
       if (hasElement) {
-        // This message is similar to the one above.  In v5/6, we could probably
+        // This message is similar to the one above.  In v6, we could probably
         // turn this warning into an error, remove `$syntax: 'element' (also in
         // language.g4), and use the above `ext-unexpected-element` only for CSN input.
         warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],

package/lib/compiler/extend.js

@@ -8,8 +8,8 @@ const {
   forEachInOrder,
   forEachDefinition,
   forEachMember,
+  forEachGeneric,
   isDeprecatedEnabled,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictAdd, pushToDict } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
@@ -27,10 +27,11 @@ const {
 const layers = require('./moduleLayers');
 const { CompilerAssertion } = require('../base/error');
 const { Location } = require('../base/location');
+const { typeParameters } = require('./builtins');
 
 const $location = Symbol.for( 'cds.$location' );
 
-// attach stupid location - TODO: remove in v5
+// attach stupid location - TODO: remove in v6
 const genLocation = new Location( '' );
 
 const draftElements = [
@@ -59,6 +60,7 @@ function extend( model ) {
     resolvePath,
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
+    resolveDefinitionName,
     attachAndEmitValidNames,
     initMembers,
     initSelectItems,
@@ -68,11 +70,11 @@ function extend( model ) {
     createRemainingAnnotateStatements,
     extendArtifactBefore,
     extendArtifactAfter,
+    extendForeignKeys,
     applyIncludes,              // TODO: re-check
   } );
 
   const includesNonShadowedFirst = isDeprecatedEnabled( model.options, 'includesNonShadowedFirst' );
-  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
 
   sortModelSources();
   const extensionsDict = Object.create( null ); // TODO TMP
@@ -91,7 +93,8 @@ function extend( model ) {
   //-----------------------------------------------------------------------------
   // Extensions: general algorithm
   //-----------------------------------------------------------------------------
-  // extendArtifactBefore, extendArtifactAfter, createRemainingAnnotateStatements
+  // extendArtifactBefore, extendArtifactAfter, createRemainingAnnotateStatements,
+  // extendForeignKeys
 
   /**
    * Goes through all (applied) annotations in the given artifact and chooses one
@@ -161,6 +164,7 @@ function extend( model ) {
     moveReturnsExtensions( art, extensionsMap );
 
     if (art.returns) {
+      ensureArtifactNotProcessed( art.returns );
       pushToDict( art.returns, '_extensions', ...extensionsMap.elements || [] );
       pushToDict( art.returns, '_extensions', ...extensionsMap.enum || [] );
       if (art.kind !== 'annotate') {
@@ -171,16 +175,66 @@ function extend( model ) {
     }
     const sub = art.items || art.targetAspect?.elements && art.targetAspect;
     if (sub) {
+      ensureArtifactNotProcessed( sub );
       pushToDict( sub, '_extensions', ...extensionsMap.elements || [] );
       pushToDict( sub, '_extensions', ...extensionsMap.enum || [] );
     }
     else {
-      moveDictExtensions( art, extensionsMap,
-                          (art.enum && art.kind !== 'annotate' ? 'enum' : 'elements'), 'elements' );
+      let elementsProp = 'elements';
+      if (art.kind !== 'annotate')
+        elementsProp = art.enum && 'enum' || art.target && 'foreignKeys' || 'elements';
+
+      // keys are handled in tweak-assocs.js; don't push them down; see extendForeignKeys()
+      if (elementsProp !== 'foreignKeys')
+        moveDictExtensions( art, extensionsMap, elementsProp, 'elements' );
       moveDictExtensions( art, extensionsMap, 'enum' );
     }
   }
 
+  /**
+   * Apply foreign key extensions.  Because foreign keys are handled late in the compiler
+   * (in tweak-assocs.js), we can't apply them in effectiveType(), yet.
+   * Instead, we postpone applying them until all foreign keys were generated.
+   *
+   * @param art
+   */
+  function extendForeignKeys( art ) {
+    // See extendArtifactAfter() for targetAspect/items handling.
+    const sub = art.items || art.targetAspect?.elements && art.targetAspect;
+    if (!art._extensions || sub)
+      return;
+
+    // push down foreign keys
+    moveDictExtensions( art, art._extensions, 'foreignKeys', 'elements' );
+    if (!art.foreignKeys)
+      return;
+
+    forEachGeneric(art, 'foreignKeys', (key) => {
+      if (!key._effectiveType)
+        throw new CompilerAssertion('foreign key should have been processed');
+      extendArtifactBefore( key );
+      extendArtifactAfter( key );
+    });
+  }
+
+  /**
+   * Applying extensions is handled in extendArtifactAfter(). And only afterward,
+   * an effective sequence number is set.  Meaning that if a sub-artifact already
+   * has a sequence number, then extensions would be lost.
+   *
+   * A special case are foreign keys, see extendForeignKeys().
+   */
+  function ensureArtifactNotProcessed( art ) {
+    if (!model.options.testMode)
+      return;
+
+    if (art.kind !== 'key' && art.$effectiveSeqNo !== 0 && art.$effectiveSeqNo !== undefined) {
+      // if the artifact already has a sequence number, then
+      // extendArtifactAfter() was already called -> annotations would be lost.
+      throw new CompilerAssertion('artifact already processed; extensions would be lost');
+    }
+  }
+
   /**
    * Create super annotate statements for remaining extensions
    */
@@ -196,15 +250,25 @@ function extend( model ) {
   }
 
   // TODO: delete again - if not, what about extensions in contexts/services?
+  //       Check test.lsp-api.js! Links in extensions are needed.
   function setArtifactLinkForExtensions( source ) {
     if (!source.extensions)
       return;
-    for (const ext of source.extensions ) {
+    for (const ext of source.extensions) {
+      if (!ext.name?.id)
+        continue;
+
       const { name } = ext;
-      if (name?.id && name._artifact === undefined) {
+      const { path } = name;
+      if (name._artifact === undefined) {
         const refCtx = (name.id.startsWith( 'localized.' )) ? '_extensions' : ext.kind;
         resolvePath( name, refCtx, ext ); // for LSP
       }
+      else if (model.options.lspMode && path?.[0]._artifact === undefined) {
+        // we don't use resolvePath(…,'extend'), as that would add a dependency
+        resolveDefinitionName( ext );
+        setArtifactLink( path[path.length - 1], name._artifact );
+      }
     }
   }
 
@@ -224,7 +288,7 @@ function extend( model ) {
             code: 'extend … with definitions',
             keyword: 'extend service',
           };
-          // TODO(v5): Discuss: make this an error?
+          // TODO(v6): 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',
@@ -327,7 +391,7 @@ function extend( model ) {
 
   function extensionOverwrites( ext, prop ) {
     return (prop.charAt(0) !== '@')
-      ? [ 'doc', 'length', 'precision', 'scale', 'srid' ].includes( prop )
+      ? (prop === 'doc' || typeParameters.list.includes(prop))
       : !annotationHasEllipsis( ext[prop] );
   }
 
@@ -393,6 +457,9 @@ function extend( model ) {
       for (const col of ext.columns)
         col.$extended = true;
 
+      if (art.kind === 'annotate' && art.$inferred === '')
+        return; // internal super-annotate for unknown artifacts
+
       if (!query?.from?.path) {
         const variant = (query?.from || query)?.op?.val || 'std';
         error( 'extend-columns', [ ext.columns[$location], ext ], { '#': variant, art } );
@@ -404,7 +471,7 @@ function extend( model ) {
         query.columns.push( ...ext.columns );
       initSelectItems( query, ext.columns, query, true );
     }
-    else if ([ 'length', 'precision', 'scale', 'srid' ].includes( prop )) {
+    else if (typeParameters.list.includes( prop )) {
       const typeExts = art.$typeExts || (art.$typeExts = {});
       typeExts[prop] = ext;
     }
@@ -490,7 +557,7 @@ function extend( model ) {
     if ('val' in upToSpec) {
       if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
         return true;
-      // TODO v5: delete the speciao UP TO comparison?
+      // TODO v6: delete the special UP TO comparison?
       const upToVal = upToSpec.val;
       const prevVal = previousItem.val;
       // eslint-disable-next-line eqeqeq
@@ -540,7 +607,7 @@ function extend( model ) {
   // - 'ext-unexpected-type-argument' (TODO) if the artifact does not have the prop
   // - 'ext-invalid-type-argument' if the value is wrong for extend (no overwrite)
   //
-  // TODO v5: do not allow `extend … with (precision: …)` alone if original def also has `scale`
+  // TODO v6: do not allow `extend … with (precision: …)` alone if original def also has `scale`
   function applyTypeExtensions( art, ext, prop, scaleDiff ) {
     // console.log('ATE:',art?.[prop],ext?.[prop],scaleDiff)
     if (!ext?.[prop])
@@ -614,20 +681,21 @@ function extend( model ) {
     const extensions = extensionsMap[extProp];
     if (!extensions)
       return;
+
     const artDict = art[artProp] || annotateFor( art, extProp ); // no auto-correction in annotate
 
     for (const ext of extensions) {
-      const extDict = ext[extProp];
       let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
-      for (const name in extDict) {
-        const elemExt = extDict[name];
+      forEachGeneric(ext, extProp, (elemExt, name) => {
         if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
-          continue;             // definitions inside extend, already handled
+          return;             // definitions inside extend, already handled
         dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
         const elem = artDict[name] || annotateFor( art, extProp, name );
         setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
-        pushToDict( elem, '_extensions', elemExt );
-      }
+        ensureArtifactNotProcessed( elem );
+        if (elem.$duplicates !== true)
+          pushToDict( elem, '_extensions', elemExt );
+      });
     }
   }
 
@@ -729,10 +797,11 @@ function extend( model ) {
     const dict = parent[prop];
     if (!dict) {
       // TODO: check - for each name? - better locations
-      const location = ext._parent[prop][$location] || ext.name.location;
+      const location = ext._parent[prop]?.[$location] || ext.name.location;
       // Remark: no `elements` dict location with `annotate Main:elem`
       switch (prop) {
         // TODO: change texts, somehow similar to checkDefinitions() ?
+        case 'foreignKeys':
         case 'elements':
         case 'enum':            // TODO: extra?
           warning( 'anno-unexpected-elements', [ location, ext._parent ],
@@ -778,6 +847,10 @@ function extend( model ) {
                     { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
                     parent.enum );
           break;
+        case 'foreignKeys':
+          notFound( 'ext-undefined-key', ext.name.location, ext,
+                    { name }, parent.foreignKeys );
+          break;
         case 'params':
           notFound( 'ext-undefined-param', ext.name.location, ext,
                     { '#': 'param', art: parent, name },
@@ -791,7 +864,8 @@ function extend( model ) {
                     parent.actions );
           break;
         default:
-          // assert
+          if (model.options.testMode)
+            throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
       }
     }
     return true;
@@ -832,8 +906,9 @@ function extend( model ) {
   }
 
   function checkRemainingMainExtensions( art, ext, localized ) {
+    const isExtend = ext.kind === 'extend';
     if (localized) {
-      if (isV5preview && ext.kind === 'extend') {
+      if (isExtend) {
         // In v5, reject any `extend` on localized.
         error( 'ref-undefined-art', [ ext.location || ext.name.location, ext ],
                { '#': 'localized', keyword: 'annotate' } );
@@ -847,22 +922,21 @@ function extend( model ) {
     if (art?.builtin) {
       info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
     }
-    else if (art?.kind === 'namespace') {
+    else if (isExtend && art?.kind === 'namespace') {
+      // `annotate` on namespaces already handled before
       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' );
-        }
+      // Because "namespaces" are the same as "unknown" artifacts in CSN, we don't report
+      // an error for `annotate`s.
+      // FIXME: The compiler generates empty `annotate` statements for
+      //        `extend ns with definitions {…}`. That's why we check the frontend.
+      if (hasAnnotations || (!ext.artifacts && ext._block.$frontend !== 'json')) {
+        error( 'ref-undefined-art', [ (firstAnno?.name || ext.name).location, ext ], {
+          '#': 'namespace', art: ext,
+        } );
       }
     }
   }
@@ -1101,7 +1175,6 @@ function extend( model ) {
                  { art: artName },
                  {
                    std: 'Unknown $(ART) - nothing to extend',
-                   // eslint-disable-next-line max-len
                    element: 'Artifact $(ART) has no element or enum $(MEMBER) - nothing to extend',
                    action: 'Artifact $(ART) has no action $(MEMBER) - nothing to extend',
                  } );
@@ -1232,7 +1305,7 @@ function extend( model ) {
           if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );
           elem.$inferred = 'include';
-          if (origin.masked)    // TODO(v5): remove 'masked'
+          if (origin.masked)    // TODO(v6): remove 'masked'
             elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
           if (origin.key)
             elem.key = Object.assign( { $inferred: 'include' }, origin.key );
@@ -1269,8 +1342,6 @@ function extend( model ) {
   /**
    * Report duplicates in parent[prop] that happen due to multiple includes having the
    * same member.  Covers `entity G : E, G {};` but not `entity G : E {};  extend G with F;`.
-   *
-   * TODO(v5): Make this a hard error; see checkRedefinition(); maybe combine both;
    */
   function checkRedefinitionThroughIncludes( parent, prop ) {
     if (!parent[prop])

package/lib/compiler/generate.js

@@ -656,7 +656,7 @@ function generate( model ) {
 
     if (elem.type && !isDirectComposition( elem )) {
       // Only issue warning for direct usages, not for projections, includes, etc.
-      // TODO: Make it configurable error; v5: error
+      // TODO: Make it configurable error; v6: error
       // TODO: move to resolve.js where we test the targetAspect,
       warning( 'type-expecting-composition', [ elem.type.location, elem ],
                { newcode: 'Composition of', code: 'Association to' },

package/lib/compiler/index.js

@@ -34,7 +34,7 @@ const { Location, emptyWeakLocation } = require('../base/location');
 const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
 const { checkRemovedDeprecatedFlags } = require('../base/model');
 const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
-const { cdsFs } = require('../utils/file');
+const { cdsFs, fileExtension } = require('../utils/file');
 
 const fs = require('fs');
 const path = require('path');
@@ -82,12 +82,8 @@ class ArgumentError extends Error {
 function parseX( source, filename, options = {}, messageFunctions = null ) {
   if (!messageFunctions)
     messageFunctions = createMessageFunctions( options, 'parse' );
-  const ext = path.extname( filename ).slice(1).toLowerCase();
-  // eslint-disable-next-line no-nested-ternary
-  const parser = options.fallbackParser === 'auto!'
-    ? (source?.startsWith( '{' ) ? parseCsn.parse : parseLanguage)
-    : (extensionParsers[ext] || extensionParsers[options.fallbackParser] ||
-       source.startsWith( '{' ) && parseCsn.parse);
+  const ext = fileExtension( filename );
+  const parser = parserForFile( source, ext, options );
   if (parser)
     return parser( source, filename, options, messageFunctions );
 
@@ -101,6 +97,27 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
   return model;
 }
 
+/**
+ * Get the correct parser for the given source / file extension.
+ * Respects the set fallback parser.
+ *
+ * @param {string} source
+ * @param {string} ext
+ * @param {object} options
+ */
+function parserForFile( source, ext, options ) {
+  // 'auto!' ignores the file's extension
+  if (options.fallbackParser === 'auto!')
+    return (source?.startsWith( '{' ) ? parseCsn.parse : parseLanguage);
+
+  if (options.fallbackParser === 'csn!')
+    return parseCsn.parse;
+
+  return extensionParsers[ext] ||
+    extensionParsers[options.fallbackParser] ||
+    (source.startsWith( '{' ) && parseCsn.parse);
+}
+
 // Main function: Compile the sources from the files given by the array of
 // `filenames`.  As usual with the `fs` library, relative file names are
 // relative to the working directory `process.cwd()`.  With argument `dir`, the
@@ -149,10 +166,10 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
     .then( () => promiseAllDoNotRejectImmediately( input.files.map( readAndParse ) ) )
     .then( testInvocation, (reason) => {
       // do not reject with PromiseAllError, use InvocationError:
-      const errs = reason.valuesOrErrors.filter( e => e instanceof Error );
+      const errs = reason.valuesOrErrors?.filter( e => e instanceof Error ) || [ reason ];
       // internal error if no file IO error (has property `path`)
       return Promise.reject( errs.find( e => !e.path ) ||
-                             new InvocationError( [ ...input.repeated, ...errs ]) );
+                             new InvocationError( [ ...(input?.repeated || []), ...errs ]) );
     } );
 
   if (!options.parseOnly && !options.parseCdl)
@@ -530,7 +547,7 @@ function processFilenamesSync( filenames, dir ) {
       // already handles non-existent files.
       name = fs.realpathSync.native( name );
     }
-    catch (e) {
+    catch {
       // Ignore the not-found (ENOENT) error
     }
     filenameMap[originalName] = name;