@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/base/messages.js

@@ -42,9 +42,10 @@ function hasErrors( messages ) {
  * @param {string} moduleName
  * @returns {boolean}
  */
-function hasNonDowngradableErrors( messages, moduleName ) {
-  return messages && messages.some( m => m.severity === 'Error' &&
-      (!m.messageId || !isDowngradable( m.messageId, moduleName )));
+function hasNonDowngradableErrors( messages, moduleName, deprecatedDowngradable ) {
+  return messages &&
+    messages.some( m => m.severity === 'Error' &&
+                   !isDowngradable( m.messageId, moduleName, deprecatedDowngradable ));
 }
 
 /**
@@ -54,10 +55,11 @@ function hasNonDowngradableErrors( messages, moduleName ) {
  *
  * @param {string} messageId
  * @param {string} moduleName
+ * @param {boolean} deprecatedDowngradable
  * @returns {boolean}
  */
-function isDowngradable( messageId, moduleName ) {
-  if (!centralMessages[messageId])
+function isDowngradable( messageId, moduleName, deprecatedDowngradable ) {
+  if (!messageId || !centralMessages[messageId])
     return false;
 
   const msg = centralMessages[messageId];
@@ -66,10 +68,12 @@ function isDowngradable( messageId, moduleName ) {
   // the module, it is NEVER downgradable.
   if (msg.errorFor && msg.errorFor.includes(moduleName))
     return false;
-
-  return (msg.severity !== 'Error' ||
-        msg.configurableFor === true || // useful with error for syntax variants
-        msg.configurableFor && msg.configurableFor.includes( moduleName ));
+  if (msg.severity !== 'Error')
+    return true;
+  const { configurableFor } = msg;
+  return (Array.isArray( configurableFor ))
+    ? configurableFor.includes( moduleName )
+    : configurableFor && (configurableFor !== 'deprecated' || deprecatedDowngradable);
 }
 
 /**
@@ -136,14 +140,11 @@ class CompileMessage {
     this.location = location;
     this.$location = { ...this.location, address: undefined };
     this.validNames = null;
-    if (home)                   // semantic location, e.g. 'entity:"E"/element:"x"'
-      this.home = home;
+    this.home = home;  // semantic location, e.g. 'entity:"E"/element:"x"'
     this.severity = severity;
-    if (id)
-      Object.defineProperty( this, 'messageId', { value: id } );
-      // this.messageId = id;  // ids not yet finalized
-    if (moduleName)
-      Object.defineProperty( this, '$module', { value: moduleName, configurable: true } );
+    Object.defineProperty( this, 'messageId', { value: id } );
+    // this.messageId = id;  // ids not yet finalized
+    Object.defineProperty( this, '$module', { value: moduleName, configurable: true } );
   }
 
   toString() {                  // should have no argument...
@@ -176,7 +177,7 @@ const severitySpecs = {
  * @param {boolean} deprecatedDowngradable
  * @returns {MessageSeverity}
  */
-function reclassifiedSeverity(msg, options, moduleName, deprecatedDowngradable ) {
+function reclassifiedSeverity( msg, options, moduleName, deprecatedDowngradable ) {
   const spec = centralMessages[msg.messageId] || { severity: msg.severity, configurableFor: null, errorFor: null };
   if (spec.severity === 'Error') {
     const { configurableFor } = spec;
@@ -353,7 +354,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
 
     messages.push( msg );
     hasNewError = hasNewError || msg.severity === 'Error' &&
-      !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
+      !(options.testMode && isDowngradable( msg.messageId, moduleName, deprecatedDowngradable ));
     if (!hasMessageArray)
       console.error( messageString( msg ) );
     return msg;
@@ -499,7 +500,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
     if (!messages || !messages.length)
       return;
     const hasError = options.testMode ? hasNonDowngradableErrors : hasErrors;
-    if (hasError( messages, moduleName ))
+    if (hasError( messages, moduleName, deprecatedDowngradable ))
       throw new CompilationError( messages, options.attachValidNames && model );
   }
 
@@ -517,7 +518,7 @@ function makeMessageFunction( model, options, moduleName = null ) {
           // Re-set the module regardless of severity, since we reclassified it.
           Object.defineProperty( msg, '$module', { value: moduleName, configurable: true } );
           hasNewError = hasNewError || severity === 'Error' &&
-            !(options.testMode && msg.messageId && isDowngradable( msg.messageId, moduleName ));
+            !(options.testMode && isDowngradable( msg.messageId, moduleName, deprecatedDowngradable ));
         }
       }
     }
@@ -605,7 +606,7 @@ function _check$Severities( id, moduleName, severity ) {
     return;
   }
   // now try whether the message could be something less than an Error in the module due to user wishes
-  if (!isDowngradable( id, moduleName )) { // always an error in module
+  if (!isDowngradable( id, moduleName, true )) { // always an error in module
     if (severity !== 'Error')
       throw new CompilerAssertion( `Inconsistent severity: Expecting "Error", not "${severity}" for message ID "${id}" in module "${moduleName}"` );
   }
@@ -639,14 +640,12 @@ function _check$Texts( id, prop, value ) {
     throw new CompilerAssertion( `Different texts for the same message ID. Expecting "${expected}", not "${value}" for ID "${id}" and text variant "${prop}"`);
 }
 
-const quote = {                 // could be an option in the future
-  name: n => `“${ n }”`,
-  prop: p => `‘${ p }’`,
-  file: f => `‘${ f }’`,
-  code: c => `«${ c }»`,
-  meta: m => `‹${ m }›`,
-  // TODO: probably use keyword as function name, but its name would not have length 4 :-(
-  word: w => w.toUpperCase(),   // keyword
+const quote = {            // could be an option in the future
+  double: p => `“${ p }”`, // for names, including annotation names (with preceeding `@`)
+  single: p => `‘${ p }’`, // for other things cited from the model
+  angle:  p => `‹${ p }›`, // for tokens like ‹Identifier›, and similar
+  number: p => p,          // for numbers like 42
+  upper:  p => p.toUpperCase(), // for keywords reported by ANTLR, use prop.single in v4
 }
 
 const paramsTransform = {
@@ -654,32 +653,38 @@ const paramsTransform = {
   name: quoted,
   id: quoted,
   alias: quoted,
-  anno: a => (a.charAt(0) === '@' ? quote.name( a ) : quote.name( '@' + a )),
-  delimited: n => '![' + n + ']',
-  file: quote.file,
-  prop: quote.prop,
-  otherprop: quote.prop,
-  code: quote.code,
-  newcode: quote.code,
-  kind: quote.meta,
-  keyword: quote.word,
+  anno: a => (a.charAt(0) === '@' ? quote.double( a ) : quote.double( '@' + a )),
+  annos: anno => anno.map(paramsTransform.anno).join(', '),
+  delimited: n => '![' + n + ']', // TODO: use quote.single around?
+  file: quote.single,
+  prop: quote.single,
+  siblingprop: quote.single,
+  parentprop: quote.single,
+  otherprop: quote.single,
+  code: quote.single,
+  newcode: quote.single,
+  kind: quote.angle,            // consider using text variants instead
+  keyword: quote.upper,
   // more complex convenience:
   names: transformManyWith( quoted ),
-  number: n => n,
-  line: l => l,
-  col: c => c,
-  literal: l => l,
+  number: quote.number,
+  line: quote.number,
+  col: quote.number,
+  value: n => (typeof n !== 'number' ? quote.single( n ) : quote.number( n )),
+  othervalue: n => (typeof n !== 'number' ? quote.single( n ) : quote.number( n )),
   art: transformArg,
   service: transformArg,
   sorted_arts: transformManyWith( transformArg, true ),
   target: transformArg,
+  source: transformArg,
   elemref: transformElementRef,
   type: transformArg,
   offending: tokenSymbol,
+  op: quote.single,
   expecting: transformManyWith( tokenSymbol ),
   // msg: m => m,
   $reviewed: ignoreTextTransform,
-  version: quote.meta,
+  version: quote.single, // TODO delete: just use for OData $(VERSION), with version: 2.0
 };
 
 function ignoreTextTransform() {
@@ -702,20 +707,20 @@ function transformManyWith( t, sorted ) {
 }
 
 function quoted( name ) {
-  return (name) ? quote.name( name ) : '<?>'; // TODO: failure in --test-mode, then remove
+  return (name) ? quote.double( name ) : quote.angle( '?' ); // TODO: failure in --test-mode, then remove
 }
 
 function tokenSymbol( token ) {
   if (token.match( /^[A-Z][A-Z]/ )) // keyword
-    return quote.word( token );
+    return quote.upper( token );
   else if (token.match( /^[A-Z][a-z]/ )) // Number, Identifier, ...
-    return quote.meta( token );
+    return quote.angle( token );
   if (token.startsWith("'") && token.endsWith("'")) // operator token symbol
-    return quote.prop( token.slice( 1, -1 ));
+    return quote.single( token.slice( 1, -1 ));
   else if (token === '<EOF>')
-    return quote.meta( token.slice( 1, -1 ) );
+    return quote.angle( 'EOF' );
   else
-    return quote.code( token ); // should not happen
+    return quote.single( token ); // should not happen
 }
 
 /**
@@ -801,6 +806,7 @@ function messageText( texts, params, transform ) {
 }
 
 function replaceInString( text, params ) {
+  const usedParams = [ '#', '$reviewed' ];
   let pattern = /\$\(([A-Z_]+)\)/g;
   let parts = [];
   let start = 0;
@@ -808,11 +814,11 @@ function replaceInString( text, params ) {
     let prop = p[1].toLowerCase();
     parts.push( text.substring( start, p.index ),
                 (prop in params ? params[prop] : p[0]) );
-    delete params[prop];
+    usedParams.push(prop);
     start = pattern.lastIndex;
   }
   parts.push( text.substring( start ) );
-  let remain = (params['#']) ? [] : Object.keys( params ).filter( n => params[n] );
+  let remain = (params['#']) ? [] : Object.keys( params ).filter( n => !usedParams.includes(n) );
   return (remain.length)
          ? parts.join('') + '; ' +
            remain.map( n => n.toUpperCase() + ' = ' + params[n] ).join(', ')
@@ -1024,6 +1030,7 @@ function compareMessage( a, b ) {
              c( aEnd.endLine, bEnd.endLine ) ||
              c( aEnd.endCol, bEnd.endCol ) ||
              c( homeSortName( a ), homeSortName( b ) ) ||
+             // TODO: severities?
              c( a.message, b.message ) );
   }
   else if (!aFile && !bFile)
@@ -1107,7 +1114,7 @@ function shortArtName( art ) {
   const { name } = art;
   if ([ 'select', 'action', 'alias', 'param' ].every( n => name[n] == null || name[n] === 1 ) &&
       !name.absolute.includes(':'))
-    return quote.name( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
+    return quote.double( name.element ? `${ name.absolute }:${ name.element }` : name.absolute );
   return artName( art );
 }
 
@@ -1172,7 +1179,9 @@ function homeNameForExtend( art ) {
 
   // Surrounding parent may be another extension.
   const parent = art._parent;
-  if (!parent)
+  if (!parent && art.name.absolute)
+    return kind + ':' + artName(removeBlock(art));
+  else if (!parent)
     return kind + ':' + quoted(absoluteName);
 
   if (art.name.param && parent.params) {
@@ -1199,6 +1208,14 @@ function homeNameForExtend( art ) {
   }
   // This case should not happen, but just in case
   return kind + ':' + artName(parent);
+
+  /**
+   * Remove `select` from the 'art's name to avoid `block:1` in artName().
+   * @TODO: Refactor homeNameForExtend (and possibly artName) to get rid of this function
+   **/
+  function removeBlock(obj) {
+    return { ...obj, name: { ...obj.name, select: null } };
+  }
 }
 
 function constructSemanticLocationFromCsnPath(csnPath, model) {
@@ -1220,11 +1237,15 @@ function constructSemanticLocationFromCsnPath(csnPath, model) {
 
   let { query } = analyseCsnPath(csnPath, model, false);
 
-  // remove definitions
-  csnPath.shift();
+  const dictName = csnPath.shift();
+  const dict = model[dictName];
   const artifactName = csnPath.shift();
-  let currentThing = model.definitions[artifactName];
-  let result = `${ (currentThing && currentThing.kind) ? currentThing.kind : 'artifact' }:${ _quoted(artifactName) }`;
+  let currentThing = dict ? dict[artifactName] : undefined;
+  let result = `${ (currentThing?.kind)
+    ? currentThing.kind
+    : (dictName === 'vocabularies'
+      ? 'annotation'
+      : 'artifact') }:${ _quoted(artifactName) }`;
 
   if (!currentThing)
     return result;

package/lib/base/model.js

@@ -26,8 +26,9 @@ const availableBetaFlags = {
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true,
   ignoreAssocPublishingInUnion: true,
-  nestedProjections: true,
   enableUniversalCsn: true,
+  postgres: true,
+  aspectWithoutElements: true,
   // disabled by --beta-mode
   nestedServices: false,
   odataOpenType: true,

package/lib/checks/actionsFunctions.js

@@ -22,7 +22,7 @@ function checkActionOrFunction(art, artName, prop, path) {
 
   const serviceName = this.csnUtils.getServiceName(artName);
   if (!serviceName)
-    this.warning(null, path, `Functions and actions must be declared in a service`);
+    this.warning(null, path, {}, 'Functions and actions must be declared in a service');
 
   if (art.kind === 'entity') {
     for (const [ actName, act ] of Object.entries(art.actions)) {

package/lib/checks/annotationsOData.js

@@ -36,7 +36,7 @@ function checkCoreMediaTypeAllowence(member) {
  */
 function checkAnalytics(member) {
   if (member['@Analytics.Measure'] && !member['@Aggregation.default']) {
-    this.info(null, member.$path,
+    this.info(null, member.$path, {},
               'Annotation “@Analytics.Measure” expects “@Aggregation.default” to be assigned for the same element as well');
   }
 }
@@ -63,7 +63,7 @@ function checkReadOnlyAndInsertOnly(artifact, artifactName) {
   if (!this.csnUtils.getServiceName(artifactName))
     return;
   if (artifact.kind === 'entity' && artifact['@readonly'] && artifact['@insertonly'])
-    this.warning(null, artifact.$path, 'Annotations “@readonly” and “@insertonly” can\'t be assigned in combination');
+    this.warning(null, artifact.$path, {}, 'Annotations “@readonly” and “@insertonly” can\'t be assigned in combination');
 }
 
 module.exports = {

package/lib/checks/arrayOfs.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { setProp } = require('../base/model');
+
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
 /**
@@ -24,20 +26,26 @@ function validateAssociationsInItems(member) {
           if (element.on) { // Unmanaged association
             // Unmanaged associations are always forbidden for now
             // TODO: Check if the on-condition only references things inside of the .items
-            this.error(null, member.$path, 'Unmanaged associations in "array of" or "many" are not allowed');
+            this.error(null, member.$path, {}, 'Unmanaged associations in "array of" or "many" are not allowed');
           }
         }
       }
     }
   };
   if (this.artifact && ( this.artifact.kind === 'entity' || this.artifact.query ) && member && member.items && member.$path[2] === 'elements') {
-    if (member.items.type && member.items.type.ref)
-      validate(this.artifactRef(member.items.type));
-
-    else if (member.items.type)
-      validate(this.csn.definitions[member.items.type]);
-    else
+    if (member.items.type) {
+      const type = member.items.type.ref
+        ? this.artifactRef(member.items.type)
+        : this.csn.definitions[member.items.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        validate(type);
+        delete type.$visited;
+      }
+    }
+    else {
       validate(member.items);
+    }
   }
 }
 

package/lib/checks/cdsPersistence.js

@@ -17,7 +17,7 @@ function validateCdsPersistenceAnnotation(artifact, artifactName, prop, path) {
     // TODO: Why not filter over persistenceAnnos, is shorter!
     const TableUdfCv = Object.keys(artifact).filter(p => persistenceAnnos.includes(p) && artifact[p]);
     if (TableUdfCv.length > 1)
-      this.error(null, path, `Annotations ${ TableUdfCv.join(', ') } can't be used in combination`);
+      this.error(null, path, { annos: TableUdfCv }, 'Annotations $(ANNOS) can\'t be used in combination');
   }
 }
 

package/lib/checks/checkForTypes.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { isPersistedOnDatabase } = require('../model/csnUtils.js');
+
+/**
+ * Check that `cds.hana` types are not used - we don't support them for postgres
+ *
+ * @param {object} parent Object with a type
+ * @param {string} name Name of the type property on parent
+ * @param {Array} type type to check
+ * @param {CSN.Path} path
+ */
+function checkForHanaTypes(parent, name, type, path) {
+  const artifact = this.csn.definitions[path[1]];
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && typeof parent.type === 'string' && parent.type.startsWith('cds.hana.')) {
+    this.error('ref-unexpected-hana-type', [ ...path, 'type' ], { type: 'cds.hana', value: this.options.sqlDialect },
+               'Types in the $(TYPE) namespace can\'t be used with sqlDialect $(VALUE)');
+  }
+}
+
+/**
+ * Check that `cds.UInt8` is not used - we don't have a clear idea how to represent it on postgres and h2
+ *
+ * @param {object} parent Object with a type
+ * @param {string} name Name of the type property on parent
+ * @param {Array} type type to check
+ * @param {CSN.Path} path
+ */
+function CheckForUInt8(parent, name, type, path) {
+  const artifact = this.csn.definitions[path[1]];
+  if (artifact.kind === 'entity' && isPersistedOnDatabase(artifact) && parent.type === 'cds.UInt8') {
+    this.error('ref-unexpected-type', [ ...path, 'type' ], { type: 'cds.UInt8', value: this.options.sqlDialect },
+               'Type $(TYPE) can\'t be used with sqlDialect $(VALUE)');
+  }
+}
+
+/**
+ * Check types - specifically for postgres and h2
+ *
+ * @param {object} parent Object with a type
+ * @param {string} name Name of the type property on parent
+ * @param {Array} type type to check
+ * @param {CSN.Path} path
+ */
+function checkTypes(parent, name, type, path) {
+  checkForHanaTypes.bind(this)(parent, name, type, path);
+  if (this.options.sqlDialect === 'postgres' || this.options.sqlDialect === 'h2')
+    CheckForUInt8.bind(this)(parent, name, type, path);
+}
+
+module.exports = {
+  type: checkTypes,
+};

package/lib/checks/defaultValues.js

@@ -20,8 +20,10 @@ function validateDefaultValues(member, memberName, prop, path) {
       // consume all unary signs
       while (member.default.xpr[i] === '-' || member.default.xpr[i] === '+')
         i++;
+      // TODO: This check only counts the number of leading signs, not inbetween (e.g. 1 - - 1).
+      //       The message also needs to be improved.
       if (i > 1)
-        this.error(null, path, `Illegal number of unary '+/-' operators`);
+        this.error(null, path, {}, 'Illegal number of unary ‘+’/‘-’ operators');
     }
   }
 }
@@ -36,7 +38,7 @@ function validateDefaultValues(member, memberName, prop, path) {
  */
 function rejectParamDefaultsInHanaCds(member, memberName, prop, path) {
   if (member.default && prop === 'params' && this.options.transformation === 'hdbcds')
-    this.error(null, path, 'Parameter default values are not supported in SAP HANA CDS');
+    this.error(null, path, {}, 'Parameter default values are not supported in SAP HANA CDS');
 }
 
 /**

package/lib/checks/elements.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const { forEachMember, forEachMemberRecursively } = require('../model/csnUtils');
+const { forEachMember, forEachMemberRecursively, isBuiltinType } = require('../model/csnUtils');
 const { isGeoTypeName } = require('../compiler/builtins');
-
+const { setProp } = require('../base/model');
 // Only to be used with validator.js - a correct `this` value needs to be provided!
 
 /**
@@ -42,13 +42,15 @@ function checkPrimaryKey(art) {
                    { type: finalBaseType.type, name: elemFqName },
                    'Type $(TYPE) can\'t be used as primary key in element $(NAME)');
       }
-      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType)) {
+      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType) && !finalBaseType.$visited) {
+        setProp(finalBaseType, '$visited', true);
         forEachMemberRecursively(finalBaseType,
                                  (subMember, subMemberName) => checkIfPrimaryKeyIsOfGeoType
                                    .bind(this)(subMember,
                                                `${ elemFqName }/${ subMemberName }`,
                                                member.key || parentIsKey,
                                                member.$path));
+        delete finalBaseType.$visited;
       }
     }
   }
@@ -68,13 +70,15 @@ function checkPrimaryKey(art) {
         this.error(null, parentPath || member.$path, { name: elemFqName },
                    'Array-like type in element $(NAME) can\'t be used as primary key');
       }
-      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType)) {
+      else if (finalBaseType && this.csnUtils.isStructured(finalBaseType) && !finalBaseType.$visited) {
+        setProp(finalBaseType, '$visited', true);
         forEachMemberRecursively(finalBaseType,
                                  (subMember, subMemberName) => checkIfPrimaryKeyIsArray
                                    .bind(this)(subMember,
                                                `${ elemFqName }/${ subMemberName }`,
                                                member.key || parentIsKey,
                                                member.$path));
+        delete finalBaseType.$visited;
       }
     }
   }
@@ -89,7 +93,7 @@ function checkPrimaryKey(art) {
 function checkVirtualElement(member) {
   if (member.virtual) {
     if (this.csnUtils.isAssociation(member.type)) { // or Composition ???
-      this.error(null, member.$path, `Element can't be virtual and an association`);
+      this.error(null, member.$path, {}, 'Element can\'t be virtual and an association');
     }
   }
 }
@@ -135,4 +139,75 @@ function checkManagedAssoc(art) {
   }
 }
 
-module.exports = { checkPrimaryKey, checkVirtualElement, checkManagedAssoc };
+/**
+ * All DB  & OData flat mode must reject recursive type usages in entities
+ * 'items' break recursion as 'items' will turn into an NCLOB and the path
+ * prefix to 'items' can be flattend in the DB.
+ * In OData flat mode the first appearance of 'items' breaks out into structured
+ * mode producing (legal) recursive complex types.
+ *
+ * @param {CSN.Artifact} art The artifact
+ */
+function checkRecursiveTypeUsage(art) {
+  const visit = (def) => {
+    const loc = def.$path;
+    // recursive types are allowed inside arrays
+    if (def.items)
+      return;
+    let { type } = def;
+    let prevType;
+    let isDeref = false;
+    if (type && !isBuiltinType(type) && !def.elements) {
+      do {
+        prevType = type;
+        // TODO: `type.ref.length > 1`, but OData backend must be tested first (#5144)
+        //  e.g. `{ ref: [ "MyType" ] }`
+        if (type.ref) {
+          def = this.artifactRef(type);
+          isDeref = true;
+        }
+        else {
+          def = this.csn.definitions[type];
+        }
+        type = def.type;
+      } while (type && !isBuiltinType(type) && !def.items && !def.elements && prevType !== type);
+    }
+    if (def.$visited || (type && prevType === type)) {
+      // Recursion via type is allowed in V4 struct, but not via dereferencing
+      if (!isDeref && this.options.odataVersion === 'v4' && this.options.odataFormat === 'structured')
+        return;
+      if (!def.$recErr) {
+        this.error(null, loc, {}, 'Unexpected recursive type definition');
+        setProp(def, '$recErr', true);
+      }
+    }
+    else if (def.elements) {
+      setProp(def, '$visited', true);
+      for (const n in def.elements)
+        visit(def.elements[n]);
+      delete def.$visited;
+    }
+  };
+  // elements & params are flattening candidates
+  // FUTURE:
+  // Once we have universal CSN for the runtimes
+  // Validate service members only for OData
+  if (art.kind === 'entity') {
+    for (const n in art.elements)
+      visit(art.elements[n]);
+    for (const n in art.params)
+      visit(art.params[n]);
+  }
+  if (this.options.odataVersion) {
+    // func/action params/returns don't allow recursive type derefs
+    if (art.kind === 'action' || art.kind === 'function') {
+      for (const n in art.params)
+        visit(art.params[n]);
+      if (art.returns)
+        visit(art.returns);
+    }
+  }
+}
+module.exports = {
+  checkPrimaryKey, checkVirtualElement, checkManagedAssoc, checkRecursiveTypeUsage,
+};

package/lib/checks/foreignKeys.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { setProp } = require('../base/model');
+
 // Only to be used with validator.js - a correct this value needs to be provided!
 
 /**
@@ -41,10 +43,10 @@ function validateForeignKeys(member) {
   // Declared as arrow-function to keep scope the same (this value)
   const checkForItems = (mem) => {
     if (mem.items) {
-      this.error(null, member.$path, 'Array-like properties must not be foreign keys');
+      this.error(null, member.$path, {}, 'Array-like properties must not be foreign keys');
     }
     else if (isUnmanagedAssoc(mem)) {
-      this.error(null, member.$path, 'Unmanaged association must not be a foreign key');
+      this.error(null, member.$path, {}, 'Unmanaged association must not be a foreign key');
     }
     else if (mem.keys) {
       handleAssociation(mem);
@@ -52,17 +54,14 @@ function validateForeignKeys(member) {
     else if (mem.elements) {
       handleStructured(mem);
     }
-    else if (mem.type && mem.type.ref) { // type of
-      checkForItems(this.artifactRef(mem.type));
-    }
-    else { // type T where T might contain items
-      const type = this.csn.definitions[mem.type];
-      if (type) {
-        if (type.keys)
-          handleAssociation(type);
-
-        else if (type.elements)
-          handleStructured(type);
+    else if (mem.type) {
+      const type = mem.type.ref
+        ? this.artifactRef(mem.type)
+        : this.csn.definitions[mem.type];
+      if (type && !type.$visited) {
+        setProp(type, '$visited', true);
+        checkForItems(type);
+        delete type.$visited;
       }
     }
   };