@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/transform/transformUtilsNew.js

@@ -6,11 +6,12 @@
 
 const { hasErrors, makeMessageFunction } = require('../base/messages');
 const { setProp } = require('../base/model');
-const { csnRefs } = require('../model/csnRefs');
 
 const { copyAnnotations, applyTransformations } = require('../model/csnUtils');
-const { cloneCsn, cloneCsnDictionary, getUtils, isBuiltinType } = require('../model/csnUtils');
+const { cloneCsnNonDict, cloneCsnDictionary, getUtils } = require('../model/csnUtils');
+const { typeParameters, isBuiltinType } = require('../compiler/builtins');
 const { ModelError } = require("../base/error");
+const { forEach } = require('../utils/objectUtils');
 
 // Return the public functions of this module, with 'model' captured in a closure (for definitions, options etc).
 // Use 'pathDelimiter' for flattened names (e.g. of struct elements or foreign key elements).
@@ -19,20 +20,18 @@ const { ModelError } = require("../base/error");
 // TODO: check the situation with assocs with values. In compacted CSN such elements have only "@Core.Computed": true
 function getTransformers(model, options, pathDelimiter = '_') {
   const { error, warning, info } = makeMessageFunction(model, options);
+  const csnUtils = getUtils(model);
   const {
     getCsnDef,
-    getFinalBaseType,
+    getFinalBaseTypeWithProps,
     hasAnnotationValue,
     inspectRef,
     isStructured,
-  } = getUtils(model);
-
-  const {
     effectiveType,
-  } = csnRefs(model);
-
+  } = csnUtils;
 
   return {
+    csnUtils,
     resolvePath,
     flattenPath,
     addDefaultTypeFacets,
@@ -44,7 +43,6 @@ function getTransformers(model, options, pathDelimiter = '_') {
     copyTypeProperties,
     isAssociationOperand,
     isDollarSelfOrProjectionOperand,
-    getFinalBaseType,
     createExposingProjection,
     createAndAddDraftAdminDataProjection,
     createScalarElement,
@@ -242,23 +240,21 @@ function getTransformers(model, options, pathDelimiter = '_') {
     // for type of 'x' -> elem.type is an object, not a string -> use directly
     let elemType;
     if (!elem.elements) // structures do not have final base type
-      elemType = getFinalBaseType(elem.type);
+      elemType = getFinalBaseTypeWithProps(elem.type);
 
     const struct = elemType ? elemType.elements : elem.elements;
 
     // Collect all child elements (recursively) into 'result'
     // TODO: Do not report collisions in the generated elements here, but instead
-    // leave that work to the receiver of this result
+    //       leave that work to the receiver of this result
     let result = Object.create(null);
     const addGeneratedFlattenedElement = (e, eName) => {
-      if(result[eName]){
-        error(null, pathInCsn, { name: eName },
-          'Generated element $(NAME) conflicts with other generated element')
-      } else {
+      if (result[eName])
+        error('name-duplicate-element', pathInCsn, { '#': 'flatten-element-gen', name: eName })
+      else
         result[eName] = e;
-      }
     }
-    Object.entries(struct).forEach(([childName, childElem]) => {
+    forEach(struct, (childName, childElem) => {
       if (isStructured(childElem)) {
         // Descend recursively into structured children
         let grandChildElems = flattenStructuredElement(childElem, childName, elementPath, pathInCsn.concat('elements',childName));
@@ -276,7 +272,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
       } else {
         // Primitive child - clone it and restore its cross references
         let flatElemName = elemName + pathDelimiter + childName;
-        let flatElem = cloneCsn(childElem, options);
+        let flatElem = cloneCsnNonDict(childElem, options);
         // Don't take over notNull from leaf elements
         delete flatElem.notNull;
         setProp(flatElem, '_flatElementNameWithDots', elementPath.concat(childName).join('.'));
@@ -285,8 +281,12 @@ function getTransformers(model, options, pathDelimiter = '_') {
     });
 
     // Fix all collected flat elements (names, annotations, properties, origin ..)
-    Object.values(result).forEach(flatElem => {
-      // Copy annotations from struct (not overwriting, because deep annotations should have precedence)
+    forEach(result, (name, flatElem) => {
+      // Copy annotations from struct (not overwriting, because deep annotations should have precedence).
+      // Attention:
+      // This has historic reasons. We don't copy doc-comments because copying annotations
+      // is questionable to begin with.  Only selected annotations should have been copied,
+      // if at all.
       copyAnnotations(elem, flatElem, false);
       // Copy selected type properties
       const props = ['key', 'virtual', 'masked', 'viaAll'];
@@ -394,82 +394,65 @@ function getTransformers(model, options, pathDelimiter = '_') {
   }
 
   /**
-   * Replace the type of 'node' with its final base type (in contrast to the compiler,
-   * also unravel derived enum types, i.e. take the final base type of the enum's base type.
-   * Similar with associations and compositions (we probably need a _baseType link)
+   * Replace the type of 'nodeWithType' with its final base type, i.e. copy relevant type properties and
+   * set the `type` property to the builtin if scalar or delete it if structured/arrayed.
    *
-   * @param {CSN.Artifact} node
+   * @param {object} nodeWithType
    * @param {WeakMap} [resolved] WeakMap containing already resolved refs
    * @param {boolean} [keepLocalized=false] Whether to clone .localized from a type def
-   * @returns {void}
    */
-  function toFinalBaseType(node, resolved, keepLocalized=false) {
-    // Nothing to do if no type (or if array/struct type)
-    if (!node || !node.type) return;
-    // In case of a ref -> Follow the ref
-    if (node.type && node.type.ref) {
-      const finalBaseType = getFinalBaseType(node.type, undefined, resolved);
-      if(finalBaseType === null)
-        throw Error('Failed to obtain final base type for reference : ' + node.type.ref.join('/'));
-      if(finalBaseType.elements) {
-          // This changes the order - to be discussed!
-        node.elements = cloneCsn(finalBaseType, options).elements; // copy elements
-        delete node.type; // delete the type reference as edm processing does not expect it
-      } else if(finalBaseType.items) {
-          // This changes the order - to be discussed!
-        node.items = cloneCsn(finalBaseType.items, options); // copy items
-        delete node.type;
-      } else {
-        node.type=finalBaseType;
-      }
+  function toFinalBaseType(nodeWithType, resolved = new WeakMap(), keepLocalized = false) {
+    const type = nodeWithType?.type;
+    if (!type || nodeWithType.elements || nodeWithType.items || resolved.has(nodeWithType)) {
       return;
     }
-    // ..  or builtin already
-    if (node.type && isBuiltinType(node.type)) return;
+    // The caller may use `{ art }` syntax for `{ ref }` objects, but we only use
+    // it to indicate that an artifact has been processed.
+    resolved.set(nodeWithType, nodeWithType);
 
-    // The type might already be a full fledged type def (array of)
-    let typeDef = typeof node.type === 'string' ? getCsnDef(node.type) : node.type;
-    // Nothing to do if type is an array or a struct type
-    if (typeDef.items || typeDef.elements) {
-      // Expand structured types on entity elements for flat OData
-      if(!(options.transformation === 'hdbcds' || options.toSql))
-        return;
+    // Nothing to copy from builtin.
+    if (typeof type === 'string' && isBuiltinType(type))
+      return;
+
+    let typeRef = null;
+    if (resolved.has(type)) {
+      typeRef = resolved.get(type)?.art
+      // The cached entry may not be resolved, yet.
+      if (typeRef.type && !isBuiltinType(typeRef.type))
+        typeRef = getFinalBaseTypeWithProps(typeRef.type);
+    } else {
+      typeRef = getFinalBaseTypeWithProps(type);
+    }
 
-      // cloneCsn only works correctly if we start "from the top"
-      const cloneTypeDef = cloneCsn(typeDef, options);
-      // With hdbcds-hdbcds, don't resolve structured types - but propagate ".items", to turn into LargeString later on.
-      if(typeDef.items) {
-        delete node.type;
-        if(!node.items)
-          Object.assign(node, {items: cloneTypeDef.items});
+    if (typeRef.elements || typeRef.items) {
+      // Copy elements/items and we're finished. No need to look up actual base type,
+      // since it must also be structured and must contain at least as many elements,
+      // if not more (in client style CSN).
+      if (typeRef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
+        nodeWithType.elements = cloneCsnDictionary(typeRef.elements, options);
+        delete nodeWithType.type;
       }
-      if(typeDef.elements && !(options.transformation === 'hdbcds' && options.sqlMapping === 'hdbcds')) {
-        if(!typeDef.items)
-          delete node.type;
-        if(!node.elements)
-          Object.assign(node, {elements: cloneTypeDef.elements});
+      if (typeRef.items) {
+        nodeWithType.items = cloneCsnNonDict(typeRef.items, options);
+        delete nodeWithType.type;
       }
-
-
       return;
     }
-    // if the declared element is an enum, these values are with priority
-    if (!node.enum && typeDef.enum) {
-      const clone = cloneCsnDictionary(typeDef.enum, options);
-      Object.assign(node, { enum: clone });
+
+    if (typeRef.enum && nodeWithType.enum === undefined)
+      nodeWithType.enum = cloneCsnDictionary(typeRef.enum, options);
+
+    // Copy type and type arguments (+ localized)
+
+    for (const param of typeParameters.list) {
+      if (nodeWithType[param] === undefined && typeRef[param] !== undefined &&!typeRef.$default) {
+        nodeWithType[param] = typeRef[param];
+      }
     }
-    if (node.length === undefined && typeDef.length !== undefined)
-      Object.assign(node, { length: typeDef.length });
-    if (node.precision === undefined && typeDef.precision !== undefined)
-      Object.assign(node, { precision: typeDef.precision });
-    if (node.scale === undefined && typeDef.scale !== undefined)
-      Object.assign(node, { scale: typeDef.scale });
-    if (node.srid === undefined && typeDef.srid !== undefined)
-      Object.assign(node, { srid: typeDef.srid });
-    if (keepLocalized && node.localized === undefined && typeDef.localized !== undefined)
-      Object.assign(node, { localized: typeDef.localized });
-    node.type = typeDef.type;
-    toFinalBaseType(node);
+    if (keepLocalized && nodeWithType.localized === undefined && typeRef.localized !== undefined)
+      nodeWithType.localized = typeRef.localized;
+    if (typeRef.type)
+      nodeWithType.type = typeRef.type;
   }
 
   // Return a full projection 'projectionId' of artifact 'art' for exposure in 'service'.
@@ -899,7 +882,7 @@ function getTransformers(model, options, pathDelimiter = '_') {
     let elements = artifact.elements;
     if (elements) {
       path.push('elements', null);
-      Object.entries(elements).forEach(([name, obj]) => {
+      forEach(elements, (name, obj) => {
         path[path.length - 1] = name;
         recurseElements(obj, path, callback);
       });

package/lib/transform/translateAssocsToJoins.js

@@ -44,7 +44,7 @@ function translateAssocsToJoinsCSN(csn, options){
   }
 
   // If A2J reports error - end! Continuing with a broken CSN makes no sense
-  makeMessageFunction(model, options).throwWithError();
+  makeMessageFunction(model, options).throwWithAnyError();
   // FIXME: Move this somewhere more appropriate
   const compact = compactModel(model, compileOptions);
   return compact;
@@ -57,10 +57,10 @@ function translateAssocsToJoins(model, inputOptions = {})
   const options = model.options || inputOptions;
 
   // create JOINs for foreign key paths
-  const noJoinForFK = options.forHana ? !options.forHana.joinfk : true;
+  const noJoinForFK = options.forHana ? !options.joinfk : true;
 
   // Note: This is called from the 'forHana' transformations, so it is controlled by its options)
-  const pathDelimiter = (options.forHana && options.forHana.names === 'hdbcds') ? '.' : '_';
+  const pathDelimiter = (options.forHana && options.sqlMapping === 'hdbcds') ? '.' : '_';
 
   forEachDefinition(model, prepareAssociations);
   forEachDefinition(model, transformQueries);
@@ -1818,6 +1818,10 @@ function walkPath(node, env)
   // or that are parameters ($parameters or escaped paths (':')
   //path.length && path[ path.length-1 ]._artifact
   const art = path && path.length && path[path.length-1]._artifact;
+
+  // regardless of the position in the query, ignore paths that have virtual path steps
+  if(art && path.some(ps => ps._artifact && ps._artifact.virtual && ps._artifact.virtual.val))
+    return path;
   if(art && !internalArtifactKinds.includes(art.kind))
   {
     if(env.callback)

package/lib/transform/universalCsn/.eslintrc.json

@@ -21,11 +21,11 @@
     "sonarjs/no-duplicate-string": "off"
   },
   "parserOptions": {
-    "ecmaVersion": 2018,
+    "ecmaVersion": 2020,
     "sourceType": "script"
   },
   "env": {
-    "es6": true,
+    "es2020": true,
     "node": true
   },
   "settings": {

package/lib/transform/universalCsn/coreComputed.js

@@ -12,7 +12,7 @@ const { setAnnotationIfNotDefined } = require('./utils');
  */
 function setCoreComputedOnViews(csn) {
   const {
-    artifactRef, getColumn, getElement,
+    artifactRef, getColumn, getElement, getOrigin,
   } = getUtils(csn, 'init-all');
 
   forEachDefinition(csn, (artifact) => {
@@ -57,7 +57,15 @@ function setCoreComputedOnViews(csn) {
       const column = getColumn(element);
       if (column)
         return column;
-      return getElementFromFrom(name, base.from);
+      const from = getElementFromFrom(name, base.from);
+      if (from)
+        return from;
+      // For .expand/.inline, we can find it via origin
+      // Although I would have expected to find it via getColumn...
+      const origin = getOrigin(element);
+      if (origin)
+        return origin;
+      throw new Error(`Could not find ancestor for ${JSON.stringify(element)} named ${name}`);
     }
 
     /**
@@ -87,10 +95,7 @@ function setCoreComputedOnViews(csn) {
         return getElementFromFrom(name, base.SET.args[0]);
       }
       else if (base.args && base.join) {
-        const result = checkJoinSources(base.args, name);
-        if (!result)
-          throw new Error(`Could not find ${name} in ${JSON.stringify(base.args)}`);
-        return result;
+        return checkJoinSources(base.args, name);
       }
 
       throw new Error(JSON.stringify(base));
@@ -137,9 +142,11 @@ function setCoreComputedOnViews(csn) {
      * @returns {boolean}
      */
     function needsCoreComputed(column) {
-      return column && ( column.xpr || column.func || column.val !== undefined || column.param || column.SELECT || column.SET || column.ref && column.ref[0] in {
-        $at: 1, $now: 1, $user: 1, $session: 1,
-      });
+      return column &&
+        (
+          column.xpr || column.func || column.val !== undefined || column.param || column.SELECT || column.SET ||
+          column.ref && [ '$at', '$now', '$user', '$session' ].includes(column.ref[0])
+        );
     }
 
     /**

package/lib/transform/universalCsn/universalCsnEnricher.js

@@ -29,10 +29,7 @@ module.exports = (csn, options) => {
   const definitionPropagationRules = {
     '@cds.autoexpose': onlyViaArtifact,
     '@fiori.draft.enabled': onlyViaArtifact,
-    '@': (prop, target, source) => {
-      if (source[prop] !== null)
-        target[prop] = source[prop];
-    },
+    '@': nullStopsPropagation,
     // Example: `type E : F;` does not have `elements`, but they are required for e.g. OData.
     elements: onlyTypeDef,
     '@cds.persistence.exists': skip,
@@ -48,7 +45,7 @@ module.exports = (csn, options) => {
     '@cds.autoexposed': skip,
     '@cds.redirection.target': skip,
     type: always,
-    doc: always,
+    doc: nullStopsPropagation,
     length: always,
     precision: always,
     scale: always,
@@ -94,6 +91,10 @@ module.exports = (csn, options) => {
     }, // overwrite from defProps
     kind: skip,
     val: always,
+    type: notWithItemsOrElements,
+    target: notWithItemsOrElements,
+    keys: notWithItemsOrElements,
+    cardinality: notWithItemsOrElements,
   };
 
   generate();
@@ -288,7 +289,11 @@ module.exports = (csn, options) => {
         if (returns.target)
           calculateForeignKeys(returns);
       },
-      items: (parent, prop, items) => propagateMemberPropsFromOrigin(items, { '@': true, doc: true }),
+      items: (parent, prop, items) => {
+        // items in items must be propagated
+        // `specialItemsRule()` does not cover this case
+        propagateMemberPropsFromOrigin(items, { '@': true, doc: true }, { items: onlyWithTypeRef });
+      },
       elements: (parent, prop, elements) => {
         forEachValue(elements, (e) => {
           // within query elements we have to propagate the `enum` prop
@@ -358,13 +363,31 @@ module.exports = (csn, options) => {
         return !origin;
       }
     }
+
+    /**
+     * Some properties must only be copied over if the target
+     * is a type reference pointing to an element of a type or
+     * an aspect.
+     *
+     * @param {string} prop
+     * @param {CSN.Element} target
+     * @param {CSN.Element} source
+     */
+    function onlyWithTypeRef(prop, target, source) {
+      const typeIsTypeRef = Boolean(typeof target.type === 'object' && target.type.ref);
+      if (typeIsTypeRef) {
+        const referencedArtifact = csn.definitions[target.type.ref[0]];
+        if (referencedArtifact.kind in { type: true, aspect: true })
+          target[prop] = source[prop];
+      }
+    }
   }
 
   /**
    * Identify the sources of the passed object and propagate the relevant
    * properties/annotations along it's $origin chain.
    *
-   * @param {Object} art Target object for propagation
+   * @param {object} art Target object for propagation
    */
   function propagateOnArtifactLevel(art) {
     // check if art was already processed by the status flag
@@ -415,7 +438,7 @@ module.exports = (csn, options) => {
           copyProperties(definition.$origin, definition, getDefinitionPropagationRuleFor);
 
         // We need to propagate .elements to type artifacts - but our direct origin might not have .elements,
-        // because they are not propagated to members. We check if our root had elements (so we know that we should have some aswell)
+        // because they are not propagated to members. We check if our root had elements (so we know that we should have some as well)
         // and then walk the origin-chain until we find the first .elements
         if (definition.kind === 'type' && root.elements && !definition.elements) {
           const firstOriginWithElements = getFirstOriginWithElements(source);
@@ -580,7 +603,7 @@ module.exports = (csn, options) => {
  * @param {Function} getCustomRule getter for the `memberProps` or `defProps`
  *                                 which shall be used for retrieving custom rules
  * @param {object} [except=null] array of properties which should not be propagated
- * @param {object} [force=null] Force propagation of the contained keys via rule "always"
+ * @param {object} [force=null] Force propagation of the contained keys via a custom rule.
  */
 function copyProperties(from, to, getCustomRule, except = null, force = null) {
   const keys = Object.keys(from);
@@ -589,7 +612,7 @@ function copyProperties(from, to, getCustomRule, except = null, force = null) {
     if (except && !(force && force[key]) && (key.charAt(0) in except || key in except))
       continue;
     if (!(key in to)) {
-      const func = force && force[key] ? always : getCustomRule(key);
+      const func = force && force[key] ? force[key] : getCustomRule(key);
       if (func)
         func(key, to, from);
     }
@@ -680,6 +703,19 @@ function notWithTypeOrigin(prop, target, source) {
     target[prop] = source[prop];
 }
 
+/**
+ * The value `null` tells us to skip the propagation of the property.
+ * This is the case e.g. for `doc` or for annotations.
+ *
+ * @param {string} prop
+ * @param {CSN.Element} target
+ * @param {CSN.Element} source
+ */
+function nullStopsPropagation(prop, target, source) {
+  if (source[prop] !== null)
+    target[prop] = source[prop];
+}
+
 /**
  * Special propagation rules for .items - depending on the exact type of .items and the
  * way it was referenced (type of, direct type, direct many), we need to propagate (or not).
@@ -700,6 +736,20 @@ function specialItemsRules(prop, target, source) {
     target[prop] = source[prop];
 }
 
+/**
+ * Don't propagate certain properties if the target already has a .items or .elements
+ *
+ * This happens with .expand/.inline
+ *
+ * @param {string} prop
+ * @param {CSN.Element} target
+ * @param {CSN.Element} source
+ */
+function notWithItemsOrElements(prop, target, source) {
+  if (!target.items && !target.elements || !source.target)
+    target[prop] = source[prop];
+}
+
 /**
  * Some properties must not be copied over if the type of this member
  * is a reference to another element.

package/lib/utils/file.js

@@ -61,12 +61,12 @@ function cdsFs(fileCache, enableTrace) {
   };
 
   function realpath(path, cb) {
-    return fs.realpath(path, cb);
+    return fs.realpath.native(path, cb);
   }
 
   function realpathSync(path, cb) {
     try {
-      cb(null, fs.realpathSync(path));
+      cb(null, fs.realpathSync.native(path));
     }
     catch (err) {
       cb(err, null);
@@ -87,7 +87,7 @@ function cdsFs(fileCache, enableTrace) {
       }
       let body = fileCache[filename];
       if (body && typeof body === 'object' && body.realname) {
-        filename = body.realname; // use fs.realpath name
+        filename = body.realname; // use fs.realpath.native name
         body = fileCache[filename];
       }
       if (body !== undefined && body !== true) { // true: we just know it is there

package/lib/utils/moduleResolve.js

@@ -28,13 +28,18 @@ const extensions = [ '.cds', '.csn', '.json' ];
  *   - Why a global?  The Umbrella could pass it as an option.
  *
  * @param {string} modulePath
+ * @param {CSN.Options} options
  * @returns {string}
  */
-function adaptCdsModule(modulePath) {
-  // eslint-disable-next-line
-  if (global['cds'] && global['cds'].home && modulePath.startsWith( '@sap/cds/' ))
+function adaptCdsModule(modulePath, options = {}) {
+  if (modulePath.startsWith( '@sap/cds/' )) {
+    if (options.cdsHome)
+      return options.cdsHome + modulePath.slice(8);
     // eslint-disable-next-line
-    return global['cds'].home + modulePath.slice(8)
+    if (global['cds'] && global['cds'].home)
+      // eslint-disable-next-line
+      return global['cds'].home + modulePath.slice(8);
+  }
   return modulePath;
 }
 
@@ -42,6 +47,7 @@ function adaptCdsModule(modulePath) {
  * @param {object} dep
  * @param {object} fileCache
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  */
 function resolveModule( dep, fileCache, options, messageFunctions ) {
   const _fs = cdsFs(fileCache, options.traceFs);
@@ -58,7 +64,7 @@ function resolveModule( dep, fileCache, options, messageFunctions ) {
     realpath: _fs.realpath,
   };
   return new Promise( (fulfill, reject) => {
-    const lookupPath = adaptCdsModule(dep.module);
+    const lookupPath = adaptCdsModule(dep.module, options);
     resolveCDS( lookupPath, opts, (err, res) => {
       // console.log('RESOLVE', dep, res, err)
       if (err) {
@@ -105,6 +111,7 @@ function resolveModule( dep, fileCache, options, messageFunctions ) {
  * @param {object} dep
  * @param {object} fileCache
  * @param {CSN.Options} options
+ * @param {object} messageFunctions
  */
 function resolveModuleSync( dep, fileCache, options, messageFunctions ) {
   const _fs = cdsFs(fileCache, options.traceFs);
@@ -118,7 +125,7 @@ function resolveModuleSync( dep, fileCache, options, messageFunctions ) {
 
   let result = null;
   let error = null;
-  const lookupPath = adaptCdsModule(dep.module);
+  const lookupPath = adaptCdsModule(dep.module, options);
 
   resolveCDS( lookupPath, opts, (err, res) => {
     if (err)

package/lib/utils/timetrace.js

@@ -14,47 +14,43 @@ class StopWatch {
    */
   constructor(id) {
     this.id = id;
-    // TODO: If we require Node 12, use process.hrtime.bigint()
-    //       as process.hrtime() is deprecated.
-    // eslint-disable-next-line no-multi-assign
-    this.startTime = this.lapTime = process.hrtime();
+    this.startTime = process.hrtime.bigint();
+    this.lapTime = this.startTime;
   }
 
   /**
-     * Start watch.
-     */
+   * Start watch.
+   */
   start() {
-    // eslint-disable-next-line no-multi-assign
-    this.startTime = this.lapTime = process.hrtime();
+    this.startTime = process.hrtime.bigint();
+    this.lapTime = this.startTime;
   }
 
   /**
-   * Stop and return delta T
+   * Stop and return delta T in nanoseconds,
    * but do not set start time
    */
   stop() {
-    return process.hrtime(this.startTime);
+    const endTime = process.hrtime.bigint();
+    return endTime - this.startTime;
   }
 
-  /**
-   * return lap time
-   */
   lap() {
-    const dt = process.hrtime(this.lapTime);
-    this.lapTime = process.hrtime();
+    const endTime = process.hrtime.bigint();
+    const dt = endTime - this.startTime;
+    this.lapTime = process.hrtime.bigint();
     return dt;
   }
 
-  // stop as sec.ns float
   stopInFloatSecs() {
     const dt = this.stop();
-    return dt[0] + dt[1] / 1000000000;
+    return dt / BigInt(1000000000);
   }
 
   // lap as sec.ns float
   lapInFloatSecs() {
     const dt = this.lap();
-    return dt[0] + dt[1] / 1000000000;
+    return dt / BigInt(1000000000);
   }
 }
 
@@ -63,7 +59,7 @@ class StopWatch {
  *
  * Results are logged to stderr
  *
- * To enable time tracing, set CDSC_TIMETRACE to true in the environment
+ * To enable time tracing, set CDSC_TIMETRACING to true in the environment
  *
  * @class TimeTracer
  */
@@ -107,10 +103,13 @@ class TimeTracer {
   stop() {
     try {
       const current = this.traceStack.pop();
-      const dT = current.stop();
+      const dt = current.stop();
       const base = `${ ' '.repeat(this.traceStack.length * 2) }${ current.id } took:`;
+      const sec = (dt / BigInt(1000000000)).toString();
+      // first, get remaining ns, then convert to ms.
+      const msec = ((dt % BigInt(1000000000)) / BigInt(1000000)).toString();
       // eslint-disable-next-line no-console
-      console.error( `${ base }${ ' '.repeat(60 - base.length) } %ds %dms`, dT[0], dT[1] / 1000000);
+      console.error( `${ base }${ ' '.repeat(60 - base.length) } %ds %dms`, sec, msec );
     }
     catch (e) {
       // eslint-disable-next-line no-console