@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/compiler/define.js

@@ -119,7 +119,11 @@
 
 'use strict';
 
-const { forEachGeneric, forEachInOrder, isBetaEnabled } = require('../base/model');
+const {
+  forEachGeneric,
+  forEachInOrder,
+  forEachMember,
+} = require('../base/model');
 const shuffleGen = require('../base/shuffle');
 const {
   dictAdd, dictAddArray, dictForEach, pushToDict,
@@ -132,7 +136,6 @@ const {
   dependsOnSilent,
   pathName,
   splitIntoPath,
-  annotationHasEllipsis,
   isDirectComposition,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
@@ -160,19 +163,15 @@ function define( model ) {
   } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
-    checkAnnotate,
   } = model.$functions;
   const { shuffleDict, shuffleArray } = shuffleGen( options.testMode );
 
-  const extensionsDict = Object.create(null);
   Object.assign( model.$functions, {
     shuffleDict,
     shuffleArray,
     initArtifact,
     initMembers,
-    extensionsDict,             // a dictionary - TODO: put directly into model?
-    checkDefinitions,
-    initAnnotations,
+    checkDefinitions,           // TODO: remove
   } );
   // During the definer, we can only resolve artifact references, i.e,
   // after a `.`, we only search in the `_subArtifacts` dictionary:
@@ -202,7 +201,7 @@ function define( model ) {
     setLink( model, '_entities', [] ); // for entities with includes
     model.$entity = 0;
     model.$compositionTargets = Object.create(null);
-    model.$lateExtensions = Object.create(null); // for generated artifacts
+    model.$lateExtensions = Object.create(null); // TODO: rename to $collectedExtensions
 
     initBuiltins( model );
     const sourceNames = shuffleArray( Object.keys( model.sources ) );
@@ -212,7 +211,7 @@ function define( model ) {
       initNamespaceAndUsing( model.sources[name] );
     dictForEach( model.definitions, initArtifact );
     dictForEach( model.vocabularies, initVocabulary );
-    dictForEach( extensionsDict, initExtension );
+    dictForEach( model.$lateExtensions, e => e._extensions.forEach( initExtension ) );
 
     addI18nBlocks();
   }
@@ -398,19 +397,52 @@ function define( model ) {
       return;
     delete ext.name.path[0]._artifact; // might point to wrong JS object in phase 1
     ext.name.absolute = absolute; // definition might not be there yet, no _artifact link
-    pushToDict( extensionsDict, absolute, ext );
+    const location = { file: '' }; // stupid required location
+    const late = model.$lateExtensions[absolute] ||
+          (model.$lateExtensions[absolute] = {
+            kind: 'annotate',
+            name: { absolute, location },
+            $inferred: '',
+            location,
+          });
+    pushToDict( late, '_extensions', ext );
     if (!ext.artifacts)
       return;
+
     // Directly add the artifacts of context and service extension:
     if (!model.$blocks)
       model.$blocks = Object.create( null );
     // Set block number for debugging (--raw-output):
     // eslint-disable-next-line no-multi-assign
     ext.name.select = model.$blocks[absolute] = (model.$blocks[absolute] || 0) + 1;
+    // add "namespace" for the case that ext.artifacts is empty (TODO: later)
+    // now add all definitions in ext.artifacts:
     const prefix = `${ absolute }.`;
     dictForEach( ext.artifacts, a => addArtifact( a, ext, prefix ) );
   }
 
+  function initExtension( parent ) {
+    forEachMember( parent, function init( sub ) {
+      if (sub.kind !== 'extend' && sub.kind !== 'annotate')
+        return;                 // for defs inside, set somewhere else - TODO: rethink
+      setLink( sub, '_block', parent._block );
+      setLink( sub, '_parent', parent );
+      setLink( sub, '_main', parent._main || parent );
+      initExtension( sub );
+    } );
+    if (parent.kind !== 'extend')
+      return;
+    if (parent.columns)            // TODO: sub queries? expand/inline?
+      parent.columns.forEach( c => setLink( c, '_block', parent._block ) );
+    if (parent.scale && !parent.precision) {
+      // TODO: where could we store the location of the name?
+      error( 'syntax-missing-type-property', [ parent.scale.location ],
+             { prop: 'scale', otherprop: 'precision' },
+             'Type extension with property $(PROP) must also have property $(OTHERPROP)' );
+      parent.scale = undefined; // no consequential error
+    }
+  }
+
   function addVocabulary( vocab, block, prefix ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
@@ -534,13 +566,10 @@ function define( model ) {
       initArtifactParentLink( art, model.definitions );
     const block = art._block;
     checkRedefinition( art );
-    initAnnotations( art, block );
     initMembers( art, art, block );
     initDollarSelf( art );      // $self
     if (art.params)
       initDollarParameters( art );
-    if (art.includes && !(art.name.absolute in extensionsDict)) // TODO: in next phase?
-      extensionsDict[art.name.absolute] = []; // structure with includes must be "extended"
 
     if (!art.query)
       return;
@@ -548,6 +577,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
@@ -560,7 +590,6 @@ function define( model ) {
     initArtifactParentLink( art, model.vocabularies );
     checkRedefinition( art );
     const block = art._block;
-    initAnnotations( art, block );
     initMembers( art, art, block );
   }
 
@@ -586,57 +615,6 @@ function define( model ) {
       parent._subArtifacts[absolute.substring( dot + 1 )] = art; // not dictAdd()
   }
 
-  /** Initialize the extension `ext`.
-   *
-   * Currently:
-   *
-   *  - initialize annotations (set _block, $priority, `...` check) on "main"
-   *    extension and its columns do more later
-   *  - for members in compile(): init annotations via extendMembers/annotateMembers
-   *  - for members in parse.cdl(): init annotation via initMembers
-   *
-   * In the future (after name cleanup):
-   *
-   *  - also initialize members and member extensions/annotations here
-   *  - we might also do other things, like calculating whether an `extend` is
-   *    `annotate`-like, i.e. only contains name-resolution irrelevant extensions.
-   */
-  function initExtension( ext ) {
-    const block = ext._block;
-    initAnnotations( ext, block, ext.kind );
-    if (ext.columns)            // the columns themselves are "definitions"
-      ext.columns.forEach( col => initAnnotations( col, block ) );
-  }
-
-  // Set _block links for annotations (necessary for layering) and do a late
-  // syntax check (`...` only with extensions, not definitions).
-  // extKind is either ext.kind (=art is extension) or false (=art is not an extension)
-  function initAnnotations( art, block, extKind = false ) {
-    // TODO: think of removing $priority, then
-    // no _block: define, _block: annotate/extend/edmx
-    // would fit with extending defs with props like length
-    for (const prop in art) {
-      if (prop.charAt(0) === '@' || prop === 'doc') {
-        const anno = art[prop];
-        // TODO: make anno never be an array, see addAnnotation() in genericAntlrParser
-        if (Array.isArray( anno ))
-          anno.forEach( init );
-        else
-          init( anno );
-      }
-    }
-    return;
-
-    function init( anno ) {
-      setLink( anno, '_block', block );
-      anno.$priority = extKind;
-      if (!extKind && annotationHasEllipsis( anno )) {
-        error( 'anno-unexpected-ellipsis',
-               [ anno.name.location, art ], { code: '...' } );
-      }
-    }
-  }
-
   // Init special things: -------------------------------------------------------
 
   function initDollarSelf( art ) {
@@ -708,7 +686,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,15 +747,16 @@ 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) {
-        error( 'query-req-alias', [ table.location, query ], {}, // TODO: not subquery.location ?
-               'Table alias is required for this subquery' );
-        return;
+      if (!table.name?.id) {
+        // We don't worry about duplicate names here.
+        const id = `$_select_${ query._main.$queries.length + 1 }__`;
+        table.name = { id, location: table.location, $inferred: '$internal' };
+        table.$inferred = '$internal';
       }
       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 ) );
     }
@@ -823,8 +801,15 @@ function define( model ) {
       table.kind = '$tableAlias';
       setMemberParent( table, table.name.id, query );
       setLink( table, '_block', query._block );
-      dictAdd( query.$tableAliases, table.name.id, table, ( name, loc ) => {
-        error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
+      dictAdd( query.$tableAliases, table.name.id, table, ( name, loc, tableAlias ) => {
+        if (tableAlias.$inferred === '$internal') {
+          const semanticLoc = tableAlias.query?.name ? tableAlias.query : tableAlias;
+          error( 'name-missing-alias', [ tableAlias.location, semanticLoc ],
+                 { '#': 'duplicate', code: 'as ‹alias›' });
+        }
+        else {
+          error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
+        }
       } );
       // also add to JOIN nodes for name restrictions:
       for (const p of joinParents) {
@@ -832,7 +817,7 @@ function define( model ) {
         // already used for duplicate aliases of queries:
         dictAddArray( p.$tableAliases, table.name.id, table );
       }
-      if (table.name.id[0] === '$') {
+      if (table.name?.id[0] === '$' && table.name.$inferred !== '$internal') {
         warning( 'name-invalid-dollar-alias', [ table.name.location, table ], {
           '#': (table.name.$inferred ? '$tableImplicit' : '$tableAlias'),
           name: '$',
@@ -935,7 +920,6 @@ function define( model ) {
       // Either expression (value), expand or new association (target && type)
       else if (col.value || col.expand || (col.target && col.type)) {
         setLink( col, '_block', parent._block );
-        initAnnotations( col, parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
             warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
@@ -1010,12 +994,14 @@ function define( model ) {
    *
    * If not for extensions: construct === parent
    *
+   * Param `initExtensions` is for parse.cdl - TODO delete
+   *
    * 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 +1029,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 +1050,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 +1078,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 +1128,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,9 +1151,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'))
         initBoundSelfParam( elem.params );
@@ -1174,31 +1161,11 @@ 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' };
       }
+      elem.$syntax = 'calc';
     }
   }