@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/edm/annotations/genericTranslation.js

@@ -1,10 +1,11 @@
 'use strict';
 const { isEdmPropertyRendered, isBuiltinType } = require('../../model/csnUtils');
 const edmUtils = require('../edmUtils.js');
-const preprocessAnnotations = require('./preprocessAnnotations.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
+const preprocessAnnotations = require('./preprocessAnnotations.js');
 const { forEachDefinition } = require('../../model/csnUtils');
-const { forEach } = require("../../utils/objectUtils");
+const { forEach } = require('../../utils/objectUtils');
+const { isBetaEnabled } = require('../../base/model.js');
 
 /*
    OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
@@ -15,19 +16,21 @@ const { forEach } = require("../../utils/objectUtils");
    JSON (published)
    Measures (published)
    Repeatability (published)
-   Temporal (not published, not yet finalized)
+   Temporal (published)
    Validation (published)
 
    SAP: https://github.com/SAP/odata-vocabularies/tree/master/vocabularies
    Analytics (published)
    CodeList (published)
-   Common (pubished)
+   Common (published)
    Communication (published)
    DataIntegration (published)
    Graph (published, experimental)
    Hierarchy (published, experimental)
    HTML5 (published, experimental)
    ODM (published, experimental)
+   Offline (experimental)
+   PDF (published)
    PersonalData (published)
    Session (published)
    UI (published)
@@ -109,6 +112,16 @@ const vocabularyDefinitions = {
     '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' }
+  },
+  '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' },
@@ -138,7 +151,6 @@ const vocabularyDefinitions = {
 
 const knownVocabularies = Object.keys(vocabularyDefinitions);
 
-
 /**************************************************************************************************
  * csn2annotationEdm
  *
@@ -146,8 +158,8 @@ const knownVocabularies = Object.keys(vocabularyDefinitions);
  *   v - array with two boolean entries, first is for v2, second is for v4
  *   dictReplacement: for test purposes, replaces the standard oDataDictionary
  */
-function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined, messageFunctions=undefined) {
-
+function csn2annotationEdm(reqDefs, csnVocabularies, serviceName, Edm = undefined, options=undefined, messageFunctions=undefined) {
+  
   if(!Edm)
     throw new Error('Please debug me: csn2annotationsEdm must be invoked with Edm');
   if(!options)
@@ -157,13 +169,30 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // global variable where we store all the generated annotations
   const g_annosArray = [];
 
-  const { info, warning, error } = messageFunctions;
+  const { message } = messageFunctions;
+
+  const [ adhocDictionary, allKnownVocabularies ] = createAdhocDictionary();
 
-  // Static dynamic expression dictionary, loaded with Edm creators
+  /*
+    allKnownVocabularies is the union of knownVocabularies & adhoc $mySchemaName annotation definition
+    this allows to identify namespace prefixes of arbitrary length.
+
+    If in the future, the full Oasis vocabulary names shall be made usable for assignments
+    eg. @com.sap.vocabularies.Common.v1.Label, all that needs to be done is to x-link the
+    vocabulary dictionary whith the full ns as key:
+    vocabularyDefinitions['@com.sap.vocabularies.Common.v1'] = vocabularyDefinitions['Common']
+  */
+  allKnownVocabularies.push(...knownVocabularies);
+  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);
+  }
+
+    // Static dynamic expression dictionary, loaded with Edm creators
   const [ dynamicExpressions, dynamicExpressionNames ] = initEdmJson();
 
   // annotation preprocessing
-  preprocessAnnotations.preprocessAnnotations(csn, serviceName, options);
+  preprocessAnnotations.preprocessAnnotations(reqDefs, serviceName, options);
 
   // we take note of which vocabularies are actually used in a service in order to avoid
   // producing useless references; reset everything to "unused"
@@ -171,32 +200,41 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     vocabularyDefinitions[n].used = false;
   });
 
+  // These vocabularies are always added for the runtimes
+  vocabularyDefinitions['Common'].used = true;
+  vocabularyDefinitions['Core'].used = true;
+
   // provide functions for dictionary lookup
   //   use closure to avoid making "dict" and "experimental" global variables
-  let { getDictTerm, getDictType } = function(){
-    let dict = options.dictReplacement || oDataDictionary; // tests can set different dictionary via options
-    let experimental = {}; // take note of all experimental annos that have been used
-    let deprecated = {}; // take note of all deprecated annos that have been used
+  const { getDictTerm, getDictType } = function(){
+    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
 
     return {
       // 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, context) {
-        const dictTerm = dict.terms[termName]
+      getDictTerm: function(termName, msg) {
+        const dictTerm = (dict.terms[termName] ||
+          adhocDictionary.terms[serviceName + '.' + termName] ||
+          adhocDictionary.terms[termName]);
         // register vocabulary usage if possible
         const vocName = termName.slice(0, termName.indexOf('.'));
         if(vocabularyDefinitions[vocName])
           vocabularyDefinitions[vocName].used = true;
-
+        else if(dictTerm?.$myServiceRoot && 
+          adhocDictionary.xrefs[dictTerm?.$myServiceRoot])
+          adhocDictionary.xrefs[dictTerm.$myServiceRoot].used = true;
         if (dictTerm) {
-          // issue warning for usage of experimental Terms, but only once per Term
+          // issue message for usage of experimental Terms, but only once per Term
           if (dictTerm['$experimental'] && !experimental[termName]) {
-            message(warning, context, 'Term "' + termName + '" is experimental and can be changed or removed at any time, do not use productively!');
+            message('odata-anno-dict', msg.location, { anno: msg.anno(), '#': 'experimental' });
             experimental[termName] = true;
           }
           if (dictTerm['$deprecated'] && !deprecated[termName]) {
-            message(info, context, 'Term "' + termName + '" is deprecated. ' + dictTerm['$deprecationText']);
+            message('odata-anno-def', msg.location,
+            { anno: msg.anno(), depr: dictTerm['$deprecationText'], '#': 'deprecated' });
             deprecated[termName] = true;
           }
         }
@@ -205,10 +243,14 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       // 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];
+        let dictType = (dict.types[typeName] ||
+          adhocDictionary.types[serviceName + '.' + typeName] ||
+          adhocDictionary.types[typeName]);
         if (dictType) {
           // register usage of vocabulary
-          vocabularyDefinitions[typeName.slice(0, typeName.indexOf('.'))].used = true;
+          const voc = vocabularyDefinitions[typeName.slice(0, typeName.indexOf('.'))];
+          if(voc)
+            voc.used = true;
         }
         return dictType;
       }
@@ -222,18 +264,20 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // 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(csn, (object, objName) => {
+  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);
+        handleAction(objName, object, null, location);
       }
       else { // service, entity, anything else?
         // handle the annotations directly tied to the object
-        handleAnnotations(objName, object);
+        handleAnnotations(objName, object, location);
         // handle the annotations of the object's elements
-        handleElements(objName, object);
+        handleElements(objName, object, location);
         // handle the annotations of the object's actions
-        handleBoundActions(objName, object);
+        handleBoundActions(objName, object, location);
       }
     }
   });
@@ -241,7 +285,9 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // filter out empty <Annotations...> elements
   // add references for the used vocabularies
   return {
-    annos: g_annosArray, usedVocabularies: Object.values(vocabularyDefinitions).filter(v => v.used)
+    annos: g_annosArray,
+    usedVocabularies: Object.values(vocabularyDefinitions).filter(v => v.used),
+    xrefs: Object.values(adhocDictionary.xrefs).filter(v => v.used).map(v => v.$myServiceRoot)
   };
 
 //-------------------------------------------------------------------------------------------------
@@ -254,21 +300,6 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     return v && v[0];
   }
 
-  // this function is called in the translation code to issue an info/warning/error message
-  // messages are reported via the severity function
-  // context contains "semantic location"
-  function message(severity, context, message) {
-    let fullMessage = 'In annotation translation: ' + message;
-    if (context) {
-      let loc = 'target: ' + context.target + ', annotation: ' + context.term;
-      if (context.stack.length > 0) {
-        loc += context.stack.join('');
-      }
-      fullMessage += ', ' + loc;
-    }
-    severity(null, null, `${fullMessage}`);
-  }
-
 /*
   Mapping annotated thing in cds/csn => annotated thing in edmx:
 
@@ -312,37 +343,17 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // handle the annotations of the elements of an object
   // in: objname : name of the object
   //     object : the object itself
-  function handleElements(objname, object) {
+  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>"
-      let edmTargetName = objname + '/' + elemName;
-      handleAnnotations(edmTargetName, element);
-
-      // handle sub elements
-      if (element.elements) {
-        handleNestedElements(objname, elemName, element.elements);
-      }
-    });
-  }
-
-  // handling annotations at nested elements is not yet supported
-  // => issue a warning, but only if there actually are annotations
-  function handleNestedElements(objname, baseElemName, elementsObj) {
-    if(!elementsObj) return;
-    Object.entries(elementsObj).forEach(([elemName, element]) => {
-      if (Object.keys(element).filter( x => x[0] === '@' ).filter(filterKnownVocabularies).length > 0) {
-        message(warning, null, `annotations at nested elements are not yet supported, object ${objname}, element ${baseElemName}.${elemName}`);
-      }
-
-      if (element.elements) {
-        handleNestedElements(objname, baseElemName + '.' + elemName, element.elements);
-      }
+      const edmTargetName = objname + '/' + elemName;
+      const eLocation = [ ...location, 'elements', elemName ];
+      handleAnnotations(edmTargetName, element, eLocation);
     });
   }
 
-
   // Annotations for actions and functions (and their parameters)
   // v2, unbound:          Target = <service>.EntityContainer/<action/function>
   // v2, bound:            Target = <service>.EntityContainer/<entity>_<action/function>
@@ -354,17 +365,17 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // 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) {
+  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
-    let nameParts = cObjectname.split('.')
-    let entityName = nameParts.pop();
-    let serviceName = nameParts.join('.');
+    const nameParts = cObjectname.split('.')
+    const entityName = nameParts.pop();
+    const serviceName = nameParts.join('.');
 
     Object.entries(cObject.actions).forEach(([n, action]) => {
-      let actionName = serviceName + '.' + (isV2() ? entityName + '_' : '') + n;
-      handleAction(actionName, action, cObjectname);
+      const actionName = serviceName + '.' + (isV2() ? entityName + '_' : '') + n;
+      handleAction(actionName, action, cObjectname, [ ...location, 'actions', n ]);
     });
   }
 
@@ -373,63 +384,63 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // 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) {
+  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.substr(lastDotIndex + 1);
+        actionName = serviceName + '.EntityContainer/' + actionName.substring(lastDotIndex + 1);
     }
     else { // add parameter type list
-      actionName += relParList(cAction, entityNameIfBound);
+      actionName += relParList();
     }
 
-    handleAnnotations(actionName, cAction);
+    handleAnnotations(actionName, cAction, location);
+
     if(cAction.params) {
       Object.entries(cAction.params).forEach(([n, p]) => {
-        let edmTargetName = actionName + '/' + n;
-        handleAnnotations(edmTargetName, p);
+        const edmTargetName = actionName + '/' + n;
+        handleAnnotations(edmTargetName, p, [ ...location, 'params', n ]);
       });
     }
-  }
 
-  function relParList(action, bindingParam) {
+    function relParList() {
     // we rely on the order of params in the csn being the correct one
-    let params = [];
-    if (bindingParam) {
-      params.push(action['@cds.odata.bindingparameter.collection'] ? 'Collection(' + bindingParam + ')' : bindingParam);
-    }
-    if (action.kind === 'function') {
-      if(action.params) {
-        action.params && Object.values(action.params).forEach(p => {
-          let isArrayType = !p.type && p.items && p.items.type;
-          params.push(isArrayType ? 'Collection(' + mapType(p.items) + ')' : mapType(p));
-        });
+      const params = [];
+      if (entityNameIfBound) {
+        params.push(cAction['@cds.odata.bindingparameter.collection'] ? 'Collection(' + entityNameIfBound + ')' : entityNameIfBound);
+      }
+      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));
+          });
+        }
       }
-    }
-    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) {
-        const schemaName = options.whatsMySchemaName(p.type);
+      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 + '.', '');
+          if(schemaName && schemaName !== options.serviceName)
+            return p.type.replace(options.serviceName + '.', '');
+        }
+        return p.type;
       }
-      return p.type;
     }
-  }
-
 
+  }
 
 
   // handle all the annotations for a given cds thing, here called carrier
   //   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) {
+  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
@@ -447,22 +458,20 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
     
-    let annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
-    const nullWhitelist = [ '@Core.OperationAvailable' ];
-    let knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+    let knownAnnos = filterKnownAnnotations();
     if (knownAnnos.length === 0) return;
 
     if(rewriteInnerAnnotations()) {
-      annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
-      knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+      knownAnnos = filterKnownAnnotations();
       if (knownAnnos.length === 0) return;
     }
+
     const prefixTree = createPrefixTree();
 
     // usually, for a given carrier there is one target
     // for some carriers (service, entity), there can be an alternative target (usually the EntitySet)
     //    alternativeEdmTargetName: name of alternative target
-    // which one to choose depends on the "AppliesTo" info of the single annotations, so we have
+    // which one to choose depends on the "AppliesTo" message of the single annotations, so we have
     //   to defer this decision; this is why we here construct a function that can make the decision
     //   later when looking at single annotations
 
@@ -480,7 +489,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     const alternativeAnnotations = [];
 
     // now create annotation objects for all the annotations of carrier
-    handleAnno2(addAnnotation, edmTargetName /*used for messages*/, prefixTree);
+    handleAnno2(addAnnotation, prefixTree, location);
 
     // Produce Edm.Annotations and attach collected Edm.Annotation(s) to the
     // envelope (or directly to the Schema)
@@ -498,6 +507,44 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       g_annosArray.push(annotations);
     }
 
+    function filterKnownAnnotations() {
+      const annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
+      const nullWhitelist = [ '@Core.OperationAvailable' ];
+      const knownAnnos = annoNames.filter(whatsMyTermNamespace).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+      if(isBetaEnabled(options, 'odataTerms')) {
+        // Extend knownAnnos with the in-service term definitions
+        const adhoc = [];
+        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];
+            }
+            adhoc.push(fqName);
+          }
+        });
+        knownAnnos.push(...adhoc);
+      }
+      return knownAnnos;
+    }
+
     // 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
@@ -522,7 +569,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       }
       // 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' info message
+      // return true to NOT trigger 'unapplicable' message message
       if(rc === false && carrier.target && carrier.keys && appliesTo.includes('Property'))
         rc = true;
       return rc;
@@ -558,7 +605,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         alternativeEdmTargetName = carrier.$entitySetName || edmTargetName
         const lastDotIndex = alternativeEdmTargetName.lastIndexOf('.');
         if (lastDotIndex > -1)
-          alternativeEdmTargetName = serviceName + '.EntityContainer/' + alternativeEdmTargetName.substr(lastDotIndex + 1);
+          alternativeEdmTargetName = serviceName + '.EntityContainer/' + alternativeEdmTargetName.substring(lastDotIndex + 1);
         hasAlternativeCarrier = carrier.$hasEntitySet;
       }
       else if(carrier.kind === 'type') {
@@ -630,7 +677,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
 
     function rewriteInnerAnnotations() {
       let rc = false;
-      for (let a of knownAnnos) {
+      for (const a of knownAnnos) {
         const [ prefix, innerAnnotation ] = a.split('.@');
         /*
           New inner annotation (de-)structuring of the core compiler to make
@@ -684,7 +731,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       //   see example at definition of function mergePathStepsIntoPrefixTree
       const prefixTree = {};
 
-      for (let a of knownAnnos) {
+      for (const a of knownAnnos) {
       // remove leading @ and split at "."
       //   stop splitting at ".@" (used for nested annotations)
       // Inline JSON EDM allows to add annotations to record members
@@ -692,7 +739,9 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       // The splitter should leave such annotations alone, handleEdmJson
       // takes care of assigning these annotations to the record members
         const [ prefix, innerAnnotation ] = a.split('.@');
-        const steps = prefix.slice(1).split('.');
+        const ns = whatsMyTermNamespace(prefix);
+        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);
@@ -738,7 +787,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       //                    q2 : ... } } }
       function mergePathStepsIntoPrefixTree(tree, pathSteps, index, carrier) {
       // TODO check nesting level > 3
-        let name = pathSteps[index];
+        const name = pathSteps[index];
         if (index+1 < pathSteps.length ) {
           if (!tree[name]) {
             tree[name] = {};
@@ -756,27 +805,35 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // handle all the annotations for a given carrier
   // addAnnotationFunc: a function that adds the <Annotation ...> tags created here into the
   //                    correct parent tag (see handleAnnotations())
-  // edmTargetName: name of the edmx target, only used for messages
   // prefixTree: the annotations
-  function handleAnno2(addAnnotationFunc, edmTargetName, prefixTree) {
+  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 (let voc of Object.keys(prefixTree)) {
-      for (let term of Object.keys(prefixTree[voc])) {
-        let fullTermName = voc + '.' + term;
+    for (const voc of Object.keys(prefixTree)) {
+      for (const term of Object.keys(prefixTree[voc])) {
+        const fullTermName = voc + '.' + term;
+
+        // msg is "semantic" location message used for messages
+        const msg = { 
+          fullTermName, 
+          stack: [],
+          location: [ ...location, '@' + fullTermName ],
+        };
+        msg.anno = () => {
+          return msg.fullTermName + msg.stack.join('');
+        }
 
-        // context is "semantic" location info used for messages
-        let context = { target: edmTargetName,  term: fullTermName, stack: [] };
         // anno is the full <Annotation Term=...>
-        let anno = handleTerm(fullTermName, prefixTree[voc][term], context);
+        const anno = handleTerm(fullTermName, prefixTree[voc][term], msg);
         if(anno !== undefined) {
-          // addAnnotationFunc needs AppliesTo info from dictionary to decide where to put the anno
-          fullTermName = fullTermName.replace(/#(\w+)$/g, ''); // remove qualifier
-          let dictTerm = getDictTerm(fullTermName, context); // message for unknown term was already issued in handleTerm
+          // 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) {
-              message(info, context, `Term "${ fullTermName }" is not applied (AppliesTo="${ dictTerm.AppliesTo.join(' ') }")`);
+              message('odata-anno-def', location, 
+              { anno: termName, rawvalues: dictTerm.AppliesTo, '#': 'notapplied' });
             }
           }
         }
@@ -788,9 +845,9 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // annoValue : the annotation value from the csn
   //             if the csn contains flattened out elements of a structured annotation,
   //             they are regrouped here
-  // context :   for messages
+  // msg :   for messages
   // return :    object that represents the annotation in the result edmx
-  function handleTerm(termName, annoValue, context) {
+  function handleTerm(termName, annoValue, msg) {
     /**
      * create the <Annotation ...> tag
      * @type {object}
@@ -798,52 +855,40 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     let newAnno = undefined;
     const omissions = { 'Aggregation.default':1 };
     const nullList = { 'Core.OperationAvailable':1 };
-    const voc = termName.slice(0, termName.indexOf('.'));
-    if(vocabularyDefinitions[voc] && annoValue !== null && !omissions[termName]|| nullList[termName]) {
-      newAnno = new Edm.Annotation(v, termName);
-
+    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
-      let p = termName.split('#');
-      let termNameWithoutQualifiers = p[0];
-      if (p.length > 1) {
-        checkOdataTerm(p[0]);
-        if (!edmUtils.isODataSimpleIdentifier(p[1])) {
-          message(error, context,
-                `OData annotation qualifier "${ p[1] }" must start with a letter or underscore, followed by at most 127 letters, underscores or digits`);
+      const i = termName.indexOf('#');
+      const termNameWithoutQualifiers = i > 0 ? termName.substring(0, i) : termName;
+      const qualifier = i >= 0 ? termName.substring(i+1) : undefined;
+
+      termNameWithoutQualifiers.split('.').forEach((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' });
         }
         newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
-        newAnno.setEdmAttribute('Qualifier', p[1]);
+        newAnno.setEdmAttribute('Qualifier', qualifier);
       }
-      if (p.length>2) {
-        message(warning, context, `multiple qualifiers (${ p[1] },${ p[2] }${ p.length > 3 ? ',...' : '' })`);
-      }
-
     // get the type of the term from the dictionary
       let termTypeName = null;
-      let dictTerm = getDictTerm(termNameWithoutQualifiers, context);
+      const dictTerm = getDictTerm(termNameWithoutQualifiers, msg);
       if (dictTerm) {
         termTypeName = dictTerm.Type;
       }
       else {
-        message(info, context, `Unknown term “${ termNameWithoutQualifiers }”`);
+        message('odata-anno-def', msg.location,{ anno: termNameWithoutQualifiers });
       }
 
     // handle the annotation value and put the result into the <Annotation ...> tag just created above
-      handleValue(annoValue, newAnno, termNameWithoutQualifiers, termTypeName, context);
+      handleValue(annoValue, newAnno, termNameWithoutQualifiers, termTypeName, msg);
     }
     return newAnno;
-
-    function checkOdataTerm(ns) {
-      const simpleIdentifiers = ns.split('.');
-      simpleIdentifiers.forEach((identifier) => {
-        if(!edmUtils.isODataSimpleIdentifier(identifier)){
-          message(error, context,
-                  `OData annotation term "${ identifier }" must consist of one or more dot separated simple identifiers (each starting with a letter or underscore, followed by at most 127 letters)`);
-        }
-      })
-    }
-
   }
 
 
@@ -852,7 +897,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   //   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, context) {
+  function handleValue(cAnnoValue, oTarget, oTermName, dTypeName, 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
@@ -863,65 +908,86 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       if (isEnumType(dTypeName))
       {
         // if we find an array although we expect an enum, this may be a "flag enum"
-        checkMultiEnumValue(cAnnoValue, dTypeName, context);
-        oTarget.setJSON({ 'EnumMember': generateMultiEnumValue(cAnnoValue, dTypeName, false), 'EnumMember@odata.type' : '#'+dTypeName });
-        oTarget.setXml( { 'EnumMember': generateMultiEnumValue(cAnnoValue, dTypeName, true) });
+        checkMultiEnumValue(cAnnoValue);
+        oTarget.setJSON({ 'EnumMember': generateMultiEnumValue(cAnnoValue, false), 'EnumMember@odata.type' : '#'+dTypeName });
+        oTarget.setXml( { 'EnumMember': generateMultiEnumValue(cAnnoValue, true) });
       }
       else
       {
-        oTarget.append(generateCollection(cAnnoValue, oTermName, dTypeName, context));
+        oTarget.append(generateCollection(cAnnoValue, oTermName, dTypeName, msg));
       }
     }
     else if (cAnnoValue && typeof cAnnoValue === 'object') {
-      if (Object.keys(cAnnoValue).length === 0) {
-        message(warning, context, 'empty record');
-      }
-      else if ('=' in cAnnoValue) {
+      // an empty record is rendered as <Record/>
+      if ('=' in cAnnoValue) {
         // expression
-        let res = handleExpression(cAnnoValue['='], dTypeName, context);
+        const res = handleExpression(cAnnoValue['='], dTypeName);
         oTarget.setXml( { [res.name] : res.value });
         oTarget.setJSON( { [res.name] : res.value });
       }
       else if (cAnnoValue['#'] !== undefined) {
+        const enumSymbol = cAnnoValue['#'];
         // enum
         if (dTypeName) {
-          checkEnumValue(cAnnoValue['#'], dTypeName, context);
-          oTarget.setXml( { 'EnumMember': dTypeName + '/' + cAnnoValue['#'] });
+          const typeDef = getDictType(stripCollection(dTypeName));
+          if(typeDef && typeDef.$Allowed && !typeDef.Members) {
+            const allowedValue = typeDef.$Allowed.Symbols[enumSymbol];
+            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'
+                });
+            }
+            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 {
-          oTarget.setXml( { 'EnumMember': oTermName + 'Type/' + cAnnoValue['#'] });
+          oTarget.setXml( { 'EnumMember': oTermName + 'Type/' + enumSymbol });
         }
-        oTarget.setJSON({ 'Edm.String': cAnnoValue['#'] });
+        oTarget.setJSON({ 'Edm.String': enumSymbol });
       }
       else if (cAnnoValue['$value'] !== undefined) {
         // "pseudo-structure" used for annotating scalar annotations
-        handleValue(cAnnoValue['$value'], oTarget, oTermName, dTypeName, context);
+        handleValue(cAnnoValue['$value'], oTarget, oTermName, dTypeName, msg);
 
-        let k = Object.keys(cAnnoValue).filter( x => x.charAt(0) === '@');
+        const k = Object.keys(cAnnoValue).filter( x => x[0] === '@');
         if (!k || k.length === 0) {
-          message(warning, context, 'pseudo-struct without nested annotation');
+          message('odata-anno-value', msg.location,
+          { anno: msg.anno(), str: 'nested', '#': 'nested' });
         }
-        for (let nestedAnnoName of k) {
-          let nestedAnno = handleTerm(nestedAnnoName.slice(1), cAnnoValue[nestedAnnoName], context);
+        for (const nestedAnnoName of k) {
+          const nestedAnno = handleTerm(nestedAnnoName.slice(1), cAnnoValue[nestedAnnoName], msg);
           oTarget.append(nestedAnno);
         }
       }
       else if (cAnnoValue['$edmJson']) {
         // "pseudo-structure" used for embedding a piece of JSON that represents "OData CSDL, JSON Representation"
-        oTarget.append(handleEdmJson(cAnnoValue['$edmJson'], context));
+        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(warning, context, 'nested annotations without corresponding base annotation');
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), str: 'base', '#': 'nested'} );
       }
       else {
         // regular record
-        oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, context));
+        oTarget.append(generateRecord(cAnnoValue, oTermName, dTypeName, msg));
       }
     }
     else {
-      let res = handleSimpleValue(cAnnoValue, dTypeName, context);
-      if(oTermName === 'Core.OperationAvailable' && dTypeName === 'Edm.Boolean' && cAnnoValue === null) {
+      const res = handleSimpleValue(cAnnoValue, dTypeName, msg);
+      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;
       }
@@ -930,81 +996,95 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       }
       oTarget.setJSON( { [res.jsonName] : res.value });
     }
-  }
-
 
-  // found an enum value ("#"), check whether this fits
-  //  the expected type "dTypeName"
-  function checkEnumValue(enumValue, dTypeName, context) {
-    let expectedType = getDictType(dTypeName);
-    if (!expectedType && !isPrimitiveType(dTypeName)) {
-      message(warning, context, `internal error: dictionary inconsistency: type '${ dTypeName }' not found`);
-    }
-    else if (isComplexType(dTypeName)) {
-      message(warning, context, `found enum value, but expected complex type ${ dTypeName }`);
-    }
-    else if (isPrimitiveType(dTypeName) || expectedType['$kind'] !== 'EnumType') {
-      message(warning, context, `found enum value, but expected non-enum type ${ dTypeName }`);
-    }
-    else if (!expectedType['Members'].includes(enumValue)) {
-      message(warning, context, `enumeration type ${ dTypeName } has no value ${ enumValue }`);
+    // found an enum value ("#"), check whether this fits
+    //  the expected type "dTypeName"
+    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 });
+      }
+      else if (isComplexType(dTypeName) || isPrimitiveType(dTypeName) || expectedType['$kind'] !== 'EnumType') {
+        message('odata-anno-value', msg.location,
+          { 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'
+          });
+      }
+      return rc;
     }
-  }
 
-  // cAnnoValue: array
-  // dTypeName: expected type, already identified as enum type
-  //   array is expected to contain enum values
-  function checkMultiEnumValue(cAnnoValue, dTypeName, context) {
+    // 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
-    let type = getDictType(dTypeName);
-    if (!type || type['IsFlags'] !== 'true') {
-      message(warning, context, `enum type '${ dTypeName }' doesn't allow multiple values`);
+      const type = getDictType(dTypeName);
+      if (!type || type['IsFlags'] !== 'true') {
+        message('odata-anno-value', msg.location,
+          { anno: msg.anno(),
+            str: 'collection',
+            type: dTypeName,
+            '#': 'struct' });
+      }
+
+      let index = 0;
+      for (let 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'
+            });
+        }
+        msg.stack.pop();
+      }
     }
 
-    let index = 0;
-    for (const e of cAnnoValue) {
-      context.stack.push('[' + index + ']');
-      index++;
-      if (e['#']) {
-        checkEnumValue(e['#'], dTypeName, context);
-      }
-      else {
-        // TODO improve message: but found ...
-        message(warning, context, 'expected an enum value');
-      }
-      context.stack.pop();
+    function generateMultiEnumValue(cAnnoValue, 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 ? ' ' : ',');
     }
   }
 
-  function generateMultiEnumValue(cAnnoValue, dTypeName, 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 ? ' ' : ',');
-  }
 
 
   // 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(expr, dTypeName, context) {
+  function handleExpression(value, dTypeName) {
     let typeName = 'Path';
     if( ['Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(dTypeName) )
       typeName = dTypeName.split('.')[1];
 
-    let val = expr;
-    if (!expr) {
-      message(warning, context, 'empty expression value');
-    }
-    else {
+    if(value) {
       // replace all occurrences of '.' by '/' up to first '@'
-      val = expr.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 : val
+      value
     }
   }
 
@@ -1016,119 +1096,147 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   //      floating point type except Edm.Decimal -> Float
   //      Edm.Decimal -> Decimal
   //      integer tpye -> Int
-  function handleSimpleValue(val, dTypeName, context) {
+  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
-    dTypeName = resolveType(dTypeName);
 
-    if (isEnumType(dTypeName)) {
-      const type = getDictType(dTypeName);
-      const expected = type.Members.map(m => `"#${m}"`).join(', ');
-      message(warning, context, `found non-enum value "${val}", expected ${expected} for ${dTypeName}`);
+    // check if type has allowed values
+    const typeDef = getDictType(dTypeName);
+    const Allowed = typeDef?.$Allowed;
+
+    let resolvedType = resolveTypeDefinition(dTypeName);
+
+    if (isEnumType(resolvedType)) {
+      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' });
     }
 
     let typeName = 'String';
-
-    if (typeof val === 'string') {
-      if (dTypeName === 'Edm.Boolean') {
+    if(Allowed && !Allowed.Values[value])
+      message('odata-anno-value', msg.location,
+        { anno: msg.anno(),
+          value,
+          rawvalues: Object.keys(Allowed.Values),
+          type: resolvedType,
+          '#': 'enum' });
+
+    if (typeof value === 'string') {
+      if (resolvedType === 'Edm.Boolean') {
         typeName = 'Bool';
-        if (val !== 'true' && val !== 'false') {
-          message(warning, context, `found String, but expected type ${ dTypeName }`);
+        if (value !== 'true' && value !== 'false') {
+          message('odata-anno-value', msg.location,
+          { anno: msg.anno(), value, type: resolvedType });
         }
       }
-      else if (dTypeName === 'Edm.Decimal') {
+      else if (resolvedType === 'Edm.Decimal') {
         typeName = 'Decimal';
-        if (isNaN(Number(val)) || isNaN(parseFloat(val))) {
-          message(warning, context, `found non-numeric string, but expected type ${ dTypeName }`);
+        if (isNaN(Number(value)) || isNaN(parseFloat(value))) {
+          message('odata-anno-value', msg.location,
+          { anno: msg.anno(), value, type: resolvedType });
         }
       }
-      else if (dTypeName === 'Edm.Double' || dTypeName === 'Edm.Single') {
+      else if (resolvedType === 'Edm.Double' || resolvedType === 'Edm.Single') {
         typeName = 'Float';
-        if (isNaN(Number(val)) || isNaN(parseFloat(val))) {
-          message(warning, context, `found non-numeric string, but expected type ${ dTypeName }`);
+        if (isNaN(Number(value)) || isNaN(parseFloat(value))) {
+          message('odata-anno-value', msg.location,
+          { anno: msg.anno(), value, type: resolvedType });
         }
       }
-      else if (isComplexType(dTypeName)) {
-        message(warning, context, `found String, but expected complex type ${ dTypeName }`);
+      else if (isComplexType(resolvedType)) {
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), value, type: resolvedType });
       }
-      else if (isEnumType(dTypeName)) {
-        message(warning, context, `found String, but expected enum type ${ dTypeName }`);
+      else if (isEnumType(resolvedType)) {
+        message('odata-anno-value', msg.location,
+          { anno: msg.anno(), value, type: resolvedType });
         typeName = 'EnumMember';
       }
-      else if (dTypeName && dTypeName.startsWith('Edm.') && !castToXmlString.includes(dTypeName)) {
+      else if (resolvedType && resolvedType.startsWith('Edm.') && !castToXmlString.includes(resolvedType)) {
         // this covers also all paths
-        typeName = dTypeName.substring(4);
+        typeName = resolvedType.substring(4);
       }
       else {
-        if(dTypeName == undefined || castToXmlString.some(t => t === dTypeName))
-          dTypeName = 'Edm.String';
+        if(resolvedType == undefined || castToXmlString.some(t => t === resolvedType))
+          resolvedType = 'Edm.String';
         // TODO
-        //message(warning, context, "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 val === 'boolean') {
-      if(dTypeName == undefined || dTypeName === 'Edm.Boolean' || dTypeName === 'Edm.PrimitiveType') {
+    else if (typeof value === 'boolean') {
+      if(resolvedType == undefined || resolvedType === 'Edm.Boolean' || resolvedType === 'Edm.PrimitiveType') {
         typeName = 'Bool';
-        dTypeName = 'Edm.Boolean';
+        resolvedType = 'Edm.Boolean';
       }
-      if (dTypeName === 'Edm.Boolean') {
-        val = val ? 'true' : 'false';
+      if (resolvedType === 'Edm.Boolean') {
+        value = value ? 'true' : 'false';
       }
-      else if (dTypeName === 'Edm.String') {
+      else if (resolvedType === 'Edm.String') {
         typeName = 'String';
       }
       else {
-        message(warning, context, `found Boolean, but expected type ${ dTypeName }`);
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), value, type: resolvedType });
       }
     }
-    else if (typeof val === 'number') {
-      if (isComplexType(dTypeName)) {
-        message(warning, context, `found number, but expected complex type ${ dTypeName }`);
+    else if (typeof value === 'number') {
+      if (isComplexType(resolvedType)) {
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), value, type: resolvedType });
       }
-      else if (dTypeName === 'Edm.String') {
+      else if (resolvedType === 'Edm.String') {
         typeName = 'String';
       }
-      else if (dTypeName === 'Edm.PropertyPath') {
-        message(warning, context, `found number, but expected type ${ dTypeName }`);
+      else if (resolvedType === 'Edm.PropertyPath') {
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), value, type: resolvedType });
       }
-      else if (dTypeName === 'Edm.Boolean') {
-        message(warning, context, `found number, but expected type ${ dTypeName }`);
+      else if (resolvedType === 'Edm.Boolean') {
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), value, type: resolvedType });
       }
-      else if (dTypeName === 'Edm.Decimal') {
+      else if (resolvedType === 'Edm.Decimal') {
         typeName = 'Decimal';
       }
-      else if (dTypeName === 'Edm.Double') {
+      else if (resolvedType === 'Edm.Double') {
         typeName = 'Float';
       }
       else {
         //typeName = Number.isInteger(val) ? 'Int' : 'Float';
-        if(Number.isInteger(val)) {
+        if(Number.isInteger(value)) {
           typeName = 'Int';
-          if(dTypeName == undefined || dTypeName === 'Edm.PrimitiveType' || !dTypeName.startsWith('Edm.'))
-            dTypeName = 'Edm.Int64';
+          if(resolvedType == undefined || resolvedType === 'Edm.PrimitiveType' || !resolvedType.startsWith('Edm.'))
+            resolvedType = 'Edm.Int64';
         }
         else {
           typeName = 'Float';
-          if(dTypeName == undefined || dTypeName === 'Edm.PrimitiveType'|| !dTypeName.startsWith('Edm.'))
-            dTypeName = 'Edm.Double';
+          if(resolvedType == undefined || resolvedType === 'Edm.PrimitiveType'|| !resolvedType.startsWith('Edm.'))
+            resolvedType = 'Edm.Double';
         }
       }
     }
-    else if (val === null && dTypeName == null && typeName === 'String') {
-      dTypeName = 'Edm.String';
-    }
-    else {
-      message(warning, context, `expected simple value, but found value '${ val }' with type '${ typeof val }'`);
-    }
+    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 });
+      }
 
-    if( ['Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(dTypeName) )
-      dTypeName = dTypeName.split('.')[1];
+    if( ['Edm.AnnotationPath', 'Edm.ModelElementPath', 'Edm.NavigationPropertyPath', 'Edm.PropertyPath', 'Edm.Path' ].includes(resolvedType) )
+      resolvedType = resolvedType.split('.')[1];
 
     return {
       name : typeName,
-      jsonName: dTypeName,
-      value : val
+      jsonName: resolvedType,
+      value : value
     };
   }
 
@@ -1137,16 +1245,18 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // 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, context) {
+  function generateRecord(obj, termName, dTypeName, msg) {
     /** @type {object} */
-    let newRecord = new Edm.Record(v);
+    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))
-        message(warning, context, `internal error: dictionary inconsistency: type '${ dTypeName }' not found`);
+        message('odata-anno-dict', msg.location,
+        { anno: msg.anno(), type: dTypeName, '#': 'std' });
       else
-        message(warning, context, `found complex type, but expected type '${ dTypeName }'`);
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), str: 'structured', type: dTypeName, '#': 'struct' });
       return newRecord;
     }
 
@@ -1155,26 +1265,32 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       actualTypeName = obj['$Type'];
       if (!getDictType(actualTypeName)) {
         // this type doesn't exist
-        message(warning, context, `explicitly specified type '${ actualTypeName }' not found in vocabulary`);
-        // explicitly mentioned type, render in XML and JSON
-        newRecord.setEdmAttribute('Type', actualTypeName);
-      }
-      else if (dTypeName && !isDerivedFrom(actualTypeName, dTypeName)) {
-        // this type doesn't fit the expected one
-        message(warning, context, `explicitly specified type '${ actualTypeName
-        }' is not derived from expected type '${ dTypeName }'`);
-        actualTypeName = dTypeName;
+        message('odata-anno-type', msg.location,
+        { anno: msg.anno(), type: actualTypeName, '#': 'unknown' });
         // explicitly mentioned type, render in XML and JSON
         newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else if (isAbstractType(actualTypeName)) {
         // this type is abstract
-        message(warning, context, `explicitly specified type '${ actualTypeName }' is abstract, specify a concrete type`);
+        message('odata-anno-type', msg.location,
+        { anno: msg.anno(), type: actualTypeName, '#': 'abstract' });
         if(dTypeName)
           actualTypeName = dTypeName;
         // set to definition name and render in XML and JSON
         newRecord.setEdmAttribute('Type', actualTypeName);
       }
+      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' });
+        actualTypeName = dTypeName;
+        // explicitly mentioned type, render in XML and JSON
+        newRecord.setEdmAttribute('Type', actualTypeName);
+      }
       else {
         // ok
         // Dictionary Type, render in XML only for backward compatibility
@@ -1191,7 +1307,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         actualTypeName = dTypeName;
       }
       if (isAbstractType(actualTypeName))
-        message(warning, context, `type '${ dTypeName }' is abstract, use '$Type' to specify a concrete type`);
+        message('odata-anno-type', msg.location,
+        { anno: msg.anno(), type: dTypeName, '#': 'abstract' });
 
       // Dictionary Type, render in XML only for backward compatibility
       newRecord.setXml( { Type: actualTypeName });
@@ -1201,37 +1318,38 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     }
 
     // now the type is clear, so look ath the value
-    let dictProperties = getAllProperties(actualTypeName);
+    const dictProperties = getAllProperties(actualTypeName);
 
     // loop over elements
-    for (let i of Object.keys(obj)) {
-      context.stack.push('.' + i);
+    for (const name of Object.keys(obj)) {
+      msg.stack.push('.' + name);
 
-      if (i === '$Type') {
+      if (name === '$Type') {
         // ignore, this is an "artificial" property used to indicate the type
       }
-      else if (i.charAt(0) === '@') {
+      else if (name[0] === '@') {
         // not a regular property, but a nested annotation
-        let newAnno = handleTerm(i.substring(1, i.length), obj[i], context);
+        const newAnno = handleTerm(name.substring(1, name.length), obj[name], msg);
         newRecord.append(newAnno);
       }
       else {
         // regular property
         let dictPropertyTypeName = null;
         if (dictProperties) {
-          dictPropertyTypeName = dictProperties[i];
-          if (!dictPropertyTypeName && !getDictType(actualTypeName).OpenType){
-            message(warning, context, `record type '${ actualTypeName }' doesn't have a property '${ i }'`);
+          dictPropertyTypeName = dictProperties[name];
+          if (!dictPropertyTypeName && !getDictType(actualTypeName).OpenType) {
+            message('odata-anno-type', msg.location,
+            { name, anno: termName, type: dTypeName });
           }
         }
 
-        let newPropertyValue = new Edm.PropertyValue(v, i);
+        let newPropertyValue = new Edm.PropertyValue(v, name);
         // property value can be anything, so delegate handling to handleValue
-        handleValue(obj[i], newPropertyValue, termName, dictPropertyTypeName, context);
+        handleValue(obj[name], newPropertyValue, termName, dictPropertyTypeName, msg);
         newRecord.append(newPropertyValue);
       }
 
-      context.stack.pop();
+      msg.stack.pop();
     }
 
     return newRecord;
@@ -1240,56 +1358,59 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
 
   // annoValue is an array
   // dTypeName : Collection(...) according to dictionary
-  function generateCollection(annoValue, termName, dTypeName, context) {
-    let newCollection = new Edm.Collection(v);
+  function generateCollection(annoValue, termName, dTypeName, msg) {
+    const newCollection = new Edm.Collection(v);
 
     let innerTypeName = null;
     if (dTypeName) {
-      var match = dTypeName.match(/^Collection\((.+)\)/);
+      const match = dTypeName.match(/^Collection\((.+)\)/);
       if (match) {
         innerTypeName = match[1];
       }
       else {
-        message(warning, context, `found collection value, but expected non-collection type ${ dTypeName }`);
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), str: 'collection', type: dTypeName, '#': 'struct' });
       }
     }
 
     let index = 0;
     for (const value of annoValue) {
-      context.stack.push('[' + 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(warning, context, 'nested collections are not supported');
+        message('odata-anno-value', msg.location,
+        { anno: msg.anno(), '#': 'nestedcollection' });
       }
       else if (value && typeof value === 'object') {
         if (value['=']) {
-          let res = handleExpression(value['='], innerTypeName, context);
-          let newPropertyPath = new Edm.ValueThing(v, res.name, res.value );
+          const res = handleExpression(value['='], innerTypeName);
+          const newPropertyPath = new Edm.ValueThing(v, res.name, res.value );
           newPropertyPath.setJSON( { [res.name] : res.value } );
           newCollection.append(newPropertyPath);
         }
         else if (value['#']) {
-          message(warning, context, 'enum inside collection is not yet supported');
+          message('odata-anno-value', msg.location,
+          { anno: msg.anno(), '#': 'enumincollection' });
         }
         else if(value['$edmJson']) {
-          newCollection.append(handleEdmJson(value['$edmJson'], context));
+          newCollection.append(handleEdmJson(value['$edmJson'], msg));
         }
         else {
-          newCollection.append(generateRecord(value, termName, innerTypeName, context));
+          newCollection.append(generateRecord(value, termName, innerTypeName, msg));
         }
       }
       else {
-        let res = handleSimpleValue(value, innerTypeName, context);
-        let newThing = (value === null) ?new Edm.ValueThing(v, 'Null') : new Edm.ValueThing(v, res.name, value );
+        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 });
         newCollection.append(newThing);
       }
 
-      context.stack.pop();
+      msg.stack.pop();
     }
 
     return newCollection;
@@ -1303,7 +1424,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   // See example in test/odataAnnotations/smallTests/edmJson_noReverse_ok
   // and test3/ODataBackends/DynExpr
 
-  function handleEdmJson(obj, context, exprDef=undefined) {
+  function handleEdmJson(obj, msg, exprDef=undefined) {
 
     let edmNode = undefined;
     if(obj === undefined || obj === null)
@@ -1312,7 +1433,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     const dynExprs = edmUtils.intersect(dynamicExpressionNames, Object.keys(obj));
 
     if(dynExprs.length > 1) {
-      message(warning, context, `EDM JSON code contains more than one dynamic expression: ${ dynExprs }`);
+      message('odata-anno-value', msg.location,
+      { anno: msg.anno(), rawvalues: dynExprs, '#': 'multexpr' });
       return edmNode;
     }
 
@@ -1328,7 +1450,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         if(Array.isArray(obj)) {
           // EDM JSON doesn't mention annotations on collections
           edmNode = new Edm.Collection(v);
-          obj.forEach(o => edmNode.append(handleEdmJson(o, context)));
+          obj.forEach(o => edmNode.append(handleEdmJson(o, msg)));
         }
         else if(typeof obj === 'object') {
           edmNode = new Edm.Record(v);
@@ -1342,11 +1464,11 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
               let child = undefined;
               const [ head, tail ] = k.split('@');
               if(tail) {
-                child = handleTerm(tail, val, context);
+                child = handleTerm(tail, val, msg);
               }
               else {
                 child = new Edm.PropertyValue(v, head);
-                child.append(handleEdmJson(val, context));
+                child.append(handleEdmJson(val, msg));
               }
               if(child) {
                 if(tail && head.length) {
@@ -1385,7 +1507,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       forEach(obj, (name, val) => {
         if(exprDef) {
           if(exprDef.anno && name[0] === '@') {
-            edmNode.append(handleTerm(name.slice(1), val, context));
+            edmNode.append(handleTerm(name.slice(1), val, msg));
           }
           else if (exprDef.attr && exprDef.attr.includes(name)) {
             if (name[0] === '$') {
@@ -1400,11 +1522,11 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           else if(exprDef.children) {
             if (Array.isArray(val)) {
               val.forEach(a => {
-                edmNode.append(handleEdmJson(a, context, exprDef));
+                edmNode.append(handleEdmJson(a, msg, exprDef));
               });
             }
             else {
-              edmNode.append(handleEdmJson(val, context, exprDef));
+              edmNode.append(handleEdmJson(val, msg, exprDef));
             }
           }
         }
@@ -1432,6 +1554,130 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     }
   }
 
+  /*
+    translate vocabulary definitions into an adhoc dictionary
+    with the same structure as the gobal jsonDictionary that
+    contains all official term and type definitions.
+
+    Return the dictionary and an array of schemas to which
+    the vocabulary definitions belong
+  */
+  function createAdhocDictionary() {
+    const allKnownVocabularies = [];
+    const dict = { terms: {}, types: {}, xrefs: {} };
+
+    if(!isBetaEnabled(options, 'odataTerms'))
+      return [ dict, allKnownVocabularies ];
+
+    for(let termName in csnVocabularies) {
+      let dictDef = oDataDictionary.terms[termName];
+      if(dictDef) {
+        message('odata-anno-dict', ['vocabularies', termName],
+        { anno: termName, '#': 'redefinition' } );
+      }
+      else if(!dictDef) {
+        const annoDef = csnVocabularies[termName];
+        if(annoDef?.$mySchemaName) {
+          if(!allKnownVocabularies.includes[annoDef.$mySchemaName])
+            allKnownVocabularies.push(annoDef.$mySchemaName);
+          const myServiceRoot = options.whatsMyServiceRootName(annoDef.$mySchemaName);
+          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;
+          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;
+          val = annoDef['@odata.term.Deprecated'];
+          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$$$$';
+            dict.types[tName] = enumType;
+            dictDef.Type = tName;
+          }
+          else
+              addTypesToDictionary(annoDef);
+        }
+      }
+    }
+    return [ dict, allKnownVocabularies ];
+
+    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) {
+        let dictDef = { };
+        const elements = typeDef.items?.elements || typeDef.elements;
+        if(elements) {
+            // complex type
+          dictDef['$kind'] = 'ComplexType';
+          dictDef.Properties = new Object(null);
+
+          for(let en in elements) {
+            const elt = elements[en];
+            if(isEdmPropertyRendered(elt, options)) {
+              const edmType = new Edm.TypeBase(options.v, {}, elt);
+              dictDef.Properties[en] = edmType._edmAttributes[edmType._typeName];
+              addTypesToDictionary(elt);
+            }
+          }
+        }
+        else {
+          // type definition
+          const edmType = new Edm.TypeBase(options.v, {}, typeDef);
+          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) {
+      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)
+        message('odata-anno-dict-enum', [ 'vocabularies', node.name ],
+          { 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)) {
+        message('odata-anno-dict-enum', path,
+        { name: node.name, type: baseType, '#': 'value' });
+      }
+      else {
+        for(const symbol in enumDic) {
+          const valDic = { '#SymbolicName': symbol };
+          const enumDef = enumDic[symbol];
+          // <Null/> values can't be rendered
+          if(enumDef.val === undefined)
+            valDic.Value = symbol;
+          else if(valDic.val !== null)
+            valDic.Value = enumDef.val;
+          dictTypeDef.$Allowed.Symbols[symbol] = dictTypeDef.$Allowed.Values[symbol] = valDic;
+        }
+      }
+      return dictTypeDef;
+    }
+  }
+
   function initEdmJson() {
     // Static dynamic expression dictionary, loaded with Edm creators
     const dynamicExpressions = {
@@ -1495,25 +1741,25 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   //-------------------------------------------------------------------------------------------------
   //-------------------------------------------------------------------------------------------------
 
-  // filter function, assumed to be used for array of string
-  //   accepts those strings that start with a known vocabulary name
-  function filterKnownVocabularies(name) {
-    var match = name.match(/^(@)(\w+)/);
-    if (match == null) return false;
-    return knownVocabularies.includes(match[2]);  // second match group
-  }
-
-  // resolve "derived types"
+    // resolve "derived types"
   // -> if dTypeName is a TypeDefinition, replace by
   //    underlying type
-  function resolveType(dTypeName) {
-    let type = getDictType(dTypeName);
+  function resolveTypeDefinition(dTypeName) {
+    const type = getDictType(dTypeName);
     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];
+    }
+    return typeName;
+  }
+
   function isPrimitiveType(typeName) {
     return typeName.split('.')[0] === 'Edm';
   }
@@ -1523,17 +1769,17 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   }
 
   function isEnumType(dTypeName) {
-    let type = getDictType(dTypeName);
+    const type = getDictType(dTypeName);
     return type && type['$kind'] === 'EnumType';
   }
 
   function isComplexType(dTypeName) {
-    let type = getDictType(dTypeName);
+    const type = getDictType(dTypeName);
     return dTypeName === 'Edm.ComplexType' || type && type['$kind'] === 'ComplexType';
   }
 
   function isAbstractType(dTypeName) {
-    let type = getDictType(dTypeName);
+    const type = getDictType(dTypeName);
     return type && type['Abstract'] === 'true';
   }