@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/compiler/utils.js

@@ -6,12 +6,15 @@
 // Please do not add functions “for completeness”, this is not an API file for
 // others but only by the core compiler.
 
-// TODO: probably split this file into utils/….js
+// TODO: split this file into utils/….js, add some functions from lib/base/model.js
 
 'use strict';
 
 const { dictAdd, pushToDict, dictFirst } = require('../base/dictionaries');
 const { kindProperties } = require('./base');
+const { XsnName, XsnArtifact, CsnLocation } = require('./classes');
+
+const $inferred = Symbol.for( 'cds.$inferred' );
 
 // for links, i.e., properties starting with an underscore '_':
 
@@ -106,17 +109,23 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   return elem;
 }
 
-function proxyCopyMembers( art, dictProp, originDict, location, kind ) {
+function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDeprecated ) {
   art[dictProp] = Object.create( null );
+  // TODO: set $inferred ? for dict?
   for (const name in originDict) {
     const origin = originDict[name];
-    const member = linkToOrigin( origin, name, art, dictProp,
-                                 location || origin.location, true );
-    member.$inferred = 'expanded';
-    if (kind)
-      member.kind = kind;
-    if (kind && origin.masked)  // TODO: remove!
-      member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
+    if (origin !== undefined) {
+      const member = linkToOrigin( origin, name, art, dictProp,
+                                   location || origin.location, true );
+      member.$inferred = 'expanded';
+      // TODO throughout the compiler: do not set art.‹prop›.$inferred if art.$inferred
+      if (kind)
+        member.kind = kind;
+      else if (origin.key && !tmpDeprecated) // TODO(v5/v6): remove tmpDeprecated
+        member.key = Object.assign( { $inferred: 'expanded' }, origin.key );
+      if (kind && origin.masked)  // TODO: remove!
+        member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
+    }
   }
 }
 
@@ -132,8 +141,8 @@ function setMemberParent( elem, name, parent, prop ) {
   if (prop) {              // extension or structure include
     // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
     const p = parent.items || parent.targetAspect || parent;
-    if (!(prop in p))
-      p[prop] = Object.create(null);
+    if (p[prop] === undefined)
+      p[prop] = Object.create( null );
     dictAdd( p[prop], name, elem );
   }
   if (parent._outer && parent._outer.items) // TODO: remove for items, too
@@ -155,7 +164,7 @@ function setMemberParent( elem, name, parent, prop ) {
 
     else
       delete elem.name[kind];
-  });
+  } );
   // try { throw new CompilerAssertion('Foo') } catch (e) { elem.name.stack = e; };
 }
 
@@ -166,10 +175,12 @@ function setMemberParent( elem, name, parent, prop ) {
  * @param {XSN.Artifact} art
  * @param {XSN.Location} location
  */
-function dependsOn( user, art, location ) {
+function dependsOn( user, art, location, semanticLoc = undefined ) {
+  while (user._outer && !user.kind)
+    user = user._outer;
   if (!user._deps)
     setLink( user, '_deps', [] );
-  user._deps.push( { art, location } );
+  user._deps.push( { art, location, semanticLoc } );
 }
 
 /**
@@ -180,6 +191,8 @@ function dependsOn( user, art, location ) {
  * @param {XSN.Artifact} art
  */
 function dependsOnSilent( user, art ) {
+  while (user._outer && !user.kind)
+    user = user._outer;
   if (!user._deps)
     setLink( user, '_deps', [] );
   user._deps.push( { art } );
@@ -197,7 +210,7 @@ function storeExtension( elem, name, prop, parent, block ) {
   //   return;
   // }
   if (!parent[kind][prop])
-    parent[kind][prop] = Object.create(null);
+    parent[kind][prop] = Object.create( null );
   pushToDict( parent[kind][prop], name, elem );
 }
 
@@ -223,7 +236,7 @@ function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = fa
  * @param {XSN.Path} path
  */
 function pathName( path ) {
-  return (path && !path.broken) ? path.map( id => id.id ).join('.') : '';
+  return (path && !path.broken) ? path.map( id => id.id ).join( '.' ) : '';
 }
 
 /**
@@ -235,7 +248,7 @@ function pathName( path ) {
  * @returns {XSN.Path}
  */
 function splitIntoPath( location, name ) {
-  return name.split('.').map( id => ({ id, location }) );
+  return name.split( '.' ).map( id => ({ id, location }) );
 }
 
 /**
@@ -249,11 +262,13 @@ function augmentPath( location, ...args ) {
 function copyExpr( expr, location, skipUnderscored, rewritePath ) {
   if (!expr || typeof expr !== 'object')
     return expr;
-  else if (Array.isArray(expr))
+  else if (Array.isArray( expr ))
     return expr.map( e => copyExpr( e, location, skipUnderscored, rewritePath ) );
 
   const proto = Object.getPrototypeOf( expr );
-  if (proto && proto !== Object.prototype) // do not copy object from special classes
+  if (proto && proto !== Object.prototype && proto !== XsnName.prototype &&
+      // do not copy object from special classes outside the compiler domain&&
+      proto !== XsnArtifact.prototype && proto !== CsnLocation.prototype)
     return expr;
   const r = Object.create( proto );
   for (const prop of Object.getOwnPropertyNames( expr )) {
@@ -284,7 +299,7 @@ function testExpr( expr, pathTest, queryTest, user ) {
   if (!expr || typeof expr === 'string') { // parse error or keywords in {xpr:...}
     return false;
   }
-  else if (Array.isArray(expr)) {
+  else if (Array.isArray( expr )) {
     return expr.some( e => testExpr( e, pathTest, queryTest, user ) );
   }
   else if (expr.path) {
@@ -295,11 +310,11 @@ function testExpr( expr, pathTest, queryTest, user ) {
   }
   else if (expr.op && expr.args) {
     // unnamed args => array
-    if (Array.isArray(expr.args))
+    if (Array.isArray( expr.args ))
       return expr.args.some( e => testExpr( e, pathTest, queryTest, user ) );
     // named args => dictionary
-    for (const namedArg of Object.keys(expr.args)) {
-      if (testExpr(expr.args[namedArg], pathTest, queryTest, user))
+    for (const namedArg of Object.keys( expr.args )) {
+      if (testExpr( expr.args[namedArg], pathTest, queryTest, user ))
         return true;
     }
   }
@@ -314,6 +329,129 @@ function targetMaxNotOne( assoc, item ) {
   return cardinality && cardinality.targetMax && cardinality.targetMax.val !== 1;
 }
 
+/**
+ * Call function `callback(art)` for each user-defined main artifact and member
+ * `art` of the model reachable from the dictionary `model[prop]`.  User-defined
+ * artifacts are those with no or a falsy `art.$inferred` value, i.e. this
+ * function is useful for checks.
+ *
+ * The callback function is not called on the following artifacts:
+ * - `enum` symbol definitions (use forEachUserDict() yourself if needed)
+ * - the anonymous aspect in the `target`/`targetAspect` property (but the
+ *   callback function is called on its elements).
+ * - table aliases
+ *
+ * The callback function is also called on duplicates.  For example, if there are
+ * two entities named `E`, the callback function is called on both.
+ * It is also called on columns with `inline`.
+ *
+ * See also function forEachDefinition(), currently in lib/base/model.js.
+ */
+function forEachUserArtifact( model, prop, callback ) { // not enums
+  forEachUserDict( model, prop, function main( art ) {
+    callback( art );
+    forEachUserDict( art, 'params', function param( par ) {
+      callback( par );
+      forEachUserElementAndFKey( par, callback );
+    } );
+    if (art.$queries) {
+      for (const query of art.$queries) {
+        callback( query );
+        forEachUserDict( query, 'mixin', callback );
+        forEachUserElementAndFKey( query, callback );
+        if (query.$inlines)     // e.g. not with `entity V as projection on V;`
+          query.$inlines.forEach( callback );
+      }
+    }
+    else if (art.returns) {
+      callback( art.returns );
+      forEachUserElementAndFKey( art.returns, callback );
+    }
+    else {
+      forEachUserElementAndFKey( art, callback );
+    }
+    forEachUserArtifact( art, 'actions', callback );
+  } );
+}
+
+/**
+ * Call function `callback(art)` for each user-defined element and foreign key
+ * reachable from artifact `art`.  Do not (again) call the callback function on
+ * `art` itself, even if it is an element.
+ *
+ * Consider that we have (nested) `array of`/`many` types, but do not call the
+ * callback function on the array item itself (only on elements inside).
+ */
+function forEachUserElementAndFKey( art, callback ) {
+  while (art.items)
+    art = art.items;
+  if (art.target) {
+    forEachUserDict( art, 'foreignKeys', callback );
+    return;
+  }
+  if (art.targetAspect)
+    art = art.targetAspect;
+  forEachUserDict( art, 'elements', function element( elem ) {
+    callback( elem );
+    forEachUserElementAndFKey( elem, callback );
+  } );
+}
+
+function forEachUserDict( art, prop, callback ) {
+  const dict = art[prop];
+  if (!dict || dict[$inferred])
+    return;
+  for (const name in dict) {
+    const obj = dict[name];
+    if (obj.$inferred)
+      continue;
+    callback( obj, name, prop );
+    if (Array.isArray( obj.$duplicates )) // redefinitions
+      obj.$duplicates.forEach( o => callback( o, name, prop ) );
+  }
+}
+
+/**
+ * Call `callback( expr, exprCtx, query )` on all direct expressions `expr` of
+ * `query`, where `exprCtx` is the expression context used as key for the
+ * `referenceSemantics` in shared.js.
+ *
+ * Indirect expressions are not called, these are:
+ * - the `from` reference (expression of the table alias)
+ * - the ON-condition of mixins (expression of the mixin)
+ * - the expressions in columns (expression of the column/element)
+ */
+function forEachQueryExpr( query, callback ) { // see resolveQuery()
+  forEachJoinOn( query, query.from, callback );
+  // TODO: run over $inlines ?
+  if (query.where)
+    callback( query.where, 'where', query );
+  if (query.groupBy)
+    forEachExprArray( query, query.groupBy, 'groupBy', 'groupBy', callback );
+  if (query.having)
+    callback( query.having, 'having', query );
+  if (query.$orderBy)
+    forEachExprArray( query, query.$orderBy, 'orderBy-set-ref', 'orderBy-set-expr', callback );
+  if (query.orderBy)
+    forEachExprArray( query, query.orderBy, 'orderBy-ref', 'orderBy-expr', callback );
+}
+
+function forEachJoinOn( query, from, callback ) {
+  if (!from?.join)
+    return;                     // TODO: run over from.path here?
+  for (const tab of from.args)
+    forEachJoinOn( query, tab, callback );
+  if (from.on)
+    callback( from.on, 'join-on', query );
+}
+
+function forEachExprArray( query, array, refContext, exprContext, callback ) {
+  for (const expr of array ) {
+    if (expr)
+      callback( expr, (expr.path ? refContext : exprContext), query );
+  }
+}
+
 // Query tree post-order traversal - called for everything which contributes to the query
 // i.e. is necessary to calculate the elements of the query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
@@ -442,28 +580,6 @@ function isDirectComposition( art ) {
   return type && type[0] && type[0].id === 'cds.Composition';
 }
 
-function traverseExpr( expr, exprCtx, user, callback ) {
-  if (!expr || typeof expr === 'string') // parse error or keywords in {xpr:...}
-    return;
-
-  if (expr.path) {
-    callback( expr, exprCtx, user );
-    // TODO: move arguments and filter traversal to here
-    return;
-  }
-  else if (expr.type || expr.query) {
-    callback( expr, exprCtx, user );
-  }
-
-  if (expr.args) {
-    const args = Array.isArray(expr.args) ? expr.args : Object.values( expr.args );
-    // TODO: re-think $expected
-    args.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
-  }
-  if (expr.suffix)              // fn( … ) OVER …
-    expr.suffix.forEach( e => traverseExpr( e, exprCtx, user, callback ) );
-}
-
 function userQuery( user ) {
   // TODO: we need _query links set by the definer
   while (user._main) {
@@ -474,6 +590,63 @@ function userQuery( user ) {
   return null;
 }
 
+function pathStartsWithSelf( ref ) {
+  const head = ref && !ref.scope && ref.path?.[0];
+  if (head?._navigation?.kind === '$self')
+    return true;
+  if (head?._artifact?.kind === 'builtin') // CDS variable
+    return false;
+  return undefined;
+}
+
+function columnRefStartsWithSelf( col ) {
+  for (; col; col = col._pathHead) {
+    const ref = col.value;
+    const head = ref && !ref.scope && ref.path?.[0];
+    if (head?._navigation?.kind === '$self')
+      return true;
+    if (head?._artifact?.kind === 'builtin') // CDS variable
+      return false;
+  }
+  return false;
+}
+
+// Remark: this function is based on an early check that no target element is
+// covered more than once by a foreign key: then…
+// we only need to check that all foreign key references are primary keys and
+// that the number of foreign and primary keys are the same.
+function isAssocToPrimaryKeys( assoc ) {
+  let fkeys = 0;
+  const { foreignKeys } = assoc;
+  if (!foreignKeys)
+    return undefined;
+  for (const name in foreignKeys) {
+    const fk = foreignKeys[name];
+    const elem = fk.targetElement._artifact;
+    if (!elem || fk.$duplicates)
+      return undefined;
+    if (!elem.key?.val)
+      return false;
+    ++fkeys;
+  }
+
+  const elements = assoc.target._artifact?.elements;
+  if (!elements)
+    return undefined;
+  for (const name in elements) {
+    if (elements[name].key?.val)
+      --fkeys;
+  }
+  return fkeys === 0;
+}
+
+// only if _effectiveType has been computed:
+function getUnderlyingBuiltinType( art ) {
+  while (art?._effectiveType && !art.builtin)
+    art = art._origin || art.type?._artifact;
+  return art;
+}
+
 function definedViaCdl( art ) {
   // return !!art._block?.artifacts;
   // TODO: the above code would work when _block links are correctly set on
@@ -483,6 +656,21 @@ function definedViaCdl( art ) {
   return $frontend !== 'json' && $frontend !== '$internal';
 }
 
+// For error messages: ----------------------------------------------------------
+
+// (To be) used for the location in error messages
+function artifactRefLocation( ref ) {
+  return (ref._artifact?._main)
+    ? ref.path[ref.path.length - 1].location
+    : ref.location;
+}
+
+function compositionTextVariant( art, composition, association = 'std' ) {
+  return (getUnderlyingBuiltinType( art )?.name.absolute === 'cds.Composition')
+    ? composition
+    : association;
+}
+
 module.exports = {
   pushLink,
   annotationVal,
@@ -505,13 +693,20 @@ module.exports = {
   copyExpr,
   testExpr,
   targetMaxNotOne,
+  forEachUserArtifact,
+  forEachQueryExpr,
   traverseQueryPost,
   traverseQueryExtra,
   viewFromPrimary,
   setExpandStatus,
   setExpandStatusAnnotate,
   isDirectComposition,
-  traverseExpr,
   userQuery,
+  pathStartsWithSelf,
+  columnRefStartsWithSelf,
+  isAssocToPrimaryKeys,
+  getUnderlyingBuiltinType,
   definedViaCdl,
+  artifactRefLocation,
+  compositionTextVariant,
 };

package/lib/edm/.eslintrc.json

@@ -1,5 +1,44 @@
 {
+  "root": true,
+  //"plugins": ["sonarjs", "jsdoc"],
+  //"extends": ["plugin:jsdoc/recommended", "../../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
+  "plugins": ["sonarjs"],
+  "extends": ["../../.eslintrc-ydkjsi.json", "plugin:sonarjs/recommended"],
   "rules": {
-    "no-shadow": "off"
+    "prefer-const": "error",
+    "quotes": ["error", "single", "avoid-escape"],
+    "prefer-template": "error",
+    "no-trailing-spaces": "error",
+    "template-curly-spacing":["error", "never"],
+    "complexity": ["warn", 50],
+    "max-len": "off",
+    // there seem to be false positives
+    "jsdoc/require-returns-check": "off",
+    // Don't enforce stupid descriptions
+    "jsdoc/require-param-description": "off",
+    "jsdoc/require-returns-description": "off",
+    // Sometimes if-else's are more specific
+    "sonarjs/prefer-single-boolean-return": "off",
+    // Very whiny and nitpicky
+    "sonarjs/cognitive-complexity": "off",
+    "sonarjs/no-duplicate-string": "off",
+    // Does not recognize TS types
+    "jsdoc/no-undefined-types": "off",
+    "jsdoc/tag-lines": "off",
+    "no-nested-ternary": "off",
+    "sonarjs/no-nested-template-literals": "off"
+  },
+  "parserOptions": {
+    "ecmaVersion": 2022,
+    "sourceType": "script"
+  },
+  "env": {
+    "es2022": true,
+    "node": true
+  },
+  "settings": {
+    "jsdoc": {
+      "mode": "typescript"
+    }
   }
 }