@sap/cds-compiler 3.7.2 → 3.8.2

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');
@@ -156,22 +159,19 @@ function define( model ) {
   const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
-    error, warning, info, message, messages,
+    error, warning, info, messages,
   } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
   } = 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:
@@ -201,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 ) );
@@ -211,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();
   }
@@ -397,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;
@@ -533,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;
@@ -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): -- TODO --
-   *
-   *  - 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 ) {
@@ -772,10 +750,11 @@ function define( model ) {
       // (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();
       // Store _origin to leading query of table.query for name resolution
@@ -822,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) {
@@ -831,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: '$',
@@ -934,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 ],
@@ -1009,7 +994,7 @@ function define( model ) {
    *
    * If not for extensions: construct === parent
    *
-   * Param `initExtensions` is for parse.cdl
+   * Param `initExtensions` is for parse.cdl - TODO delete
    *
    * TODO: separate extension!
    */
@@ -1166,7 +1151,6 @@ function define( model ) {
       setMemberParent( elem, name, parent, add && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );
-      initAnnotations( elem, bl );
       initMembers( elem, elem, bl, initExtensions );
       if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
         initBoundSelfParam( elem.params );
@@ -1181,11 +1165,6 @@ function define( model ) {
         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';
     }
   }