@sap/cds-compiler 2.4.4 → 2.10.2

package/lib/compiler/definer.js

@@ -107,9 +107,7 @@
 
 'use strict';
 
-const {
-  makeMessageFunction, searchName, weakLocation,
-} = require('../base/messages');
+const { searchName, weakLocation } = require('../base/messages');
 const {
   isDeprecatedEnabled, isBetaEnabled,
   setProp, forEachGeneric, forEachInOrder,
@@ -155,7 +153,7 @@ function getDefinerFunctions( 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,
@@ -206,7 +204,7 @@ function getDefinerFunctions( model ) {
 
     mergeI18nBlocks( model );
 
-    if (model.options && model.options.parseCdl) {
+    if (options.parseCdl) {
       initExtensionsWithoutApplying();
       // Check for redefinitions
       Object.keys( model.definitions ).forEach( preProcessArtifact );
@@ -218,7 +216,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);
@@ -494,7 +493,7 @@ function getDefinerFunctions( model ) {
     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)
@@ -609,14 +608,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,17 +616,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 && (sub.value || sub.expand)) {
-        setProp( sub, '_block', elem._block );
-        setProp( sub, '_pathHead', elem );
-        defineAnnotations( sub, sub, elem._block );
-        initExpandInline( sub );
+  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 (!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 ) {
@@ -653,9 +669,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
@@ -703,6 +748,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 );
@@ -842,7 +889,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];
@@ -856,6 +903,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;
@@ -911,7 +959,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;
@@ -980,6 +1028,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)
@@ -1264,7 +1313,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 },
@@ -1309,7 +1358,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__' );
     }
@@ -1323,7 +1372,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;
@@ -1370,7 +1419,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
@@ -1418,6 +1467,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';
+        }
       }
     }
   }
@@ -1559,7 +1614,7 @@ function getDefinerFunctions( model ) {
       else {
         const fake = { name: { absolute: artifact.name.absolute } };
         // to-csn just needs a fake element whose absolute name and _parent/_main links are correct
-        setLink( fake, '_parent', artifact._parent, '_parent' );
+        setLink( fake, '_parent', artifact._parent );
         setLink( fake, '_main', artifact._main ); // value does not matter...
         setLink( root, '_artifact', fake );
       }
@@ -1701,6 +1756,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) {
@@ -1746,7 +1802,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 );
@@ -1984,8 +2045,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)
@@ -2127,9 +2189,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)
@@ -2245,9 +2307,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 } );
         }
       }
     }

package/lib/compiler/index.js

@@ -15,7 +15,7 @@ const check = require('./checks');
 
 
 const { emptyWeakLocation } = require('../base/location');
-const { handleMessages, makeMessageFunction } = require('../base/messages');
+const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
 const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
 const { cdsFs } = require('../utils/file');
 
@@ -50,28 +50,28 @@ class ArgumentError extends Error {
  * @param {string} source Source code of the file.
  * @param {string} filename Filename including its extension, e.g. "file.cds"
  * @param {object} options Compile options
+ * @param {object} messageFunctions If not provided, parse errors will not lead to an exception
  */
-function parseX( source, filename, options = {} ) {
+function parseX( source, filename, options = {}, messageFunctions ) {
+  if (!messageFunctions)
+    messageFunctions = createMessageFunctions( options, 'parse' );
   const ext = path.extname( filename ).toLowerCase();
-  if ([ '.json', '.csn' ].includes(ext) || (options.fallbackParser === 'csn')) {
-    return parseCsn.parse( source, filename, options );
-  }
-  else if ([ '.cds', '.hdbcds', '.hdbdd', '.cdl' ].includes(ext) || options.fallbackParser) {
-    // Note: Historically, all truthy values for options.fallbackParser were interpreted as 'cdl'.
-    //       To not break existing programs, we do the same if it's not set to `csn`.
-    return parseLanguage( source, filename, options );
-  }
-  // eslint-disable-next-line no-else-return
-  else {
-    const model = { location: { file: filename } };
-    const { error } = makeMessageFunction( model, options, 'compile' );
-    error( 'file-unknown-ext', emptyWeakLocation(filename),
-           { file: ext && ext.slice(1), '#': !ext && 'none' }, {
-             std: 'Unknown file extension $(FILE)',
-             none: 'No file extension',
-           } );
-    return model;
-  }
+  if ([ '.json', '.csn' ].includes(ext) || options.fallbackParser === 'csn!')
+    return parseCsn.parse( source, filename, options, messageFunctions );
+  if ([ '.cds', '.hdbcds', '.hdbdd', '.cdl' ].includes(ext))
+    return parseLanguage( source, filename, options, messageFunctions );
+  if (options.fallbackParser === 'csn')
+    return parseCsn.parse( source, filename, options, messageFunctions );
+  if (options.fallbackParser)   // any other value: like 'cdl' (historic reasons)
+    return parseLanguage( source, filename, options, messageFunctions );
+
+  const model = { location: { file: filename } };
+  messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),
+                          { file: ext && ext.slice(1), '#': !ext && 'none' }, {
+                            std: 'Unknown file extension $(FILE)',
+                            none: 'No file extension',
+                          } );
+  return model;
 }
 
 // Main function: Compile the sources from the files given by the array of
@@ -83,7 +83,8 @@ function parseX( source, filename, options = {} ) {
 //  - Truthy `lintMode`: do not do checks and propagation
 //  - many others - TODO
 
-// This function returns a Promise.  See ../bin/cdsv.js for an example usage.
+// This function returns a Promise and can be used with `await`.  For an example
+// see `examples/api-usage/`.
 // See function `compileSyncX` or `compileSourcesX` for alternative compile
 // functions.
 //
@@ -112,6 +113,7 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   a.fileContentDict = Object.create(null);
 
   const model = { sources: a.sources, options };
+  model.$messageFunctions = createMessageFunctions( options, 'compile', model );
   let all = promiseAllDoNotRejectImmediately( a.files.map(readAndParse) );
 
   all = all
@@ -148,7 +150,7 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
         else {
           try {
             a.fileContentDict[filename] = source;
-            const ast = parseX( source, rel, options );
+            const ast = parseX( source, rel, options, model.$messageFunctions );
             a.sources[filename] = ast;
             ast.location = { file: rel };
             ast.dirname = path.dirname( filename );
@@ -188,8 +190,10 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
       }
       // create promises after all usingFroms have been collected, as the
       // Promise executor is called immediately with `new`:
-      for (const module in dependencies)
-        promises.push( resolveModule( dependencies[module], fileCache, options ) );
+      for (const module in dependencies) {
+        promises.push( resolveModule( dependencies[module], fileCache, options,
+                                      model.$messageFunctions ) );
+      }
     }
     if (!promises.length)
       return [];
@@ -219,6 +223,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   a.fileContentDict = Object.create(null);
 
   const model = { sources: a.sources, options };
+  model.$messageFunctions = createMessageFunctions( options, 'compile', model );
 
   let asts = [];
   const errors = [];
@@ -277,7 +282,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       else {
         try {
           a.fileContentDict[filename] = source;
-          const ast = parseX( source, rel, options );
+          const ast = parseX( source, rel, options, model.$messageFunctions );
           a.sources[filename] = ast;
           ast.location = { file: rel };
           ast.dirname = path.dirname( filename );
@@ -308,8 +313,10 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       }
       // create promises after all usingFroms have been collected, as the
       // Promise executor is called immediately with `new`:
-      for (const module in dependencies)
-        fileNames.push( resolveModuleSync( dependencies[module], fileCache, options ) );
+      for (const module in dependencies) {
+        fileNames.push( resolveModuleSync( dependencies[module], fileCache, options,
+                                           model.$messageFunctions ) );
+      }
     }
     if (!fileNames.length)
       return [];
@@ -331,23 +338,23 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
  * are parse or other compilation errors, throw an exception CompilationError
  * containing a vector of individual errors.
  *
+ * TODO: re-check `using from` dependencies.
+ *
  * @param {string|object} sourcesDict Files to compile.
  * @param {object} [options={}] Compilation options.
  * @returns {XSN.Model} Augmented CSN
  */
 function compileSourcesX( sourcesDict, options = {} ) {
-  // eslint-disable-next-line no-nested-ternary
-  const content = sourcesDict.sources
-    ? sourcesDict.sources
-    : (typeof sourcesDict === 'string') ? { '<stdin>.cds': sourcesDict } : sourcesDict;
-
+  if (typeof sourcesDict === 'string')
+    sourcesDict = { '<stdin>.cds': sourcesDict };
   const sources = Object.create(null);
   const model = { sources, options };
+  model.$messageFunctions = createMessageFunctions( options, 'compile', model );
 
-  for (const filename in content) {
-    const source = content[filename];
+  for (const filename in sourcesDict) {
+    const source = sourcesDict[filename];
     if (typeof source === 'string') {
-      const ast = parseX( source, filename, options );
+      const ast = parseX( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
       ast.location = { file: filename };
       assertConsistency( ast, options );
@@ -356,26 +363,43 @@ function compileSourcesX( sourcesDict, options = {} ) {
       sources[filename] = source;
     }
   }
-
-  // add dependencies to AST
-  for (const filename in sourcesDict.dependencies) {
-    const dependency = sourcesDict.dependencies[filename];
-    for (const val in dependency) {
-      const dep = {
-        literal: 'string', val, realname: dependency[val], // location ?
-      };
-      const arr = sources[filename].dependencies;
-      if (arr)
-        arr.push( dep );
-      else
-        sources[filename].dependencies = [ dep ];
-    }
-  }
   moduleLayers.setLayers( sources );
 
   return compileDoX( model );
 }
 
+/**
+ * Recompile the given CSN
+ *
+ * @param {object} csn Input CSN to recompile to XSN
+ * @param {object} options Options
+ * @returns {object} XSN
+ *
+ * TODO: probaby issue message api-recompiled-csn there.
+ */
+function recompileX( csn, options ) {
+  options = { ...options, parseCdl: false, $recompile: true };
+  // TODO: $recompile: true should be enough
+  // Explicitly set parseCdl to false because backends cannot handle it
+  // Explicitly delete all toCsn options:
+  delete options.toCsn;
+
+  const file = csn.$location && csn.$location.file &&
+    csn.$location.file.replace(/[.]cds$/, '.cds.csn') || '<recompile>.csn';
+
+  const sources = Object.create(null);
+  const model = { sources, options };
+  model.$messageFunctions = createMessageFunctions( options, 'compile', model );
+  // TODO: or use module which invokes the recompilation?
+
+  sources[file] = parseCsn.augment( csn, file, options, model.$messageFunctions );
+  moduleLayers.setLayers( sources );
+  const compiled = compileDoX( model ); // calls throwWithError()
+  if (options.messages)         // does not help with exception in compileDoX()
+    deduplicateMessages(options.messages); // TODO: do better
+  return compiled;
+}
+
 /**
  * On the given model (AST like CSN) run the definer, resolver as well as semantic checks.
  * Creates an augmented CSN (XSN) and returns it.
@@ -385,24 +409,28 @@ function compileSourcesX( sourcesDict, options = {} ) {
  */
 function compileDoX( model ) {
   const { options } = model;
+  const { throwWithError } = model.$messageFunctions;
   if (!options.testMode)
     model.meta = {}; // provide initial central meta object
-  if (options.parseOnly)
-    return handleMessages( model, options );
-
+  if (options.parseOnly) {
+    throwWithError();
+    return model;
+  }
   define( model );
   // do not run the resolver in parse-cdl mode or we get duplicate annotations, etc.
-  if (options.parseCdl)
-    return handleMessages( model, options );
-
+  // TODO: do not use this function for parseCdl anyway…
+  if (options.parseCdl) {
+    throwWithError();
+    return model;
+  }
   resolve( model );
   assertConsistency( model );
-  handleMessages( model, options ); // stop compilation with errors
+  throwWithError();
   if (options.lintMode)
     return model;
 
   check(model);
-  handleMessages( model, options );
+  throwWithError();
   return propagator.propagate( model );
 }
 
@@ -450,5 +478,6 @@ module.exports = {
   compileX,
   compileSyncX,
   compileSourcesX,
+  recompileX,
   InvocationError,    // TODO: make it no error if same file name is provided twice
 };