@sap/cds-compiler 4.6.0 → 4.7.4

package/lib/edm/annotations/genericTranslation.js

@@ -1,10 +1,11 @@
 'use strict';
 
-const { isEdmPropertyRendered, isBuiltinType } = require('../../model/csnUtils');
+const { isEdmPropertyRendered, isBuiltinType, transformExpression } = require('../../model/csnUtils');
 const edmUtils = require('../edmUtils.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const { forEachDefinition } = require('../../model/csnUtils');
+// const { csnRefs } = require('../../model/csnRefs');
 const { isBetaEnabled, setProp } = require('../../base/model.js');
 const { xpr2edmJson, getEdmJsonHandler } = require('./edmJson.js');
 const { vocabularyDefinitions } = require('./vocabularyDefinitions.js');
@@ -18,14 +19,16 @@ const { EdmPathTypeMap } = require('../EdmPrimitiveTypeDefinitions.js');
  *   dictReplacement: for test purposes, replaces the standard oDataDictionary
  */
 function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
-                            Edm = undefined, options = undefined, messageFunctions = undefined, mergedVocDefs = vocabularyDefinitions ) {
+                            Edm, options, messageFunctions, mergedVocDefs = vocabularyDefinitions ) {
   const gAnnosArray = []; // global variable where we store all the generated annotations
   const usedExperimentalTerms = {}; // take note of all experimental annos that have been used
   const usedDeprecatedTerms = {}; // take note of all deprecated annos that have been used
 
   const { v } = options;
-  const { message } = messageFunctions;
+  const { message, error } = messageFunctions;
   const { handleEdmJson } = getEdmJsonHandler(Edm, options, messageFunctions, handleTerm);
+  // const { inspectRef } = csnRefs(reqDefs);
+
   const [ userDefinedTermDict, allKnownVocabularies ] = createUserDefinedTermDictionary();
 
 
@@ -34,7 +37,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
   const whatsMyTermNamespace = anno => allKnownVocabularies.reduce((rc, ns) => (!rc && anno && anno.startsWith(`@${ns}.`) ? ns : rc), undefined);
 
   // annotation preprocessing
-  preprocessAnnotations.preprocessAnnotations(reqDefs, serviceName, options);
+  preprocessAnnotations.preprocessAnnotations(reqDefs, serviceName, options, messageFunctions);
 
   // we take note of which vocabularies are actually used in a service in order to avoid
   // producing useless references; reset everything to "unused"
@@ -54,57 +57,27 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
             { name: serviceName, '#': 'service' } );
   }
 
-  // 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 (attr[0] === '@') {
-          const [ prefix, innerAnnotation ] = attr.split('.@');
-          const ns = whatsMyTermNamespace(prefix);
-          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('')}`;
-              let newAnno = steps.join('.');
-              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)
-                delete object._origin[attr];
-            }
-          }
-        }
-      }
-    }
-  });
+  assignParameterAnnotations();
 
   // Crawl over the csn and trigger the annotation translation for all kinds
   //   of annotated things.
   // Note: only works for single service
   // 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}.`)) {
-      const location = [ 'definitions', objName ];
-      if (object.kind === 'action' || object.kind === 'function') {
-        handleAction(objName, object, null, location);
-      }
-      else { // service, entity, anything else?
-        // handle the annotations directly tied to the object
-        handleAnnotations(objName, object, location);
-        // handle the annotations of the object's elements
-        handleElements(objName, object, location);
-        // handle the annotations of the object's actions
-        handleBoundActions(objName, object, location);
-      }
+  forEachDefinition(reqDefs, (def, defName) => {
+    if (defName === serviceName || defName.startsWith(`${serviceName}.`)) {
+      const location = [ 'definitions', defName ];
+      // the <objName> is not the carrier name for <objName>Type
+      // and sometimes the object.name doesn't have a service prefix
+      if (def.name && def.name.startsWith(`${serviceName}.`))
+        defName = def.name;
+      if (def.kind === 'action' || def.kind === 'function')
+        handleAction(defName, def, null, location);
+      else
+        handleDefinition(defName, def, location);
     }
   });
 
-
   // filter out empty <Annotations...> elements
   // add references for the used vocabularies
   return {
@@ -123,6 +96,77 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     return v && v[0];
   }
 
+  function assignParameterAnnotations() {
+    // Copy annotations from origin to parameter entity if it's
+    // qualified with #$parameters or if its applicable to an EntitySet or Singleton
+    const scopeCheck = {
+      ref: (elemref, prop, xpr, path) => {
+        if (scopeCheck.scope === 'param' && (!elemref.param || (xpr[0].id || xpr[0]) === '$self'))
+          error('odata-anno-xpr-ref', path, { elemref, anno: scopeCheck.anno, '#': 'notaparam' });
+        if (scopeCheck.scope === 'type' && elemref.param)
+          error('odata-anno-xpr-ref', path, { elemref, anno: scopeCheck.anno, '#': 'notaneelement' });
+      },
+    };
+    const checkDict = (dict, scope) => {
+      if (dict) {
+        scopeCheck.scope = scope;
+        Object.values(dict).forEach((carrier) => {
+          const knownAnnos = filterKnownAnnotations(carrier);
+          knownAnnos.forEach((pn) => {
+            scopeCheck.anno = pn;
+            transformExpression(carrier, pn, scopeCheck, carrier.$path);
+          });
+        });
+      }
+    };
+    const checkDef = (def, scope) => {
+      scopeCheck.scope = scope;
+      const knownAnnos = filterKnownAnnotations(def);
+      knownAnnos.forEach((pn) => {
+        scopeCheck.anno = pn;
+        transformExpression(def, pn, scopeCheck, def.$path);
+      });
+    };
+    forEachDefinition(reqDefs, (object) => {
+      if (object.$isParamEntity && object._origin) {
+        // check for correct paths
+        if (object._origin.$paramAnnoProxies) {
+          object.$eltAnnoProxies = object._origin.$paramAnnoProxies;
+          object._origin.$paramAnnoProxies = null;
+          checkDict(object.$eltAnnoProxies, 'param');
+        }
+        checkDict(object._origin.$eltAnnoProxies, 'type');
+        checkDict(object.elements, 'param');
+        checkDict(object._origin.elements, 'type');
+
+        scopeCheck.scope = 'param';
+        Object.keys(object._origin).forEach((attr) => {
+          if (attr[0] === '@') {
+            scopeCheck.anno = attr;
+            const [ prefix, innerAnnotation ] = attr.split('.@');
+            const ns = whatsMyTermNamespace(prefix);
+            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('')}`;
+                let newAnno = steps.join('.');
+                if (innerAnnotation)
+                  newAnno += `.@${innerAnnotation}`;
+                edmUtils.assignAnnotation(object, newAnno, object._origin[attr]);
+                transformExpression(object._origin, attr, scopeCheck, object._origin.$path);
+                if (paramAnnoParts.length > 1)
+                  delete object._origin[attr];
+              }
+            }
+          }
+        });
+        checkDef(object._origin, 'type');
+      }
+    });
+  }
+
   /*
   Mapping annotated thing in cds/csn => annotated thing in edmx:
 
@@ -160,20 +204,27 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     like above, but append "/<parameter" to the Target
 */
 
-
-  // 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 ]) => {
-      // determine the name of the target in the resulting edm
-      //   for non-assoc element, this simply is "<objectName>/<elementName>"
-      const edmTargetName = `${objname}/${elemName}`;
-      const eLocation = [ ...location, 'elements', elemName ];
-      handleAnnotations(edmTargetName, element, eLocation);
-    });
+  function handleDefinition( defName, def, location ) {
+    // definition bound annotations
+    handleAnnotations(defName, def, location);
+    // definition bound element annotations
+    if (def.$eltAnnoProxies) {
+      Object.entries(def.$eltAnnoProxies).forEach(([ elemPath, element ]) => {
+        const edmTargetName = `${defName}/${elemPath}`;
+        handleAnnotations(edmTargetName, element, element.$path);
+      });
+    }
+    // element bound annotations
+    if (def.elements) {
+      Object.entries(def.elements).forEach(([ elemName, element ]) => {
+        const edmTargetName = `${defName}/${elemName}`;
+        const eLocation = [ ...location, 'elements', elemName ];
+        handleAnnotations(edmTargetName, element, eLocation);
+      });
+    }
+    // bound actions
+    if (def.actions)
+      handleBoundActions(defName, def, location);
   }
 
   // Annotations for actions and functions (and their parameters)
@@ -188,8 +239,6 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
   // in: cObjectname : qualified name of the object that holds the actions
   //     cObject     : the object itself
   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('.');
@@ -293,12 +342,12 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
 
-    let knownAnnos = filterKnownAnnotations();
+    let knownAnnos = filterKnownAnnotations(carrier);
     if (knownAnnos.length === 0)
       return;
 
     if (rewriteInnerAnnotations()) {
-      knownAnnos = filterKnownAnnotations();
+      knownAnnos = filterKnownAnnotations(carrier);
       if (knownAnnos.length === 0)
         return;
     }
@@ -350,47 +399,6 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
       gAnnosArray.push(annotations);
     }
 
-    function filterKnownAnnotations() {
-      const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
-      const nullWhitelist = [ '@Core.OperationAvailable' ];
-      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')) {
-        // Extend knownAnnos with the in-service term definitions
-        annoNames.forEach((an) => {
-          const paths = an.slice(1).split('.');
-          const hasNSPrefix = paths[0] === serviceName;
-          if (!hasNSPrefix)
-            paths.splice(0, 0, serviceName);
-
-          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}`];
-          // 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) {
-            // 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) {
-              carrier[fqName] = carrier[an];
-              delete carrier[an];
-            }
-            knownAnnosP.push(fqName);
-          }
-        });
-      }
-      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
@@ -486,7 +494,7 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
           // this might be more precise if handleAnnotation would know more about the carrier
           testToStandardEdmTargetP = (x => (x
             ? [ 'Parameter', 'Property' ].some(y => x.includes(y) ||
-              carrier._isCollection && x.includes('Collection'))
+              carrier.$isCollection && x.includes('Collection'))
             : true));
         }
       }
@@ -1448,6 +1456,48 @@ function csn2annotationEdm( reqDefs, csnVocabularies, serviceName,
     }
   }
 
+  function filterKnownAnnotations( carrier ) {
+    const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
+    const nullWhitelist = [ '@Core.OperationAvailable' ];
+    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')) {
+      // Extend knownAnnos with the in-service term definitions
+      annoNames.forEach((an) => {
+        const paths = an.slice(1).split('.');
+        const hasNSPrefix = paths[0] === serviceName;
+        if (!hasNSPrefix)
+          paths.splice(0, 0, serviceName);
+
+        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}`];
+        // 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) {
+          // 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) {
+            carrier[fqName] = carrier[an];
+            delete carrier[an];
+          }
+          knownAnnosP.push(fqName);
+        }
+      });
+    }
+    return knownAnnosP;
+  }
+
+
   //-------------------------------------------------------------------------------------------------
   // Dictionary access
   //-------------------------------------------------------------------------------------------------

package/lib/edm/annotations/preprocessAnnotations.js

@@ -1,6 +1,5 @@
 'use strict';
 
-const { makeMessageFunction } = require('../../base/messages.js');
 const { forEachDefinition, forEachGeneric } = require('../../model/csnUtils.js');
 
 
@@ -14,8 +13,8 @@ const { forEachDefinition, forEachGeneric } = require('../../model/csnUtils.js')
  * try to proceed with the processing as good as possible.
  *
  */
-function preprocessAnnotations( csn, serviceName, options ) {
-  const { message } = makeMessageFunction(csn, options);
+function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
+  const { message } = messageFunctions;
   const fkSeparator = '_';
 
   resolveShortcuts();
@@ -237,20 +236,18 @@ function preprocessAnnotations( csn, serviceName, options ) {
             //     or shortcut expansion array of paths
             // OR
             //   the (single) non-key string field, if there is one
-            let textField = null;
+            let stringFields = [];
             const Identification = vlEntity['@UI.Identification'];
             if (Identification && Identification[0] && Identification[0]['=']) {
-              textField = Identification[0]['='];
+              stringFields.push(Identification[0]['=']);
             }
             else if (Identification && Identification[0] && Identification[0].Value && Identification[0].Value['=']) {
-              textField = Identification[0].Value['='];
+              stringFields.push(Identification[0].Value['=']);
             }
             else {
-              const stringFields = Object.keys(vlEntity.elements).filter(
+              stringFields = Object.keys(vlEntity.elements).filter(
                 x => !vlEntity.elements[x].key && vlEntity.elements[x].type === 'cds.String'
               );
-              if (stringFields.length === 1)
-                textField = stringFields[0];
             }
 
             // explicitly provided parameters win
@@ -261,12 +258,12 @@ function preprocessAnnotations( csn, serviceName, options ) {
                 LocalDataProperty: { '=': localDataProp },
                 ValueListProperty: valueListProp,
               } ];
-              if (textField) {
-                parameters[1] = {
+              stringFields.forEach((n) => {
+                parameters.push({
                   $Type: 'Common.ValueListParameterDisplayOnly',
-                  ValueListProperty: textField,
-                };
-              }
+                  ValueListProperty: n,
+                });
+              });
             }
 
             const newObj = Object.create( Object.getPrototypeOf(carrier) );

package/lib/edm/csn2edm.js

@@ -11,7 +11,7 @@ const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp, isBetaEnabled } = require('../base/model');
 const {
-  cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType, getUtils,
+  isEdmPropertyRendered, isBuiltinType, getUtils,
 } = require('../model/csnUtils');
 const { checkCSNVersion } = require('../json/csnVersion');
 const {
@@ -20,7 +20,8 @@ const {
   EdmPrimitiveTypeMap,
 } = require('./EdmPrimitiveTypeDefinitions.js');
 const { getEdm } = require('./edm.js');
-
+const { cloneFullCsn } = require('../model/cloneCsn');
+const { forEach, forEachValue } = require('../utils/objectUtils.js');
 /*
 OData V2 spec 06/01/2017 PDF version is available here:
 https://msdn.microsoft.com/en-us/library/dd541474.aspx
@@ -46,7 +47,7 @@ function csn2edm( _csn, serviceName, _options, messageFunctions ) {
  */
 function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
   // get us a fresh model copy that we can work with
-  const csn = cloneCsnNonDict(_csn, _options);
+  const csn = cloneFullCsn(_csn, _options);
   const special$self = !csn?.definitions?.$self && '$self';
   messageFunctions.setModel(csn);
 
@@ -85,6 +86,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
     return rc;
   }
 
+  const reqDefsUtils = getUtils(reqDefs);
+
   if (serviceNames === undefined)
     serviceNames = options.serviceNames;
   if (serviceNames) {
@@ -198,7 +201,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     if (options.isV4()) {
       // Add additional schema containers as sub contexts to the service
-      Object.entries(allSchemas).forEach(([ fqName, art ]) => {
+      forEach(allSchemas, (fqName, art) => {
         if (serviceCsn.name === whatsMyServiceRootName(fqName) &&
           fqName.startsWith(`${serviceCsn.name}.`)) {
           if (art.kind === 'reference')
@@ -250,7 +253,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
     */
     service._children.forEach((c) => {
       if (c._ec) {
-        Object.entries(c._ec._registry).forEach((([ setName, arr ]) => {
+        forEach(c._ec._registry, ( setName, arr ) => {
           if (arr.length > 1) {
             error(null, null, {
               name: c._edmAttributes.Namespace,
@@ -258,7 +261,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
               names: arr.map(a => a.getDuplicateMessage()),
             }, 'Namespace $(NAME): Duplicate entries in EntityContainer with Name=$(ID) for $(NAMES)');
           }
-        }));
+        });
       }
     });
     // Create annotations and distribute into Schemas, merge vocabulary cross refs into xServiceRefs
@@ -266,7 +269,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     // Finally add cross service references into the EDM and extract the targetSchemaNames
     // for the type cross check
-    Object.values(xServiceRefs).forEach((ref) => {
+    forEachValue(xServiceRefs, (ref) => {
       const r = new Edm.Reference(v, ref.ref);
       r.append(new Edm.Include(v, ref.inc));
       edm._defaultRefs.push(r);
@@ -305,7 +308,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     // Sort definitions into their schema container
     function populateSchemas( schemas ) {
-      Object.entries(reqDefs.definitions).forEach(([ fqName, art ]) => {
+      forEach(reqDefs.definitions, ( fqName, art ) => {
         // Identify service members by their definition name only, this allows
         // to let the internal object.name have the sub-schema name.
         // With nested services we must do a longest path match and check whether
@@ -412,7 +415,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
       // create the complex types
       edmUtils.foreach(schemaCsn.definitions,
-                       a => edmUtils.isStructuredType(a) && a.name.startsWith(schemaNamePrefix),
+                       a => edmUtils.isStructuredType(a) && a.name.startsWith(schemaNamePrefix) && !a.$ignoreInAPI,
                        [ createComplexType, markRendered ]);
 
       if (options.isV4()) {
@@ -470,7 +473,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         Schema._children.splice(Schema._children.indexOf(Schema._ec), 1);
 
 
-      Object.entries(NamesInSchemaXRef).forEach(([ name, refs ]) => {
+      forEach(NamesInSchemaXRef, ( name, refs ) => {
         if (refs.length > 1) {
           error(null, [ 'definitions', `${Schema._edmAttributes.Namespace}.${name}` ], { name: Schema._edmAttributes.Namespace },
                 'Duplicate name in Schema $(NAME)');
@@ -485,7 +488,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         const isSingleton = edmUtils.isSingleton(entityCsn) && options.isV4();
         const [ properties, hasStream ] = createProperties(entityCsn);
 
-        const location = [ 'definitions', entityCsn.name ];
+        const location = reqDefs.definitions[entityCsn.name] ? [ 'definitions', entityCsn.name ] : entityCsn.$path;
         const type = `${schema.name}.${EntityTypeName}`;
         if (properties.length === 0)
           warning(null, location, { type }, 'EDM EntityType $(TYPE) has no properties');
@@ -504,7 +507,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           if (p._edmAttributes.Name === EntityTypeName)
             message('odata-spec-violation-property-name', pLoc, { meta: entityCsn.kind });
 
-          if (options.isV2() && p._isCollection && !p._csn.target)
+          if (options.isV2() && p.$isCollection && !p._csn.target)
             message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
           if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name)) {
@@ -554,7 +557,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
         // put actions behind entity types in Schema/EntityContainer
         if (entityCsn.actions) {
-          Object.entries(entityCsn.actions).forEach(([ n, a ]) => {
+          forEach(entityCsn.actions, ( n, a ) => {
             if (options.isV4())
               createActionV4(a, n, entityCsn);
             else
@@ -585,7 +588,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             message('odata-spec-violation-id', pLoc, { id: p._edmAttributes.Name });
 
           if (options.isV2()) {
-            if (p._isCollection && !p._csn.target)
+            if (p.$isCollection && !p._csn.target)
               message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
             if (p._csn.target)
@@ -612,7 +615,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         const streamProps = [];
 
         if (elementsCsn.elements) {
-          Object.entries(elementsCsn.elements).forEach(([ elementName, elementCsn ]) => {
+          forEach(elementsCsn.elements, ( elementName, elementCsn ) => {
             if (!elementCsn._edmParentCsn)
               setProp(elementCsn, '_edmParentCsn', edmParentCsn);
 
@@ -683,10 +686,10 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         // derived types are already resolved to base types
         const attributes = { Name: typeCsn.name.replace(schemaNamePrefix, '') };
         if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-spec-violation-id', [ 'definitions', typeCsn.name ], { id: attributes.Name });
+          message('odata-spec-violation-id', typeCsn.$path, { id: attributes.Name });
 
         const typeDef = new Edm.TypeDefinition(v, attributes, typeCsn );
-        edmTypeCompatibilityCheck(typeDef, [ 'definitions', typeCsn.name ]);
+        edmTypeCompatibilityCheck(typeDef, typeCsn.$path);
         Schema.append(typeDef);
       }
 
@@ -700,6 +703,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
           : [ 'definitions', actionCsn.name ];
 
+
         if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
           message('odata-spec-violation-id', location, { id: attributes.Name });
 
@@ -779,7 +783,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
         // Parameter Nodes
         if (actionCsn.params) {
-          Object.entries(actionCsn.params).forEach(([ parameterName, parameterCsn ]) => {
+          forEach(actionCsn.params, ( parameterName, parameterCsn ) => {
             const p = new Edm.Parameter(v, { Name: parameterName }, parameterCsn );
             const pLoc = [ ...location, 'params', p._edmAttributes.Name ];
             if (!edmUtils.isODataSimpleIdentifier(parameterName))
@@ -857,7 +861,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         }
 
         // is this still required?
-        Object.entries(actionCsn).forEach(([ key, val ]) => {
+        forEach(actionCsn, ( key, val ) => {
           if (key.match(/^@sap\./))
             functionImport.setXml( { [`sap:${key.slice(5).replace(/\./g, '-')}`]: val });
         });
@@ -888,7 +892,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
             !edmUtils.isStructuredType(csn.definitions[param._type]))
                 message('odata-spec-violation-param', pLoc, { version: '2.0' });
 
-              if (param._isCollection)
+              if (param.$isCollection)
                 message('odata-spec-violation-array', pLoc, { version: '2.0' });
 
               functionImport.append(param);
@@ -924,7 +928,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
                   message('odata-spec-violation-type-unknown', returnsLoc, { type });
                 }
               }
-              if (action.returns._isCollection)
+              if (action.returns.$isCollection)
                 type = `Collection(${type})`;
             }
             else {
@@ -1038,7 +1042,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           NamesInSchemaXRef[assocName].push(edmAssociation);
 
         // Add ReferentialConstraints if any
-        if (!navigationProperty._isCollection && Object.keys(constraints.constraints).length > 0) {
+        if (!navigationProperty.$isCollection && Object.keys(constraints.constraints).length > 0) {
           // A managed composition is treated as association
           if (navigationProperty._csn.type === 'cds.Composition' && navigationProperty._csn.on) {
             edmAssociation.append(Edm.ReferentialConstraint.createV2(v,
@@ -1068,8 +1072,7 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
     // generate the Edm.Annotations tree and append it to the corresponding schema
     function addAnnotations2XServiceRefs( ) {
-      const { getFinalTypeInfo } = getUtils(csn);
-      options.getFinalTypeInfo = getFinalTypeInfo;
+      options.getFinalTypeInfo = reqDefsUtils.getFinalTypeInfo;
       const { annos, usedVocabularies, xrefs } = translate.csn2annotationEdm(reqDefs, csn.vocabularies, serviceCsn.name, Edm, options, messageFunctions, mergedVocabularies);
       // distribute edm:Annotations into the schemas
       // Distribute each anno into Schema