@sap/cds-compiler 4.1.2 → 4.2.2

package/lib/transform/forRelationalDB.js

@@ -9,7 +9,7 @@ const { cloneCsnNonDict,
 const { makeMessageFunction } = require('../base/messages');
 const transformUtils = require('./transformUtils');
 const { translateAssocsToJoinsCSN } = require('./translateAssocsToJoins');
-const { csnRefs, pathId, traverseQuery } = require('../model/csnRefs');
+const { csnRefs, pathId, traverseQuery, columnAlias} = require('../model/csnRefs');
 const { checkCSNVersion } = require('../json/csnVersion');
 const validate = require('../checks/validator');
 const { rejectManagedAssociationsAndStructuresForHdbcdsNames } = require('../checks/selectItems');
@@ -163,6 +163,8 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   // Needs to happen before tuple expansion, so the newly generated WHERE-conditions have it applied
   handleExists(csn, options, error, csnUtils.inspectRef, csnUtils.initDefinition, csnUtils.dropDefinitionCache);
 
+  doA2J && flattening.linkForeignKeyAnnotationExtensionsToAssociation(csn, options);
+
   // Check if structured elements and managed associations are compared in an expression
   // and expand these structured elements. This tuple expansion allows all other
   // subsequent procession steps (especially a2j) to see plain paths in expressions.
@@ -463,70 +465,71 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
     Object.assign(csnUtils, csnRefApi);
   }
 
+  // For non-A2J only
   function handleMixinOnConditions(artifact, artifactName) {
-    if (!artifact.query)
+    if (!artifact.query) // projections can't have mixins
       return;
     forAllQueries(artifact.query, (query, path) => {
-      const { mixin } = query.SELECT  || {};
-      if(mixin) {
+      const { mixin } = query.SELECT || {};
+      if (mixin) {
         query.SELECT.columns
-        // filter for associations which are used in the SELECT
-        .filter((c) => {
-          return c.ref &&  c.ref.length > 1;
-        })
-        .forEach((usedAssoc) => {
-          const assocName = pathId(usedAssoc.ref[0]);
-          const mixinAssociation = mixin[assocName];
-          if(mixinAssociation){
-            mixinAssociation.on = getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path.concat(['mixin', assocName]));
-          }
-        })
+          // filter for associations which are used in the SELECT
+          .filter((c) => {
+            return c.ref && c.ref.length > 1;
+          })
+          .forEach((usedAssoc) => {
+            const assocName = pathId(usedAssoc.ref[0]);
+            const mixinAssociation = mixin[assocName];
+            if (mixinAssociation)
+              mixinAssociation.on = getResolvedMixinOnCondition(mixinAssociation, query, assocName, path.concat(['mixin', assocName]));
+          })
       }
-    }, [ 'definitions', artifactName, 'query' ]);
-
-    function getResolvedMixinOnCondition(csn, mixinAssociation, query, assocName, path){
-      const { inspectRef } = csnRefs(csn);
-      const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
-      return mixinAssociation.on
-            .map((onConditionPart, i) => {
-              let columnToReplace;
-              if(onConditionPart.ref && (onConditionPart.ref[0] === '$projection' || onConditionPart.ref[0] === '$self')){
-                const { links } = inspectRef(path.concat(['on', i]));
-                if(links){
-                  columnToReplace = onConditionPart.ref[links.length - 1];
-                }
-              }
-              if (!columnToReplace)
-                return onConditionPart;
-
-              const replaceWith = query.SELECT.columns.find((column) =>
-                column.as && column.as === columnToReplace ||
-                column.ref && column.ref[0] === columnToReplace
-              );
-              if (!replaceWith && referencedThroughStar) {
-                // not explicitly in column list, check query sources
-                // get$combined also includes elements which are part of "excluding {}"
-                // this shouldn't be an issue here, as such references get rejected
-                const elementsOfQuerySources = csnUtils.get$combined(query);
-                forEach(elementsOfQuerySources, (id, element) => {
-                  // if the ref points to an element which is not explicitly exposed in the column list,
-                  // but through the '*' operator -> replace the $projection / $self with the correct source entity
-                  if(id === columnToReplace)
-                    onConditionPart.ref[0] = element[0].parent;
-                });
-              }
+    }, ['definitions', artifactName, 'query']);
+  }
 
-              // No implicit CAST in on-condition
-              if(replaceWith && replaceWith.cast) {
-                const clone = cloneCsnNonDict(replaceWith, options);
-                delete clone.cast;
-                return clone;
-              }
-              return replaceWith || onConditionPart;
-            });
+  // For non-A2J only
+  function getResolvedMixinOnCondition(mixinAssociation, query, assocName, path) {
+    const referencedThroughStar = query.SELECT.columns.some((column) => column === '*');
+    return mixinAssociation.on.map(handeMixinOnConditionPart);
+
+    function handeMixinOnConditionPart(onConditionPart, i)  {
+      let columnToReplace;
+      if (onConditionPart.ref && (onConditionPart.ref[0] === '$projection' || onConditionPart.ref[0] === '$self')){
+        const { links } = csnUtils.inspectRef(path.concat(['on', i]));
+        if (links) {
+          columnToReplace = onConditionPart.ref[links.length - 1];
+        }
+      }
+      if (!columnToReplace)
+        return onConditionPart;
+
+      const replaceWith = query.SELECT.columns.find(col => columnAlias(col) === columnToReplace);
+      if (!replaceWith && referencedThroughStar) {
+          // not explicitly in column list, check query sources
+          // get$combined also includes elements which are part of "excluding {}"
+          // this shouldn't be an issue here, as such references get rejected
+        const elementsOfQuerySources = csnUtils.get$combined(query);
+        forEach(elementsOfQuerySources, (id, element) => {
+            // if the ref points to an element which is not explicitly exposed in the column list,
+            // but through the '*' operator -> replace the $projection / $self with the correct source entity
+          if(id === columnToReplace)
+            onConditionPart.ref[0] = element[0].parent;
+        });
+        return onConditionPart;
+      }
+      else if (replaceWith) {
+        const clone = cloneCsnNonDict(replaceWith, options);
+        delete clone.cast;  // No implicit CAST in on-condition
+        delete clone.as;
+        return clone;
+      }
+      else {
+        return onConditionPart
+      }
     }
   }
 
+
   /**
    * @param {CSN.Artifact} artifact
    * @param {string} artifactName
@@ -701,7 +704,9 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
     throwWithAnyError();
     // the augmentor isn't able to deal with technical configurations and since assoc2join can ignore it we
     // simply make it invisible and copy it over to the result csn
-    forEachDefinition(csn, art => art.technicalConfig && setProp(art, 'technicalConfig', art.technicalConfig));
+    forEachDefinition(csn,
+      art => art.technicalConfig && setProp(art, 'technicalConfig',
+      art.technicalConfig));
 
     const newCsn = translateAssocsToJoinsCSN(csn, options);
 
@@ -714,6 +719,23 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
         newCsn.definitions[artName].technicalConfig = art.technicalConfig;
 
     });
+    // restore $fkExtensions and $structRef for foreign key annotations
+    if (isBetaEnabled(options, 'annotateForeignKeys')) {
+      forEachDefinition(csn, (oldDef, artName) => {
+        const newDef = newCsn.definitions[artName];
+        if(oldDef?.elements) {
+          Object.entries(oldDef.elements).forEach(([eltName, oldElt]) => {
+            const newElt = newDef.elements[eltName];
+            if(oldElt.$fkExtensions)
+              setProp(newElt, '$fkExtensions', oldElt.$fkExtensions);
+            oldElt.keys?.forEach((fk, i) => {
+              if(fk.$structRef && newElt.keys?.[i])
+                setProp(newElt.keys[i], '$structRef', fk.$structRef);
+            })
+          })
+        }
+      });
+    }
     csn = newCsn;
   }
 
@@ -748,11 +770,7 @@ function transformForRelationalDBWithCsn(csn, options, moduleName) {
   function renamePrimitiveTypesAndUuid(val, node, key) {
     // assert key === 'type'
     const hanaNamesMap = createDict({
-      'cds.DateTime': 'cds.UTCDateTime',
-      'cds.Timestamp': 'cds.UTCTimestamp',
-      'cds.Date': 'cds.LocalDate',
-      'cds.Time': 'cds.LocalTime',
-      'cds.UUID': 'cds.String',
+      'cds.UUID': 'cds.String'
     });
     node[key] = hanaNamesMap[val] || val;
     if (val === 'cds.UUID' && !node.length) {

package/lib/transform/localized.js

@@ -13,6 +13,7 @@ const {
   forAllQueries,
   sortCsnDefinitionsForTests,
 } = require('../model/csnUtils');
+const {CompilerAssertion} = require('../base/error');
 
 /**
  * Indicator that a definition is localized and has a convenience view.
@@ -34,10 +35,11 @@ const _isViewForEntity = Symbol('_isViewForEntity'); // $inferred = 'LOCALIZED-H
  * Used to transitively create convenience views.
  */
 const _targetFor = Symbol('_targetFor');
+const annoPersistenceSkip = '@cds.persistence.skip';
 
 /**
  * Callback function returning `true` if the localization view should be created.
- * @callback acceptLocalizedView
+ * @callback AcceptLocalizedViewCallback
  * @param {string} viewName localization view name
  * @param {string} originalName Artifact name of the original view
  */
@@ -45,20 +47,22 @@ const _targetFor = Symbol('_targetFor');
 /**
  * Create transitive localized convenience views.
  *
- * A convenience view is created if the entity/view has a localized element
+ * A convenience view is created if the entity/view has a localized element[^1]
  * or if it exposes an association leading to a localized-tagged target.
  *
  * INTERNALS:
  * We have three kinds of localized convenience views:
  *
  *  1. "direct ones" using coalesce() for the table entities with localized
- *     elements: as projection on the original (created in extend.js)
- *  2. for table entities with associations to entities which have a localized
- *     convenience views or redirections thereon: as projection on the original
- *  3. for view entities with associations to entities which have a localized
- *     convenience views or redirections thereon: as entity using the same
- *     query as the original, but replacing all sources by their localized
- *     convenience view variant if present
+ *     elements[^1]: as projection on the original and '.texts' entity (created in extend.js)
+ *  2. for _table_ entities with associations to entities which have a localized
+ *     convenience: as projection on the original
+ *  3. for _view_ entities with either localized elements[^1] or associations
+ *     to entities which have a localized convenience view:
+ *     as view using a copy of the original query, but replacing all sources by
+ *     their localized convenience view variant if present
+ *
+ * [^1]: That is, the element has `localized: true`.
  *
  * First, all "direct ones" are built (1).  Then we build all 2 and 3
  * transitively (i.e. as long as an entity has an association which directly or
@@ -68,21 +72,46 @@ const _targetFor = Symbol('_targetFor');
  * variant if present.
  *
  * @param {CSN.Model} csn
- * @param {CSN.Options} options
- * @param {boolean} useJoins If true, rewrite the "localized" association to a
- *                           join in direct convenience views.
+ *     Input CSN model.  Should not have existing convenience views.
+ *
+ * @param {object} options
+ *     CSN options.  Only few options are used, see below for important ones.
+ *     Options such as `testMode` or `testSortCsn` can also be set.
+ *
+ * @param {string} [options.localizedLanguageFallback]
+ *     Valid values (if set): 'none', 'coalesce' (default)
+ *     Whether to use a `coalesce()` function when selecting from `.texts` entities.
+ *     If not set, untranslated strings may not return any value.  If 'coalesce'
+ *     is used, it will fall back to the original string.
+ *
+ * @param {boolean} [options.localizedWithoutCoalesce]
+ *     Deprecated version of localizedLanguageFallback. Do not use.
+ *
+ * @param {boolean} [options.fewerLocalizedViews]
+ *
  * @param {object} config
+ *     Configuration for creating convenience views.  Non-user visible options.
+ *
+ * @param {boolean} [config.useJoins]
+ *     If true, rewrite the "localized" association to a join in direct convenience views.
+ *
+ * @param {AcceptLocalizedViewCallback} [config.acceptLocalizedView]
+ *     A callback that can be used to suppress the creation of localized convenience views
+ *     if desired.  For example, if you want to know which definitions get a convenience view
+ *     but don't actually want to create them.
+ *
+ * @param {boolean} [config.ignoreUnknownExtensions]
+ *     If true, do not emit a warning for annotations on unknown `localized.*` views.
  */
-function _addLocalizationViews(csn, options, useJoins, config) {
+function _addLocalizationViews(csn, options, config) {
   const messageFunctions = makeMessageFunction(csn, options);
-  if (checkExistingLocalizationViews(csn, options, messageFunctions)) {
-    messageFunctions.throwWithError();
+  if (checkExistingLocalizationViews(csn, options, messageFunctions))
     return csn;
-  }
 
-  const { acceptLocalizedView, ignoreUnknownExtensions } = config;
+  const { useJoins, acceptLocalizedView, ignoreUnknownExtensions } = config;
   const noCoalesce = (options.localizedLanguageFallback === 'none' ||
                       options.localizedWithoutCoalesce);
+  const ignoreAssocToLocalized = !!options.fewerLocalizedViews;
 
   createDirectConvenienceViews();     // 1
   createTransitiveConvenienceViews(); // 2 + 3
@@ -179,10 +208,10 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     copyLocation(convenienceView.query, entity);
 
     if (shouldUseJoin)
-      // Expand elements:
+      // Expand elements; (variant 1)
       columns.push( ...columnsForEntityWithExcludeList( entity, 'L_0', textElements ) )
     else
-      columns.push( '*' );
+      columns.push( '*' ); // (variant 2)
 
     for (const originalElement of textElements) {
       const elem = entity.elements[originalElement];
@@ -330,7 +359,7 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     let keyCount = 0;
     let textElements = [];
 
-    forEachGeneric(art, 'elements', (elem, elemName , _prop, path) => {
+    forEachGeneric(art, 'elements', (elem, elemName , _prop) => {
       if (elem.$ignore) // from SAP HANA backend
         return;
 
@@ -339,11 +368,6 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
       if (elem.key || elem.$key || elem.localized)
         textElements.push( elemName );
-
-      if ((elem.key|| elem.$key) && elem.localized) {
-        messageFunctions.warning('def-ignoring-localized', path, { keyword: 'localized' },
-          'Keyword $(KEYWORD) is ignored for primary keys');
-      }
     }, artPath);
 
     if (textElements.length <= keyCount || keyCount <= 0)
@@ -364,12 +388,17 @@ function _addLocalizationViews(csn, options, useJoins, config) {
              'Skipped creation of convenience view for $(NAME) because its texts entity could not be found' );
       return null;
     }
-
     if (!isValidTextsEntity( textsEntity )) {
       messageFunctions.info( null, [ 'definitions', textsName ], { name: artName },
              'Skipped creation of convenience view for $(NAME) because its texts entity does not appear to be valid' );
       return null;
     }
+    if (!art[annoPersistenceSkip] && textsEntity[annoPersistenceSkip]) {
+      messageFunctions.message( 'anno-unexpected-localized-skip', artPath,
+          { name: textsName, art: artName, anno: annoPersistenceSkip },
+          'Compiler generated entity $(NAME) must not be annotated with $(ANNO) if $(ART) is not skipped' );
+      return null;
+    }
 
     // There may be keys in the original artifact that were added by the core compiler,
     // for example elements that are marked @cds.valid.from.
@@ -391,22 +420,23 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
   /**
    * Transitively create convenience views for entities/views that have
-   * associations to localized entities or to views that themselves have such
-   * a dependency.
+   * associations to localized entities, views that themselves have such
+   * a dependency or views that contain projections on localized elements.
    *
    * The algorithm is as follows:
    *
-   *  1. For each view/entity with associations:
-   *    - If target is NOT localized => add view/entity to target's `_targetFor` property
-   *    - If target is     localized => add view/entity to array `entities`
+   *  1. For each view with elements that have `localized: true` markers:
+   *      => add view to array `entities`
+   *     For each view/entity with associations:
+   *      - If target is NOT localized => add view/entity to target's `_targetFor` property
+   *      - If target is     localized => add view/entity to array `entities`
    *  2. As long as `entities` has entries:
-   *     a. For each entry in `entities`
-   *        - Create a convenience view
-   *        - If the entry has a `_targetFor` property, add its entries to
-   *          `nextEntities` because they now have a transitive dependency on a
-   *          localized view.
-   *     b. Copy all entries from `nextEntities` to `entities`.
-   *     c. Clear `nextEntities`.
+   *      a. For each entry in `entities`
+   *         - Create a convenience view
+   *         - If the entry has a `_targetFor` property, add its entries to `nextEntities`
+   *           because they now have a transitive dependency on a localized view.
+   *      b. Copy all entries from `nextEntities` to `entities`.
+   *      c. Clear `nextEntities`.
    *  3. Rewrite all references to the localized variants.
    */
   function createTransitiveConvenienceViews() {
@@ -448,10 +478,9 @@ function _addLocalizationViews(csn, options, useJoins, config) {
             // if the artifact is an entity (already processed in (1))
             entities.push(artName);
           }
-          else if (elem.target) {
+          else if (!ignoreAssocToLocalized && elem.target) {
             // If the target has a localized view then we are localized as well.
             const def = csn.definitions[elem.target];
-            // TODO: What if elem.target cannot be found? Could this happen after flattening, ...?
             if (!def)
               continue;
 
@@ -490,7 +519,7 @@ function _addLocalizationViews(csn, options, useJoins, config) {
 
       addLocalizedView(artName);
 
-      if (art[_targetFor])
+      if (!ignoreAssocToLocalized && art[_targetFor])
         nextEntities.push(...art[_targetFor]);
       delete art[_targetFor];
     }
@@ -578,14 +607,22 @@ function _addLocalizationViews(csn, options, useJoins, config) {
     if (!obj || !obj.ref)
       return;
     const ref = Array.isArray(obj.ref) ? obj.ref[0] : obj.ref;
-    if (typeof ref !== 'string')
-      return;
-    const def = csn.definitions[ref];
-    if (def && def[_hasLocalizedView]) {
-      if (Array.isArray(obj.ref))
-        obj.ref[0] = def[_hasLocalizedView];
-      else
+    if (typeof ref === 'string') {
+      const def = csn.definitions[ref];
+      if (def && def[_hasLocalizedView]) {
+        if (Array.isArray(obj.ref))
+          obj.ref[0] = def[_hasLocalizedView];
+        else
         obj.ref = def[_hasLocalizedView];
+      }
+
+    } else if (ref.id) {
+      const def = csn.definitions[ref.id];
+      if (def && def[_hasLocalizedView])
+        obj.ref[0].id = def[_hasLocalizedView];
+
+    } else if (options.testMode) {
+      throw new CompilerAssertion('Debug me: Unhandled reference during localized-rewrite!');
     }
   }
 
@@ -593,7 +630,7 @@ function _addLocalizationViews(csn, options, useJoins, config) {
    * @param {string} artName
    */
   function textsEntityName(artName) {
-    // We can assume, that the element exists.  This is checked in isEntityPreprocessed()
+    // We can assume that the element exists.  This is checked in isEntityPreprocessed().
     return csn.definitions[artName].elements.texts.target;
   }
 
@@ -626,23 +663,23 @@ function _addLocalizationViews(csn, options, useJoins, config) {
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config]
  */
 function addLocalizationViews(csn, options, config = {}) {
-  return _addLocalizationViews(csn, options, false, config);
+  return _addLocalizationViews(csn, options, { ...config, useJoins: false });
 }
 
 /**
  * Create transitive localized convenience views to the given CSN but
  * rewrite the "localized" association to joins in direct entity convenience
- * views.  This is needed by e.g. SQL for SQLite where A2J is used.
+ * views.  This is needed e.g. by SQL for SQLite where A2J is used.
  *
  * @param {CSN.Model} csn
  * @param {CSN.Options} options
- * @param [config] config.acceptLocalizedView: optional callback function returning true if the localized view name and its parent name provided as parameter should be created
+ * @param [config]
  */
 function addLocalizationViewsWithJoins(csn, options, config = {}) {
-  return _addLocalizationViews(csn, options, true, config);
+  return _addLocalizationViews(csn, options, { ...config, useJoins: true });
 }
 
 /**

package/lib/transform/transformUtils.js

@@ -265,7 +265,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       } else {
         // Primitive child - clone it and restore its cross references
         let flatElemName = elemName + pathDelimiter + childName;
-        let flatElem = cloneCsnNonDict(childElem, options);
+        let flatElem = cloneCsnNonDict(childElem, { ...options, hiddenPropertiesToClone: [ '$structRef', '$fkExtensions' ] } );
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
@@ -536,7 +536,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       addElement(draftUuid, artifact, artifactName);
 
       // CreationDateTime : Timestamp;
-      const creationDateTime = createScalarElement('CreationDateTime', hanaMode ? 'cds.UTCTimestamp' : 'cds.Timestamp');
+      const creationDateTime = createScalarElement('CreationDateTime', 'cds.Timestamp');
       creationDateTime.CreationDateTime['@Common.Label'] = '{i18n>Draft_CreationDateTime}';
       addElement(creationDateTime, artifact, artifactName);
 
@@ -553,7 +553,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       addElement(draftIsCreatedByMe, artifact, artifactName);
 
       // LastChangeDateTime : Timestamp;
-      const lastChangeDateTime = createScalarElement('LastChangeDateTime', hanaMode ? 'cds.UTCTimestamp' : 'cds.Timestamp');
+      const lastChangeDateTime = createScalarElement('LastChangeDateTime', 'cds.Timestamp');
       lastChangeDateTime.LastChangeDateTime['@Common.Label'] = '{i18n>Draft_LastChangeDateTime}';
       addElement(lastChangeDateTime, artifact, artifactName);
 
@@ -1175,13 +1175,12 @@ function getTransformers(model, options, pathDelimiter = '_') {
               // do the paths match?
               if(op !== 'like' && !(x.lhs && x.rhs)) {
                 if(xn.length) {
-                  error(null, location,
-                    {
-                      prefix: prefix(lhs, op, rhs),
-                      name: xn,
-                      alias: (x.lhs ? rhs : lhs).ref.join('.')
-                    },
-                    '$(PREFIX): Sub path $(NAME) not found in $(ALIAS)');
+                  error('expr-invalid-expansion', location, {
+                    value: prefix(lhs, op, rhs),
+                    name: xn,
+                    alias: (x.lhs ? rhs : lhs).ref.join('.')
+                  },
+                    'Missing sub path $(NAME) in $(ALIAS) for tuple expansion of $(VALUE); both sides must expand to the same sub paths');
                 }
                 else {
                   error(null, location,

package/lib/utils/file.js

@@ -101,22 +101,22 @@ function cdsFs( fileCache, enableTrace ) {
         if (body && body.stack && body.message) {
           // NOTE: checks for instanceof Error are not reliable if error
           //       created in different execution env
-          traceFS( 'READFILE:cache-error:', filename, body.message );
+          traceFS( 'READFILE:cache-err:', filename, body.message );
           cb( body );   // no need for process.nextTick( cb, body ) with moduleResolve
         }
         else {
-          traceFS( 'READFILE:cache:', filename, body );
+          traceFS( 'READFILE:cache:    ', filename, body );
           cb( null, body );
         }
       }
       else {
-        traceFS( 'READFILE:start:', filename );
+        traceFS( 'READFILE:start:    ', filename );
         // TODO: set cache directly to some "delay" - store error differently?
         // e.g. an error of callback functions!
         try {
           reader(filename, enc, (err, data) => {
             fileCache[filename] = err || data;
-            traceFS('READFILE:data:', filename, err || data);
+            traceFS('READFILE:data:     ', filename, err || data);
             cb(err, data);
           });
         }
@@ -137,14 +137,14 @@ function cdsFs( fileCache, enableTrace ) {
     return ( filename, cb ) => {
       let body = fileCache[filename];
       if (body !== undefined) {
-        traceFS( 'ISFILE:cache:', filename, body );
+        traceFS( 'ISFILE:cache:      ', filename, body );
         if (body instanceof Error)
           cb( body );   // no need for process.nextTick( cb, body ) with moduleResolve
         else // body could be empty string
           cb( null, !!body || typeof body === 'string');
       }
       else {
-        traceFS( 'ISFILE:start:', filename, body );
+        traceFS( 'ISFILE:start:      ', filename, body );
         // in the future (if we do module resolve ourselves with just readFile),
         // we avoid parallel readFile by storing having an array of `cb`s in
         // fileCache[ filename ] before starting fs.readFile().
@@ -156,7 +156,7 @@ function cdsFs( fileCache, enableTrace ) {
               body = !!(stat.isFile() || stat.isFIFO());
             if (fileCache[filename] === undefined) // parallel readFile() has been processed
               fileCache[filename] = body;
-            traceFS('ISFILE:data:', filename, body);
+            traceFS('ISFILE:data:       ', filename, body);
             if (body instanceof Error)
               cb(err);
             else