@sap/cds-compiler 2.5.2 → 2.11.0

package/lib/compiler/index.js

@@ -1,5 +1,17 @@
 // Main XSN-based compiler functions
 
+// ...
+
+// How functions are shared across the Core Compiler sub modules:
+
+// - Shared XSN-related functions which do not use a context are in utils.js,
+//   they are `require`d as usual at the beginning of sub modules.
+// - The XSN is the only context which context-dependent functions can depend on.
+// - Sharing such a function is by adding it to `‹xsn›.$functions`,
+//   e.g. `resolvePath` and similar will be attached to the XSN.
+// - Functions which might be overwritten in a next sub module
+//   are added to `‹xsn›.$volatileFunctions`, currently just `environment`.
+
 'use strict';
 
 const { resolveModule, resolveModuleSync } = require('../utils/moduleResolve');
@@ -8,6 +20,7 @@ const parseCsn = require('../json/from-csn');
 
 const assertConsistency = require('./assert-consistency');
 const moduleLayers = require('./moduleLayers');
+const { fns } = require('./shared');
 const { define } = require('./definer');
 const resolve = require('./resolver');
 const propagator = require('./propagator');
@@ -15,7 +28,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,25 +63,27 @@ 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 );
+    return parseCsn.parse( source, filename, options, messageFunctions );
   if ([ '.cds', '.hdbcds', '.hdbdd', '.cdl' ].includes(ext))
-    return parseLanguage( source, filename, options );
+    return parseLanguage( source, filename, options, messageFunctions );
   if (options.fallbackParser === 'csn')
-    return parseCsn.parse( source, filename, options );
+    return parseCsn.parse( source, filename, options, messageFunctions );
   if (options.fallbackParser)   // any other value: like 'cdl' (historic reasons)
-    return parseLanguage( source, filename, options );
+    return parseLanguage( source, filename, options, messageFunctions );
 
   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',
-         } );
+  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;
 }
 
@@ -108,9 +123,9 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   //   fileCache = Object.assign( Object.create(null), fileCache );
   dir = path.resolve(dir);
   const a = processFilenames( filenames, dir );
-  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
@@ -146,8 +161,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 );
@@ -187,8 +201,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 [];
@@ -215,9 +231,9 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   // absolute file names - they start with `/` or `\` or similar
   dir = path.resolve(dir);
   const a = processFilenames( filenames, dir );
-  a.fileContentDict = Object.create(null);
 
   const model = { sources: a.sources, options };
+  model.$messageFunctions = createMessageFunctions( options, 'compile', model );
 
   let asts = [];
   const errors = [];
@@ -275,8 +291,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 );
@@ -307,8 +322,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 [];
@@ -341,11 +358,12 @@ function compileSourcesX( sourcesDict, options = {} ) {
     sourcesDict = { '<stdin>.cds': sourcesDict };
   const sources = Object.create(null);
   const model = { sources, options };
+  model.$messageFunctions = createMessageFunctions( options, 'compile', model );
 
   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 );
@@ -359,6 +377,38 @@ function compileSourcesX( sourcesDict, options = {} ) {
   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.
@@ -368,24 +418,31 @@ 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;
+  }
+  model.$functions = {};
+  model.$volatileFunctions = {};
+  fns( model );                 // attach (mostly) paths functions
   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 );
 }
 
@@ -433,5 +490,6 @@ module.exports = {
   compileX,
   compileSyncX,
   compileSourcesX,
+  recompileX,
   InvocationError,    // TODO: make it no error if same file name is provided twice
 };

package/lib/compiler/propagator.js

@@ -8,7 +8,7 @@ const {
   setProp,
   isDeprecatedEnabled,
 } = require( '../base/model');
-const { linkToOrigin, withAssociation } = require('./shared');
+const { linkToOrigin, withAssociation } = require('./utils');
 // const { refString } = require( '../base/messages')
 
 function propagate( model ) {
@@ -179,6 +179,8 @@ function propagate( model ) {
   // accessed at their type being a main artifact
   function expensive( prop, target, source ) {
     // console.log(prop,source.name,'->',target.kind,target.name);
+    if (source.kind === 'builtin')
+      return;
     if (prop !== 'foreignKeys' && availableAtType( prop, target, source ))
       // foreignKeys must always be copied with target to avoid any confusion
       // whether we have to generated implicit keys
@@ -211,7 +213,8 @@ function propagate( model ) {
   }
 
   function onlyViaParent( prop, target, source ) {
-    if (target.$inferred === 'proxy') // assocs and enums do not have 'include'
+    if (target.$inferred === 'proxy' || target.$inferred === 'expand-element')
+      // assocs and enums do not have 'include'
       always( prop, target, source );
   }