@sap/cds-compiler 3.6.2 → 3.7.2

package/lib/compiler/define.js

@@ -156,11 +156,10 @@ function define( model ) {
   const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
-    error, warning, info, messages,
+    error, warning, info, message, messages,
   } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
-    checkAnnotate,
   } = model.$functions;
   const { shuffleDict, shuffleArray } = shuffleGen( options.testMode );
 
@@ -548,6 +547,7 @@ function define( model ) {
     setLink( art, '_from', [] ); // for sequence of resolve steps
     if (!setLink( art, '_leadingQuery', initQueryExpression( art.query, art ) ) )
       return;                   // null or undefined in case of parse error
+    // if (art._leadingQuery !== art.$queries [0]) throw Error('FOO');
     setLink( art._leadingQuery, '_$next', art );
     if (art.elements) { // specified element via compilation of client-style CSN
       // TODO: consider this part of a revamped on-demand 'extend' functionality
@@ -595,7 +595,7 @@ function define( model ) {
    *  - for members in compile(): init annotations via extendMembers/annotateMembers
    *  - for members in parse.cdl(): init annotation via initMembers
    *
-   * In the future (after name cleanup):
+   * In the future (after name cleanup): -- TODO --
    *
    *  - also initialize members and member extensions/annotations here
    *  - we might also do other things, like calculating whether an `extend` is
@@ -708,7 +708,6 @@ function define( model ) {
         setLink( self, '_origin', query );
         setLink( self, '_parent', query );
         setLink( self, '_main', query._main );
-        setLink( self, '_effectiveType', query ); // TODO: remove
         query.$tableAliases.$self = self;
         query.$tableAliases.$projection = self;
       }
@@ -770,6 +769,7 @@ function define( model ) {
       // _origin is set when we resolve the ref
       if (query._parent.kind !== 'select')
         query._main._from.push( table ); // store tabref if outside "real" subquery
+      // (tab refs on the right of union are unnecessary)
     }
     else if (table.query) {
       if (!table.name || !table.name.id) {
@@ -778,7 +778,6 @@ function define( model ) {
         return;
       }
       addAsAlias();
-      setLink( table, '_effectiveType', table.query ); // TODO: remove!
       // Store _origin to leading query of table.query for name resolution
       setLink( table, '_origin', initQueryExpression( table.query, table ) );
     }
@@ -1010,12 +1009,14 @@ function define( model ) {
    *
    * If not for extensions: construct === parent
    *
+   * Param `initExtensions` is for parse.cdl
+   *
    * TODO: separate extension!
    */
   function initMembers( construct, parent, block, initExtensions = false ) {
     // TODO: split extend from init
     const main = parent._main || parent;
-    const isQueryExtension = kindProperties[construct.kind].isExtension && main.query;
+    const isQueryExtension = construct.kind === 'extend' && main.query;
     let obj = construct;
     let { items } = obj;
     while (items) {
@@ -1043,46 +1044,8 @@ function define( model ) {
                'A managed aspect composition can\'t have a specified ON-condition' );
         delete obj.on;          // continuation semantics: not specified
       }
-      if (targetAspect.elements) {
-        // TODO: main?
-        const inEntity = parent._main && parent._main.kind === 'entity';
-        // TODO: also allow indirectly (component in component in entity)?
-        setLink( targetAspect, '_outer', obj );
-        setLink( targetAspect, '_parent', parent._parent );
-        setLink( targetAspect, '_main', null ); // for name resolution
-
-        parent = targetAspect;
-        construct = parent;     // avoid extension behavior
-        targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
-        setLink( targetAspect, '_block', block );
-        initDollarSelf( targetAspect );
-        // allow ref of up_ in anonymous aspect inside entity
-        // (TODO: complain if used and the managed composition is included into
-        // another entity - might induce auto-redirection):
-        if (inEntity && !targetAspect.elements.up_) {
-          const up = {
-            name: {
-              id: 'up_',
-              alias: 'up_',
-              element: obj.name.element,
-              absolute: obj.name.absolute,
-            },
-            kind: '$navElement',
-            location: obj.location,
-          };
-          setLink( up, '_parent', targetAspect );
-          setLink( up, '_main', targetAspect ); // used on main artifact
-          // recompilation case: both target and targetAspect → allow up_ in that case, too:
-          const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
-          const entity = name && model.definitions[name];
-          if (entity && entity.elements)
-            setLink( up, '_origin', entity.elements.up_ );
-          // processAspectComposition/expand() sets _origin to element of
-          // generated target entity
-          targetAspect.$tableAliases.up_ = up;
-        }
-        obj = targetAspect;
-      }
+      if (targetAspect.elements)
+        initAnonymousAspect();
     }
     if (obj !== parent && obj.elements && parent.enum) { // applying the extension
       initElementsAsEnum();
@@ -1102,7 +1065,8 @@ function define( model ) {
       forEachInOrder( construct, 'params', init );
     const { returns } = construct;
     if (returns) {
-      returns.kind = (kindProperties[construct.kind].isExtension) ? construct.kind : 'param';
+      const { kind } = construct;
+      returns.kind = (kind === 'extend' || kind === 'annotate') ? kind : 'param';
       init( returns, '' );      // '' is special name for returns parameter
     }
     return;
@@ -1129,6 +1093,47 @@ function define( model ) {
       forEachGeneric( { enum: obj.elements }, 'enum', init );
     }
 
+    function initAnonymousAspect() {
+      // TODO: main?
+      const inEntity = parent._main && parent._main.kind === 'entity';
+      // TODO: also allow indirectly (component in component in entity)?
+      setLink( targetAspect, '_outer', obj );
+      setLink( targetAspect, '_parent', parent._parent );
+      setLink( targetAspect, '_main', null ); // for name resolution
+
+      parent = targetAspect;
+      construct = parent;     // avoid extension behavior
+      targetAspect.kind = 'aspect';   // TODO: probably '$aspect' to detect
+      setLink( targetAspect, '_block', block );
+      initDollarSelf( targetAspect );
+      // allow ref of up_ in anonymous aspect inside entity
+      // (TODO: complain if used and the managed composition is included into
+      // another entity - might induce auto-redirection):
+      if (inEntity && !targetAspect.elements.up_) {
+        const up = {
+          name: {
+            id: 'up_',
+            alias: 'up_',
+            element: obj.name.element,
+            absolute: obj.name.absolute,
+          },
+          kind: '$navElement',
+          location: obj.location,
+        };
+        setLink( up, '_parent', targetAspect );
+        setLink( up, '_main', targetAspect ); // used on main artifact
+        // recompilation case: both target and targetAspect → allow up_ in that case, too:
+        const name = obj.target && resolveUncheckedPath( obj.target, 'target', obj );
+        const entity = name && model.definitions[name];
+        if (entity && entity.elements)
+          setLink( up, '_origin', entity.elements.up_ );
+        // processAspectComposition/expand() sets _origin to element of
+        // generated target entity
+        targetAspect.$tableAliases.up_ = up;
+      }
+      obj = targetAspect;
+    }
+
     function init( elem, name, prop ) {
       if (!elem.kind)           // wrong CSN input
         elem.kind = dictKinds[prop];
@@ -1138,12 +1143,12 @@ function define( model ) {
           elem.name = Object.assign( { $inferred: 'as' },
                                      ref.path[ref.path.length - 1] );
         }
-        else {                  // if JSON parser misses to set name
+        else {                  // RETURNS, parser robustness
           elem.name = { id: name, location: elem.location };
         }
       }
       // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
-      if (kindProperties[elem.kind].isExtension && !initExtensions) {
+      if ((elem.kind === 'extend' || elem.kind === 'annotate') && !initExtensions) {
         storeExtension( elem, name, prop, parent, block );
         return;
       }
@@ -1161,8 +1166,6 @@ function define( model ) {
       setMemberParent( elem, name, parent, add && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );
-      if (elem.kind === 'annotate' || elem.kind === 'extend')
-        checkAnnotate( elem, elem );
       initAnnotations( elem, bl );
       initMembers( elem, elem, bl, initExtensions );
       if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
@@ -1174,31 +1177,16 @@ function define( model ) {
           elem.$syntax === 'enum' && parent.kind === 'extend') // ambiguous in parse-cdl
         return;
       // -> it's a calculated element
-      checkCalculatedElement(elem);
-      elem.$syntax = 'calc';
-    }
-  }
-
-  function checkCalculatedElement( elem ) {
-    const loc = [ elem.value.location, elem ];
-    if (elem._main.kind !== 'entity' && elem._main.kind !== 'aspect' &&
-        elem._main.kind !== 'extend') {
-      error( 'syntax-invalid-calc-elem', loc, { '#': elem._main.kind } );
-    }
-    else if (!isBetaEnabled( options, 'calculatedElements' )) {
-      error( 'def-unsupported-calc-elem', loc,
-             'Calculated elements are not supported' );
-    }
-    else {
-      const noTruthyAllowed = [ 'localized', 'key', 'virtual' ];
-      for (const prop of noTruthyAllowed) {
-        if (elem[prop]?.val) {
-          // probably better than a parse error (which is good for DEFAULT vs calc),
-          // also appears with parse-cdl:
-          error('syntax-invalid-calc-elem', loc, { '#': prop });
-          return; // one error is enough
-        }
+      if (!elem.type && elem.value?.type) {  // top-level CAST( expr AS type )
+        if (!elem.target)
+          elem.type = { ...elem.value.type, $inferred: 'cast' };
       }
+      if (!isBetaEnabled( options, 'calculatedElements' )) {
+        const loc = [ elem.value.location, elem ];
+        // TODO: this could be considered a syntax check
+        message( 'def-unsupported-calc-elem', loc, { '#': 'std' } );
+      }
+      elem.$syntax = 'calc';
     }
   }