@sap/cds-compiler 5.6.0 → 5.7.0

package/lib/compiler/resolve.js

@@ -82,7 +82,7 @@ const expWithFilter = [ 'from', 'expand', 'inline' ];
 // exception in case of an error, but push the corresponding error object to
 // that property (should be a vector).
 function resolve( model ) {
-  // const { options } = model;
+  const { options } = model;
   // Get shared functionality and the message function:
   const {
     info, warning, error, message,
@@ -90,6 +90,7 @@ function resolve( model ) {
   const {
     resolvePath,
     resolveDefinitionName,
+    attachAndEmitValidNames,
     traverseExpr,
     effectiveType,
     getOrigin,
@@ -103,7 +104,7 @@ function resolve( model ) {
   } );
 
   const ignoreSpecifiedElements
-    = isDeprecatedEnabled( model.options, 'ignoreSpecifiedQueryElements' );
+    = isDeprecatedEnabled( options, 'ignoreSpecifiedQueryElements' );
 
   return doResolve();
 
@@ -127,7 +128,7 @@ function resolve( model ) {
     // Phase 4: resolve all artifacts:
     forEachDefinition( model, resolveRefs );
     forEachGeneric( model, 'vocabularies', resolveRefs );
-    if (model.options.lspMode) {
+    if (options.lspMode) {
       for (const name in model.sources)
         resolveDefinitionName( model.sources[name].namespace );
     }
@@ -405,7 +406,7 @@ 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)
+    if (options.lspMode && art.name && !art._main)
       resolveDefinitionName( art );
 
     // Check KEY (TODO: make this an extra function)
@@ -551,9 +552,11 @@ function resolve( model ) {
       addForeignKeyNavigations( art );
     }
 
-    resolveExpr( art.default, 'default', art );
+    resolveExprWithEnum( art.default, 'default', art );
+
     // TODO: distinguish not by $syntax (it is semantics), but whether in query
-    resolveExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
+    const valueCtx = (art.$syntax === 'calc') ? 'calc' : 'column';
+    resolveExprWithEnum( art.value, valueCtx, art );
     if (art.type?.$inferred === 'cast')
       inferTypePropertiesFromCast( art );
     if (art.value) {
@@ -612,7 +615,7 @@ function resolve( model ) {
       // If specified type is `null`, type could not be resolved.
       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)) {
+        (!options.$recompile || sType !== iType.type?._artifact)) {
         const typeName = !iTypeArt && 'typeExtra' ||  // no inferred type prop
           iType?.name && sType?.name && 'typeName' || // both types are named
           'type';                                     // unknown type names
@@ -1391,8 +1394,13 @@ function resolve( model ) {
 
   function resolveExprInAnnotations( art ) {
     for (const anno in art) {
-      if (anno.charAt(0) === '@')
+      if (anno.charAt(0) === '@') {
+        const { name } = art[anno];
+        const annoDef = model.vocabularies?.[name.id];
+        if (annoDef)
+          setLink( name, '_artifact', annoDef );
         resolveAnnoExpr( art[anno], art );
+      }
     }
   }
 
@@ -1400,7 +1408,7 @@ function resolve( model ) {
     if (expr.$tokenTexts) {
       if (!anno.kind)
         initAnnotationForExpression( anno, art );
-      resolveExpr( expr, 'annotation', anno );
+      resolveExprWithEnum( expr, 'annotation', anno );
     }
     else if (expr.literal === 'array') {
       expr.val.forEach( val => resolveAnnoExpr( val, art, anno ) );
@@ -1428,6 +1436,34 @@ 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 );
   }

package/lib/compiler/shared.js

@@ -1172,6 +1172,7 @@ function fns( model ) {
       // TODO: if it becomes non-configurable, we can omit this warning
       let id = pathName( path );
       let head = path[0]._artifact || { _parent: art };
+      // eslint-disable-next-line sonarjs/no-nested-assignment
       while ((head = head?._parent) && head.kind === 'builtin')
         id = `${ head.name.id }.${ id }`;
       const msgId = (art.$uncheckedElements) ? 'ref-unknown-var' : 'ref-undefined-var';

package/lib/edm/annotations/edmJson.js

@@ -538,8 +538,8 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                   }
                   else {
                     const facetVal = facetArg.args[0].val;
-                    const isNaN = Number.isNaN(Number.parseInt(facetVal, 10));
-                    if (isNaN && options.isV4() && facetName === 'Scale' && facetVal !== 'variable') {
+                    const isNan = Number.isNaN(Number.parseInt(facetVal, 10));
+                    if (isNan && options.isV4() && facetName === 'Scale' && facetVal !== 'variable') {
                       error('odata-anno-xpr-args', location, {
                         anno,
                         op: `${facetFuncName}(…)`,
@@ -548,7 +548,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions ) {
                         '#': 'wrongval_meta_list',
                       });
                     }
-                    else if (isNaN && facetName !== 'Scale') {
+                    else if (isNan && facetName !== 'Scale') {
                       error('odata-anno-xpr-args', location, {
                         anno, op: `${facetFuncName}(…)`, meta: 'number', '#': 'wrongval_meta',
                       });

package/lib/edm/annotations/genericTranslation.js

@@ -64,7 +64,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   // Crawl over the csn and trigger the annotation translation for all kinds
   //   of annotated things.
   // Note: only works for single service
-  // Note: we assume that all objects ly flat in the service, i.e. objName always
+  // Note: we assume that all objects lie flat in the service, i.e. objName always
   //       looks like <service name, can contain dots>.<id>
   forEachDefinition(reqDefs, (def, defName) => {
     if (defName === serviceName || defName.startsWith(`${serviceName}.`)) {
@@ -1345,6 +1345,10 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       //   if DataFieldAbstract is expected and no explicit type is provided, automatically choose DataField
       if (dTypeName === 'UI.DataFieldAbstract')
         actualTypeName = 'UI.DataField';
+      //   if SemanticObjectMappingAbstract is expected and no explicit type
+      //   is provided, automatically choose SemanticObjectMappingType
+      else if (dTypeName === 'Common.SemanticObjectMappingAbstract')
+        actualTypeName = 'Common.SemanticObjectMappingType';
 
       else
         actualTypeName = dTypeName;

package/lib/edm/annotations/vocabularyDefinitions.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /*
-   OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
+   OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/main/vocabularies
    Aggregation (published)
    Authorization (published)
    Capabilities (published)
@@ -12,7 +12,7 @@
    Temporal (published)
    Validation (published)
 
-   SAP: https://github.com/SAP/odata-vocabularies/tree/master/vocabularies
+   SAP: https://github.com/SAP/odata-vocabularies/tree/main/vocabularies
    Analytics (published)
    CodeList (published)
    Common (published)

package/lib/edm/edmUtils.js

@@ -866,8 +866,9 @@ function createSchemaRef( serviceRoots, targetSchemaName ) {
   function path4( def, _path = def['@path'] ) {
     if (_path)
       return _path.replace(/^\//, '');
+    const last = def.name.split('.').at(-1); // > my.very.CatalogService --> CatalogService
     return ( // generate one from the service's name
-      /[^.]+$/.exec(def.name)[0]  // > my.very.CatalogService --> CatalogService
+      last
         .replace(/Service$/, '')     // > CatalogService --> Catalog
         .replace(/([a-z0-9])([A-Z])/g, (_, c, C) => `${c}-${C.toLowerCase()}`)  // > ODataFooBarX9 --> odata-foo-bar-x9
         .replace(/_/g, '-')  // > foo_bar_baz --> foo-bar-baz

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.1.19
+// Base class for generated parser, for redepage v0.2.1
 
 'use strict';
 
@@ -263,6 +263,8 @@ class BaseParser {
     if (this.tokenIdx === this.fixKeywordTokenIdx)
       return this.e();
     const la = this.tokens[this.tokenIdx];
+    // TODO: consider this like a failed condition? Will be relevant if we try
+    // different error recovery possibilities.
     if (this.keywords[la.keyword])
       this.reportReservedWord_();
     // with error recovery: use that (consider this having a good score)
@@ -314,7 +316,7 @@ class BaseParser {
     }
     // calling the condition might have side effects (precendence conditions have)
     // → call tracing “name” before
-    const fail = !this[cond]( true, arg );
+    const fail = this[cond]( true, arg );
     if (this.constructor.tracingParser)
       this._traceSubPush( !fail );
     // The default case must not have actions. If written in grammar with action,
@@ -334,6 +336,10 @@ class BaseParser {
         this.fixKeywordTokenIdx = this.tokenIdx;
       this.conditionTokenIdx = this.tokenIdx;
       this.conditionStackLength = this.stack.length;
+      this.conditionName = cond;
+      // we also set the failure here, because the reporting might have a
+      // different context (consider immediate exit)
+      this.conditionFailure = fail;
     }
     return !fail || this.g( state ) && false;
   }
@@ -558,7 +564,7 @@ class BaseParser {
     if (!cond || lean && !this.leanConditions[cond])
       return false;
     if (!this.constructor.tracingParser)
-      return !this[cond]( mode, cmd[4] );
+      return !!this[cond]( mode, cmd[4] );
     // TODO: let this[cond]( true ) return recovery badness in error case
     if (!lean) {
       const { traceName } = this[cond];
@@ -566,9 +572,9 @@ class BaseParser {
       // calling the condition might have side effects (precendence conditions have)
       // → call tracing “name” before
     }
-    const fail = !this[cond]( mode, cmd[4] );
-    this._traceSubPush( lean ? { true: 'C✔', false: 'C✖' }[!fail] : !fail );
-    return fail;
+    const succeed = !this[cond]( mode, cmd[4] );
+    this._traceSubPush( lean ? { true: 'C✔', false: 'C✖' }[succeed] : succeed );
+    return !succeed;
   }
 
   _matchesInFollow( type, keyword, mode ) { // mode = E | R
@@ -658,7 +664,7 @@ class BaseParser {
   //   ( <prefer, guard=fail> 'foo' | rule ) with
   //   rule : 'foo' | Id ;
   // doing it already here would list `foo` as expected token
-  _tokenSetInRule( expecting, val, cmd ) {
+  _tokenSetInRule( expecting, val, cmd, collectKeywordsAndIdOnly = false ) {
     const savedDynamic = this.dynamic_;
     const savedState = this.s;
     let enteredRules = 0;
@@ -669,27 +675,19 @@ class BaseParser {
         const dict = cmd;
         for (const prop in dict) {
           if (prop && Object.hasOwn( dict, prop ) && prop !== 'Id' &&
-              !Object.hasOwn( expecting, prop ) && prop.charAt(0) !== ' ') {
-            // TODO: or call this.translateParserToken_ always?
-            // it should then directly set the dictionary -> setTokenInSet_()
-            if (lookahead) {    // yes, independently from ckA()
-              for (const p of this.translateParserToken_( prop, lookahead ))
-                expecting[p] = val;
-            }
-            else {
-              expecting[prop] = val;
-            }
-          }
+              !Object.hasOwn( expecting, prop ) && prop.charAt(0) !== ' ')
+            this.addTokenToSet_( expecting, prop, val, collectKeywordsAndIdOnly, lookahead );
         }
         cmd = dict[''];
         if (dict.Id) {
           // recursive call only if Id branch with non-error default branch
           if (cmd[0] === 'e') {
+            collectKeywordsAndIdOnly = true;
             cmd = dict.Id;
           }
           else {                // Id branch never leads to rule exit:
             this._tracePush( [ '[' ] );
-            this._tokenSetInRule( expecting, val, dict.Id );
+            this._tokenSetInRule( expecting, val, dict.Id, true );
             this._tracePush( [ ']' ] );
           }
         }
@@ -697,10 +695,10 @@ class BaseParser {
       this._traceSubPush( this.s );
       switch (cmd[0]) {
         case 'm': case 'mk':
-          expecting[cmd[2]] ??= val;
+          this.addTokenToSet_( expecting, cmd[2], val, collectKeywordsAndIdOnly );
           break loop;
         case 'ci': case 'ciA': case 'mi': case 'miA':
-          expecting['Id'] ??= val;
+          this.addTokenToSet_( expecting, 'Id', val, false );
           // TODO: should we do s/th special, such that a reserved word is a sync
           // token for Id<all>?  Probably not, see also comment in
            // _findSyncToken()
@@ -731,8 +729,10 @@ class BaseParser {
     return inspectOuterRules;
   }
 
-  translateParserToken_( token ) {
-    return [ token ];
+  // Remark: when called for `Id` token, `collectKeywordsOnly` is `false`
+  addTokenToSet_( set, token, val, collectKeywordsOnly, _lookahead ) {
+    if (!collectKeywordsOnly || /^[_a-z]/.test( token ))
+      set[token] ??= val;
   }
 
   // Error reporting and recovery -----------------------------------------------
@@ -924,37 +924,37 @@ class BaseParser {
   // Predefined conditions with extra option names:
 
   hide_( mode ) {
-    return mode !== 'M';
+    return mode === 'M';
   }
   precLeft_( _test, prec ) {    // <prec=…>, <…,assoc=left>, <…,prefix=once>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec)
-      return false;
+      return true;
     this.prec_ = prec;
-    return true;
+    return false;
   }
   precRight_( _test, prec ) {   // <…,assoc=right>, <…,prefix>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec)
-      return false;
+      return true;
     this.prec_ = prec - 1;
-    return true;
+    return false;
   }
   precNone_( _test, prec ) {    // <…,assoc=none>, <…,postfix=once>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec ||
         this.prec_ != null && this.prec_ <= prec)
-      return false;
+      return true;
     this.prec_ = prec;
-    return true;
+    return false;
   }
   precPost_( _test, prec ) {    // <…,postfix>
     const parentPrec = this.stack.at( -1 ).prec;
     if (parentPrec != null && parentPrec >= prec ||
         this.prec_ != null && this.prec_ < prec)
-      return false;
+      return true;
     this.prec_ = prec;
-    return true;
+    return false;
   }
 }
 const members = BaseParser.prototype;