@sap/cds-compiler 4.9.2 → 5.0.6

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');
@@ -30,7 +30,7 @@ const { Location } = require('../base/location');
 
 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 +59,7 @@ function extend( model ) {
     resolvePath,
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
+    resolveDefinitionName,
     attachAndEmitValidNames,
     initMembers,
     initSelectItems,
@@ -72,7 +73,6 @@ function extend( model ) {
   } );
 
   const includesNonShadowedFirst = isDeprecatedEnabled( model.options, 'includesNonShadowedFirst' );
-  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
 
   sortModelSources();
   const extensionsDict = Object.create( null ); // TODO TMP
@@ -161,6 +161,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 +172,35 @@ 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.foreignKeys && 'foreignKeys' || 'elements';
+      moveDictExtensions( art, extensionsMap, elementsProp, 'elements' );
       moveDictExtensions( art, extensionsMap, 'enum' );
     }
   }
 
+  /**
+   * 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.
+   */
+  function ensureArtifactNotProcessed( art ) {
+    if (!model.options.testMode)
+      return;
+
+    if (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 +216,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 +254,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',
@@ -393,6 +423,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 } );
@@ -490,7 +523,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 +573,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])
@@ -617,17 +650,17 @@ function extend( model ) {
     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 );
+      });
     }
   }
 
@@ -778,6 +811,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 +828,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 +870,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 +886,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 +1139,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 +1269,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 +1306,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

@@ -83,11 +83,7 @@ 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 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
@@ -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;