@sap/cds-compiler 4.1.2 → 4.2.2

package/lib/edm/annotations/genericTranslation.js

@@ -1,4 +1,5 @@
 'use strict';
+
 const { isEdmPropertyRendered, isBuiltinType } = require('../../model/csnUtils');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
@@ -37,115 +38,115 @@ const { isBetaEnabled, setProp } = require('../../base/model.js');
 */
 
 const vocabularyDefinitions = {
-  'Aggregation': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Aggregation.V1.xml' },
-    'inc': { Alias: 'Aggregation', Namespace: 'Org.OData.Aggregation.V1' },
-    'int': { filename: 'Aggregation.xml' }
+  Aggregation: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Aggregation.V1.xml' },
+    inc: { Alias: 'Aggregation', Namespace: 'Org.OData.Aggregation.V1' },
+    int: { filename: 'Aggregation.xml' },
   },
-  'Analytics': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Analytics.xml' },
-    'inc': { Alias: 'Analytics', Namespace: 'com.sap.vocabularies.Analytics.v1' },
-    'int': { filename: 'Analytics.xml' }
+  Analytics: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Analytics.xml' },
+    inc: { Alias: 'Analytics', Namespace: 'com.sap.vocabularies.Analytics.v1' },
+    int: { filename: 'Analytics.xml' },
   },
-  'Authorization': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Authorization.V1.xml' },
-    'inc': { Alias: 'Authorization', Namespace: 'Org.OData.Authorization.V1' },
-    'int': { filename: 'Authorization.xml' }
+  Authorization: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Authorization.V1.xml' },
+    inc: { Alias: 'Authorization', Namespace: 'Org.OData.Authorization.V1' },
+    int: { filename: 'Authorization.xml' },
   },
-  'Capabilities': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Capabilities.V1.xml' },
-    'inc': { Alias: 'Capabilities', Namespace: 'Org.OData.Capabilities.V1' },
-    'int': { filename: 'Capabilities.xml' }
+  Capabilities: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Capabilities.V1.xml' },
+    inc: { Alias: 'Capabilities', Namespace: 'Org.OData.Capabilities.V1' },
+    int: { filename: 'Capabilities.xml' },
   },
-  'CodeList': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/CodeList.xml' },
-    'inc': { Alias: 'CodeList', Namespace: 'com.sap.vocabularies.CodeList.v1' },
-    'int': { filename: 'CodeList.xml' }
+  CodeList: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/CodeList.xml' },
+    inc: { Alias: 'CodeList', Namespace: 'com.sap.vocabularies.CodeList.v1' },
+    int: { filename: 'CodeList.xml' },
   },
-  'Common': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Common.xml' },
-    'inc': { Alias: 'Common', Namespace: 'com.sap.vocabularies.Common.v1' },
-    'int': { filename: 'Common.xml' }
+  Common: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Common.xml' },
+    inc: { Alias: 'Common', Namespace: 'com.sap.vocabularies.Common.v1' },
+    int: { filename: 'Common.xml' },
   },
-  'Communication': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Communication.xml' },
-    'inc': { Alias: 'Communication', Namespace: 'com.sap.vocabularies.Communication.v1' },
-    'int': { filename: 'Communication.xml' }
+  Communication: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Communication.xml' },
+    inc: { Alias: 'Communication', Namespace: 'com.sap.vocabularies.Communication.v1' },
+    int: { filename: 'Communication.xml' },
   },
-  'Core': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Core.V1.xml' },
-    'inc': { Alias: 'Core', Namespace: 'Org.OData.Core.V1' },
-    'int': { filename: 'Core.xml' }
+  Core: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Core.V1.xml' },
+    inc: { Alias: 'Core', Namespace: 'Org.OData.Core.V1' },
+    int: { filename: 'Core.xml' },
   },
-  'DataIntegration': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/DataIntegration.xml' },
-    'inc': { Alias: 'DataIntegration', Namespace: 'com.sap.vocabularies.DataIntegration.v1' },
-    'int': { filename: 'DataIntegration.xml' }
+  DataIntegration: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/DataIntegration.xml' },
+    inc: { Alias: 'DataIntegration', Namespace: 'com.sap.vocabularies.DataIntegration.v1' },
+    int: { filename: 'DataIntegration.xml' },
   },
-  'Graph': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Graph.xml' },
-    'inc': { Alias: 'Graph', Namespace: 'com.sap.vocabularies.Graph.v1' },
-    'int': { filename: 'Graph.xml' }
+  Graph: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Graph.xml' },
+    inc: { Alias: 'Graph', Namespace: 'com.sap.vocabularies.Graph.v1' },
+    int: { filename: 'Graph.xml' },
   },
-  'Hierarchy': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Hierarchy.xml' },
-    'inc': { Alias: 'Hierarchy', Namespace: 'com.sap.vocabularies.Hierarchy.v1' },
-    'int': { filename: 'Hierarchy.xml' }
+  Hierarchy: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Hierarchy.xml' },
+    inc: { Alias: 'Hierarchy', Namespace: 'com.sap.vocabularies.Hierarchy.v1' },
+    int: { filename: 'Hierarchy.xml' },
   },
-  'HTML5': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/HTML5.xml' },
-    'inc': { Alias: 'HTML5', Namespace: 'com.sap.vocabularies.HTML5.v1' },
-    'int': { filename: 'HTML5.xml' }
+  HTML5: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/HTML5.xml' },
+    inc: { Alias: 'HTML5', Namespace: 'com.sap.vocabularies.HTML5.v1' },
+    int: { filename: 'HTML5.xml' },
   },
-  'JSON': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.JSON.V1.xml' },
-    'inc': { Alias: 'JSON', Namespace: 'Org.OData.JSON.V1' },
-    'int': { filename: 'JSON.xml' }
+  JSON: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.JSON.V1.xml' },
+    inc: { Alias: 'JSON', Namespace: 'Org.OData.JSON.V1' },
+    int: { filename: 'JSON.xml' },
   },
-  'Measures': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Measures.V1.xml' },
-    'inc': { Alias: 'Measures', Namespace: 'Org.OData.Measures.V1' },
-    'int': { filename: 'Measures.xml' }
+  Measures: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Measures.V1.xml' },
+    inc: { Alias: 'Measures', Namespace: 'Org.OData.Measures.V1' },
+    int: { filename: 'Measures.xml' },
   },
-  'ODM': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/ODM.xml' },
-    'inc': { Alias: 'ODM', Namespace: 'com.sap.vocabularies.ODM.v1' },
-    'int': { filename: 'ODM.xml' }
+  ODM: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/ODM.xml' },
+    inc: { Alias: 'ODM', Namespace: 'com.sap.vocabularies.ODM.v1' },
+    int: { filename: 'ODM.xml' },
   },
-  'Offline': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Offline.xml' },
-    'inc': { Alias: 'Offline', Namespace: 'com.sap.vocabularies.Offline.v1' },
-    'int': { filename: 'Offline.xml' }
+  Offline: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Offline.xml' },
+    inc: { Alias: 'Offline', Namespace: 'com.sap.vocabularies.Offline.v1' },
+    int: { filename: 'Offline.xml' },
   },
-  'PDF': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/PDF.xml' },
-    'inc': { Alias: 'PDF', Namespace: 'com.sap.vocabularies.PDF.v1' },
-    'int': { filename: 'PDF.xml' }
+  PDF: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/PDF.xml' },
+    inc: { Alias: 'PDF', Namespace: 'com.sap.vocabularies.PDF.v1' },
+    int: { filename: 'PDF.xml' },
   },
-  'PersonalData': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/PersonalData.xml' },
-    'inc': { Alias: 'PersonalData', Namespace: 'com.sap.vocabularies.PersonalData.v1' },
-    'int': { filename: 'PersonalData.xml' }
+  PersonalData: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/PersonalData.xml' },
+    inc: { Alias: 'PersonalData', Namespace: 'com.sap.vocabularies.PersonalData.v1' },
+    int: { filename: 'PersonalData.xml' },
   },
-  'Repeatability': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Repeatability.V1.xml' },
-    'inc': { Alias: 'Repeatability', Namespace: 'Org.OData.Repeatability.V1' },
-    'int': { filename: 'Repeatability.xml' }
+  Repeatability: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Repeatability.V1.xml' },
+    inc: { Alias: 'Repeatability', Namespace: 'Org.OData.Repeatability.V1' },
+    int: { filename: 'Repeatability.xml' },
   },
-  'Session': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Session.xml' },
-    'inc': { Alias: 'Session', Namespace: 'com.sap.vocabularies.Session.v1' },
-    'int': { filename: 'Session.xml' }
+  Session: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Session.xml' },
+    inc: { Alias: 'Session', Namespace: 'com.sap.vocabularies.Session.v1' },
+    int: { filename: 'Session.xml' },
   },
-  'UI': {
-    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/UI.xml' },
-    'inc': { Alias: 'UI', Namespace: 'com.sap.vocabularies.UI.v1' },
-    'int': { filename: 'UI.xml' }
+  UI: {
+    ref: { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/UI.xml' },
+    inc: { Alias: 'UI', Namespace: 'com.sap.vocabularies.UI.v1' },
+    int: { filename: 'UI.xml' },
   },
-  'Validation': {
-    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Validation.V1.xml' },
-    'inc': { Alias: 'Validation', Namespace: 'Org.OData.Validation.V1' },
-    'int': { filename: 'Validation.xml' }
+  Validation: {
+    ref: { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Validation.V1.xml' },
+    inc: { Alias: 'Validation', Namespace: 'Org.OData.Validation.V1' },
+    int: { filename: 'Validation.xml' },
   },
   /* unvalidated vocabularies below here:
      A vocabulary is unvalidated if it doesn't have an int.filename property as this indicates that
@@ -164,29 +165,27 @@ Object.entries(vocabularyDefinitions).forEach(([n, v]) => {
     vocabularyDefinitions[v.inc.Namespace] = vocabularyDefinitions[n];
 });
 */
-/**************************************************************************************************
+/** ************************************************************************************************
  * csn2annotationEdm
  *
  * options:
  *   v - array with two boolean entries, first is for v2, second is for v4
  *   dictReplacement: for test purposes, replaces the standard oDataDictionary
  */
-function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
-  Edm = undefined, options=undefined, messageFunctions=undefined, mergedVocDefs=vocabularyDefinitions) {
+function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
+                            Edm = undefined, options = undefined, messageFunctions = undefined, mergedVocDefs = vocabularyDefinitions ) {
   // global variable where we store all the generated annotations
-  const g_annosArray = [];
+  const gAnnosArray = [];
 
   const { message } = messageFunctions;
 
   const [ userDefinedTermDict, allKnownVocabularies ] = createUserDefinedTermDictionary();
 
   allKnownVocabularies.push(...Object.keys(mergedVocDefs));
-  allKnownVocabularies.sort((a,b) => b.length-a.length);
-  const whatsMyTermNamespace = function(anno) {
-    return allKnownVocabularies.reduce((rc, ns) => !rc && anno && anno.startsWith('@' + ns + '.') ? ns : rc, undefined);
-  }
+  allKnownVocabularies.sort((a, b) => b.length - a.length);
+  const whatsMyTermNamespace = anno => allKnownVocabularies.reduce((rc, ns) => (!rc && anno && anno.startsWith(`@${ns}.`) ? ns : rc), undefined);
 
-    // Static dynamic expression dictionary, loaded with Edm creators
+  // Static dynamic expression dictionary, loaded with Edm creators
   const [ dynamicExpressions, dynamicExpressionNames ] = initEdmJson();
 
   // annotation preprocessing
@@ -194,25 +193,25 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
   // we take note of which vocabularies are actually used in a service in order to avoid
   // producing useless references; reset everything to "unused"
-  for(const n in mergedVocDefs) {
+  for (const n in mergedVocDefs) {
     mergedVocDefs[n].used = false;
     delete mergedVocDefs[n].$ignore;
   }
 
   // These vocabularies are always added for the runtimes
-  mergedVocDefs['Common'].used = true;
-  mergedVocDefs['Core'].used = true;
+  mergedVocDefs.Common.used = true;
+  mergedVocDefs.Core.used = true;
 
   const vocDef = mergedVocDefs[serviceName];
-  if(vocDef && vocDef.$optVocRef) {
+  if (vocDef && vocDef.$optVocRef) {
     setProp(vocDef, '$ignore', true);
     message('odata-anno-vocref', null,
-                { name: serviceName, '#': 'service' } );
+            { name: serviceName, '#': 'service' } );
   }
 
   // provide functions for dictionary lookup
   //   use closure to avoid making "dict" and "experimental" global variables
-  const { getDictTerm, getDictType } = function(){
+  const { getDictTerm, getDictType } = (function createDictGetters() {
     const dict = options.dictReplacement || oDataDictionary; // tests can set different dictionary via options
     const experimental = {}; // take note of all experimental annos that have been used
     const deprecated = {}; // take note of all deprecated annos that have been used
@@ -221,27 +220,27 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       // called to look-up a term in the dictionary
       //   in addition: - note usage of the respective vocabulary
       //                - issue a warning if the term is flagged as "experimental"
-      getDictTerm: function(termName, msg) {
+      getDictTerm(termName, msg) {
         const dictTerm = (dict.terms[termName] ||
-          userDefinedTermDict.terms[serviceName + '.' + termName] ||
+          userDefinedTermDict.terms[`${serviceName}.${termName}`] ||
           userDefinedTermDict.terms[termName]);
         // register vocabulary usage if possible
         const vocName = termName.slice(0, termName.indexOf('.'));
-        const vocDef = mergedVocDefs[vocName];
-        if(vocDef && !vocDef.$ignore)
-          vocDef.used = true;
-        else if(dictTerm?.$myServiceRoot &&
+        const myVocDef = mergedVocDefs[vocName];
+        if (myVocDef && !myVocDef.$ignore)
+          myVocDef.used = true;
+        else if (dictTerm?.$myServiceRoot &&
           userDefinedTermDict.xrefs[dictTerm?.$myServiceRoot])
           userDefinedTermDict.xrefs[dictTerm.$myServiceRoot].used = true;
         if (dictTerm) {
           // issue message for usage of experimental Terms, but only once per Term
-          if (dictTerm['$experimental'] && !experimental[termName]) {
+          if (dictTerm.$experimental && !experimental[termName]) {
             message('odata-anno-dict', msg.location, { anno: msg.anno(), '#': 'experimental' });
             experimental[termName] = true;
           }
-          if (dictTerm['$deprecated'] && !deprecated[termName]) {
+          if (dictTerm.$deprecated && !deprecated[termName]) {
             message('odata-anno-def', msg.location,
-            { anno: msg.anno(), depr: dictTerm['$deprecationText'], '#': 'deprecated' });
+                    { anno: msg.anno(), depr: dictTerm.$deprecationText, '#': 'deprecated' });
             deprecated[termName] = true;
           }
         }
@@ -249,44 +248,44 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       },
       // called to look-up a type in the dictionary
       //   in addition, note usage of the respective vocabulary
-      getDictType: function (typeName) {
-        let dictType = (dict.types[typeName] ||
-          userDefinedTermDict.types[serviceName + '.' + typeName] ||
+      getDictType(typeName) {
+        const dictType = (dict.types[typeName] ||
+          userDefinedTermDict.types[`${serviceName}.${typeName}`] ||
           userDefinedTermDict.types[typeName]);
         if (dictType) {
           // register usage of vocabulary
           const vocName = typeName.slice(0, typeName.indexOf('.'));
-          const vocDef = mergedVocDefs[vocName];
-          if(vocDef && !vocDef.$ignore)
-            vocDef.used = true;
+          const myVocDef = mergedVocDefs[vocName];
+          if (myVocDef && !myVocDef.$ignore)
+            myVocDef.used = true;
         }
         return dictType;
-      }
-    }
-  }();
+      },
+    };
+  }());
 
-  const v = options.v;
+  const { v } = options;
 
   // Copy annotations from origin to parameter entity if it's
   // qualified with #$parameters or if its applicable to an EntitySet or Singleton
   forEachDefinition(reqDefs, (object) => {
-    if(object.$isParamEntity && object._origin) {
-      for(const attr in object._origin) {
+    if (object.$isParamEntity && object._origin) {
+      for (const attr in object._origin) {
         if (attr[0] === '@') {
           const [ prefix, innerAnnotation ] = attr.split('.@');
           const ns = whatsMyTermNamespace(prefix);
-          if(ns) {
-            const steps = prefix.replace('@' + ns + '.', '').split('.');
+          if (ns) {
+            const steps = prefix.replace(`@${ns}.`, '').split('.');
             const paramAnnoParts = steps[0].split('#$parameters');
-            const dictTerm = getDictTerm(ns + '.' + paramAnnoParts[0], options);
-            if(paramAnnoParts.length > 1 || ['Singleton', 'EntitySet'].some(y => dictTerm?.AppliesTo?.includes(y))) {
-              steps[0] = '@' + ns + '.' + paramAnnoParts.join('');
+            const dictTerm = getDictTerm(`${ns}.${paramAnnoParts[0]}`, options);
+            if (paramAnnoParts.length > 1 || [ 'Singleton', 'EntitySet' ].some(y => dictTerm?.AppliesTo?.includes(y))) {
+              steps[0] = `@${ns}.${paramAnnoParts.join('')}`;
               let newAnno = steps.join('.');
-              if(innerAnnotation)
-                newAnno += '.@' + innerAnnotation;
+              if (innerAnnotation)
+                newAnno += `.@${innerAnnotation}`;
               edmUtils.assignAnnotation(object, newAnno, object._origin[attr]);
               // delete original annotation only if it was qualified with $parameters
-              if(paramAnnoParts.length > 1)
+              if (paramAnnoParts.length > 1)
                 delete object._origin[attr];
             }
           }
@@ -301,8 +300,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // Note: we assume that all objects ly flat in the service, i.e. objName always
   //       looks like <service name, can contain dots>.<id>
   forEachDefinition(reqDefs, (object, objName) => {
-    if (objName === serviceName || objName.startsWith(serviceName + '.')) {
-
+    if (objName === serviceName || objName.startsWith(`${serviceName}.`)) {
       const location = [ 'definitions', objName ];
       if (object.kind === 'action' || object.kind === 'function') {
         handleAction(objName, object, null, location);
@@ -322,14 +320,14 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // filter out empty <Annotations...> elements
   // add references for the used vocabularies
   return {
-    annos: g_annosArray,
-    usedVocabularies: Object.values(mergedVocDefs).filter(v => v.used),
-    xrefs: Object.values(userDefinedTermDict.xrefs).filter(v => v.used).map(v => v.$myServiceRoot)
+    annos: gAnnosArray,
+    usedVocabularies: Object.values(mergedVocDefs).filter(voc => voc.used),
+    xrefs: Object.values(userDefinedTermDict.xrefs).filter(voc => voc.used).map(voc => voc.$myServiceRoot),
   };
 
-//-------------------------------------------------------------------------------------------------
-//-------------------------------------------------------------------------------------------------
-//-------------------------------------------------------------------------------------------------
+  //-------------------------------------------------------------------------------------------------
+  //-------------------------------------------------------------------------------------------------
+  //-------------------------------------------------------------------------------------------------
 
   // helper to determine the OData version
   // TODO: improve option handling
@@ -337,7 +335,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     return v && v[0];
   }
 
-/*
+  /*
   Mapping annotated thing in cds/csn => annotated thing in edmx:
 
   carrier: the annotated thing in cds, can be: service, entity, structured type, element of entity or structured type,
@@ -375,17 +373,16 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 */
 
 
-
-
   // handle the annotations of the elements of an object
   // in: objname : name of the object
   //     object : the object itself
-  function handleElements(objname, object, location) {
-    if (!object.elements) return;
-    Object.entries(object.elements).forEach(([elemName, element]) => {
+  function handleElements( objname, object, location ) {
+    if (!object.elements)
+      return;
+    Object.entries(object.elements).forEach(([ elemName, element ]) => {
       // determine the name of the target in the resulting edm
       //   for non-assoc element, this simply is "<objectName>/<elementName>"
-      const edmTargetName = objname + '/' + elemName;
+      const edmTargetName = `${objname}/${elemName}`;
       const eLocation = [ ...location, 'elements', elemName ];
       handleAnnotations(edmTargetName, element, eLocation);
     });
@@ -402,16 +399,16 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // handle the annotations of cObject's (an entity) bound actions/functions and their parameters
   // in: cObjectname : qualified name of the object that holds the actions
   //     cObject     : the object itself
-  function handleBoundActions(cObjectname, cObject, location) {
-    if(!cObject.actions) return;
+  function handleBoundActions( cObjectname, cObject, location ) {
+    if (!cObject.actions)
+      return;
     // get service name: remove last part of the object name
     // only works if all objects ly flat in the service
-    const nameParts = cObjectname.split('.')
+    const nameParts = cObjectname.split('.');
     const entityName = nameParts.pop();
-    const serviceName = nameParts.join('.');
 
-    Object.entries(cObject.actions).forEach(([n, action]) => {
-      const actionName = serviceName + '.' + (isV2() ? entityName + '_' : '') + n;
+    Object.entries(cObject.actions).forEach(([ n, action ]) => {
+      const actionName = `${serviceName}.${isV2() ? `${entityName}_` : ''}${n}`;
       handleAction(actionName, action, cObjectname, [ ...location, 'actions', n ]);
     });
   }
@@ -421,12 +418,12 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // in: cActionName       : qualified name of the action
   //     cAction           : the action object
   //     entityNameIfBound : qualified name of entity if bound action/function
-  function handleAction(cActionName, cAction, entityNameIfBound, location) {
+  function handleAction( cActionName, cAction, entityNameIfBound, location ) {
     let actionName = cActionName;
     if (isV2()) { // Replace up to last dot with <serviceName>.EntityContainer
       const lastDotIndex = actionName.lastIndexOf('.');
       if (lastDotIndex > -1)
-        actionName = serviceName + '.EntityContainer/' + actionName.substring(lastDotIndex + 1);
+        actionName = `${serviceName}.EntityContainer/${actionName.substring(lastDotIndex + 1)}`;
     }
     else { // add parameter type list
       actionName += relParList();
@@ -434,17 +431,17 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
     handleAnnotations(actionName, cAction, location);
 
-    if(cAction.params) {
-      Object.entries(cAction.params).forEach(([n, p]) => {
-        const edmTargetName = actionName + '/' + n;
+    if (cAction.params) {
+      Object.entries(cAction.params).forEach(([ n, p ]) => {
+        const edmTargetName = `${actionName}/${n}`;
         handleAnnotations(edmTargetName, p, [ ...location, 'params', n ]);
       });
     }
-    if(cAction.returns) {
-      const edmTargetName = actionName + '/$ReturnType';
+    if (cAction.returns) {
+      const edmTargetName = `${actionName}/$ReturnType`;
       setProp(cAction.returns, '$appliesToReturnType', true);
       handleAnnotations(edmTargetName, cAction.returns, [ ...location, 'returns' ]);
-      delete cAction.returns['$appliesToReturnType'];
+      delete cAction.returns.$appliesToReturnType;
     }
 
     function relParList() {
@@ -452,40 +449,37 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       const params = [];
       if (entityNameIfBound) {
         // If this is an action and has an explicit binding parameter add it here
-        if(cAction.$bindingParam && cAction.kind === 'action') {
-          params.push(cAction.$bindingParam.items ? 'Collection(' + entityNameIfBound + ')' : entityNameIfBound);
-        }
+        if (cAction.$bindingParam && cAction.kind === 'action')
+          params.push(cAction.$bindingParam.items ? `Collection(${entityNameIfBound})` : entityNameIfBound);
+
         // If action/function has no explicit binding parameter add it here
-        else if (!cAction.$bindingParam) {
-          params.push(cAction['@cds.odata.bindingparameter.collection'] ? 'Collection(' + entityNameIfBound + ')' : entityNameIfBound);
-        }
+        else if (!cAction.$bindingParam)
+          params.push(cAction['@cds.odata.bindingparameter.collection'] ? `Collection(${entityNameIfBound})` : entityNameIfBound);
       }
       // In case this is a function the explicit binding parameter is part of
       // the functions params dictionary. Only for functions all parameters must
       // be listed in the annotation target
-      if (cAction.kind === 'function') {
-        if(cAction.params) {
-          cAction.params && Object.values(cAction.params).forEach(p => {
-            const isArrayType = !p.type && p.items && p.items.type;
-            params.push(isArrayType ? 'Collection(' + mapType(p.items) + ')' : mapType(p));
-          });
-        }
+      if (cAction.kind === 'function' && cAction.params) {
+        Object.values(cAction.params).forEach((p) => {
+          const isArrayType = !p.type && p.items && p.items.type;
+          params.push(isArrayType ? `Collection(${mapType(p.items)})` : mapType(p));
+        });
       }
-      return '(' + params.join(',') + ')';
+      return `(${params.join(',')})`;
 
-      function mapType(p) {
-        if(isBuiltinType(p.type))
-          return edmUtils.mapCdsToEdmType(p, messageFunctions, false /*is only called for v4*/)
-        else if(options.whatsMySchemaName) {
+      function mapType( p ) {
+        if (isBuiltinType(p.type)) {
+          return edmUtils.mapCdsToEdmType(p, messageFunctions, false /* is only called for v4 */);
+        }
+        else if (options.whatsMySchemaName) {
           const schemaName = options.whatsMySchemaName(p.type);
-        // strip the service namespace of from a parameter type
-          if(schemaName && schemaName !== options.serviceName)
-            return p.type.replace(options.serviceName + '.', '');
+          // strip the service namespace of from a parameter type
+          if (schemaName && schemaName !== options.serviceName)
+            return p.type.replace(`${options.serviceName}.`, '');
         }
         return p.type;
       }
     }
-
   }
 
 
@@ -493,7 +487,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   //   edmTargetName : string, name of the target in edm
   //   carrier: object, the annotated cds thing, contains all the annotations
   //                    as properties with names starting with @
-  function handleAnnotations(edmTargetName, carrier, location) {
+  function handleAnnotations( edmTargetName, carrier, location ) {
     // collect the names of the carrier's annotation properties
     // keep only those annotations that - start with a known vocabulary name
     //                                  - have a value other than null
@@ -503,20 +497,22 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     // if the carrier is a media stream element in V2
     // do nothing
 
-    if(!isEdmPropertyRendered(carrier, options) ||
-      (isV2() && (edmUtils.isDerivedType(carrier)))) {
+    if (!isEdmPropertyRendered(carrier, options) ||
+      (isV2() && (edmUtils.isDerivedType(carrier))))
       return;
-    }
+
 
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
 
     let knownAnnos = filterKnownAnnotations();
-    if (knownAnnos.length === 0) return;
+    if (knownAnnos.length === 0)
+      return;
 
-    if(rewriteInnerAnnotations()) {
+    if (rewriteInnerAnnotations()) {
       knownAnnos = filterKnownAnnotations();
-      if (knownAnnos.length === 0) return;
+      if (knownAnnos.length === 0)
+        return;
     }
 
     const prefixTree = createPrefixTree();
@@ -529,12 +525,12 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     //   later when looking at single annotations
 
     const [
-        stdEdmTargetName,           // either the schema path or the EntityContainer itself
-        hasAlternativeCarrier,      // is the alternative annotation target available in the EDM?
-        alternativeEdmTargetName,   // EntitySet path name
-        testToStandardEdmTarget,    // if true, assign to standard Edm Target
-        testToAlternativeEdmTarget, // if true, assign to alternative Edm Target
-      ] = initCarrierControlVars();
+      stdEdmTargetName,           // either the schema path or the EntityContainer itself
+      hasAlternativeCarrier,      // is the alternative annotation target available in the EDM?
+      alternativeEdmTargetName,   // EntitySet path name
+      testToStandardEdmTarget,    // if true, assign to standard Edm Target
+      testToAlternativeEdmTarget, // if true, assign to alternative Edm Target
+    ] = initCarrierControlVars();
 
     // collect produced Edm.Annotation nodes for various carriers
     const serviceAnnotations = [];
@@ -546,66 +542,66 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
     // Produce Edm.Annotations and attach collected Edm.Annotation(s) to the
     // envelope (or directly to the Schema)
-    if(serviceAnnotations.length) {
-      g_annosArray.push(...serviceAnnotations.filter(a=>a));
-    }
-    if(stdAnnotations.length) {
+    if (serviceAnnotations.length)
+      gAnnosArray.push(...serviceAnnotations.filter(a => a));
+
+    if (stdAnnotations.length) {
       const annotations = new Edm.Annotations(v, stdEdmTargetName); // used in closure
       annotations.append(...stdAnnotations);
-      g_annosArray.push(annotations);
+      gAnnosArray.push(annotations);
     }
-    if(alternativeAnnotations.length) {
+    if (alternativeAnnotations.length) {
       const annotations = new Edm.Annotations(v, alternativeEdmTargetName);
       annotations.append(...alternativeAnnotations);
-      g_annosArray.push(annotations);
+      gAnnosArray.push(annotations);
     }
 
     function filterKnownAnnotations() {
       const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
       const nullWhitelist = [ '@Core.OperationAvailable' ];
-      const knownAnnos = annoNames.filter(n => {
+      const knownAnnosP = annoNames.filter((n) => {
         const tns = whatsMyTermNamespace(n);
         return tns &&
           (mergedVocDefs[tns] && !mergedVocDefs[tns].$ignore ||
            !mergedVocDefs[tns]);
       }).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
-      if(isBetaEnabled(options, 'odataTerms')) {
+      if (isBetaEnabled(options, 'odataTerms')) {
         // Extend knownAnnos with the in-service term definitions
-        annoNames.forEach(an => {
+        annoNames.forEach((an) => {
           const paths = an.slice(1).split('.');
           const hasNSPrefix = paths[0] === serviceName;
-          if(!hasNSPrefix) {
+          if (!hasNSPrefix)
             paths.splice(0, 0, serviceName);
-          }
-          const fqName = '@' + paths.join('.');
+
+          const fqName = `@${paths.join('.')}`;
           const i = paths[1].indexOf('#');
           const termNameWithoutQualifiers = i > 0 ? paths[1].substring(0, i) : paths[1];
-          const def = reqDefs.definitions[paths[0] + '.' + termNameWithoutQualifiers];
+          const def = reqDefs.definitions[`${paths[0]}.${termNameWithoutQualifiers}`];
           // if there is a term definition inside the service and the
           // annotation value is != null, then add the annotation to the list
           // of known annotations
-          if(def?.kind === 'annotation' && carrier[an] !== null) {
+          if (def?.kind === 'annotation' && carrier[an] !== null) {
             // Subsequent annotation handler code expects that first path segment
             // is the Vocabulary namespace. The ad-hoc namespace is the service
             // name itself.
             // For service S an annotation assignment  could be addressed
             // relative or absolute to the service @S.foo or @foo
-            if(!hasNSPrefix) {
+            if (!hasNSPrefix) {
               carrier[fqName] = carrier[an];
               delete carrier[an];
             }
-            knownAnnos.push(fqName);
+            knownAnnosP.push(fqName);
           }
         });
       }
-      return knownAnnos;
+      return knownAnnosP;
     }
 
     // construct a function that is used to add an <Annotation ...> to the
     //   respective collector array
     // this function is specific to the actual carrier, following the mapping rules given above
-    function addAnnotation(annotation, appliesTo) {
-      let rc=false;
+    function addAnnotation( annotation, appliesTo ) {
+      let rc = false;
       if (testToAlternativeEdmTarget && appliesTo && testToAlternativeEdmTarget(appliesTo)) {
         if (carrier.kind === 'service') {
           if (isV2()) {
@@ -614,98 +610,98 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
           }
           serviceAnnotations.push(annotation); // for target Schema: no <Annotations> element
         }
-        else if(hasAlternativeCarrier) {
+        else if (hasAlternativeCarrier) {
           alternativeAnnotations.push(annotation);
         }
-        rc=true;
+        rc = true;
       }
-      if(testToStandardEdmTarget(appliesTo)) {
+      if (testToStandardEdmTarget(appliesTo)) {
         stdAnnotations.push(annotation);
-        rc=true;
+        rc = true;
       }
       // Another crazy hack due to this crazy function:
       // If carrier is a managed association (has keys) and rc is false (annotation was not applicable)
       // return true to NOT trigger 'unapplicable' message message
-      if(rc === false && carrier.target && carrier.keys && appliesTo.includes('Property'))
+      if (rc === false && carrier.target && carrier.keys && appliesTo.includes('Property'))
         rc = true;
       return rc;
     }
 
     function initCarrierControlVars() {
     // eslint-disable-next-line no-unused-vars
-      let testToStandardEdmTarget = () => true; // if true, assign to standard Edm Target
-      let stdEdmTargetName = edmTargetName;
-      let alternativeEdmTargetName = null;
-      let hasAlternativeCarrier = false; // is the alternative annotation target available in the EDM?
-      let testToAlternativeEdmTarget = null; // if true, assign to alternative Edm Target
+      let testToStandardEdmTargetP = () => true; // if true, assign to standard Edm Target
+      let stdEdmTargetNameP = edmTargetName;
+      let alternativeEdmTargetNameP = null;
+      let hasAlternativeCarrierP = false; // is the alternative annotation target available in the EDM?
+      let testToAlternativeEdmTargetP = null; // if true, assign to alternative Edm Target
 
       if (carrier.kind === 'entity') {
       // If AppliesTo=[EntitySet/Singleton/Collection, EntityType], EntitySet/Singleton/Collection has precedence
-        testToAlternativeEdmTarget = (x => {
-          if(options.isV2()) {
-            return ['Singleton', 'EntitySet', 'Collection'].some(y => x.includes(y));
-          }
-          else {
-            return edmUtils.isSingleton(carrier)
-              ? x.includes('Singleton')
-              : ['EntitySet', 'Collection'].some(y => x.includes(y));
-          }
+        testToAlternativeEdmTargetP = ((x) => {
+          if (options.isV2())
+            return [ 'Singleton', 'EntitySet', 'Collection' ].some(y => x.includes(y));
+
+
+          return edmUtils.isSingleton(carrier)
+            ? x.includes('Singleton')
+            : [ 'EntitySet', 'Collection' ].some(y => x.includes(y));
         });
-        testToStandardEdmTarget = (x => x ? x.includes('EntityType') : true);
-      // if carrier has an alternate 'entitySetName' use this instead of EdmTargetName
-      // (see edmPreprocessor.initializeParameterizedEntityOrView(), where parameterized artifacts
-      // are split into *Parameter and *Type entities and their respective EntitySets are eventually
-      // renamed.
-      // (which is the definition key in the CSN and usually the name of the EntityType)
-      // Replace up to last dot with <serviceName>.EntityContainer/
-        alternativeEdmTargetName = carrier.$entitySetName || edmTargetName
-        const lastDotIndex = alternativeEdmTargetName.lastIndexOf('.');
+        testToStandardEdmTargetP = (x => (x ? x.includes('EntityType') : true));
+        // if carrier has an alternate 'entitySetName' use this instead of EdmTargetName
+        // (see edmPreprocessor.initializeParameterizedEntityOrView(), where parameterized artifacts
+        // are split into *Parameter and *Type entities and their respective EntitySets are eventually
+        // renamed.
+        // (which is the definition key in the CSN and usually the name of the EntityType)
+        // Replace up to last dot with <serviceName>.EntityContainer/
+        alternativeEdmTargetNameP = carrier.$entitySetName || edmTargetName;
+        const lastDotIndex = alternativeEdmTargetNameP.lastIndexOf('.');
         if (lastDotIndex > -1)
-          alternativeEdmTargetName = serviceName + '.EntityContainer/' + alternativeEdmTargetName.substring(lastDotIndex + 1);
-        hasAlternativeCarrier = carrier.$hasEntitySet;
+          alternativeEdmTargetNameP = `${serviceName}.EntityContainer/${alternativeEdmTargetNameP.substring(lastDotIndex + 1)}`;
+        hasAlternativeCarrierP = carrier.$hasEntitySet;
       }
-      else if(carrier.kind === 'type') {
-        testToStandardEdmTarget = (x => x ? x.includes(carrier.elements ? 'ComplexType' : 'TypeDefinition') : true);
+      else if (carrier.kind === 'type') {
+        testToStandardEdmTargetP = (x => (x ? x.includes(carrier.elements ? 'ComplexType' : 'TypeDefinition') : true));
       }
       else if (carrier.kind === 'service') {
       // if annotated object is a service, annotation goes to EntityContainer,
       //   except if AppliesTo contains Schema but not EntityContainer, then annotation goes to Schema
-        testToAlternativeEdmTarget = (x => x.includes('Schema') && !x.includes('EntityContainer'));
-        testToStandardEdmTarget = ( x => x ? (
+        testToAlternativeEdmTargetP = (x => x.includes('Schema') && !x.includes('EntityContainer'));
+        testToStandardEdmTargetP = ( x => (x ? (
         // either only AppliesTo=[EntityContainer]
-        (!x.includes('Schema') && x.includes('EntityContainer')) ||
+          (!x.includes('Schema') && x.includes('EntityContainer')) ||
         // or AppliesTo=[Schema, EntityContainer]
         (x.includes('Schema') && x.includes('EntityContainer')))
-          : true );
-        stdEdmTargetName = edmTargetName + '.EntityContainer';
-        alternativeEdmTargetName = edmTargetName;
-        hasAlternativeCarrier = true; // EntityContainer is always available
+          : true) );
+        stdEdmTargetNameP = `${edmTargetName}.EntityContainer`;
+        alternativeEdmTargetNameP = edmTargetName;
+        hasAlternativeCarrierP = true; // EntityContainer is always available
       }
-      //element => decide if navprop or normal property
-      else if(!carrier.kind) {
+      // element => decide if navprop or normal property
+      else if (!carrier.kind) {
         // if appliesTo is undefined, return true
-        if(carrier.target) {
-          testToStandardEdmTarget = (x => x
+        if (carrier.target) {
+          testToStandardEdmTargetP = (x => (x
             ? x.includes('NavigationProperty') ||
               carrier.cardinality && carrier.cardinality.max === '*' && x.includes('Collection')
-            : true);
+            : true));
+        }
+        else if (carrier.$appliesToReturnType) {
+          testToStandardEdmTargetP = (x => (x ? x.includes('ReturnType') : true));
         }
-        else if(carrier.$appliesToReturnType)
-          testToStandardEdmTarget = (x => x ? x.includes('ReturnType') : true);
         else {
           // this might be more precise if handleAnnotation would know more about the carrier
-          testToStandardEdmTarget = (x => x
-            ? ['Parameter', 'Property'].some(y => x.includes(y) ||
+          testToStandardEdmTargetP = (x => (x
+            ? [ 'Parameter', 'Property' ].some(y => x.includes(y) ||
               carrier._isCollection && x.includes('Collection'))
-            : true);
+            : true));
         }
       }
       return [
-        stdEdmTargetName,
-        hasAlternativeCarrier,
-        alternativeEdmTargetName,
-        testToStandardEdmTarget,
-        testToAlternativeEdmTarget
+        stdEdmTargetNameP,
+        hasAlternativeCarrierP,
+        alternativeEdmTargetNameP,
+        testToStandardEdmTargetP,
+        testToAlternativeEdmTargetP,
       ];
       /* all AppliesTo entries:
         "Action",
@@ -759,17 +755,17 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
           Insert $value into $edmJson with inner annotation as well.
         */
-        if(innerAnnotation) {
+        if (innerAnnotation) {
           // != null => also != undefined
-          if(carrier[prefix] != null) {
-            const valPrefix = prefix + '.$value';
+          if (carrier[prefix] != null) {
+            const valPrefix = `${prefix}.$value`;
             carrier[valPrefix] = carrier[prefix];
             delete carrier[prefix];
             rc = true;
           }
-          const edmJsonPrefix = prefix + '.$edmJson';
-          if(carrier[edmJsonPrefix] != null) {
-            const valPrefix = prefix + '.$value.$edmJson';
+          const edmJsonPrefix = `${prefix}.$edmJson`;
+          if (carrier[edmJsonPrefix] != null) {
+            const valPrefix = `${prefix}.$value.$edmJson`;
             carrier[valPrefix] = carrier[edmJsonPrefix];
             delete carrier[edmJsonPrefix];
             rc = true;
@@ -787,7 +783,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       // in OData, there are "structured" annotations -> we first need to regroup the cds annotations
       //   by building a "prefix tree" for the annotations attached to the carrier
       //   see example at definition of function mergePathStepsIntoPrefixTree
-      const prefixTree = {};
+      const prefixTreeP = {};
 
       for (const a of knownAnnos) {
       // remove leading @ and split at "."
@@ -798,27 +794,26 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       // takes care of assigning these annotations to the record members
         const [ prefix, innerAnnotation ] = a.split('.@');
         const ns = whatsMyTermNamespace(prefix);
-        const steps = prefix.replace('@' + ns + '.', '').split('.');
+        const steps = prefix.replace(`@${ns}.`, '').split('.');
         steps.splice(0, 0, ns);
         let i = steps.lastIndexOf('$edmJson');
-        if(i > -1) {
-          i = steps.findIndex(s => s.includes('@'), i+1);
-          if(i > -1) {
-            steps.splice(i, steps.length-i, steps.slice(i).join('.'));
-          }
+        if (i > -1) {
+          i = steps.findIndex(s => s.includes('@'), i + 1);
+          if (i > -1)
+            steps.splice(i, steps.length - i, steps.slice(i).join('.'));
         }
         if (innerAnnotation) {
         // A voc annotation has two steps (Namespace+Name),
         // any further steps need to be rendered separately
           const innerAnnoSteps = innerAnnotation.split('.');
-          const tailSteps = innerAnnoSteps.splice(2, innerAnnoSteps.length-2);
-        // prepend annotation prefix (path) to tail steps
-          tailSteps.splice(0, 0, '@' + innerAnnoSteps.join('.'));
+          const tailSteps = innerAnnoSteps.splice(2, innerAnnoSteps.length - 2);
+          // prepend annotation prefix (path) to tail steps
+          tailSteps.splice(0, 0, `@${innerAnnoSteps.join('.')}`);
           steps.push(...tailSteps);
         }
-        mergePathStepsIntoPrefixTree(prefixTree, steps, 0, carrier);
+        mergePathStepsIntoPrefixTree(prefixTreeP, steps, 0);
       }
-      return prefixTree;
+      return prefixTreeP;
 
       // tree: object where to put the next level of names
       // path: the parts of the annotation name
@@ -843,17 +838,17 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       //                    q2 : ... }
       //           t3#y : { q1 : ...,
       //                    q2 : ... } } }
-      function mergePathStepsIntoPrefixTree(tree, pathSteps, index, carrier) {
+      function mergePathStepsIntoPrefixTree( tree, pathSteps, index ) {
       // TODO check nesting level > 3
         const name = pathSteps[index];
-        if (index+1 < pathSteps.length ) {
-          if (!tree[name]) {
+        if (index + 1 < pathSteps.length ) {
+          if (!tree[name])
             tree[name] = {};
-          }
-          mergePathStepsIntoPrefixTree(tree[name], pathSteps, index+1, carrier);
+
+          mergePathStepsIntoPrefixTree(tree[name], pathSteps, index + 1);
         }
-        else if(typeof tree === 'object' ){
-          tree[name] = carrier['@' + pathSteps.join('.')];
+        else if (typeof tree === 'object' ) {
+          tree[name] = carrier[`@${pathSteps.join('.')}`];
         }
       }
     }
@@ -864,34 +859,33 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // addAnnotationFunc: a function that adds the <Annotation ...> tags created here into the
   //                    correct parent tag (see handleAnnotations())
   // prefixTree: the annotations
-  function handleAnno2(addAnnotationFunc, prefixTree, location) {
+  function handleAnno2( addAnnotationFunc, prefixTree, location ) {
     // first level names of prefix tree are the vocabulary names
     // second level names are the term names
     // create an annotation tag <Annotation ...> for each term
     for (const voc of Object.keys(prefixTree)) {
       for (const term of Object.keys(prefixTree[voc])) {
-        const fullTermName = voc + '.' + term;
+        const fullTermName = `${voc}.${term}`;
 
         // msg is "semantic" location message used for messages
         const msg = {
           fullTermName,
           stack: [],
-          location: [ ...location, '@' + fullTermName ],
+          location: [ ...location, `@${fullTermName}` ],
         };
-        msg.anno = () => {
-          return msg.fullTermName + msg.stack.join('');
-        }
+        msg.anno = () => msg.fullTermName + msg.stack.join('');
 
         // anno is the full <Annotation Term=...>
         const anno = handleTerm(fullTermName, prefixTree[voc][term], msg);
-        if(anno !== undefined) {
+        if (anno !== undefined) {
           // addAnnotationFunc needs AppliesTo message from dictionary to decide where to put the anno
           const termName = fullTermName.replace(/#(\w+)$/g, ''); // remove qualifier
           const dictTerm = getDictTerm(termName, msg); // message for unknown term was already issued in handleTerm
-          if(!addAnnotationFunc(anno, dictTerm && dictTerm.AppliesTo)) {
-            if(dictTerm && dictTerm.AppliesTo) {
+          // eslint-disable-next-line sonarjs/no-collapsible-if
+          if (!addAnnotationFunc(anno, dictTerm && dictTerm.AppliesTo)) {
+            if (dictTerm && dictTerm.AppliesTo) {
               message('odata-anno-def', location,
-              { anno: termName, rawvalues: dictTerm.AppliesTo, '#': 'notapplied' });
+                      { anno: termName, rawvalues: dictTerm.AppliesTo, '#': 'notapplied' });
             }
           }
         }
@@ -905,30 +899,30 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   //             they are regrouped here
   // msg :   for messages
   // return :    object that represents the annotation in the result edmx
-  function handleTerm(termName, annoValue, msg) {
+  function handleTerm( termName, annoValue, msg ) {
     /**
      * create the <Annotation ...> tag
      * @type {object}
      * */
-    let newAnno = undefined;
-    const omissions = { 'Aggregation.default':1 };
-    const nullList = { 'Core.OperationAvailable':1 };
-    if(annoValue !== null && !omissions[termName]|| nullList[termName]) {
+    let newAnno;
+    const omissions = { 'Aggregation.default': 1 };
+    const nullList = { 'Core.OperationAvailable': 1 };
+    if (annoValue !== null && !omissions[termName] || nullList[termName]) {
     // termName may contain a qualifier: @UI.FieldGroup#shippingStatus
     // -> remove qualifier from termName and set Qualifier attribute in newAnno
       const i = termName.indexOf('#');
       const termNameWithoutQualifiers = i > 0 ? termName.substring(0, i) : termName;
-      const qualifier = i >= 0 ? termName.substring(i+1) : undefined;
+      const qualifier = i >= 0 ? termName.substring(i + 1) : undefined;
 
       termNameWithoutQualifiers.split('.').forEach((id) => {
-        if(!edmUtils.isODataSimpleIdentifier(id))
+        if (!edmUtils.isODataSimpleIdentifier(id))
           message('odata-spec-violation-id', msg.location, { id });
-      })
+      });
       newAnno = new Edm.Annotation(v, termNameWithoutQualifiers);
       if (qualifier?.length) {
         if (!edmUtils.isODataSimpleIdentifier(qualifier)) {
           message('odata-spec-violation-id', msg.location,
-          { id: qualifier, '#': 'qualifier' });
+                  { id: qualifier, '#': 'qualifier' });
         }
         newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
         newAnno.setEdmAttribute('Qualifier', qualifier);
@@ -941,9 +935,9 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       }
       else {
         // message if term is completely unknown or if vocabulary is unchecked
-        const vocDef = mergedVocDefs[whatsMyTermNamespace('@'+termNameWithoutQualifiers)];
-        if((vocDef?.int && vocDef?.int?.filename) || !vocDef)
-          message('odata-anno-def', msg.location,{ anno: termNameWithoutQualifiers });
+        const myVocDef = mergedVocDefs[whatsMyTermNamespace(`@${termNameWithoutQualifiers}`)];
+        if ((myVocDef?.int && myVocDef?.int?.filename) || !myVocDef)
+          message('odata-anno-def', msg.location, { anno: termNameWithoutQualifiers });
       }
 
       // handle the annotation value and put the result into the <Annotation ...> tag just created above
@@ -957,131 +951,143 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   //   cAnnoValue: the annotation value (c : csn)
   //   oTarget: the result object (o: odata)
   //   oTermName: current term
-  //   dTypeName: expected type of cAnnoValue according to dictionary, may be null (d: dictionary)
-  function handleValue(cAnnoValue, oTarget, oTermName, dTypeName, msg) {
+  //   dTypeNameArg: expected type of cAnnoValue according to dictionary, may be null (d: dictionary)
+  function handleValue( cAnnoValue, oTarget, oTermName, dTypeNameArg, msg ) {
     // this function basically only figures out what kind of annotation value we have
     //   (can be: array, expression, enum, pseudo-record, record, simple value),
     //   then calls a more specific function to deal with it and puts
     //   the result into the oTarget object
 
-    if (Array.isArray(cAnnoValue))
-    {
-      if (isEnumType(dTypeName))
-      {
+    const [ dTypeName, dTypeIsACollection ] = stripCollection(dTypeNameArg);
+
+    if (Array.isArray(cAnnoValue)) {
+      if (isEnumType(dTypeName)) {
         // if we find an array although we expect an enum, this may be a "flag enum"
-        checkMultiEnumValue(cAnnoValue);
-        oTarget.setJSON({ 'EnumMember': generateMultiEnumValue(cAnnoValue, false), 'EnumMember@odata.type' : '#'+dTypeName });
-        oTarget.setXml( { 'EnumMember': generateMultiEnumValue(cAnnoValue, true) });
+        checkMultiEnumValue();
+        oTarget.setJSON({ EnumMember: generateMultiEnumValue(false), 'EnumMember@odata.type': `#${dTypeName}` });
+        oTarget.setXml( { EnumMember: generateMultiEnumValue(true) });
       }
-      else
-      {
-        oTarget.append(generateCollection(cAnnoValue, oTermName, dTypeName, msg));
+      else {
+        oTarget.append(generateCollection(cAnnoValue, oTermName, dTypeName, dTypeIsACollection, msg));
       }
     }
     else if (cAnnoValue && typeof cAnnoValue === 'object') {
       // an empty record is rendered as <Record/>
       if ('=' in cAnnoValue) {
+        if (dTypeIsACollection) {
+          message('odata-anno-value', msg.location,
+                  { anno: msg.anno(), str: 'path', '#': 'incompval' });
+        }
         // expression
         const res = handleExpression(cAnnoValue['='], dTypeName);
-        oTarget.setXml( { [res.name] : res.value });
-        oTarget.setJSON( { [res.name] : res.value });
+        oTarget.setXml( { [res.name]: res.value });
+        oTarget.setJSON( { [res.name]: res.value });
       }
       else if (cAnnoValue['#'] !== undefined) {
         const enumSymbol = cAnnoValue['#'];
         // enum
         if (dTypeName) {
-          const typeDef = getDictType(stripCollection(dTypeName));
-          if(typeDef && typeDef.$Allowed && !typeDef.Members) {
+          const typeDef = getDictType(dTypeName);
+          if (typeDef && typeDef.$Allowed && !typeDef.Members) {
             const allowedValue = typeDef.$Allowed.Symbols[enumSymbol];
-            if(!allowedValue) {
+            if (!allowedValue) {
               message('odata-anno-value', msg.location,
-                { anno: msg.anno(),
-                  type: dTypeName,
-                  value: `"#${enumSymbol}"`,
-                  rawvalues: Object.keys(typeDef.$Allowed.Symbols).map(m => `"#${m}"`),
-                  '#': 'enum'
-                });
+                      {
+                        anno: msg.anno(),
+                        type: dTypeName,
+                        value: `"#${enumSymbol}"`,
+                        rawvalues: Object.keys(typeDef.$Allowed.Symbols).map(m => `"#${m}"`),
+                        '#': 'enum',
+                      });
             }
             else {
               oTarget.setXml( { [typeDef.UnderlyingType?.replace('Edm.', '') || 'String']: allowedValue.Value || enumSymbol });
             }
           }
-          else if(checkEnumValue(enumSymbol))
-            oTarget.setXml( { 'EnumMember': dTypeName + '/' + enumSymbol });
-          else
-            oTarget.setXml( { 'String': enumSymbol });
+          else if (checkEnumValue(enumSymbol)) {
+            oTarget.setXml( { EnumMember: `${dTypeName}/${enumSymbol}` });
+          }
+          else {
+            oTarget.setXml( { String: enumSymbol });
+          }
         }
         else {
-          oTarget.setXml( { 'EnumMember': oTermName + 'Type/' + enumSymbol });
+          oTarget.setXml( { EnumMember: `${oTermName}Type/${enumSymbol}` });
         }
         oTarget.setJSON({ 'Edm.String': enumSymbol });
       }
-      else if (cAnnoValue['$value'] !== undefined) {
+      else if (cAnnoValue.$value !== undefined) {
         // "pseudo-structure" used for annotating scalar annotations
-        handleValue(cAnnoValue['$value'], oTarget, oTermName, dTypeName, msg);
+        handleValue(cAnnoValue.$value, oTarget, oTermName, dTypeNameArg, msg);
 
         const k = Object.keys(cAnnoValue).filter( x => x[0] === '@');
         if (!k || k.length === 0) {
           message('odata-anno-value', msg.location,
-          { anno: msg.anno(), str: 'nested', '#': 'nested' });
+                  { anno: msg.anno(), str: 'nested', '#': 'nested' });
         }
         for (const nestedAnnoName of k) {
           const nestedAnno = handleTerm(nestedAnnoName.slice(1), cAnnoValue[nestedAnnoName], msg);
           oTarget.append(nestedAnno);
         }
       }
-      else if (cAnnoValue['$edmJson']) {
+      else if (cAnnoValue.$edmJson) {
         // "pseudo-structure" used for embedding a piece of JSON that represents "OData CSDL, JSON Representation"
-        oTarget.append(handleEdmJson(cAnnoValue['$edmJson'], msg));
+        oTarget.append(handleEdmJson(cAnnoValue.$edmJson, msg));
       }
       else if ( Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
         // object consists only of properties starting with "@", no $value
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), str: 'base', '#': 'nested'} );
+                { anno: msg.anno(), str: 'base', '#': 'nested' } );
       }
       else {
         // regular record
-        oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, msg));
+        if (dTypeIsACollection) {
+          message('odata-anno-value', msg.location,
+                  { anno: msg.anno(), str: 'structured', '#': 'incompval' });
+        }
+        oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, dTypeIsACollection, msg));
       }
     }
     else {
       const res = handleSimpleValue(cAnnoValue, dTypeName, msg);
-      if(((oTermName === 'Core.OperationAvailable' && dTypeName === 'Edm.Boolean') ||
-        (oTermName === 'Validation.AllowedValues' && dTypeName === 'Edm.PrimitiveType'))
-        && cAnnoValue === null) {
+      if (((oTermName === 'Core.OperationAvailable' && dTypeName === 'Edm.Boolean') ||
+        (oTermName === 'Validation.AllowedValues' && dTypeName === 'Edm.PrimitiveType')) &&
+        cAnnoValue === null) {
         oTarget.append(new Edm.ValueThing(v, 'Null'));
         oTarget._ignoreChildren = true;
       }
       else {
-        oTarget.setXml( { [res.name] : res.value });
+        oTarget.setXml( { [res.name]: res.value });
       }
-      oTarget.setJSON( { [res.jsonName] : res.value });
+      oTarget.setJSON( { [res.jsonName]: res.value });
     }
-
     // found an enum value ("#"), check whether this fits
     //  the expected type "dTypeName"
-    function checkEnumValue(value) {
+    function checkEnumValue( value ) {
       let rc = true;
       const expectedType = getDictType(dTypeName);
       if (!expectedType && !isPrimitiveType(dTypeName)) {
         message('odata-anno-dict', msg.location,
-        { anno: msg.anno(), type: dTypeName });
+                { anno: msg.anno(), type: dTypeName });
       }
-      else if (isComplexType(dTypeName) || isPrimitiveType(dTypeName) || expectedType['$kind'] !== 'EnumType') {
+      else if (isComplexType(dTypeName) || isPrimitiveType(dTypeName) || expectedType.$kind !== 'EnumType') {
         message('odata-anno-value', msg.location,
-          { anno: msg.anno(),
-            type: dTypeName,
-            value: `"#${value}"` });
+                {
+                  anno: msg.anno(),
+                  type: dTypeName,
+                  value: `"#${value}"`,
+                });
         rc = false;
       }
       else if (!expectedType.Members.includes(value)) {
         message('odata-anno-value', msg.location,
-          { anno: msg.anno(),
-            type: dTypeName,
-            value: `"#${value}"`,
-            rawvalues: expectedType.Members.map(m => `"#${m}"`),
-            '#': 'enum'
-          });
+                {
+                  anno: msg.anno(),
+                  type: dTypeName,
+                  value: `"#${value}"`,
+                  rawvalues: expectedType.Members.map(m => `"#${m}"`),
+                  '#': 'enum',
+                });
       }
       return rc;
     }
@@ -1089,64 +1095,65 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     // cAnnoValue: array
     // dTypeName: expected type, already identified as enum type
     //   array is expected to contain enum values
-    function checkMultiEnumValue(cAnnoValue) {
-    // we know that dTypeName is not null
+    function checkMultiEnumValue( ) {
+      // we know that dTypeName is not null
       const type = getDictType(dTypeName);
-      if (!type || type['IsFlags'] !== 'true') {
+      if (!type || type.IsFlags !== 'true') {
         message('odata-anno-value', msg.location,
-          { anno: msg.anno(),
-            str: 'collection',
-            type: dTypeName,
-            '#': 'struct' });
+                {
+                  anno: msg.anno(),
+                  str: 'collection',
+                  type: dTypeName,
+                  '#': 'incompval',
+                });
       }
 
       let index = 0;
-      for (let value of cAnnoValue) {
-        msg.stack.push('[' + index + ']');
+      for (const value of cAnnoValue) {
+        msg.stack.push(`[${index}]`);
         index++;
         if (value['#']) {
           checkEnumValue(value['#']);
         }
         else {
           message('odata-anno-value', msg.location,
-            { anno: msg.anno(),
-              type: dTypeName,
-              value: value['='] || value,
-              rawvalues: type.Members.map(m => `"#${m}"`),
-              '#': 'enum'
-            });
+                  {
+                    anno: msg.anno(),
+                    type: dTypeName,
+                    value: value['='] || value,
+                    rawvalues: type.Members.map(m => `"#${m}"`),
+                    '#': 'enum',
+                  });
         }
         msg.stack.pop();
       }
     }
 
-    function generateMultiEnumValue(cAnnoValue, forXml) {
+    function generateMultiEnumValue( forXml ) {
       // remove all invalid entries (warnining message has already been issued)
       // replace short enum name by the full name
       // concatenate all the enums to a string, separated by spaces
-      return cAnnoValue.filter( x => x['#'] != undefined ).map( x => (forXml ? dTypeName + '/' : '') + x['#'] ).join(forXml ? ' ' : ',');
+      return cAnnoValue.filter( x => x['#']).map( x => (forXml ? `${dTypeName}/` : '') + x['#'] ).join(forXml ? ' ' : ',');
     }
   }
 
-
-
   // found an expression value ("=") "expr"
   //   expected type is dTypeName
   // note: expr can also be provided if an enum/complex type/collection is expected
-  function handleExpression(value, dTypeName) {
+  function handleExpression( value, dTypeName ) {
     let typeName = 'Path';
-    if( ['Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(dTypeName) )
+    if ( [ 'Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(dTypeName) )
       typeName = dTypeName.split('.')[1];
 
-    if(value) {
+    if (value) {
       // replace all occurrences of '.' by '/' up to first '@'
-      value = value.split('@').map((o,i) => (i === 0 ? o.replace(/\./g, '/') : o)).join('@');
+      value = value.split('@').map((o, i) => (i === 0 ? o.replace(/\./g, '/') : o)).join('@');
     }
 
     return {
-      name : typeName,
-      value
-    }
+      name: typeName,
+      value,
+    };
   }
 
 
@@ -1157,7 +1164,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   //      floating point type except Edm.Decimal -> Float
   //      Edm.Decimal -> Decimal
   //      integer type -> Int
-  function handleSimpleValue(value, dTypeName, msg) {
+  function handleSimpleValue( value, dTypeName, msg ) {
     // these types must be represented as "String" values in XML:
     const castToXmlString = [ 'Edm.PrimitiveType', 'Edm.Stream', 'Edm.Untyped' ];
     // caller already made sure that val is neither object nor array
@@ -1172,66 +1179,72 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       const type = getDictType(resolvedType);
       const expected = type.Members.map(m => `"#${m}"`);
       message('odata-anno-value', msg.location,
-        { anno: msg.anno(),
-          value,
-          rawvalues: expected,
-          type: resolvedType,
-          '#': 'enum' });
+              {
+                anno: msg.anno(),
+                value,
+                rawvalues: expected,
+                type: resolvedType,
+                '#': 'enum',
+              });
     }
 
     let typeName = 'String';
-    if(Allowed && !Allowed.Values[value])
+    if (Allowed && !Allowed.Values[value]) {
       message('odata-anno-value', msg.location,
-        { anno: msg.anno(),
-          value,
-          rawvalues: Object.keys(Allowed.Values),
-          type: resolvedType,
-          '#': 'enum' });
+              {
+                anno: msg.anno(),
+                value,
+                rawvalues: Object.keys(Allowed.Values),
+                type: resolvedType,
+                '#': 'enum',
+              });
+    }
 
     if (typeof value === 'string') {
       if (resolvedType === 'Edm.Boolean') {
         typeName = 'Bool';
         if (value !== 'true' && value !== 'false') {
           message('odata-anno-value', msg.location,
-          { anno: msg.anno(), value, type: resolvedType });
+                  { anno: msg.anno(), value, type: resolvedType });
         }
       }
       else if (resolvedType === 'Edm.Decimal') {
         typeName = 'Decimal';
+        // eslint-disable-next-line no-restricted-globals
         if (isNaN(Number(value)) || isNaN(parseFloat(value))) {
           message('odata-anno-value', msg.location,
-          { anno: msg.anno(), value, type: resolvedType });
+                  { anno: msg.anno(), value, type: resolvedType });
         }
       }
       else if (resolvedType === 'Edm.Double' || resolvedType === 'Edm.Single') {
         typeName = 'Float';
+        // eslint-disable-next-line no-restricted-globals
         if (isNaN(Number(value)) || isNaN(parseFloat(value))) {
           message('odata-anno-value', msg.location,
-          { anno: msg.anno(), value, type: resolvedType });
+                  { anno: msg.anno(), value, type: resolvedType });
         }
       }
       else if (isComplexType(resolvedType)) {
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), value, type: resolvedType });
+                { anno: msg.anno(), value, type: resolvedType });
       }
       else if (isEnumType(resolvedType)) {
         message('odata-anno-value', msg.location,
-          { anno: msg.anno(), value, type: resolvedType });
+                { anno: msg.anno(), value, type: resolvedType });
         typeName = 'EnumMember';
       }
       else if (resolvedType && resolvedType.startsWith('Edm.') && !castToXmlString.includes(resolvedType)) {
         // this covers also all paths
         typeName = resolvedType.substring(4);
       }
-      else {
-        if(resolvedType == undefined || castToXmlString.some(t => t === resolvedType))
-          resolvedType = 'Edm.String';
+      else if (!resolvedType || castToXmlString.some(t => t === resolvedType)) {
+        resolvedType = 'Edm.String';
         // TODO
-        //message(message, msg, "type is not yet handled: found String, expected type: " + dTypeName);
+        // message(message, msg, "type is not yet handled: found String, expected type: " + dTypeName);
       }
     }
     else if (typeof value === 'boolean') {
-      if(resolvedType == undefined || resolvedType === 'Edm.Boolean' || resolvedType === 'Edm.PrimitiveType') {
+      if (!resolvedType || resolvedType === 'Edm.Boolean' || resolvedType === 'Edm.PrimitiveType') {
         typeName = 'Bool';
         resolvedType = 'Edm.Boolean';
       }
@@ -1243,7 +1256,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       }
       else {
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), value, type: resolvedType });
+                { anno: msg.anno(), value, type: resolvedType });
       }
     }
     else if (typeof value === 'number') {
@@ -1251,7 +1264,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
           resolvedType === 'Edm.PropertyPath' ||
           resolvedType === 'Edm.Boolean') {
         message('odata-anno-value', msg.location,
-          { anno: msg.anno(), value, type: resolvedType });
+                { anno: msg.anno(), value, type: resolvedType });
       }
       else if (resolvedType === 'Edm.String') {
         typeName = 'String';
@@ -1262,36 +1275,35 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
       else if (resolvedType === 'Edm.Double') {
         typeName = 'Float';
       }
+      else if (Number.isInteger(value)) {
+        // typeName = Number.isInteger(val) ? 'Int' : 'Float';
+        typeName = 'Int';
+        if (resolvedType == null || resolvedType === 'Edm.PrimitiveType' || !resolvedType.startsWith('Edm.'))
+          resolvedType = 'Edm.Int64';
+      }
       else {
-        //typeName = Number.isInteger(val) ? 'Int' : 'Float';
-        if(Number.isInteger(value)) {
-          typeName = 'Int';
-          if(resolvedType == null || resolvedType === 'Edm.PrimitiveType' || !resolvedType.startsWith('Edm.'))
-            resolvedType = 'Edm.Int64';
-        }
-        else {
-          typeName = 'Float';
-          if(resolvedType == null || resolvedType === 'Edm.PrimitiveType'|| !resolvedType.startsWith('Edm.'))
-            resolvedType = 'Edm.Double';
-        }
+        typeName = 'Float';
+        if (resolvedType == null || resolvedType === 'Edm.PrimitiveType' || !resolvedType.startsWith('Edm.'))
+          resolvedType = 'Edm.Double';
       }
     }
-    else if (value === null)
-      if((resolvedType == null || resolvedType === 'Edm.PrimitiveType') && typeName === 'String') {
+    else if (value === null) {
+      if ((resolvedType == null || resolvedType === 'Edm.PrimitiveType') && typeName === 'String') {
         resolvedType = 'Edm.String';
       }
       else {
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), value, type: resolvedType });
+                { anno: msg.anno(), value, type: resolvedType });
       }
+    }
 
-    if( ['Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(resolvedType) )
+    if ( [ 'Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(resolvedType) )
       resolvedType = resolvedType.split('.')[1];
 
     return {
-      name : typeName,
+      name: typeName,
       jsonName: resolvedType,
-      value : value
+      value,
     };
   }
 
@@ -1300,59 +1312,67 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // dTypeName : name of the expected record type according to vocabulary, may be null
   //
   // can be called for a record directly below a term, or at a deeper level
-  function generateRecord(obj, termName, dTypeName, msg) {
+  function generateRecord( obj, termName, dTypeName, dTypeIsACollection, msg ) {
     /** @type {object} */
     const newRecord = new Edm.Record(v);
 
     // first determine what is the actual type to be used for the record
     if (dTypeName && !isComplexType(dTypeName)) {
-      if (!getDictType(dTypeName) && !isPrimitiveType(dTypeName) && !isCollection(dTypeName))
+      if (!getDictType(dTypeName) && !isPrimitiveType(dTypeName) && !dTypeIsACollection) {
         message('odata-anno-dict', msg.location,
-        { anno: msg.anno(), type: dTypeName });
-      else
+                { anno: msg.anno(), type: dTypeName });
+      }
+      else {
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'struct' });
+                {
+                  anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'incompval',
+                });
+      }
       return newRecord;
     }
 
     let actualTypeName = null;
-    if (obj['$Type']) { // type is explicitly specified
-      actualTypeName = obj['$Type'];
+    if (obj.$Type) { // type is explicitly specified
+      actualTypeName = obj.$Type;
       if (!getDictType(actualTypeName)) {
         // this type doesn't exist
         message('odata-anno-type', msg.location,
-        { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
+                { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
         // explicitly mentioned type, render in XML and JSON
-        newRecord.setXml({ 'Type': actualTypeName});
+        newRecord.setXml({ Type: actualTypeName });
         // unknown dictionary type: can't fully qualify it
-        newRecord.setJSON({ 'Type': actualTypeName});
+        newRecord.setJSON({ Type: actualTypeName });
       }
       else {
         if (isAbstractType(actualTypeName)) {
           // this type is abstract
           message('odata-anno-type', msg.location,
-          { anno: msg.anno(), type: actualTypeName, code: '$Type', '#': 'abstract' });
-          if(dTypeName)
+                  {
+                    anno: msg.anno(), type: actualTypeName, code: '$Type', '#': 'abstract',
+                  });
+          if (dTypeName)
             actualTypeName = dTypeName;
         }
         else if (dTypeName && !isDerivedFrom(actualTypeName, dTypeName)) {
           // this type doesn't fit the expected one
           message('odata-anno-type', msg.location,
-            { anno: msg.anno(),
-              type: actualTypeName,
-              name: dTypeName,
-              code: '$Type',
-              '#': 'derived' });
+                  {
+                    anno: msg.anno(),
+                    type: actualTypeName,
+                    name: dTypeName,
+                    code: '$Type',
+                    '#': 'derived',
+                  });
           actualTypeName = dTypeName;
         }
         // Dictionary Type, render in XML only for backward compatibility
         newRecord.setXml( { Type: actualTypeName });
         const vocName = actualTypeName.slice(0, actualTypeName.indexOf('.'));
-        const vocDef = mergedVocDefs[vocName];
+        const myVocDef = mergedVocDefs[vocName];
         // Set full qualified type in JSON
         // TODO: Adhoc type x-ref URIs (only if abstract types are allowed in CDS)
-        if(vocDef)
-          newRecord.setJSON( { 'Type': `${vocDef.ref.Uri}#${actualTypeName}` });
+        if (myVocDef)
+          newRecord.setJSON( { Type: `${myVocDef.ref.Uri}#${actualTypeName}` });
         // don't add short actualTypeName into JSON as this would be wrong for a resolved! type.
         // A $Type w/o vocDef can only occur for adhoc type defs and these can't be abstract but
         // are fully resolvable due to their term usage via schema x-ref.
@@ -1361,15 +1381,18 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     else if (dTypeName) { // there is an expected type name according to dictionary
       // convenience for common situation:
       //   if DataFieldAbstract is expected and no explicit type is provided, automatically choose DataField
-      if (dTypeName === 'UI.DataFieldAbstract') {
+      if (dTypeName === 'UI.DataFieldAbstract')
         actualTypeName = 'UI.DataField';
-      }
-      else {
+
+      else
         actualTypeName = dTypeName;
-      }
-      if (isAbstractType(actualTypeName))
+
+      if (isAbstractType(actualTypeName)) {
         message('odata-anno-type', msg.location,
-        { anno: msg.anno(), type: dTypeName, code: '$Type', '#': 'abstract' });
+                {
+                  anno: msg.anno(), type: dTypeName, code: '$Type', '#': 'abstract',
+                });
+      }
 
       // Dictionary Type, render in XML only for backward compatibility
       newRecord.setXml( { Type: actualTypeName });
@@ -1383,7 +1406,7 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
     // loop over elements
     for (const name of Object.keys(obj)) {
-      msg.stack.push('.' + name);
+      msg.stack.push(`.${name}`);
 
       if (name === '$Type') {
         // ignore, this is an "artificial" property used to indicate the type
@@ -1400,11 +1423,11 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
           dictPropertyTypeName = dictProperties[name];
           if (!dictPropertyTypeName && !getDictType(actualTypeName).OpenType) {
             message('odata-anno-type', msg.location,
-            { name, anno: termName, type: dTypeName });
+                    { name, anno: termName, type: dTypeName });
           }
         }
 
-        let newPropertyValue = new Edm.PropertyValue(v, name);
+        const newPropertyValue = new Edm.PropertyValue(v, name);
         // property value can be anything, so delegate handling to handleValue
         handleValue(obj[name], newPropertyValue, termName, dictPropertyTypeName, msg);
         newRecord.append(newPropertyValue);
@@ -1419,55 +1442,50 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
   // annoValue is an array
   // dTypeName : Collection(...) according to dictionary
-  function generateCollection(annoValue, termName, dTypeName, msg) {
+  function generateCollection( annoValue, termName, dTypeName, dTypeIsACollection, msg ) {
     const newCollection = new Edm.Collection(v);
 
-    let innerTypeName = null;
-    if (dTypeName) {
-      const match = dTypeName.match(/^Collection\((.+)\)/);
-      if (match) {
-        innerTypeName = match[1];
-      }
-      else {
-        message('odata-anno-value', msg.location,
-        { anno: msg.anno(), str: 'collection', type: dTypeName, '#': 'struct' });
-      }
+    if (dTypeName && !dTypeIsACollection) {
+      message('odata-anno-value', msg.location,
+              {
+                anno: msg.anno(), str: 'collection', type: dTypeName, '#': 'incompval',
+              });
     }
 
     let index = 0;
     for (const value of annoValue) {
-      msg.stack.push('[' + index + ']');
-      index++
+      msg.stack.push(`[${index}]`);
+      index++;
 
       // for dealing with the single array entries we unfortunately cannot call handleValue(),
       //   as the values inside an array are represented differently from the values
       //   in a record or term
       if (Array.isArray(value)) {
         message('odata-anno-value', msg.location,
-        { anno: msg.anno(), '#': 'nestedcollection' });
+                { anno: msg.anno(), '#': 'nestedcollection' });
       }
       else if (value && typeof value === 'object') {
         if (value['=']) {
-          const res = handleExpression(value['='], innerTypeName);
+          const res = handleExpression(value['='], dTypeName);
           const newPropertyPath = new Edm.ValueThing(v, res.name, res.value );
-          newPropertyPath.setJSON( { [res.name] : res.value } );
+          newPropertyPath.setJSON( { [res.name]: res.value } );
           newCollection.append(newPropertyPath);
         }
         else if (value['#']) {
           message('odata-anno-value', msg.location,
-          { anno: msg.anno(), '#': 'enumincollection' });
+                  { anno: msg.anno(), '#': 'enumincollection' });
         }
-        else if(value['$edmJson']) {
-          newCollection.append(handleEdmJson(value['$edmJson'], msg));
+        else if (value.$edmJson) {
+          newCollection.append(handleEdmJson(value.$edmJson, msg));
         }
         else {
-          newCollection.append(generateRecord(value, termName, innerTypeName, msg));
+          newCollection.append(generateRecord(value, termName, dTypeName, dTypeIsACollection, msg));
         }
       }
       else {
-        const res = handleSimpleValue(value, innerTypeName, msg);
-        const newThing = (value === null) ?new Edm.ValueThing(v, 'Null') : new Edm.ValueThing(v, res.name, value );
-        newThing.setJSON( { [res.jsonName] : res.value });
+        const res = handleSimpleValue(value, dTypeName, msg);
+        const newThing = (value === null) ? new Edm.ValueThing(v, 'Null') : new Edm.ValueThing(v, res.name, value );
+        newThing.setJSON( { [res.jsonName]: res.value });
         newCollection.append(newThing);
       }
 
@@ -1485,17 +1503,16 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
   // See example in test/odataAnnotations/smallTests/edmJson_noReverse_ok
   // and test3/ODataBackends/DynExpr
 
-  function handleEdmJson(obj, msg, exprDef=undefined) {
-
-    let edmNode = undefined;
-    if(obj == null)
+  function handleEdmJson( obj, msg, exprDef = undefined ) {
+    let edmNode;
+    if (obj == null)
       return edmNode;
 
     const dynExprs = edmUtils.intersect(dynamicExpressionNames, Object.keys(obj));
 
-    if(dynExprs.length > 1) {
+    if (dynExprs.length > 1) {
       message('odata-anno-value', msg.location,
-      { anno: msg.anno(), rawvalues: dynExprs, '#': 'multexpr' });
+              { anno: msg.anno(), rawvalues: dynExprs, '#': 'multexpr' });
       return edmNode;
     }
 
@@ -1506,61 +1523,60 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
         edmNode = new Edm.ValueThing(v, k[0] === '$' ? k.slice(1) : k, val );
         edmNode.setJSON( { [edmNode.kind]: val } );
       }
-      else {
-        // This thing is either a record or a collection or a literal
-        if(Array.isArray(obj)) {
-          // EDM JSON doesn't mention annotations on collections
-          edmNode = new Edm.Collection(v);
-          obj.forEach(o => edmNode.append(handleEdmJson(o, msg)));
-        }
-        else if(typeof obj === 'object') {
-          edmNode = new Edm.Record(v);
-          const annos = Object.create(null);
-          const props = Object.create(null);
-          Object.entries(obj).forEach(([k, val]) => {
-            if(k === '@type') {
-              edmNode.setJSON({ 'Type': val});
-              // try to shorten full qualified type URI to short type name
-              const parts = val.split('#');
-              const shortTypeName = parts[parts.length-1];
-              edmNode.setXml({ Type: shortTypeName });
+      // This thing is either a record or a collection or a literal
+      else if (Array.isArray(obj)) {
+        // EDM JSON doesn't mention annotations on collections
+        edmNode = new Edm.Collection(v);
+        obj.forEach(o => edmNode.append(handleEdmJson(o, msg)));
+      }
+      else if (typeof obj === 'object') {
+        edmNode = new Edm.Record(v);
+        const annos = Object.create(null);
+        const props = Object.create(null);
+        Object.entries(obj).forEach(([ k, val ]) => {
+          if (k === '@type') {
+            edmNode.setJSON({ Type: val });
+            // try to shorten full qualified type URI to short type name
+            const parts = val.split('#');
+            const shortTypeName = parts[parts.length - 1];
+            edmNode.setXml({ Type: shortTypeName });
+          }
+          else {
+            let child;
+            const [ head, tail ] = k.split('@');
+            if (tail) {
+              child = handleTerm(tail, val, msg);
             }
             else {
-              let child = undefined;
-              const [ head, tail ] = k.split('@');
-              if(tail) {
-                child = handleTerm(tail, val, msg);
+              child = new Edm.PropertyValue(v, head);
+              child.append(handleEdmJson(val, msg));
+            }
+            if (child) {
+              if (tail && head.length) {
+                if (!annos[head])
+                  annos[head] = [ child ];
+                else
+                  annos[head].push(child);
               }
               else {
-                child = new Edm.PropertyValue(v, head);
-                child.append(handleEdmJson(val, msg));
-              }
-              if(child) {
-                if(tail && head.length) {
-                  if(!annos[head])
-                    annos[head] = [ child ];
-                  else
-                    annos[head].push(child);
-                }
-                else {
-                  if(head.length)
-                    props[head] = child;
-                  edmNode.append(child);
-                }
+                if (head.length)
+                  props[head] = child;
+                edmNode.append(child);
               }
             }
-          });
-          // add collected annotations to record members
-          Object.entries(annos).forEach(([n, val]) => {
-            props[n] && props[n].prepend(...val);
-          });
-        }
-        else { // literal
-          edmNode = new Edm.ValueThing(v,
-            exprDef && exprDef.valueThingName || getXmlTypeName(obj), obj);
-          // typename for static expression rendering
-          edmNode.setJSON( { [getJsonTypeName(obj)]: obj } );
-        }
+          }
+        });
+        // add collected annotations to record members
+        Object.entries(annos).forEach(([ n, val ]) => {
+          if (props[n])
+            props[n].prepend(...val);
+        });
+      }
+      else { // literal
+        edmNode = new Edm.ValueThing(v,
+                                     exprDef && exprDef.valueThingName || getXmlTypeName(obj), obj);
+        // typename for static expression rendering
+        edmNode.setJSON( { [getJsonTypeName(obj)]: obj } );
       }
     }
     else {
@@ -1570,23 +1586,21 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
       // iterate over each obj.property and translate expression into EDM
       forEach(obj, (name, val) => {
-        if(exprDef) {
-          if(exprDef.anno && name[0] === '@') {
+        if (exprDef) {
+          if (exprDef.anno && name[0] === '@') {
             edmNode.append(handleTerm(name.slice(1), val, msg));
           }
           else if (exprDef.attr && exprDef.attr.includes(name)) {
-            if (name[0] === '$') {
+            if (name[0] === '$')
               edmNode.setEdmAttribute(name.slice(1), val);
-            }
           }
           else if (exprDef.jsonAttr && exprDef.jsonAttr.includes(name)) {
-            if (name[0] === '$') {
-              edmNode.setJSON( { [name.slice(1)]: val }) ;
-            }
+            if (name[0] === '$')
+              edmNode.setJSON( { [name.slice(1)]: val });
           }
-          else if(exprDef.children) {
+          else if (exprDef.children) {
             if (Array.isArray(val)) {
-              val.forEach(a => {
+              val.forEach((a) => {
                 edmNode.append(handleEdmJson(a, msg, exprDef));
               });
             }
@@ -1599,23 +1613,22 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
     }
     return edmNode;
 
-    function getXmlTypeName(val) {
+    function getXmlTypeName( val ) {
       let typeName = 'String';
-      if (typeof val === 'boolean') {
+      if (typeof val === 'boolean')
         typeName = 'Bool';
-      }
-      else if (typeof val === 'number') {
+
+      else if (typeof val === 'number')
         typeName = Number.isInteger(val) ? 'Int' : 'Decimal';
-      }
+
       return typeName;
     }
 
-    function getJsonTypeName(val) {
-      let typeName = getXmlTypeName(val);
-      if(typeName === 'Int')
-        return 'Edm.Int32'
-      else
-        return 'Edm.'+typeName;
+    function getJsonTypeName( val ) {
+      const typeName = getXmlTypeName(val);
+      if (typeName === 'Int')
+        return 'Edm.Int32';
+      return `Edm.${typeName}`;
     }
   }
 
@@ -1630,73 +1643,75 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
    * @returns [object, Array<object>]
    */
   function createUserDefinedTermDictionary() {
-    const allKnownVocabularies = [];
+    const allKnownVocabulariesP = [];
     const dict = { terms: {}, types: {}, xrefs: {} };
 
-    if(!isBetaEnabled(options, 'odataTerms'))
-      return [ dict, allKnownVocabularies ];
+    if (!isBetaEnabled(options, 'odataTerms'))
+      return [ dict, allKnownVocabulariesP ];
 
-    for(let termName in csnVocabularies) {
+    for (const termName in csnVocabularies) {
       let dictDef = oDataDictionary.terms[termName];
-      if(dictDef) {
-        message('odata-anno-dict', ['vocabularies', termName],
-        { anno: termName, string: 'annotation', '#': 'redefinition' } );
+      if (dictDef) {
+        message('odata-anno-dict', [ 'vocabularies', termName ],
+                { anno: termName, string: 'annotation', '#': 'redefinition' } );
       }
-      else if(!dictDef) {
+      else if (!dictDef) {
         const annoDef = csnVocabularies[termName];
-        if(annoDef?.$mySchemaName) {
-          if(!allKnownVocabularies.includes[annoDef.$mySchemaName])
-            allKnownVocabularies.push(annoDef.$mySchemaName);
+        if (annoDef?.$mySchemaName) {
+          if (!allKnownVocabulariesP.includes[annoDef.$mySchemaName])
+            allKnownVocabulariesP.push(annoDef.$mySchemaName);
           const myServiceRoot = options.whatsMyServiceRootName(annoDef.$mySchemaName);
-          if(!dict.xrefs[myServiceRoot])
+          if (!dict.xrefs[myServiceRoot])
             dict.xrefs[myServiceRoot] = { $myServiceRoot: myServiceRoot, used: false };
           const edmType = new Edm.TypeBase(options.v, {}, annoDef);
           dictDef = edmType._edmAttributes;
-          dictDef['$myServiceRoot'] = myServiceRoot;
+          dictDef.$myServiceRoot = myServiceRoot;
           let val = annoDef['@odata.term.AppliesTo'];
-          if(val != null)
-            dictDef.AppliesTo = Array.isArray(val) ? val.map(v=>v['='] || v) : [val['='] || val];
-          val  = annoDef['@odata.term.Experimental'];
-          if(val != null)
-            dictDef['$experimental'] = !!val;
+          if (val != null)
+            dictDef.AppliesTo = Array.isArray(val) ? val.map(av => av['='] || av) : [ val['='] || val ];
+          val = annoDef['@odata.term.Experimental'];
+          if (val != null)
+            dictDef.$experimental = !!val;
           val = annoDef['@odata.term.Deprecated'];
-          if(val != null) {
-            dictDef['$deprecated'] = !!val;
-            if(typeof val === 'string')
-              dictDef['$deprecationText'] = val;
+          if (val != null) {
+            dictDef.$deprecated = !!val;
+            if (typeof val === 'string')
+              dictDef.$deprecationText = val;
           }
           dict.terms[termName] = dictDef;
 
-          if((annoDef.items?.enum || annoDef.enum) && isBuiltinType(annoDef.items?.type || annoDef.type)) {
-            const enumType = createTypeDefWithAllowedValues(annoDef, annoDef, dictDef.Type, ['vocabularies', termName ]);
-            const tName = termName + '_$$$EnumType$$$$';
+          if ((annoDef.items?.enum || annoDef.enum) && isBuiltinType(annoDef.items?.type || annoDef.type)) {
+            const enumType = createTypeDefWithAllowedValues(annoDef, annoDef, dictDef.Type, [ 'vocabularies', termName ]);
+            const tName = `${termName}_$$$EnumType$$$$`;
             dict.types[tName] = enumType;
             dictDef.Type = tName;
           }
-          else
-              addTypesToDictionary(annoDef);
+          else {
+            addTypesToDictionary(annoDef);
+          }
         }
       }
     }
-    return [ dict, allKnownVocabularies ];
+    return [ dict, allKnownVocabulariesP ];
 
-    function addTypesToDictionary(node) {
+    function addTypesToDictionary( node ) {
       const typeName = node.items?.type || node.type;
       // for type reuse in x-ref mode, the definition has already been
       // replaced by a reference object in edmPreprocessor.
       // Fall back to original type (the one of the other service).
-      const typeDef = reqDefs.definitions[typeName] || reqDefs.definitions[typeName.replace(serviceName + '.', '')];
-      if(typeDef) {
+      const typeDef = reqDefs.definitions[typeName] || reqDefs.definitions[typeName.replace(`${serviceName}.`, '')];
+      if (typeDef) {
         let dictDef = { };
         const elements = typeDef.items?.elements || typeDef.elements;
-        if(elements) {
-            // complex type
-          dictDef['$kind'] = 'ComplexType';
+        if (elements) {
+          // complex type
+          dictDef.$kind = 'ComplexType';
+          // eslint-disable-next-line no-new-object
           dictDef.Properties = new Object(null);
 
-          for(let en in elements) {
+          for (const en in elements) {
             const elt = elements[en];
-            if(isEdmPropertyRendered(elt, options)) {
+            if (isEdmPropertyRendered(elt, options)) {
               const edmType = new Edm.TypeBase(options.v, {}, elt);
               dictDef.Properties[en] = edmType._edmAttributes[edmType._typeName];
               addTypesToDictionary(elt);
@@ -1706,39 +1721,42 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
         else {
           // type definition
           const edmType = new Edm.TypeBase(options.v, {}, typeDef);
-          dictDef = createTypeDefWithAllowedValues(node, typeDef, edmType._edmAttributes[edmType._typeName], ['definitions', typeName ]);
-          if(!typeDef.enum)
+          dictDef = createTypeDefWithAllowedValues(node, typeDef, edmType._edmAttributes[edmType._typeName], [ 'definitions', typeName ]);
+          if (!typeDef.enum)
             delete dictDef.$Allowed;
         }
         dict.types[typeName] = dictDef;
       }
     }
 
-    function createTypeDefWithAllowedValues(node, typeDef, UnderlyingType, path) {
+    function createTypeDefWithAllowedValues( node, typeDef, UnderlyingType, path ) {
       const dictTypeDef = { $kind: 'TypeDefinition', UnderlyingType, $Allowed: { Values: {}, Symbols: {} } };
       // create an artificial type that holds the $Allowed enum symbols and values
-      if(node.items && typeDef.enum || typeDef.items?.enum)
+      if (node.items && typeDef.enum || typeDef.items?.enum) {
         message('odata-anno-dict-enum', [ 'vocabularies', node.name ],
-          { name: node.name,
-            type: typeDef.name,
-            '#': node.name === typeDef.name ? 'std' : 'type'
-          });
+                {
+                  name: node.name,
+                  type: typeDef.name,
+                  '#': node.name === typeDef.name ? 'std' : 'type',
+                });
+      }
       const enumDic = (typeDef.items?.enum || typeDef.enum);
       const baseType = (typeDef.items || typeDef).type;
-      if(baseType !== 'cds.String' && Object.values(enumDic).some(v => !v.val)) {
+      if (baseType !== 'cds.String' && Object.values(enumDic).some(av => !av.val)) {
         message('odata-anno-dict-enum', path,
-        { name: node.name, type: baseType, '#': 'value' });
+                { name: node.name, type: baseType, '#': 'value' });
       }
       else {
-        for(const symbol in enumDic) {
+        for (const symbol in enumDic) {
           const valDic = { '#SymbolicName': symbol };
           const enumDef = enumDic[symbol];
           // <Null/> values can't be rendered
-          if(enumDef.val === undefined)
+          if (enumDef.val === undefined)
             valDic.Value = symbol;
-          else if(valDic.val !== null)
+          else if (valDic.val !== null)
             valDic.Value = enumDef.val;
-          dictTypeDef.$Allowed.Symbols[symbol] = dictTypeDef.$Allowed.Values[symbol] = valDic;
+          dictTypeDef.$Allowed.Values[symbol] = valDic;
+          dictTypeDef.$Allowed.Symbols[symbol] = valDic;
         }
       }
       return dictTypeDef;
@@ -1747,127 +1765,126 @@ function csn2annotationEdm(reqDefs, csnVocabularies, serviceName,
 
   function initEdmJson() {
     // Static dynamic expression dictionary, loaded with Edm creators
-    const dynamicExpressions = {
-      '$And':   { create: () => { return new Edm.Expr(v, 'And') }, anno: true },
-      '$Or':    { create: () => { return new Edm.Expr(v, 'Or') }, anno: true },
-      '$Not':   { create: () => { return new Edm.Expr(v, 'Not') }, anno: true },
-      '$Eq':    { create: () => { return new Edm.Expr(v, 'Eq') }, anno: true },
-      '$Ne':    { create: () => { return new Edm.Expr(v, 'Ne') }, anno: true },
-      '$Gt':    { create: () => { return new Edm.Expr(v, 'Gt') }, anno: true },
-      '$Ge':    { create: () => { return new Edm.Expr(v, 'Ge') }, anno: true },
-      '$Lt':    { create: () => { return new Edm.Expr(v, 'Lt') }, anno: true },
-      '$Le':    { create: () => { return new Edm.Expr(v, 'Le') }, anno: true },
-      //valueThingName: 'EnumMember' Implicit Cast Rule String => Primitive Type is OK
-      '$Has':   { create: () => { return new Edm.Expr(v, 'Has') }, anno: true },
-      '$In':    { create: () => { return new Edm.Expr(v, 'In') }, anno: true },
-      '$Add':   { create: () => { return new Edm.Expr(v, 'Add') }, anno: true },
-      '$Sub':   { create: () => { return new Edm.Expr(v, 'Sub') }, anno: true },
-      '$Neg':   { create: () => { return new Edm.Expr(v, 'Neg') }, anno: true },
-      '$Mul':   { create: () => { return new Edm.Expr(v, 'Mul') }, anno: true },
-      '$Div':   { create: () => { return new Edm.Expr(v, 'Div') }, anno: true },
-      '$DivBy': { create: () => { return new Edm.Expr(v, 'DivBy') }, anno: true },
-      '$Mod':   { create: () => { return new Edm.Expr(v, 'Mod') }, anno: true },
-      '$Apply': {
-        create: () => { return new Edm.Apply(v) },
+    const dynamicExpressionsP = {
+      $And: { create: () => new Edm.Expr(v, 'And'), anno: true },
+      $Or: { create: () => new Edm.Expr(v, 'Or'), anno: true },
+      $Not: { create: () => new Edm.Expr(v, 'Not'), anno: true },
+      $Eq: { create: () => new Edm.Expr(v, 'Eq'), anno: true },
+      $Ne: { create: () => new Edm.Expr(v, 'Ne'), anno: true },
+      $Gt: { create: () => new Edm.Expr(v, 'Gt'), anno: true },
+      $Ge: { create: () => new Edm.Expr(v, 'Ge'), anno: true },
+      $Lt: { create: () => new Edm.Expr(v, 'Lt'), anno: true },
+      $Le: { create: () => new Edm.Expr(v, 'Le'), anno: true },
+      // valueThingName: 'EnumMember' Implicit Cast Rule String => Primitive Type is OK
+      $Has: { create: () => new Edm.Expr(v, 'Has'), anno: true },
+      $In: { create: () => new Edm.Expr(v, 'In'), anno: true },
+      $Add: { create: () => new Edm.Expr(v, 'Add'), anno: true },
+      $Sub: { create: () => new Edm.Expr(v, 'Sub'), anno: true },
+      $Neg: { create: () => new Edm.Expr(v, 'Neg'), anno: true },
+      $Mul: { create: () => new Edm.Expr(v, 'Mul'), anno: true },
+      $Div: { create: () => new Edm.Expr(v, 'Div'), anno: true },
+      $DivBy: { create: () => new Edm.Expr(v, 'DivBy'), anno: true },
+      $Mod: { create: () => new Edm.Expr(v, 'Mod'), anno: true },
+      $Apply: {
+        create: () => new Edm.Apply(v),
         attr: [ '$Function' ],
-        anno: true
+        anno: true,
       },
-      '$Cast': {
-        create: () => { return new Edm.Cast(v) },
+      $Cast: {
+        create: () => new Edm.Cast(v),
         attr: [ '$Type' ],
         jsonAttr: [ '$Collection' ],
-        anno: true
+        anno: true,
       },
-      '$IsOf': {
-        create: () => { return new Edm.IsOf(v) },
+      $IsOf: {
+        create: () => new Edm.IsOf(v),
         attr: [ '$Type' ],
-        anno: true
+        anno: true,
       },
-      '$If': { create: () => { return new Edm.If(v) }, anno: true },
-      '$LabeledElement': {
-        create: () => { return new Edm.LabeledElement(v) },
+      $If: { create: () => new Edm.If(v), anno: true },
+      $LabeledElement: {
+        create: () => new Edm.LabeledElement(v),
         attr: [ '$Name' ],
-        anno: true
+        anno: true,
       },
-      '$LabeledElementReference': {
-        create: (obj) => { return new Edm.LabeledElementReference(v, obj['$LabeledElementReference']); },
+      $LabeledElementReference: {
+        create: obj => new Edm.LabeledElementReference(v, obj.$LabeledElementReference),
       },
-      '$UrlRef': { create: () => { return new Edm.UrlRef(v); }, anno: true },
-      '$Null': { create: () => { return new Edm.Null(v); }, anno: true, children: false },
+      $UrlRef: { create: () => new Edm.UrlRef(v), anno: true },
+      $Null: { create: () => new Edm.Null(v), anno: true, children: false },
     };
 
-    Object.entries(dynamicExpressions).forEach(([k, v]) => {
-      if(!v.name)
-        v.name = k.slice(1);
-      if(v.children === undefined)
-        v.children = true;
+    Object.entries(dynamicExpressionsP).forEach(([ k, dv ]) => {
+      if (!dv.name)
+        dv.name = k.slice(1);
+      if (dv.children === undefined)
+        dv.children = true;
     });
-    return [ dynamicExpressions, Object.keys(dynamicExpressions) ];
+    return [ dynamicExpressionsP, Object.keys(dynamicExpressionsP) ];
   }
   //-------------------------------------------------------------------------------------------------
   //-------------------------------------------------------------------------------------------------
   //-------------------------------------------------------------------------------------------------
 
-    // resolve "derived types"
+  // resolve "derived types"
   // -> if dTypeName is a TypeDefinition, replace by
   //    underlying type
-  function resolveTypeDefinition(dTypeName) {
+  function resolveTypeDefinition( dTypeName ) {
     const type = getDictType(dTypeName);
-    if (type && type.UnderlyingType && type['$kind'] === 'TypeDefinition') {
+    if (type && type.UnderlyingType && type.$kind === 'TypeDefinition')
       return type.UnderlyingType;
-    }
+
     return dTypeName;
   }
 
-  function stripCollection(typeName) {
-    const match = typeName.match(/^Collection\((.+)\)/);
-    if (match) {
-      typeName = match[1];
+  function stripCollection( typeName ) {
+    if (typeName) {
+      const match = typeName.match(/^Collection\((.+)\)/);
+      if (match)
+        return [ match[1], true ];
     }
-    return typeName;
-  }
 
-  function isPrimitiveType(typeName) {
-    return typeName.split('.')[0] === 'Edm';
+    return [ typeName, false ];
   }
 
-  function isCollection(typeName) {
-    return typeName.match(/^Collection\((.+)\)/) !== null;
+  function isPrimitiveType( typeName ) {
+    return typeName.split('.')[0] === 'Edm';
   }
 
-  function isEnumType(dTypeName) {
+  function isEnumType( dTypeName ) {
     const type = getDictType(dTypeName);
-    return type && type['$kind'] === 'EnumType';
+    return type && type.$kind === 'EnumType';
   }
 
-  function isComplexType(dTypeName) {
+  function isComplexType( dTypeName ) {
     const type = getDictType(dTypeName);
-    return dTypeName === 'Edm.ComplexType' || type && type['$kind'] === 'ComplexType';
+    return dTypeName === 'Edm.ComplexType' || type && type.$kind === 'ComplexType';
   }
 
-  function isAbstractType(dTypeName) {
+  function isAbstractType( dTypeName ) {
     const type = getDictType(dTypeName);
-    return type && type['Abstract'] === 'true';
+    return type && type.Abstract === 'true';
   }
 
   // return true if derived has baseCandidate as direct or indirect base type
-  function isDerivedFrom(derived, baseCandidate) {
+  function isDerivedFrom( derived, baseCandidate ) {
     while (derived) {
-      if (derived == baseCandidate) return true;
+      if (derived === baseCandidate)
+        return true;
       derived = getDictType(derived).BaseType;
     }
     return false;
   }
 
   // return dictionary of all properties of typeName, including those of base types
-  function getAllProperties(typeName) {
-    if (!typeName || !getDictType(typeName)) return null;
+  function getAllProperties( typeName ) {
+    if (!typeName || !getDictType(typeName))
+      return null;
     return getDictType(typeName).Properties;
   }
-
 }
 
-function mergeOdataVocabularies(options, message) {
+function mergeOdataVocabularies( options, message ) {
   /*  Merge options.odataVocabularies into vocabularyDefinitions and
       create a csn2edm stack local dictionary.
       odataVocabularies is an object, each property is the
@@ -1878,43 +1895,40 @@ function mergeOdataVocabularies(options, message) {
       inverted index of mergedVocDefs above)
   */
   const mergedVocDefs = Object.assign({}, vocabularyDefinitions);
-  const reqProps = ['Alias', 'Namespace', 'Uri'];
-  if(options.odataVocabularies) {
+  const reqProps = [ 'Alias', 'Namespace', 'Uri' ];
+  if (options.odataVocabularies) {
     const vocRefs = options.odataVocabularies;
     if (typeof vocRefs === 'object' && !Array.isArray(vocRefs)) {
-      Object.entries(vocRefs).forEach(([id, def]) => {
+      Object.entries(vocRefs).forEach(([ id, def ]) => {
         let defOk = true;
-        reqProps.forEach(name => {
-          if(!def[name] || typeof def[name] !== 'string') {
+        reqProps.forEach((name) => {
+          if (!def[name] || typeof def[name] !== 'string') {
             message('odata-anno-vocref', null,
-              { id, name, '#': 'malformed' } );
+                    { id, name, '#': 'malformed' } );
             defOk = false;
           }
-          else if(name === 'Alias' && !edmUtils.isODataSimpleIdentifier(def[name])) {
-            message('odata-spec-violation-id', null, { id:name, value: def[name], '#': 'vocrefalias' });
+          else if (name === 'Alias' && !edmUtils.isODataSimpleIdentifier(def[name])) {
+            message('odata-spec-violation-id', null, { id: name, value: def[name], '#': 'vocrefalias' });
             defOk = false;
           }
         });
-        if(defOk) {
+        if (defOk) {
           const vocDef = mergedVocDefs[id];
-          if(vocDef && !vocDef.$optVocRef) {
+          if (vocDef && !vocDef.$optVocRef) {
+            message('odata-anno-vocref', null,
+                    { id, type: mergedVocDefs[id].inc.Namespace, '#': 'redef' } );
+          }
+          else if (id !== def.Alias) {
             message('odata-anno-vocref', null,
-              { id, type: mergedVocDefs[id].inc.Namespace, '#': 'redef' } );
+                    { id, name: def.Alias } );
           }
           else {
-            if(id !== def.Alias) {
-              message('odata-anno-vocref', null,
-                { id, name: def.Alias } );
-            }
-            else {
-              // no int.filename => no validation
-              const vocDef = {
-                ref: { Uri: def.Uri },
-                inc: { Alias: def.Alias, Namespace: def.Namespace }
-              };
-              setProp(vocDef, '$optVocRef', true);
-              mergedVocDefs[id] = vocDef;
-            }
+            // no int.filename => no validation
+            mergedVocDefs[id] = {
+              ref: { Uri: def.Uri },
+              inc: { Alias: def.Alias, Namespace: def.Namespace },
+            };
+            setProp(mergedVocDefs[id], '$optVocRef', true);
           }
         }
       });