@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/compiler/definer.js

@@ -88,7 +88,7 @@
 // Sub Phase 2 (initXYZ)
 //  - set _parent, _main (later: _service?) links, and _block links of members
 //  - add _subArtifacts dictionary and "namespace artifacts" for name resolution
-//  - duplicate checks (TODO - currently via preProcessArtifact in definer)
+//  - duplicate checks
 //  - structure checks ?
 //  - annotation assignments
 //  - POST: resolvePath() can be called for artifact references (if complete model)
@@ -101,19 +101,19 @@
 //    to avoid consequential or repeated errors.
 //  - But: The same artifact is added to multiple dictionaries.
 //  - Solution part 1: $duplicates as property of the artifact or member
-//    for 'definitions', '_artifacts' and member dictionaries.
-//  - Solution part 2: array value in dictionary for duplicates in CDL 'artifacts'
-//    dictionary, also used for `_combined` in query search dictionary.
+//    for `definitions`, `_artifacts`, member dictionaries, `vocabulary`
+//    dictionary of the whole model, `$tableAliases` dictionary of queries.
+//  - Solution part 2: array value in dictionary for duplicates in CDL `artifacts`
+//    dictionary, `_combined` dictionary for query search, `$tableAliases`
+//    of JOIN restrictions, `vocabulary` dictionary of a CDL input source.
 
 'use strict';
 
-const {
-  makeMessageFunction, searchName, weakLocation,
-} = require('../base/messages');
+const { searchName, weakLocation } = require('../base/messages');
 const {
   isDeprecatedEnabled, isBetaEnabled,
   setProp, forEachGeneric, forEachInOrder,
-  forEachMember, forEachDefinition,
+  forEachDefinition,
   forEachMemberRecursivelyWithQuery,
 } = require('../base/model');
 const {
@@ -122,20 +122,20 @@ const {
 const {
   dictLocation,
 } = require('../base/location');
+const { kindProperties, dictKinds } = require('./base');
 const {
-  annotationVal, annotationIsFalse, annotateWith,
-} = require('./utils');
-const {
-  dictKinds,
-  kindProperties,
-  fns,
+  annotationVal,
+  annotationIsFalse,
+  annotateWith,
   linkToOrigin,
   setMemberParent,
   storeExtension,
   dependsOnSilent,
-} = require('./shared');
+  augmentPath,
+  splitIntoPath,
+} = require('./utils');
 const { compareLayer, layer } = require('./moduleLayers');
-const { initBuiltins } = require('./builtins');
+const { initBuiltins, isInReservedNamespace } = require('./builtins');
 const setLink = setProp;
 
 /**
@@ -150,36 +150,41 @@ const setLink = setProp;
  *
  * @param {XSN.Model} model Model with `sources` property that contain AST-like CSNs.
  */
-function getDefinerFunctions( model ) {
+function define( model ) {
   const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
     message, error, warning, info, messages,
-  } = makeMessageFunction( model, model.options, 'compile' );
+  } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
     resolvePath,
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model );
-  const extensionsDict = Object.create(null);
-  let addTextsLanguageAssoc = false;
-
-  return {
-    define,
+  } = model.$functions;
+  Object.assign( model.$functions, {
     initArtifact,
     lateExtensions,
     projectionAncestor,
     hasTruthyProp,
+  } );
+  // During the definer, we can only resolve artifact references, i.e,
+  // after a `.`, we only search in the `_subArtifacts` dictionary:
+  model.$volatileFunctions.environment = function artifactsEnv( art ) {
+    return art._subArtifacts || Object.create(null);
   };
 
+  const extensionsDict = Object.create(null);
+  let addTextsLanguageAssoc = false;
+  return doDefine();
+
   /**
    * Main function of the definer.
    *
    * @returns {XSN.Model}
    */
-  function define() {
+  function doDefine() {
     if (options.deprecated &&
         messages.every( m => m.messageId !== 'api-deprecated-option' )) {
       warning( 'api-deprecated-option', {},
@@ -206,10 +211,8 @@ function getDefinerFunctions( model ) {
 
     mergeI18nBlocks( model );
 
-    if (model.options && model.options.parseCdl) {
+    if (options.parseCdl) {
       initExtensionsWithoutApplying();
-      // Check for redefinitions
-      Object.keys( model.definitions ).forEach( preProcessArtifact );
       // If no extensions shall be applied then we can skip further
       // artifact processing and return the model with an `extensions` property.
       return model;
@@ -217,8 +220,8 @@ function getDefinerFunctions( model ) {
 
     applyExtensions();
 
-    Object.keys( model.definitions ).forEach( preProcessArtifact );
-    const commonLanguagesEntity = isBetaEnabled( options, 'addTextsLanguageAssoc' ) &&
+    const commonLanguagesEntity // TODO: remove beta after a grace period
+        = (options.addTextsLanguageAssoc || isBetaEnabled( options, 'addTextsLanguageAssoc' )) &&
           model.definitions['sap.common.Languages'];
     addTextsLanguageAssoc = !!(commonLanguagesEntity && commonLanguagesEntity.elements &&
                                commonLanguagesEntity.elements.code);
@@ -239,13 +242,13 @@ function getDefinerFunctions( model ) {
    * @param {XSN.AST} src
    */
   function addSource( src ) {
-    // handle sub model from CSN parser
+    // handle sub model from parser
     if (!src.kind)
       src.kind = 'source';
 
     let namespace = src.namespace && src.namespace.path;
     let prefix = namespace ? `${ pathName( namespace ) }.` : '';
-    if (prefix.startsWith( 'cds.') && !prefix.match(/^cds\.foundation(\.|$)/)) {
+    if (isInReservedNamespace(prefix)) {
       error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -281,8 +284,7 @@ function getDefinerFunctions( model ) {
   function addDefinition( art, block ) {
     const { absolute } = art.name;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
-    if (absolute === 'cds' ||
-        absolute.startsWith( 'cds.') && !absolute.match(/^cds\.foundation(\.|$)/)) {
+    if (absolute === 'cds' || isInReservedNamespace(absolute)) {
       error( 'reserved-namespace-cds', [ art.name.location, art ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -306,7 +308,7 @@ function getDefinerFunctions( model ) {
     }
     else {
       setLink( art, '_block', block );
-      // dictAdd might set $duplicates to true if def in other source
+      // dictAdd might set $duplicates to true
       dictAdd( model.definitions, absolute, art );
       return true;
     }
@@ -445,6 +447,23 @@ function getDefinerFunctions( model ) {
 
   // Phase 2 ("init") --------------------------------------------------------
 
+  function checkRedefinition( art ) {
+    if (!art.$duplicates)
+      return;
+    if (art._main) {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.id,
+        '#': kindProperties[art.kind].normalized || art.kind,
+      } );
+    }
+    else {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.absolute,
+        '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
+      } );
+    }
+  }
+
   function initNamespaceAndUsing( src ) {
     if (src.namespace) {
       const decl = src.namespace;
@@ -489,12 +508,13 @@ function getDefinerFunctions( model ) {
     if (!reInit)
       initParentLink( art, model.definitions );
     const block = art._block;
+    checkRedefinition( art );
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
     initDollarSelf( art );      // $self
     if (art.params)
       initParams( art );        // $parameters
-    if (art.includes && !(art.name.absolute in extensionsDict))
+    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)
@@ -514,6 +534,7 @@ function getDefinerFunctions( model ) {
 
   function initVocabulary( art ) {
     initParentLink( art, model.vocabularies );
+    checkRedefinition( art );
     const block = art._block;
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
@@ -555,20 +576,6 @@ function getDefinerFunctions( model ) {
 
   // From here til EOF, reexamine code ---------------------------------------
 
-  // currently called from preProcessArtifact(), do be called in "init"
-  function checkRedefinitions( obj, name, prop ) {
-    forEachMember( obj, checkRedefinitions, obj.targetAspect );
-    if (!obj.$duplicates)
-      return;
-    if (obj.name.location.file === '<built-in>') {
-      // builtin types like namespace 'cds' or namespace 'localized' shouldn't be printed.
-      // The error shall only be printed for the user-defined conflicting artifact.
-      return;
-    }
-    error( 'duplicate-definition', [ obj.name.location, obj ],
-           { name, '#': (obj.kind === 'namespace') ? 'namespace' : dictKinds[prop] } );
-  }
-
   function initDollarSelf( art ) {
     const selfname = '$self';
     // TODO: use setMemberParent() ?
@@ -609,14 +616,7 @@ function getDefinerFunctions( model ) {
     if (query.on)
       initExprForQuery( query.on, query );
     // TODO: MIXIN with name = ...subquery (not yet supported anyway)
-    for (const elem of query.columns || []) {
-      if (elem && (elem.value || elem.expand)) {
-        setProp( elem, '_block', query._block );
-        defineAnnotations( elem, elem, query._block );
-        initExprForQuery( elem.value, query );
-        initExpandInline( elem );
-      }
-    }
+    initSelectItems( query, query.columns );
     if (query.where)
       initExprForQuery( query.where, query );
     if (query.having)
@@ -624,22 +624,41 @@ function getDefinerFunctions( model ) {
     initMembers( query, query, query._block );
   }
 
-  function initExpandInline( elem ) {
-    // TODO: forbid with :param, global:true, in ref-where, outside queries (CSN), ...
-    for (const sub of elem.expand || elem.inline || []) {
-      if (!sub)                 // parse error
+  function initSelectItems( parent, columns ) {
+    // TODO: forbid expand/inline with :param, global:true, in ref-where, outside queries (CSN), ...
+    let wildcard = null;
+    for (const col of columns || parent.expand || parent.inline || []) {
+      if (!col)                 // parse error
         continue;
-      if (elem.value)
-        setProp( sub, '_pathHead', elem ); // also set for '*' in expand/inline
-      else if (elem._pathHead)
-        setProp( sub, '_pathHead', elem._pathHead );
-      if (sub.value || sub.expand) {
-        setProp( sub, '_block', elem._block );
-        defineAnnotations( sub, sub, elem._block ); // TODO: complain with inline
-        initExpandInline( sub );
+      if (!columns) {
+        if (parent.value)
+          setProp( col, '_pathHead', parent ); // also set for '*' in expand/inline
+        else if (parent._pathHead)
+          setProp( col, '_pathHead', parent._pathHead );
+      }
+      if (col.val === '*') {
+        if (!wildcard) {
+          wildcard = col;
+        }
+        else {
+          // a late syntax error (this code also runs with parse-cdl), i.e.
+          // no semantic loc (wouldn't be available for expand/inline anyway)
+          error( 'syntax-duplicate-clause', [ col.location, null ],
+                 { prop: '*', line: wildcard.location.line, col: wildcard.location.col },
+                 'You have provided a $(PROP) already at line $(LINE), column $(COL)' );
+          // TODO: extra text variants for expand/inline? - probably not
+          col.val = null;       // do not consider it for expandWildcard()
+        }
+      }
+      else if (col.value || col.expand) {
+        setProp( col, '_block', parent._block );
+        defineAnnotations( col, col, parent._block ); // TODO: complain with inline
+        // TODO: allow sub queries? at least in top-level expand without parallel ref
+        if (columns)
+          initExprForQuery( col.value, parent );
+        initSelectItems( col );
       }
     }
-    // TODO: allow sub queries in top-level expand without parallel ref
   }
 
   function initExprForQuery( expr, query ) {
@@ -658,9 +677,38 @@ function getDefinerFunctions( model ) {
     }
     else if (expr.path && expr.$expected === 'exists') {
       expr.$expected = 'approved-exists';
+      approveExistsInChildren(expr);
     }
   }
 
+  /**
+   * If we have a valid top-level exists, exists in filters of sub-expressions can be translated,
+   * since we will have a top-level subquery after exists-processing in the forHanaNew.
+   *
+   * Recursively drill down into:
+   * - the .path
+   * - the .args
+   * - the .where.args
+   *
+   * Any $expected === 'exists' encountered along the way are turned into 'approved-exists'
+   *
+   * working:     exists toE[exists toE] -> select from E where exists toE
+   * not working: toE[exists toE] -> we don't support subqueries in filters
+   *
+   * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
+   */
+  function approveExistsInChildren(exprOrPathElement) {
+    if (exprOrPathElement.$expected === 'exists')
+      exprOrPathElement.$expected = 'approved-exists';
+    // Drill down
+    if (exprOrPathElement.args)
+      exprOrPathElement.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.where && exprOrPathElement.where.args)
+      exprOrPathElement.where.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.path)
+      exprOrPathElement.path.forEach(elem => approveExistsInChildren(elem));
+  }
+
   // table is table expression in FROM, becomes an alias
   function initTableExpression( table, query, joinParents ) {
     if (!table)                 // parse error
@@ -708,6 +756,8 @@ function getDefinerFunctions( model ) {
           //        ? ta._joinParent.args[ta.$joinArgsIndex] // in JOIN
           //        : ta._parent.from )                      // directly in FROM
           // Note for --raw-output: _joinParent pointing to CROSS JOIN node has not name
+          if (!tab)             // parse error; time for #6241
+            return;             // (parser method to only add non-null to array)
           setProp( tab, '_joinParent', table );
           tab.$joinArgsIndex = index;
           initTableExpression( tab, query, joinParents );
@@ -732,12 +782,13 @@ function getDefinerFunctions( model ) {
       setMemberParent( table, table.name.id, query );
       setProp( table, '_block', query._block );
       dictAdd( query.$tableAliases, table.name.id, table, ( name, loc ) => {
-        error( 'duplicate-definition', [ loc, table ], { name, '#': '$tableAlias' } );
+        error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
       } );
       // also add to JOIN nodes for name restrictions:
       for (const p of joinParents) {
-        // console.log('ADD:', query.name.id, parents.length, p)
-        dictAdd( p.$tableAliases, table.name.id, table );
+        // for JOIN alias restriction, we cannot use $duplicates, as it is
+        // already used for duplicate aliases of queries:
+        dictAddArray( p.$tableAliases, table.name.id, table );
       }
       if (table.name.id[0] === '$') {
         warning( 'syntax-dollar-ident', [ table.name.location, table ], {
@@ -824,7 +875,7 @@ function getDefinerFunctions( model ) {
           // assignments on the mixin... (also for future mixin definitions
           // with generated values)
           dictAdd( query.$tableAliases, name, query.mixin[name], ( dupName, loc ) => {
-            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': '$tableAlias' } );
+            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
           } );
           if (mixin.name.id[0] === '$') {
             warning( 'syntax-dollar-ident', [ mixin.name.location, mixin ],
@@ -847,7 +898,7 @@ function getDefinerFunctions( model ) {
       // TODO: error if CSN has both target.elements and targetAspect.elements -> delete target
       return true;
     }
-    if (elem.targetAspect || !isDirectComposition( elem ))
+    if (elem.targetAspect || options.parseCdl || !isDirectComposition( elem ))
       return false;
     const name = resolveUncheckedPath( target, 'compositionTarget', elem );
     const aspect = name && model.definitions[name];
@@ -861,6 +912,7 @@ function getDefinerFunctions( model ) {
    * (which is basically the component name of the `parent` element plus a dot).
    */
   function initMembers( construct, parent, block, initExtensions = false ) {
+    // TODO: split extend from init
     const isQueryExtension = kindProperties[construct.kind].isExtension &&
           (parent._main || parent).query;
     let obj = construct;
@@ -916,7 +968,7 @@ function getDefinerFunctions( model ) {
       forEachInOrder( construct, 'params', init );
     const { returns } = construct;
     if (returns) {
-      returns.kind = 'param';
+      returns.kind = (kindProperties[construct.kind].isExtension) ? construct.kind : 'param';
       init( returns, '' );      // '' is special name for returns parameter
     }
     return;
@@ -950,6 +1002,7 @@ function getDefinerFunctions( model ) {
       setProp( elem, '_block', bl );
       setMemberParent( elem, name, parent, construct !== parent && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
+      checkRedefinition( elem );
       defineAnnotations( elem, elem, bl );
       initMembers( elem, elem, bl, initExtensions );
 
@@ -985,6 +1038,7 @@ function getDefinerFunctions( model ) {
   }
 
   function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
+    // TODO: do differently, see also annotateMembers() in resolver
     // To have been checked by parsers:
     // - artifacts (CDL-only anyway) only inside [extend] context|service
     if (!dict)
@@ -1269,7 +1323,7 @@ function getDefinerFunctions( model ) {
   }
 
   function createTargetEntity( target, elem, keys, entityName, base ) {
-    const location = elem.target && elem.target.location || elem.location;
+    const { location } = elem.targetAspect || elem.target || elem;
     elem.on = {
       location,
       op: { val: '=', location },
@@ -1314,7 +1368,7 @@ function getDefinerFunctions( model ) {
     // If 'up_' shall be rendered unmanaged, infer the parent
     // primary keys and add the ON condition
     if (isDeprecatedEnabled( options, 'unmanagedUpInComponent' )) {
-      addProxyElements( art, keys, 'aspect-composition', location,
+      addProxyElements( art, keys, 'aspect-composition', target.name && location,
                         'up__', '@odata.containment.ignore' );
       up.on = augmentEqual( location, 'up_', Object.values( keys ), 'up__' );
     }
@@ -1328,7 +1382,7 @@ function getDefinerFunctions( model ) {
       setLink( art, '_base', base._base || base );
 
     dictAdd( art.elements, 'up_', up);
-    addProxyElements( art, target.elements, 'aspect-composition', location );
+    addProxyElements( art, target.elements, 'aspect-composition', target.name && location );
 
     setLink( art, '_block', model.$internal );
     model.definitions[entityName] = art;
@@ -1375,7 +1429,7 @@ function getDefinerFunctions( model ) {
       const exts = model.$lateExtensions[name];
       if (art && art.kind !== 'namespace') {
         if (art.builtin) {
-          for (const ext in exts)
+          for (const ext of exts)
             info( 'anno-builtin', [ ext.name.location, ext ] );
         }
         // created texts entity, autoexposed entity
@@ -1423,6 +1477,12 @@ function getDefinerFunctions( model ) {
 
         model.extensions.push(annotationArtifact);
         extendArtifact( exts, annotationArtifact ); // also sets _artifact link in extensions
+        // if one of the annotate statement mentions 'returns', assume it
+        // TODO: with warning/info?
+        for (const ext of exts) {
+          if (ext.$syntax === 'returns')
+            annotationArtifact.$syntax = 'returns';
+        }
       }
     }
   }
@@ -1706,6 +1766,7 @@ function getDefinerFunctions( model ) {
   }
 
   function extendMembers( extensions, art, noExtend ) {
+    // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
     extensions.sort( compareLayer );
     for (const ext of extensions) {
@@ -1751,7 +1812,12 @@ function getDefinerFunctions( model ) {
     [ 'elements', 'actions' ].forEach( (prop) => {
       const dict = art._extend && art._extend[prop];
       for (const name in dict) {
-        const validDict = art[prop] || prop === 'elements' && art.enum;
+        let obj = art;
+        if (obj.targetAspect)
+          obj = obj.targetAspect;
+        while (obj.items)
+          obj = obj.items;
+        const validDict = obj[prop] || prop === 'elements' && obj.enum;
         const member = validDict[name];
         if (!member)
           extendNothing( dict[name], prop, name, art, validDict );
@@ -1902,24 +1968,6 @@ function getDefinerFunctions( model ) {
     }
   }
 
-  // TODO: move to "init" phase
-  /**
-   * Check whether redefinitions of the given artifact name exist and
-   * adapt to `targetAspect`.
-   *
-   * @param {string} name
-   */
-  function preProcessArtifact( name ) {
-    const art = model.definitions[name];
-    if (Array.isArray(art.$duplicates)) {
-      // A definition name containing a `.` is not invalid (TODO: starting or
-      // ending with a dot is invalid and could be checked here)
-      for (const a of art.$duplicates)
-        checkRedefinitions( a, name, 'definitions' );
-    }
-    checkRedefinitions( art, name, 'definitions' );
-  }
-
   /**
    * Process "composition of" artifacts.
    *
@@ -1989,8 +2037,9 @@ function getDefinerFunctions( model ) {
       }
 
       if (isKey && isLocalized) { // key with localized is wrong - ignore localized
-        warning( 'localized-key', [ elem.localized.location, elem ], {},
-                 'Keyword "localized" is ignored for primary keys' );
+        const errpos = elem.localized || elem.type || elem.name;
+        warning( 'localized-key', [ errpos.location, elem ], { keyword: 'localized' },
+                 'Keyword $(KEYWORD) is ignored for primary keys' );
       }
     }
     if (textElems.length <= keys)
@@ -2132,9 +2181,9 @@ function getDefinerFunctions( model ) {
           });
         }
       }
-      else {                    // use location of LOCALIZED keyword
+      if (hasTruthyProp( orig, 'localized' )) { // use location of LOCALIZED keyword
         const localized = orig.localized || orig.type || orig.name;
-        elem.localized = { val: false, $inferred: 'localized', location: localized.location };
+        elem.localized = { val: null, $inferred: 'localized', location: localized.location };
       }
     }
     if (fioriEnabled)
@@ -2250,9 +2299,9 @@ function mergeI18nBlocks( model ) {
           model.i18n[langKey][textKey] = sourceVal;
         }
         else if (modelVal.val !== sourceVal.val) {
-          const { warning } = makeMessageFunction( model );
-          warning('i18n-different-value', [ sourceVal.location, null ],
-                  { prop: textKey, otherprop: langKey });
+          // TODO: put mergeI18nBlocks() into main function instead
+          model.$messageFunctions.warning( 'i18n-different-value', sourceVal.location,
+                                           { prop: textKey, otherprop: langKey } );
         }
       }
     }
@@ -2269,26 +2318,6 @@ function pathName(path) {
   return path.map( id => id.id ).join('.');
 }
 
-/**
- * Generates an XSN path out of the given name. Path segments are delimited by a dot.
- * Each segment will have the given location assigned.
- *
- * @param {CSN.Location} location
- * @param {string} name
- * @returns {XSN.Path}
- */
-function splitIntoPath( location, name ) {
-  return name.split('.').map( id => ({ id, location }) );
-}
-
-/**
- * @param {CSN.Location} location
- * @param  {...any} args
- */
-function augmentPath( location, ...args ) {
-  return { path: args.map( id => ({ id, location }) ), location };
-}
-
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)
@@ -2317,9 +2346,4 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
 // these function could be used to a future lib/compiler/utils.js, but DO NOT
 // SHARE with utility functions for CSN processors
 
-module.exports = {
-  define: model => getDefinerFunctions( model ).define(),
-  getDefinerFunctions,
-  augmentPath,
-  splitIntoPath,
-};
+module.exports = { define };