@sap/cds-compiler 2.13.6 → 2.15.4

package/lib/compiler/index.js

@@ -128,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 );
@@ -173,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;
   }
 
@@ -225,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 );
@@ -453,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()
@@ -478,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);
@@ -488,10 +537,10 @@ function processFilenames( filenames, dir ) {
       repeated.push( new ArgumentError( name, msg ) );
     }
   }
+
   return { sources, files, repeated };
 }
 
-
 module.exports = {
   parseX,
   compileX,

package/lib/compiler/populate.js

@@ -5,9 +5,9 @@
 // used when resolving element references: when starting a references at a
 // certain definition or element, which names are allowed next?
 //
-// To calculate that info, the compiler might needs the same info for other
-// definitions. In other words: it calls itself recursively (using an iterative
-// algorithm where appropriate).  The be able to calculate that info on demand,
+// To calculate that info, the compiler might need the same info for other
+// definitions.  In other words: it calls itself recursively (using an iterative
+// algorithm where appropriate).  To be able to calculate that info on demand,
 // the definitions need to have enough information, which must have been set in
 // an earlier compiler phase.  It is essential to do things in the right order.
 
@@ -166,7 +166,7 @@ function populate( model ) {
     const chain = [];
     while (art && !('_effectiveType' in art) &&
            (art.type || art._origin || art.value && art.value.path) &&
-           // TODO: really stop at art.enum?
+           // TODO: really stop at art.enum? See #8942
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
       setLink( art, '_effectiveType', 0 ); // initial setting in case of cycles
@@ -564,7 +564,8 @@ function populate( model ) {
         error( null, [ col.location, query ], { prop: (col.expand ? 'expand' : 'inline') },
                'Unsupported nested $(PROP)' );
       }
-      if (!col.value && !col.expand)
+      // If neither expression (value), expand nor new association.
+      if (!col.value && !col.expand && !(col.target && col.type))
         continue;             // error should have been reported by parser
       if (col.inline) {
         col.kind = '$inline';

package/lib/compiler/propagator.js

@@ -117,6 +117,9 @@ function propagate( model ) {
   function runMembers( art ) {
     // console.log('MEMBERS:',refString(art), art.elements ? Object.keys(art.elements) : 0)
     forEachMember( art, run ); // after propagation in parent!
+    // propagate to sub query elements even if not requested:
+    if (art.$queries)
+      art.$queries.forEach( run );
     let obj = art;
     if (art.returns) {
       obj = art.returns;
@@ -230,7 +233,7 @@ function propagate( model ) {
   }
 
   function notWithExpand( prop, target, source ) {
-    if (!target.expand)
+    if (!target.expand || prop === 'type' && source.elements)
       always( prop, target, source );
   }
 

package/lib/compiler/resolve.js

@@ -50,6 +50,7 @@ const { dictLocation } = require('../base/location');
 const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
 const { forEachValue } = require('../utils/objectUtils');
+const { typeParameters } = require('./builtins');
 
 const { kindProperties } = require('./base');
 const {
@@ -89,13 +90,13 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
-    resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
     lateExtensions,
     effectiveType,
     directType,
     resolveType,
+    resolveTypeArgumentsUnchecked,
     populateQuery,
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
@@ -371,8 +372,8 @@ function resolve( model ) {
       // console.log(obj.name,obj._origin.name)
       if (obj._origin && obj._origin.$inferred === 'REDIRECTED')
         resolveTarget( art, obj._origin );
-      // console.log(message( null, obj.location, obj, {target:obj.target}, 'Info','TARGET')
-      //             .toString(), obj.target.$inferred)
+      // console.log(error( 'test-target', [ obj.location, obj ],
+      //   { target: obj.target, kind: obj.kind }, 'Target: $(TARGET), Kind $(KIND)'));
       if (!obj.target.$inferred || obj.target.$inferred === 'aspect-composition')
         resolveTarget( art, obj );
       else
@@ -448,8 +449,10 @@ function resolve( model ) {
   // propagation/rewrite has been done yet, cyclic dependency must have been
   // checked before!
   function getAssocSpec( type ) {
+    const cyclic = new Set(); // TODO(#8942): May not be necessary if effectiveType() is adapted.
     // only to be called without cycles
-    while (type) {
+    while (type && !cyclic.has(type)) {
+      cyclic.add(type);
       if (type.on || type.foreignKeys || type.targetAspect)
         return type;
       type = directType( type );
@@ -464,7 +467,7 @@ function resolve( model ) {
       // op.val is also correctly set with CSN input
       elem.type = { ...type, $inferred: 'cast' };
       setArtifactLink( elem.type, type._artifact );
-      for (const prop of [ 'length', 'precision', 'scale', 'srid' ]) {
+      for (const prop of typeParameters.list) {
         if (elem.value[prop])
           elem[prop] = { ...elem.value[prop], $inferred: 'cast' };
       }
@@ -1026,6 +1029,15 @@ function resolve( model ) {
       return;
     }
     const target = resolvePath( obj.target, 'target', art );
+
+    if (obj._pathHead && obj.type && !obj.type.$inferred && art._main && art._main.query) {
+      // New association inside expand/inline: The on-condition can't be properly checked,
+      // so abort early. See #8797
+      error( 'query-unexpected-assoc', [ obj.name.location, art ], {},
+             'Unexpected new association in expand/inline' );
+      return; // avoid subsequent errors
+    }
+
     if (obj.on) {
       if (!art._main || !art._parent.elements && !art._parent.items && !art._parent.targetAspect) {
         // TODO: test of .items a bit unclear - we should somehow restrict the
@@ -1057,20 +1069,29 @@ function resolve( model ) {
     else if (art.kind === 'mixin') {
       error( 'assoc-in-mixin', [ obj.target.location, art ], {},
              'Managed associations are not allowed for MIXIN elements' );
+      return; // avoid subsequent errors
+    }
+    else if (obj.type && !obj.type.$inferred && art._parent && art._parent.kind === 'select') {
+      // New association in views, i.e. parent is a query.
+      error( 'query-expected-on-condition', [ obj.target.location, art ], {},
+             'Expected on-condition for published association' );
+      return; // avoid subsequent errors
     }
     else if (target && !obj.foreignKeys && target.kind === 'entity') {
       if (obj.$inferred === 'REDIRECTED') {
         addImplicitForeignKeys( art, obj, target );
       }
-      else if (!obj.type || obj.type.$inferred || obj.target.$inferred) { // REDIRECTED
-        resolveRedirected( art, target );
-      }
-      else if (obj.type._artifact && obj.type._artifact.internal) { // cds.Association, ...
+      else if (obj.type && obj.type._artifact && obj.type._artifact.internal) {
+        // cds.Association, ...
         addImplicitForeignKeys( art, obj, target );
       }
-      // else console.log( message( null,obj.location,obj, {target}, 'Info','NOTARGET').toString())
     }
-    // else console.log( message( null, obj.location, obj, {target}, 'Info','NORE').toString())
+
+    if (target && !target.$inferred) {
+      if (!obj.type || obj.type.$inferred || obj.target.$inferred) { // REDIRECTED
+        resolveRedirected( art, target );
+      }
+    }
   }
 
   function addImplicitForeignKeys( art, obj, target ) {
@@ -1130,7 +1151,9 @@ function resolve( model ) {
     const assoc = directType( elem );
     const origType = assoc && effectiveType( assoc );
     if (!origType || !origType.target) {
-      error( 'redirected-no-assoc', [ elem.target.location, elem ], {},
+      const path = (elem.value && elem.value.path);
+      const loc = (path && path[path.length - 1] || elem.value || elem).location;
+      error( 'redirected-no-assoc', [ loc, elem ], {},
              'Only an association can be redirected' );
       return;
     }
@@ -1138,7 +1161,7 @@ function resolve( model ) {
     //             .toString(), elem.value)
     const nav = elem._main && elem._main.query && elem.value && pathNavigation( elem.value );
     if (nav && nav.item !== elem.value.path[elem.value.path.length - 1]) {
-      if (origType.on) {
+      if (!elem.on && origType.on) {
         error( 'rewrite-not-supported', [ elem.target.location, elem ], {},
                // TODO: Better text ?
                'The ON condition is not rewritten here - provide an explicit ON condition' );
@@ -1151,7 +1174,9 @@ function resolve( model ) {
 
     const chain = [];
     if (target === origTarget) {
-      if (!elem.target.$inferred) {
+      if (!elem.target.$inferred && !elem.on && !elem.foreignKeys) {
+        // Only a managed redirection gets this info message.  Because otherwise
+        // we'd have to check whether on-condition/foreignKeys are the same.
         info( 'redirected-to-same', [ elem.target.location, elem ], { art: target },
               'The redirected target is the original $(ART)' );
       }
@@ -1265,8 +1290,71 @@ function resolve( model ) {
   // Resolve the type and its arguments if applicable.
   function resolveTypeExpr( art, user ) {
     const typeArt = resolveType( art.type, user );
-    if (typeArt)
-      resolveTypeArguments( art, typeArt, user );
+    if (typeArt) {
+      resolveTypeArgumentsUnchecked( art, typeArt, user );
+      checkTypeArguments( art );
+    }
+  }
+
+  /**
+   * Check the type arguments on `artWithType`.
+   * If the effective type is an array or structured type, an error is emitted.
+   */
+  function checkTypeArguments( artWithType ) {
+    // Note: `_effectiveType` may point to `artWithType` itself, if the type is structured.
+    //       Also: For enums, it points to the enum type, which is why this trick is needed.
+    // TODO(#8942): May not be necessary if effectiveType() is adapted.  Furthermore, the enum
+    //              trick may be removed if effectiveType() does not stop at enums.
+    const cyclic = new Set();
+    let effectiveTypeArt = effectiveType( artWithType );
+    while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
+      cyclic.add(effectiveTypeArt);
+      const underlyingEnumType = directType(effectiveTypeArt);
+      if (underlyingEnumType)
+        effectiveTypeArt = effectiveType(underlyingEnumType);
+      else
+        break;
+    }
+
+    if (!effectiveTypeArt)
+      return; // e.g. illegal definition references
+
+    const params = effectiveTypeArt.parameters &&
+      effectiveTypeArt.parameters.map(p => p.name || p) || [];
+
+    for (const param of typeParameters.list) {
+      if (artWithType[param] !== undefined) {
+        if (!params.includes(param)) {
+          // Whether the type ref itself is a builtin or a custom type with a builtin as base.
+          const type = directType(artWithType);
+
+          let variant;
+          if (type.builtin)
+          // `.type` is already a builtin: use a nicer message.
+            variant = 'builtin';
+          else if (effectiveTypeArt.builtin)
+          // base type is a builtin, i.e. a scalar
+            variant = 'type';
+          else
+          // effectiveType is not a builtin -> array or structured
+            variant = 'non-scalar';
+
+          error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
+            '#': variant, prop: param, art: artWithType.type, type: effectiveTypeArt,
+          });
+          break; // Avoid spam: Only emit the first error.
+        }
+        else if (!typeParameters.expectedLiteralsFor[param].includes(artWithType[param].literal)) {
+          error('type-unexpected-argument', [ artWithType[param].location, artWithType ], {
+            '#': 'incorrect-type',
+            prop: param,
+            code: artWithType[param].literal,
+            names: typeParameters.expectedLiteralsFor[param],
+          });
+          break; // Avoid spam: Only emit the first error.
+        }
+      }
+    }
   }
 
   function resolveExpr( expr, expected, user, extDict, expandOrInline) {

package/lib/compiler/shared.js

@@ -157,8 +157,8 @@ function fns( model ) {
   const VolatileFns = model.$volatileFunctions;
   Object.assign( model.$functions, {
     resolveUncheckedPath,
+    resolveTypeArgumentsUnchecked,
     resolvePath,
-    resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
   } );
@@ -459,35 +459,64 @@ function fns( model ) {
     }
   }
 
-  // Resolve the type arguments provided with a type referenced for artifact or
-  // element `artifact`.  This function does nothing if the referred type
-  // `typeArtifact` does not have a `parameters` property (currently, only
-  // builtin-types have it, see ./builtins.js).
-  //
-  // For each property name `<prop>` in `typeArtifact.parameters`, we move a number
-  // in art.$typeArgs (a vector of numbers with locations) to `artifact.<prop>`.
-  // TODO: error if no parameters applicable
-  // TODO: also check for number
-  function resolveTypeArguments(artifact, typeArtifact, user) {
-    const args = artifact.$typeArgs || [];
+  /**
+   * Resolve the type arguments of `artifact` according to the type `typeArtifact`.
+   * User is used for semantic message location.
+   *
+   * For builtins, for each property name `<prop>` in `typeArtifact.parameters`, we move a value
+   * in art.$typeArgs (a vector of numbers with locations) to `artifact.<prop>`.
+   *
+   * For non-builtins, we take either one or two arguments and interpret them
+   * as `length` or `precision`/`scale`.
+   *
+   * Left-over arguments are errors for non-builtins and warnings for builtins.
+   *
+   * @param {object}  artifact
+   * @param {object} typeArtifact
+   * @param {CSN.Artifact} user
+   */
+  function resolveTypeArgumentsUnchecked(artifact, typeArtifact, user) {
+    let args = artifact.$typeArgs || [];
     const parameters = typeArtifact.parameters || [];
-    const parLength = parameters.length;
 
-    for (let i = 0; i < parLength; ++i) {
-      let par = parameters[i];
-      if (!(par instanceof Object))
-        par = { name: par };
-      if (!artifact[par.name] && i < args.length)
-        artifact[par.name] = args[i];
+    if (parameters.length > 0) {
+      // For Builtins
+      for (let i = 0; i < parameters.length; ++i) {
+        let par = parameters[i];
+        if (!(par instanceof Object))
+          par = { name: par };
+        if (!artifact[par.name] && i < args.length)
+          artifact[par.name] = args[i];
+      }
+      args = args.slice(parameters.length);
     }
-    if (args.length > parLength) {
-      artifact.$typeArgs = artifact.$typeArgs.slice(parLength);
-      warning( 'unexpected-type-arg', [ artifact.$typeArgs[0].location, user ],
-               { art: typeArtifact }, 'Too many arguments for type $(ART)' );
+    else if (args.length > 0 && !typeArtifact.builtin) {
+      // One or two arguments are interpreted as either length or precision/scale.
+      // For builtins, we know what arguments are expected, and we do not need this mapping.
+      // Also, we expect non-structured types.
+      if (args.length === 1) {
+        artifact.length = args[0];
+        args = args.slice(1);
+      }
+      else if (args.length === 2) {
+        artifact.precision = args[0];
+        artifact.scale = args[1];
+        args = args.slice(2);
+      }
     }
-    else if (artifact.$typeArgs) {
-      delete artifact.$typeArgs;
+
+    if (!artifact.$typeArgs)
+      return;
+
+    // Warn about left-over arguments.
+    if (args.length > 0) {
+      const loc = [ args[args.length - 1].location, user ];
+      if (typeArtifact.builtin)
+        warning( 'type-ignoring-argument', loc, { art: typeArtifact } );
+      else
+        error( 'type-unexpected-argument', loc, { '#': 'std', art: typeArtifact });
     }
+    artifact.$typeArgs = undefined;
   }
 
   // Return artifact or element referred by name `head`.  The first environment
@@ -732,7 +761,7 @@ function fns( model ) {
         signalNotFound( spec.undefinedDef || 'ref-undefined-def', [ item.location, user ],
                         [ env ], { art: a } );
       }
-      else if (art.name.select && art.name.select > 1) {
+      else if (art.name && art.name.select && art.name.select > 1) {
         // TODO: 'The current query has no element $(MEMBER)' with $self.MEMBER
         // and 'The sub query for alias $(ALIAS) has no element $(MEMBER)'
         // TODO: probably not extra messageId, but text variant
@@ -748,8 +777,13 @@ function fns( model ) {
                         { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
       }
       else {
+        const variant = art.kind === 'aspect' && !art.name && 'aspect';
         signalNotFound( spec.undefinedDef || 'ref-undefined-element', [ item.location, user ],
-                        [ env ], { art: searchName( art, item.id, 'element' ) } );
+                        [ env ], {
+                          '#': variant,
+                          art: (variant ? '' : searchName( art, item.id, 'element' )),
+                          id: item.id,
+                        } );
       }
       return null;
     }

package/lib/compiler/tweak-assocs.js

@@ -459,7 +459,13 @@ function tweakAssocs( model ) {
           if (!forKeys)
             break;
           setArtifactLink( item, null );
-          error( 'rewrite-undefined-key', [ weakLocation( (elem.target || elem).location ), assoc ],
+          const culprit = elem.target && !elem.target.$inferred && elem.target ||
+                          (elem.value && elem.value.path &&
+                           elem.value.path[elem.value.path.length - 1]) ||
+                          elem;
+          // TODO: probably better to collect the non-projected foreign keys
+          // and have one message for all
+          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), assoc ],
                  { id: item.id, art: alias._main },
                  'Foreign key $(ID) has not been found in target $(ART)' );
           return null;