@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/compiler/finalize-parse-cdl.js

@@ -0,0 +1,237 @@
+// Things which needs to done for parse.cdl after define()
+
+'use strict';
+
+const { forEachGeneric, forEachMember } = require('../base/model');
+const { setLink, setArtifactLink } = require('./utils');
+
+
+// Used for resolving types in parseCdl mode.
+// See resolveTypesForParseCdl().
+const parseCdlSpeciallyHandledXsnProps = [ '$queries', 'mixin', 'columns', 'args', 'returns' ];
+const parseCdlIgnoredXsnProps = [ 'location', 'query', '$tableAliases' ];
+
+function finalizeParseCdl( model ) {
+  // Get simplified "resolve" functionality and the message function:
+  const { message, error } = model.$messageFunctions;
+  const {
+    resolveUncheckedPath,
+    resolveTypeArgumentsUnchecked,
+    defineAnnotations,
+    initMembers,
+    extensionsDict,
+  } = model.$functions;
+
+  resolveTypesAndExtensionsForParseCdl();
+  return;
+
+  function resolveTypesAndExtensionsForParseCdl() {
+    const extensions = [];
+
+    // TODO: probably better to loop over extensions of all sources (there is just one)
+    for (const name in extensionsDict) {
+      for (const ext of extensionsDict[name]) {
+        ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
+        // Define annotations of this top-level extension
+        defineAnnotations( ext, ext, ext._block );
+        mergeAnnotatesForSameArtifact( ext );
+        // Initialize members and define annotations in sub-elements.
+        initMembers( ext, ext, ext._block, true );
+        extensions.push( ext );
+        for (const col of ext.columns || []) {
+          // Note, no `priority` argument, since we don't apply the extension in the end.
+          defineAnnotations( col, col, ext._block );
+        }
+      }
+    }
+
+    forEachGeneric(model, 'definitions', art => resolveTypesForParseCdl(art, art));
+    forEachGeneric(model, 'vocabularies', art => resolveTypesForParseCdl(art, art));
+
+    if (extensions.length > 0) {
+      model.extensions = extensions;
+      model.extensions.forEach(ext => resolveTypesForParseCdl(ext, ext));
+    }
+  }
+
+  /**
+   * Resolve all types in parseCdl mode for the given artifact.
+   * `main` refers to the current user/scope, e.g. top-level definition, element, function, etc.
+   *
+   * @param {*} artifact
+   * @param {XSN.Artifact} main
+   */
+  function resolveTypesForParseCdl(artifact, main) {
+    if (!artifact || typeof artifact !== 'object')
+      return;
+
+    if (Array.isArray(artifact)) {
+      // e.g. `args` array
+      artifact.forEach(art => resolveTypesForParseCdl(art, main));
+      return;
+    }
+
+    if (artifact.kind === 'namespace' || artifact.kind === 'service' || artifact.kind === 'context')
+      // Services and context artifacts don't have any types.
+      return;
+
+    if (artifact.type)
+      resolveTypeUnchecked(artifact, main);
+
+    for (const include of artifact.includes || [])
+      resolveUncheckedPath(include, 'include', main);
+
+    if (artifact.target)
+      resolveUncheckedPath(artifact.target, 'target', main);
+
+    if (artifact.from) {
+      const { from } = artifact;
+      // Note: `_from` only contains sources necessary for calculating elements,
+      //       not e.g. those from the `where exists` clause.
+      resolveUncheckedPath(from, 'from', main);
+      resolveTypesForParseCdl(from, main);
+    }
+
+    if (artifact.targetAspect) {
+      if (artifact.targetAspect.path)
+        resolveUncheckedPath(artifact.targetAspect, 'target', main);
+      resolveTypesForParseCdl(artifact.targetAspect, main);
+    }
+
+    // Recursively go through all XSN properties.  There are a few that need to be
+    // handled specifically.  Refer to the code below this loop for details.
+    for (const prop in artifact) {
+      if (parseCdlSpeciallyHandledXsnProps.includes(prop) || parseCdlIgnoredXsnProps.includes(prop))
+        continue;
+
+      // define.js (and initMembers()) initializes annotations.  If there is a duplicate, the
+      // annotation is an array in XSN.
+      if (prop[0] === '@' && Array.isArray(artifact[prop]))
+        chooseAndReportDuplicateAnnotation(artifact, prop);
+
+      if (artifact[prop] && Object.getPrototypeOf(artifact[prop]) === null)
+        // Dictionary in XSN
+        forEachGeneric(artifact, prop, art => resolveTypesForParseCdl(art, art));
+      else
+        resolveTypesForParseCdl(artifact[prop], main);
+    }
+
+    // `$queries` has a flat structure that we can use instead of going through all `query`.
+    // For these query-related properties, we need to keep the reference to the artifact
+    // containing it.  Otherwise some type's aren't properly resolved.
+    // TODO: If resolveTypeUnchecked is reworked, we may be able to simplify this coding.
+    (artifact.$queries || []).forEach( art => resolveTypesForParseCdl(art, artifact) );
+    (artifact.columns || []).forEach( art => resolveTypesForParseCdl(art, artifact) );
+    forEachGeneric( artifact, 'mixin', art => resolveTypesForParseCdl(art, artifact) );
+
+    // For better error messages for `type of`s in `returns`, we pass the object as the new main.
+    resolveTypesForParseCdl(artifact.returns, artifact.returns);
+
+    // Because `args` can be used in different contexts with different semantics,
+    // it needs to be handled specifically.
+    if (artifact.args && typeof artifact.args === 'object') {
+      if (Array.isArray(artifact.args)) {
+        // `args` may either be an array (e.g. query 'from' args) ...
+        artifact.args.forEach((from) => {
+          // ... and could be either inside a `from` ...
+          if (from && from.kind === '$tableAlias')
+            resolveUncheckedPath(from, 'from', from._main);
+
+          // ... or only params ...
+          resolveTypesForParseCdl(from, main);
+        });
+      }
+      else {
+        // ... or dictionary (e.g. params)
+        forEachGeneric(artifact, 'args', obj => resolveTypesForParseCdl(obj, obj));
+      }
+    }
+  }
+
+  /**
+   * Resolves `artWithType.type` in an unchecked manner. Handles `type of` cases.
+   * `artWithType` has the `type` property, i.e. it could be an `items` object.
+   * `user` is the actual artifact, e.g. entity or element.
+   *
+   * @param {object} artWithType
+   * @param {XSN.Artifact} user
+   */
+  function resolveTypeUnchecked(artWithType, user) {
+    if (!artWithType.type)
+      return;
+    const root = artWithType.type.path && artWithType.type.path[0];
+    if (!root) // parse error
+      return;
+    // `scope` is only `typeOf` for `type of element` and not
+    // `type of Entity:element`. For the latter we can resolve the path
+    // without special treatment.
+    if (artWithType.type.scope !== 'typeOf') {
+      // elem: Type   or   elem: type of Artifact:elem
+      const name = resolveUncheckedPath( artWithType.type, 'type', user );
+      const type = name && model.definitions[name] || { name: { absolute: name } };
+      resolveTypeArgumentsUnchecked( artWithType, type, user );
+      return;
+    }
+    else if (!user._main) {
+      error( 'ref-undefined-typeof', [ artWithType.type.location, user ], {},
+             'Current artifact has no element to refer to as type' );
+      return;
+    }
+    else if (root.id === '$self' || root.id === '$projection') {
+      setArtifactLink( root, user._main );
+    }
+    else {
+      // For better error messages, check for invalid TYPE OFs similarly
+      // to how `resolveType()` does.
+      let struct = artWithType;
+      while (struct.kind === 'element')
+        struct = struct._parent;
+      if (struct.kind === 'select' || struct !== user._main) {
+        message( 'type-unexpected-typeof', [ artWithType.type.location, user ],
+                 { keyword: 'type of', '#': struct.kind } );
+        return;
+      }
+
+      const fake = { name: { absolute: user.name.absolute } };
+      // to-csn just needs a fake element whose absolute name and _parent/_main links are correct
+      setLink( fake, '_parent', user._parent );
+      setLink( fake, '_main', user._main ); // value does not matter...
+      setArtifactLink( root, fake );
+    }
+  }
+
+  function chooseAndReportDuplicateAnnotation(artifact, annoName) {
+    for (const anno of artifact[annoName])
+      message( 'anno-duplicate', [ anno.name.location, artifact ], { anno: annoName } );
+
+    // Choose any annotation, doesn't matter because of the error above.
+    artifact[annoName] = artifact[annoName][0];
+  }
+
+  /**
+   * For duplicate entries in `annotate {}` blocks, we de-duplicate the entries and merge them.
+   * Since it is allowed in "normal" compilations to have e.g.
+   * `annotate E with { @anno1 id, @anno2 id }`.
+   *
+   * @param {object} ext
+   */
+  function mergeAnnotatesForSameArtifact( ext ) {
+    if (!ext || typeof ext !== 'object')
+      return;
+
+    forEachMember(ext, sub => mergeAnnotatesForSameArtifact(sub));
+
+    if (ext.$annotations && Array.isArray(ext.$duplicates)) {
+      const annotates = ext.$duplicates.filter(val => (val.kind === 'annotate'));
+      for (const dup of annotates) {
+        ext.$annotations.push(...dup.$annotations);
+        delete dup.$annotations;
+      }
+      ext.$duplicates = ext.$duplicates.filter(val => (val.kind !== 'annotate'));
+      if (ext.$duplicates.length === 0)
+        delete ext.$duplicates;
+    }
+  }
+}
+
+module.exports = finalizeParseCdl;

package/lib/compiler/index.js

@@ -21,8 +21,13 @@ 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 define = require('./define');
+const finalizeParseCdl = require('./finalize-parse-cdl');
+const extend = require('./extend');
+const kickStart = require('./kick-start');
+const populate = require('./populate');
+const resolve = require('./resolve');
+const tweakAssocs = require('./tweak-assocs');
 const propagator = require('./propagator');
 const check = require('./checks');
 
@@ -34,6 +39,8 @@ const { cdsFs } = require('../utils/file');
 const fs = require('fs');
 const path = require('path');
 
+const csnExtensions = [ '.json', '.csn' ];
+const cdlExtensions = [ '.cds', '.hdbcds', '.hdbdd', '.cdl' ];
 
 // Class for command invocation errors.  Additional members:
 //  `errors`: vector of errors (file IO or ArgumentError)
@@ -56,8 +63,8 @@ class ArgumentError extends Error {
 
 /**
  * Parse the given source with the correct parser based on the file name's
- * extension. For example use edm2csn for `.xml` files and the CDL parser
- * for `.cds` files.
+ * extension. For example uses CDL parser for `.cds` files.
+ * Respects the value of `options.fallbackParser`.
  *
  * @param {string} source Source code of the file.
  * @param {string} filename Filename including its extension, e.g. "file.cds"
@@ -68,9 +75,9 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
   if (!messageFunctions)
     messageFunctions = createMessageFunctions( options, 'parse' );
   const ext = path.extname( filename ).toLowerCase();
-  if ([ '.json', '.csn' ].includes(ext) || options.fallbackParser === 'csn!')
+  if (csnExtensions.includes(ext) || options.fallbackParser === 'csn!')
     return parseCsn.parse( source, filename, options, messageFunctions );
-  if ([ '.cds', '.hdbcds', '.hdbdd', '.cdl' ].includes(ext))
+  if (cdlExtensions.includes(ext))
     return parseLanguage( source, filename, options, messageFunctions );
   if (options.fallbackParser === 'csn')
     return parseCsn.parse( source, filename, options, messageFunctions );
@@ -89,8 +96,8 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
 // Main function: Compile the sources from the files given by the array of
 // `filenames`.  As usual with the `fs` library, relative file names are
 // relative to the working directory `process.cwd()`.  With argument `dir`, the
-// file names are relative to `process.cwd()+dir`.  Options can have the
-// following properties:
+// file names are relative to `process.cwd()+dir` (or just `dir` if it is absolute).
+// Options can have the following properties:
 //  - Truthy `parseOnly`: stop compilation after parsing.
 //  - Truthy `lintMode`: do not do checks and propagation
 //  - many others - TODO
@@ -102,7 +109,7 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
 //
 // The promise is fulfilled if all files could be read and processed without
 // errors.  The fulfillment value is an augmented CSN (see
-// ./compiler/definer.js).
+// ./compiler/define.js).
 //
 // If there are errors, the promise is rejected.  If there was an invocation
 // error (repeated filenames or if the file could not be read), the rejection
@@ -121,30 +128,35 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   // if (Object.getPrototypeOf( fileCache ))
   //   fileCache = Object.assign( Object.create(null), fileCache );
   dir = path.resolve(dir);
-  const a = processFilenames( filenames, dir );
-
-  const model = { sources: a.sources, options };
+  const model = { sources: null, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
-  let all = promiseAllDoNotRejectImmediately( a.files.map(readAndParse) );
-
-  all = all
+  let input = null;
+
+  let all = processFilenames( filenames, dir )
+    .then((processedInput) => {
+      input = processedInput;
+      model.sources = input.sources;
+    })
+    .then(() => promiseAllDoNotRejectImmediately( input.files.map(readAndParse) ))
     .then( testInvocation, (reason) => {
       // do not reject with PromiseAllError, use InvocationError:
       const errs = reason.valuesOrErrors.filter( e => e instanceof Error );
       // internal error if no file IO error (has property `path`)
       return Promise.reject( errs.find( e => !e.path ) ||
-                             new InvocationError( [ ...a.repeated, ...errs ]) );
+                             new InvocationError( [ ...input.repeated, ...errs ]) );
     });
+
   if (!options.parseOnly && !options.parseCdl)
     all = all.then( readDependencies );
+
   return all.then( () => {
-    moduleLayers.setLayers( a.sources );
+    moduleLayers.setLayers( input.sources );
     return compileDoX( model );
   });
 
   // Read file `filename` and parse its content, return messages
   async function readAndParse( filename ) {
-    const { sources } = a;
+    const { sources } = input;
     if ( filename === false )   // module which has not been found
       return [];
     const rel = sources[filename] || path.relative( dir, filename );
@@ -166,9 +178,9 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
 
   // Combine the parse results (if there are not file IO errors)
   function testInvocation( values ) {
-    if (a.repeated.length)
+    if (input.repeated.length)
       // repeated file names in invocation => just report these
-      return Promise.reject( new InvocationError(a.repeated) );
+      return Promise.reject( new InvocationError(input.repeated) );
     return values;
   }
 
@@ -218,7 +230,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   // A non-proper dictionary (i.e. with prototype) is safe if the keys are
   // absolute file names - they start with `/` or `\` or similar
   dir = path.resolve(dir);
-  const a = processFilenames( filenames, dir );
+  const a = processFilenamesSync( filenames, dir );
 
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
@@ -326,9 +338,10 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
 /**
  * Promise-less main functions: compile the given sources.
  *
- * Argument `sourcesDict` is a dictionary (it could actually be a ordinary object)
- * mapping filenames to either source texts (string) or XSN objects (AST-like
- * augmented CSNs).  It could also be a simple string, which is then considered
+ * Argument `sourcesDict` is a dictionary (it could actually be an ordinary object)
+ * mapping filenames to either source texts (string) or JS objects; the objects
+ * are usually CSNs, or XSNs (AST-like augmented CSNs) with option `$xsnObjects`.
+ * It could also be a simple string, which is then considered
  * to be the source text of a file named `<stdin>.cds`.
  *
  * See function `compileX` for the meaning of the argument `options`.  If there
@@ -356,9 +369,15 @@ function compileSourcesX( sourcesDict, options = {} ) {
       ast.location = { file: filename };
       assertConsistency( ast, options );
     }
-    else {                      // source is a XSN object (CSN/CDL parser output)
+    else if (options.$xsnObjects) { // source is a XSN object with option $xsnObjects
       sources[filename] = source;
     }
+    else {                      // source is a CSN object
+      const ast = parseCsn.augment( source, filename, options, model.$messageFunctions );
+      sources[filename] = ast;
+      ast.location = { file: filename };
+      assertConsistency( ast, options );
+    }
   }
   moduleLayers.setLayers( sources );
 
@@ -420,10 +439,15 @@ function compileDoX( model ) {
   // do not run the resolver in parse-cdl mode or we get duplicate annotations, etc.
   // TODO: do not use this function for parseCdl anyway…
   if (options.parseCdl) {
+    finalizeParseCdl( model );
     throwWithError();
     return model;
   }
+  extend( model );
+  kickStart( model );
+  populate( model );
   resolve( model );
+  tweakAssocs( model );
   assertConsistency( model );
   throwWithError();
   if (options.lintMode)
@@ -434,22 +458,44 @@ function compileDoX( model ) {
   return propagator.propagate( model );
 }
 
-// Process an array of `filenames`.  Returns an object with properties:
-//  - `sources`: dictionary which has a filename as key (value is irrelevant)
-//  - `files`: the argument array without repeating the same name
-//  - `repeated`: array of filenames which have been repeatedly listed
-//    (listed only once here even if listed thrice)
-//
-// Note: there is nothing file-specific about the filenames, the filenames are
-// not normalized - any strings work
-function processFilenames( filenames, dir ) {
-  const sources = Object.create(null); // not {} = no [[Prototype]]
-  const files = [];
-  const repeated = [];
+/**
+ * Process an array of `filenames`.  Returns an object with properties:
+ *  - `sources`: dictionary which has a filename as key (value is irrelevant)
+ *  - `files`: the argument array without repeating the same name
+ *  - `repeated`: array of filenames which have been repeatedly listed
+ *    (listed only once here even if listed thrice)
+ *
+ * Note: there is nothing file-specific about the filenames, the filenames are
+ * not normalized - any strings work
+ */
+async function processFilenames( filenames, dir ) {
+  const filenameMap = Object.create(null);
 
+  const promises = [];
   for (const originalName of filenames) {
-    let name = path.resolve(dir, originalName);
+    const setName = (name) => {
+      filenameMap[originalName] = name;
+    };
+    // Resolve possible symbolic link; if the file does not exist
+    // we just continue using the original name because readFile()
+    // already handles non-existent files.
+    const promise = fs.promises.realpath(path.resolve(dir, originalName))
+      .then(setName, () => setName(originalName));
+    promises.push(promise);
+  }
+
+  await Promise.all(promises);
+  return createSourcesDict( filenames, filenameMap, dir );
+}
 
+/**
+ * Synchronous version of processFilenames().
+ */
+function processFilenamesSync( filenames, dir ) {
+  const filenameMap = Object.create(null);
+
+  for (const originalName of filenames) {
+    let name = path.resolve(dir, originalName);
     try {
       // Resolve possible symbolic link; if the file does not exist
       // we just continue using the original name because readFile()
@@ -459,7 +505,29 @@ function processFilenames( filenames, dir ) {
     catch (e) {
       // Ignore the not-found (ENOENT) error
     }
+    filenameMap[originalName] = name;
+  }
+
+  return createSourcesDict( filenames, filenameMap, dir );
+}
+
+/**
+ * Creates the sources dictionary as well as a list of absolute filenames.
+ * If files are repeated, `repeated` will contain ArgumentErrors for it.
+ *
+ * @param {string[]} filenames List of (possibly relative) filenames. Defines the file order.
+ * @param {Record<string, string>} filenameMap Map from original name to actual filename
+ *                                             (e.g. from symlink to underlying path)
+ * @param {string} dir "Current working directory"
+ * @return {{sources: object, files: string[], repeated: ArgumentError[]}}
+ */
+function createSourcesDict( filenames, filenameMap, dir ) {
+  const sources = Object.create(null);
+  const files = [];
+  const repeated = [];
 
+  for (const originalName of filenames) {
+    const name = filenameMap[originalName];
     if (!sources[name]) {
       sources[name] = path.relative( dir, name );
       files.push(name);
@@ -469,10 +537,10 @@ function processFilenames( filenames, dir ) {
       repeated.push( new ArgumentError( name, msg ) );
     }
   }
+
   return { sources, files, repeated };
 }
 
-
 module.exports = {
   parseX,
   compileX,