@sap/cds-compiler 4.6.2 → 4.7.4

package/lib/render/toSql.js

@@ -24,7 +24,7 @@ const { checkCSNVersion } = require('../json/csnVersion');
 const { timetrace } = require('../utils/timetrace');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { smartFuncId } = require('../sql-identifier');
-const { sortCsn } = require('../json/to-csn');
+const { sortCsn } = require('../model/cloneCsn');
 const { manageConstraints, manageConstraint } = require('./manageConstraints');
 const { renderUniqueConstraintString, renderUniqueConstraintDrop, renderUniqueConstraintAdd } = require('./utils/unique');
 const { ModelError, CompilerAssertion } = require('../base/error');
@@ -104,6 +104,8 @@ class SqlRenderEnvironment {
  * @returns {object} Dictionary of artifact-type:artifacts, where artifacts is a dictionary of name:content
  */
 function toSqlDdl( csn, options, messageFunctions ) {
+  const withHanaAssociations = options.withHanaAssociations && options.sqlDialect === 'hana';
+
   timetrace.start('SQL rendering');
   const {
     error, warning, info, throwWithAnyError,
@@ -146,7 +148,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
     SET( x) {
       return `(${renderQuery(x, this.env.withIncreasedIndent())})`;
     },
-  }, true);
+  });
 
   function renderExpr( x, env ) {
     return exprRenderer.renderExpr(x, env);
@@ -610,7 +612,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       result += renderTechnicalConfiguration(art.technicalConfig, childEnv);
 
 
-    if (options.sqlDialect === 'hana' && options.withHanaAssociations) {
+    if (withHanaAssociations) {
       const associations = Object.keys(art.elements)
         .map(name => renderAssociationElement(name, art.elements[name], childEnv))
         .filter(s => s !== '')
@@ -773,10 +775,6 @@ function toSqlDdl( csn, options, messageFunctions ) {
     let result = '';
     if (elm.target) {
       result += env.indent;
-      const on = (!options.tenantAsColumn || elm.target['@cds.tenant.independent'])
-        ? elm.on
-        : [ { ref: [ 'tenant' ] }, '=', { ref: [ elementName, 'tenant' ] },
-          'and', { xpr: elm.on } ];
       if (elm.cardinality) {
         if (isBetaEnabled(options, 'hanaAssocRealCardinality') && elm.cardinality.src && elm.cardinality.src === 1)
           result += 'ONE TO ';
@@ -793,7 +791,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       }
       result += ' JOIN ';
       result += `${renderArtifactName(elm.target)} AS ${quoteSqlId(elementName)} ON (`;
-      result += `${renderExpr(on, env.withSubPath([ 'on' ]))})`;
+      result += `${renderExpr(elm.on, env.withSubPath([ 'on' ]))})`;
     }
     return result;
   }
@@ -1154,7 +1152,7 @@ function toSqlDdl( csn, options, messageFunctions ) {
       .map(name => renderAssociationElement(name, art.elements[name], childEnv))
       .filter(s => s !== '')
       .join(',\n');
-    if (associations !== '' && options.sqlDialect === 'hana' && options.withHanaAssociations) {
+    if (associations !== '' && withHanaAssociations) {
       result += `${env.indent}\nWITH ASSOCIATIONS (\n${associations}\n`;
       result += `${env.indent})`;
     }

package/lib/render/utils/common.js

@@ -598,10 +598,9 @@ function withoutCast( xpr ) {
  * (no trailing LF, don't indent if inline)
  *
  * @param {ExpressionConfiguration} rendererBase
- * @param {boolean} [adaptPath] If true, `env.path` will be adapted for lists and subExpr.
  * @returns {ExpressionRenderer} Expression rendering utility
  */
-function createExpressionRenderer( rendererBase, adaptPath = false ) {
+function createExpressionRenderer( rendererBase ) {
   const renderer = Object.create(rendererBase);
   renderer.visitExpr = visitExpr;
   /**
@@ -616,7 +615,6 @@ function createExpressionRenderer( rendererBase, adaptPath = false ) {
     // are nested.  This information is used for adding parentheses around
     // expressions (see `this.xpr()`).
     renderObj.isNestedXpr = false;
-    renderObj.adaptPath = adaptPath;
     return renderObj.visitExpr(x);
   };
   /**
@@ -628,7 +626,6 @@ function createExpressionRenderer( rendererBase, adaptPath = false ) {
     const renderObj = Object.create(renderer);
     renderObj.env = env || this?.env;
     renderObj.isNestedXpr = true;
-    renderObj.adaptPath = adaptPath;
     return renderObj.visitExpr(x);
   };
 
@@ -654,12 +651,10 @@ function visitExpr( x ) {
     // If xpr is part of an array, it's always a nested xpr,
     // e.g. CSN for `(1=1 or 2=2) and 3=3`.
     const tokens = x.map((item, i) => {
-      if (this.adaptPath) {
-      // We want to keep the prototype of the original env.
-        const env = Object.assign(Object.create(Object.getPrototypeOf(this.env || {})), this.env, { path: [ ...this.env.path, i ] });
-        return this.renderSubExpr(item, env);
-      }
-      return this.renderSubExpr(item);
+      this.env.path.push( i );
+      const result = this.renderSubExpr(item, this.env);
+      this.env.path.length -= 1;
+      return result;
     });
     return beautifyExprArray(tokens);
   }
@@ -673,12 +668,10 @@ function visitExpr( x ) {
   else if (x.list) {
     // Render as non-nested expr.
     return `(${x.list.map((item, i) => {
-      if (this.adaptPath) {
-      // We want to keep the prototype of the original env.
-        const env = Object.assign(Object.create(Object.getPrototypeOf(this.env || {})), this.env, { path: [ ...this.env.path, 'list', i ] });
-        return this.renderExpr(item, env);
-      }
-      return this.renderExpr(item);
+      this.env.path.push('list', i);
+      const result = this.renderExpr(item, this.env);
+      this.env.path.length -= 2;
+      return result;
     }).join(', ')})`;
   }
   else if (x.val !== undefined) {

package/lib/transform/addTenantFields.js

@@ -1,4 +1,4 @@
-// Add tenant field MANDT to entities
+// Add tenant field to entities, check validity
 
 // Prerequisites:
 
@@ -6,23 +6,23 @@
 // - using structure types with unmanaged associations is not supported by the
 //   Core Compiler (due to missing ON-rewrite)
 
-// TODO entities without MANDT:
-
-// - cache whether structure type contains (managed) association to entity with MANDT
-// - disallow use of such a type in entity without MANDT
+// TODO clarify:
+//
+// - do we have to do something for secondary keys?
 
 // Implementation remark:
-
+//
 // - the functions `forEachDefinition` & friends in csnUtils.js have become quite
 //   (too) general and are probably slow → not used here
 
 'use strict';
 
 const { createMessageFunctions } = require( '../base/messages' );
-const { traverseQuery } = require( '../model/csnRefs' );
+const { csnRefs, traverseQuery, implicitAs } = require( '../model/csnRefs' );
+
+const annoTenantIndep = '@cds.tenant.independent';
 
-const fieldName = 'tenant';
-const fieldDef = {
+const tenantDef = {
   key: true,
   type: 'cds.String',
   length: 36,
@@ -30,119 +30,198 @@ const fieldDef = {
 };
 
 function addTenantFields( csn, options ) {
+  const { error, throwWithError } = createMessageFunctions( options, 'tenant', csn );
+  const { tenantDiscriminator } = options;
+  const tenantName = tenantDiscriminator === true ? 'tenant' : tenantDiscriminator;
+  if (tenantName !== 'tenant') {
+    error( 'api-invalid-option', null, {
+      '#': 'value2',
+      option: 'tenantDiscriminator',
+      value: 'tenant',
+      rawvalue: true,
+      othervalue: tenantName,
+    } );
+    throwWithError();
+  }
+
   const { definitions } = csn;
   if (!definitions)
     return csn;
-  const { error, throwWithError } = createMessageFunctions( options, 'tenant', csn );
+  const { initDefinition, artifactRef, effectiveType } = csnRefs( csn );
 
+  const typeCache = new WeakMap();
   const csnPath = [ 'definitions', '' ];
+  let independent;
   let projection;
 
   for (const name in definitions) {
     const art = definitions[name];
-    if (art?.kind !== 'entity')
-      continue;
+    initDefinition( art );
     csnPath[1] = name;
+    independent = art[annoTenantIndep];
+    projection = art.query || art.projection && art;
 
-    if (art['@cds.tenant.independent'] != null) {
-      error( null, csnPath, { anno: '@cds.tenant.independent' },
-             'Can\'t yet add annotation $(ANNO) to an entity' );
+    if (art.kind === 'entity') {
+      independent = !!independent; // value should not influence message variant
+      if (independent && art.includes && !checkIncludes( art ))
+        continue;
+      handleElements( art );
+      if (projection)
+        traverseQuery( projection, null, null, handleQuery );
     }
-    if (!handleElements( art ))
-      continue;
-    projection = art.query || art.projection && art;
-    if (projection)
+    else if (!independent && independent != null) {
+      error( 'tenant-invalid-anno-value', csnPath, { anno: annoTenantIndep, value: independent },
+             // eslint-disable-next-line max-len
+             'Can\'t add $(ANNO) with value $(VALUE) to a non-entity, which is always tenant-independent' );
+    }
+    else if (art.includes) {
+      independent = art.kind;   // might be used for message variant
+      checkIncludes( art );     // recompile should work
+    }
+    else if (projection) {      // events - TODO: mention in doc
+      independent = art.kind;   // might be used for message variant
+      // recompile should work: no new `tenant` source element for `select *`
       traverseQuery( projection, null, null, handleQuery );
+    }
+  }
+  // Finally add the `tenant` element (do separately in order not to confuse
+  // the cache of csnRefs):
+  for (const name in definitions) {
+    const art = definitions[name];
+    if (isTenantDepEntity( art ))
+      art.elements = { [tenantName]: { ...tenantDef }, ...art.elements };
+    // consider non-enumerable `elements` of subqueries if that is supported
   }
 
-  (csn.extensions || []).forEach( (ext, idx) => {
-    const tenant = ext.elements?.[fieldName];
+  (csn.extensions || []).forEach( ( ext, idx ) => {
+    const tenant = ext.elements?.[tenantName];
     const name = ext.annotate || ext.extend; // extend should not happen
-    if (tenant && definitions[name]?.kind === 'entity') { // TODO: ok for tenant-independent
-      error( null, [ 'extensions', idx, 'elements', 'tenant' ],
-             { name: fieldName },
+    if (tenant && isTenantDepEntity( definitions[name] )) {
+      error( 'tenant-unexpected-ext', [ 'extensions', idx, 'elements', 'tenant' ],
+             { name: tenantName },
              'Can\'t annotate element $(NAME) of a tenant-dependent entity' );
     }
   } );
 
   throwWithError();
+  csn.meta ??= {};
+  csn.meta.tenantDiscriminator = tenantName;
   return csn;                   // input CSN changed by side effect
 
+  function checkIncludes( art ) {
+    const names = art.includes
+      .filter( name => isTenantDepEntity( csn.definitions[name] ) );
+    if (names.length) {
+      error( 'tenant-invalid-include', csnPath, { names }, {
+        // eslint-disable-next-line max-len
+        std: 'Can\'t include the tenant-dependent entities $(NAMES) into a tenant-independent definition',
+        // eslint-disable-next-line max-len
+        one: 'Can\'t include the tenant-dependent entity $(NAMES) into a tenant-independent definition',
+      } );
+    }
+    return !names.length;
+  }
+
   function handleElements( art ) {
     const { elements } = art;
-    if (elements[fieldName]) {
-      error( null, [ ...csnPath, 'elements', fieldName ], { name: fieldName },
-             'Can\'t add tenant field to entity having an element $(NAME)' );
-      return false;
+    if (elements[tenantName]) {
+      error( 'tenant-unexpected-element', [ ...csnPath, 'elements', tenantName ],
+             { name: tenantName, option: 'tenantDiscriminator' },
+             'Can\'t have entity with element $(NAME) when using option $(OPTION)' );
     }
-    if (!Object.values( elements ).some( e => e.key )) {
-      error( null, csnPath, {},
+    else if (!independent && !Object.values( elements ).some( e => e.key )) {
+      error( 'tenant-expecting-key', csnPath, {},
              'There must be a key in a tenant-dependent entity' );
-      return false;
     }
-    handleAssociations( art );
-    art.elements = { [fieldName]: { ...fieldDef }, ...elements };
-    return true;
+    else {
+      traverse( art, handleAssociations );
+    }
   }
 
+  // Queries --------------------------------------------------------------------
+
   function handleQuery( query ) {
     // TODO: errors are temporary: start with simple projections only = no better
-    // message $location necessary yet
-    if (!projection)            // error already reported
-      return;
-    if (query.ref) {
-      if ((query.as || implicitAs( query.ref )) === fieldName) {
-        error( null, csnPath, { name: fieldName },
-               'Can\'t have a table alias named $(NAME) in a tenant-dependent entity' );
-      }
+    // message $location necessary yet - better: set `name` in csnRefs
+    if (!projection || query.ref && handleQuerySource( query ))
       return;
-    }
 
-    const select = query.SELECT || query.projection;
-    if (query.SET || query !== projection || !select?.from?.ref) {
-      error( null, csnPath, {},
-             'Can\'t add tenant columns to non-simple query entities' );
+    if (query !== projection && !independent) {
+      error( 'tenant-unsupported-query', csnPath, {},
+             'Can\'t yet have tenant-dependent non-simple query entities' );
       projection = null;
       return;
     }
 
     if (query.projection)
       csnPath.push( 'projection' );
-    else
+    else if (query.SELECT)
       csnPath.push( 'query', 'SELECT' );
+    else
+      return;                   // query.SET or query.join
 
+    const select = query.SELECT || query.projection;
     if (select.mixin)
-      handleMixins( select.mixin );
-    if (select.excluding)
-      checkExcluding( select.excluding );
-    if (select.columns)
-      handleColumns( select.columns );
-    // TODO: for subqueries, we might need to adapt the inferred elements
-    // TODO: where exists ref -
-    // TODO: select and query clauses, especially with aggregation functions
-    handleGroupBy( select );
+      checkMixins( select.mixin );
+    if (!independent) {
+      if (select.excluding)
+        checkExcluding( select.excluding );
+      if (select.columns)
+        handleColumns( select.columns );
+      // TODO: when we allow subqueries, we must also check for published in redirected assocs
+      // TODO: for subqueries, we might need to adapt the inferred elements
+      // TODO: where exists ref -
+      // TODO: select and query clauses, especially with aggregation functions
+      handleGroupBy( select );
+    }
+    else if (query !== projection && select.columns) {
+      checkColumnCasts( select.columns );
+    }
     csnPath.length = 2;
   }
 
-  function handleMixins( mixin ) {
+  function handleQuerySource( query ) {
+    if (independent) {
+      const art = query.ref[0]; // yes, the base
+      if (csn.definitions[art][annoTenantIndep])
+        return true;
+      error( 'tenant-invalid-query-source', csnPath, { art, '#': independent }, {
+        std: 'Can\'t use a tenant-dependent query source $(ART) in a tenant-independent entity',
+        event: 'Can\'t use a tenant-dependent query source $(ART) in an event',
+      } );
+      return true;
+    }
+    if (query !== (projection.SELECT || projection.projection)?.from) // with `join`
+      return false;
+    if ((query.as || implicitAs( query.ref )) === tenantName) {
+      error( 'tenant-invalid-alias-name', csnPath,
+             { name: tenantName, '#': (query.as ? 'std' : 'implicit') } );
+    }
+    const art = artifactRef.from( query );
+    if (art[annoTenantIndep]) {
+      error( 'tenant-expecting-tenant-source', csnPath, { art: query },
+             // TODO: better the final entity name of assoc navigation in FROM
+             // eslint-disable-next-line max-len
+             'Expecting the query source $(ART) to be tenant-dependent for a tenant-dependent query entity' );
+    }
+    return true;
+  }
+
+  function checkMixins( mixin ) {
     csnPath.push( 'mixin', '' );
     for (const name in mixin) {
       csnPath[csnPath.length - 1] = name;
-      if (name !== fieldName) {
-        addToCondition( mixin[name], name );
-      }
-      else {
-        error( null, csnPath, { name },
-               'Can\'t define a mixin named $(NAME) in a tenant-dependent entity' );
-      }
+      if (name === tenantName && !independent)
+        error( 'tenant-invalid-alias-name', csnPath, { name, '#': 'mixin' } );
+      handleAssociations( mixin[name], null );
     }
     csnPath.length -= 2;
   }
 
   function checkExcluding( excludeList ) {
-    if (excludeList.includes( fieldName )) {
-      error( null, csnPath, { name: fieldName },
-             'Can\'t exclude $(NAME) from query source' );
+    if (excludeList.includes( tenantName )) {
+      error( 'tenant-invalid-excluding', csnPath, { name: tenantName },
+             'Can\'t exclude $(NAME) from the query source of a tenant-dependent entity' );
     }
   }
 
@@ -153,7 +232,7 @@ function addTenantFields( csn, options ) {
     // already contains a GROUP BY. And anyway: if we miss to add GROUP BY MANDT,
     // the database will complain → no safetly risk.
     if (select.groupBy)
-      select.groupBy.unshift( { ref: [ fieldName ] } );
+      select.groupBy.unshift( { ref: [ tenantName ] } );
   }
 
   function handleColumns( columns ) {
@@ -162,65 +241,161 @@ function addTenantFields( csn, options ) {
     for (const col of columns) {
       ++csnPath[csnPath.length - 1];
       if (col.expand || col.inline) {
-        error( null, csnPath, {},
+        error( 'tenant-unsupported-expand-inline', csnPath, {},
                'Can\'t use expand/inline in a tenant-dependent entity' );
       }
       if (col.key != null)      // yes, also with key: false
         specifiedKey = true;
-      if (col.cast?.on) // REDIRECTED TO with explicit ON - TODO (low prio): less $self
-        addToCondition( col.cast, col.as || implicitAs( col.ref ) );
+      // REDIRECTED TO: also check new target here? (main query: already checked via elements)
     }
     csnPath.length -= 2;
     columns.unshift( specifiedKey
-      ? { key: true, ref: [ fieldName ] }
-      : { ref: [ fieldName ] } );
+      ? { key: true, ref: [ tenantName ] }
+      : { ref: [ tenantName ] } );
+  }
+
+  function checkColumnCasts( columns, prop = 'columns' ) {
+    csnPath.push( prop, -1 );
+    for (const col of columns) {
+      ++csnPath[csnPath.length - 1];
+      if (col.cast?.target)
+        handleAssociations( col.cast, null );
+      else if (col.expand)
+        checkColumnCasts( col.expand, 'expand' );
+      else if (col.inline)
+        checkColumnCasts( col.inline, 'inline' );
+    }
+    csnPath.length -= 2;
+  }
+
+  // Associations ---------------------------------------------------------------
+
+  function handleAssociations( elem, afterRecursion ) {
+    if (afterRecursion != null)
+      return null;
+
+    if (elem.target) {
+      if (!csn.definitions[elem.target][annoTenantIndep]) {
+        if (independent)
+          error( 'tenant-invalid-target', csnPath, { target: elem.target } );
+      }
+      else if (!independent && isComposition( elem )) {
+        error( 'tenant-invalid-composition', csnPath, { target: elem.target } );
+      }
+    }
+    else if (elem.type && (independent || !elem.elements && !elem.items)) {
+      // check type, but not with expanded elements in dependent entity, because
+      // composition could have redirected tenant-dependent target
+      const dep = typeDependency( artifactRef( elem.type, null ) );
+      if (independent) {
+        if (!dep || dep === 'Composition')
+          return true;          // check elements (assocs could be redirected)
+        error( 'tenant-invalid-target', csnPath, { type: elem.type, '#': 'type' } );
+      }
+      else if (dep && dep !== 'dependent') {
+        error( 'tenant-invalid-composition', csnPath, { type: elem.type, '#': 'type' } );
+      }
+    }
+    else {
+      return true;
+    }
+    return null;
   }
 
-  function handleAssociations( elem ) {
+  /**
+   * Returns “type dependency”, a string, for type `assoc`:
+   *
+   * - '': type does not contain associations other than non-composition associations to
+   *   tenant-independent entities
+   * - 'Composition': type contains associations (and at least one composition) to
+   *   tenant-independent entities, and no associations to tenant-dependent entities
+   * - 'dependent': type contains associations, at least one to a tenant-dependent entity,
+   *   but no compositions to tenant-independent entities
+   * - 'ERR': type contains associations, at least one to a tenant-dependent entity,
+   *   and at least one composition to a tenant-independent entity
+   *
+   * Type references are followed, but only without sibling `elements` or `items`.
+   */
+  function typeDependency( assoc ) {
+    if (!assoc || !(assoc = effectiveType( assoc )))
+      return '';
+    const assocDep = typeCache.get( assoc );
+    if (assocDep != null)
+      return assocDep;
+    let parentDep = '';
+    traverse( assoc, typeCallback );
+    return parentDep;
+
+    function typeCallback( type, savedDep ) {
+      let currentDep = typeCache.get( type );
+      if (currentDep != null) {
+        // nothing
+      }
+      else if (savedDep != null) {
+        currentDep = parentDep;
+        parentDep = savedDep;
+      }
+      else if (type.target) {
+        const annoDep = !csn.definitions[type.target][annoTenantIndep];
+        currentDep = (annoDep) ? 'dependent' : isComposition( type ) && 'Composition';
+      }
+      else if (type.elements || type.items) {
+        savedDep = parentDep;
+        parentDep = '';
+        return savedDep || '';      // recurse
+      }
+      else if (type.type) {
+        currentDep = typeDependency( artifactRef( type.type, null ) );
+      }
+      else {
+        currentDep = '';
+      }
+
+      typeCache.set( type, currentDep );
+      if (!currentDep || !parentDep)
+        parentDep ||= currentDep;
+      else if (currentDep !== parentDep)
+        parentDep = 'ERR';
+      return null;              // do not (further) recurse
+    }
+  }
+
+  // Generic functions ----------------------------------------------------------
+
+  function traverse( elem, callback ) {
+    const recurse = callback( elem, null );
+    if (recurse == null)
+      return;
     const { elements } = elem;
     if (elements) {
       csnPath.push( 'elements', '' );
       for (const name in elements) {
         csnPath[csnPath.length - 1] = name;
-        handleAssociations( elements[name] );
+        traverse( elements[name], callback );
       }
       csnPath.length -= 2;
     }
-    else if (elem.target) {
-      if (elem.on) {
-        addToCondition( elem, csnPath[csnPath.length - 1] );
-      }
-      else {
-        error( null, csnPath, {},
-               'Can\'t yet use managed associations in a tenant-dependent entity' );
-      }
-    }
     else if (elem.items) {
       csnPath.push( 'items' );
-      handleAssociations( elem.items );
+      traverse( elem.items, callback );
       --csnPath.length;
     }
+    callback( elem, recurse );
   }
 
-  function addToCondition( elem, assoc ) {
-    if (!elem.on)
-      return;
-    const withSelf = csnPath.length > 4;
-    elem.on = [
-      { ref: [ assoc, fieldName ] }, // TODO: consider assoc name starting with '$'
-      '=',
-      { ref: (withSelf) ? [ '$self', fieldName ] : [ fieldName ] },
-      'and',
-      // TODO: avoid (...) for standard AND-ed EQ-comparisons ?
-      { xpr: elem.on },
-    ];
+  function isComposition( assoc ) {
+    while (assoc && assoc.type !== 'cds.Association') {
+      const { type } = assoc;
+      if (type === 'cds.Composition')
+        return true;
+      assoc = artifactRef( type, null );
+    }
+    return false;
   }
 }
 
-function implicitAs( ref ) {
-  const item = ref[ref.length - 1];
-  const id = (typeof item === 'string') ? item : item.id;
-  return id.substring( id.lastIndexOf('.') + 1 );
+function isTenantDepEntity( art ) {
+  return art?.kind === 'entity' && !art[annoTenantIndep];
 }
 
 module.exports = {

package/lib/transform/db/applyTransformations.js

@@ -307,6 +307,16 @@ function applyTransformationsOnDictionary( dictionary, customTransformers = {},
  * @returns {object} transformed node
  */
 function transformExpression( parent, propName, transformers, path = [] ) {
+  const callT = (t, cpn, child) => {
+    const ct = t[cpn];
+    if (ct) {
+      const ppn = propName;
+      if (Array.isArray(ct))
+        ct.forEach(cti => cti(child, cpn, child[cpn], path, parent, ppn));
+      else
+        ct(child, cpn, child[cpn], path, parent, ppn);
+    }
+  };
   if (propName != null) {
     const child = parent[propName];
     if (!child || typeof child !== 'object' ||
@@ -319,15 +329,10 @@ function transformExpression( parent, propName, transformers, path = [] ) {
     }
     else {
       for (const cpn of Object.getOwnPropertyNames( child )) {
-        const ct = transformers[cpn];
-        if (ct) {
-          const ppn = propName;
-          if (Array.isArray(ct))
-            ct.forEach(cti => cti(child, cpn, child[cpn], path, parent, ppn));
-
-          else
-            ct(child, cpn, child[cpn], path, parent, ppn);
-        }
+        if (Array.isArray(transformers))
+          transformers.forEach(t => callT(t, cpn, child));
+        else
+          callT(transformers, cpn, child);
         transformExpression(child, cpn, transformers, path);
       }
     }