@sap/cds-compiler 2.13.8 → 3.0.0

package/lib/compiler/shared.js

@@ -11,6 +11,7 @@ const {
   setArtifactLink,
   dependsOn,
   pathName,
+  annotationHasEllipsis,
 } = require('./utils');
 
 function artifactsEnv( art ) {
@@ -157,8 +158,8 @@ function fns( model ) {
   const VolatileFns = model.$volatileFunctions;
   Object.assign( model.$functions, {
     resolveUncheckedPath,
+    resolveTypeArgumentsUnchecked,
     resolvePath,
-    resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
   } );
@@ -459,35 +460,64 @@ function fns( model ) {
     }
   }
 
-  // Resolve the type arguments provided with a type referenced for artifact or
-  // element `artifact`.  This function does nothing if the referred type
-  // `typeArtifact` does not have a `parameters` property (currently, only
-  // builtin-types have it, see ./builtins.js).
-  //
-  // For each property name `<prop>` in `typeArtifact.parameters`, we move a number
-  // in art.$typeArgs (a vector of numbers with locations) to `artifact.<prop>`.
-  // TODO: error if no parameters applicable
-  // TODO: also check for number
-  function resolveTypeArguments(artifact, typeArtifact, user) {
-    const args = artifact.$typeArgs || [];
+  /**
+   * Resolve the type arguments of `artifact` according to the type `typeArtifact`.
+   * User is used for semantic message location.
+   *
+   * For builtins, for each property name `<prop>` in `typeArtifact.parameters`, we move a value
+   * in art.$typeArgs (a vector of numbers with locations) to `artifact.<prop>`.
+   *
+   * For non-builtins, we take either one or two arguments and interpret them
+   * as `length` or `precision`/`scale`.
+   *
+   * Left-over arguments are errors for non-builtins and warnings for builtins.
+   *
+   * @param {object}  artifact
+   * @param {object} typeArtifact
+   * @param {CSN.Artifact} user
+   */
+  function resolveTypeArgumentsUnchecked(artifact, typeArtifact, user) {
+    let args = artifact.$typeArgs || [];
     const parameters = typeArtifact.parameters || [];
-    const parLength = parameters.length;
 
-    for (let i = 0; i < parLength; ++i) {
-      let par = parameters[i];
-      if (!(par instanceof Object))
-        par = { name: par };
-      if (!artifact[par.name] && i < args.length)
-        artifact[par.name] = args[i];
+    if (parameters.length > 0) {
+      // For Builtins
+      for (let i = 0; i < parameters.length; ++i) {
+        let par = parameters[i];
+        if (!(par instanceof Object))
+          par = { name: par };
+        if (!artifact[par.name] && i < args.length)
+          artifact[par.name] = args[i];
+      }
+      args = args.slice(parameters.length);
     }
-    if (args.length > parLength) {
-      artifact.$typeArgs = artifact.$typeArgs.slice(parLength);
-      warning( 'unexpected-type-arg', [ artifact.$typeArgs[0].location, user ],
-               { art: typeArtifact }, 'Too many arguments for type $(ART)' );
+    else if (args.length > 0 && !typeArtifact.builtin) {
+      // One or two arguments are interpreted as either length or precision/scale.
+      // For builtins, we know what arguments are expected, and we do not need this mapping.
+      // Also, we expect non-structured types.
+      if (args.length === 1) {
+        artifact.length = args[0];
+        args = args.slice(1);
+      }
+      else if (args.length === 2) {
+        artifact.precision = args[0];
+        artifact.scale = args[1];
+        args = args.slice(2);
+      }
     }
-    else if (artifact.$typeArgs) {
-      delete artifact.$typeArgs;
+
+    if (!artifact.$typeArgs)
+      return;
+
+    // Warn about left-over arguments.
+    if (args.length > 0) {
+      const loc = [ args[args.length - 1].location, user ];
+      if (typeArtifact.builtin)
+        message( 'type-ignoring-argument', loc, { art: typeArtifact } );
+      else
+        error( 'type-unexpected-argument', loc, { '#': 'std', art: typeArtifact });
     }
+    artifact.$typeArgs = undefined;
   }
 
   // Return artifact or element referred by name `head`.  The first environment
@@ -644,6 +674,9 @@ function fns( model ) {
         art = item._artifact;
         if (Array.isArray(art))
           return false;
+        if (art.$requireElementAccess && path.length === 1)
+          // Path with only one item, but we expect an element, e.g. `$at.from`.
+          signalMissingElementAccess(art, [ item.location, user ]);
         continue;
       }
 
@@ -732,7 +765,7 @@ function fns( model ) {
         signalNotFound( spec.undefinedDef || 'ref-undefined-def', [ item.location, user ],
                         [ env ], { art: a } );
       }
-      else if (art.name.select && art.name.select > 1) {
+      else if (art.name && art.name.select && art.name.select > 1) {
         // TODO: 'The current query has no element $(MEMBER)' with $self.MEMBER
         // and 'The sub query for alias $(ALIAS) has no element $(MEMBER)'
         // TODO: probably not extra messageId, but text variant
@@ -748,8 +781,13 @@ function fns( model ) {
                         { param: 'Entity $(ART) has no parameter $(MEMBER)' } );
       }
       else {
+        const variant = art.kind === 'aspect' && !art.name && 'aspect';
         signalNotFound( spec.undefinedDef || 'ref-undefined-element', [ item.location, user ],
-                        [ env ], { art: searchName( art, item.id, 'element' ) } );
+                        [ env ], {
+                          '#': variant,
+                          art: (variant ? '' : searchName( art, item.id, 'element' )),
+                          id: item.id,
+                        } );
       }
       return null;
     }
@@ -774,11 +812,30 @@ function fns( model ) {
       attachAndEmitValidNames(err, ...valid.reverse());
   }
 
+  /**
+   * Emit a 'ref-expected-element' error for magic variable references
+   * that require element accesses but don't do.
+   * For example: `$at`, but `$at.from` or `$at.to` is required.
+   *
+   * @param {object} art
+   * @param {any} location
+   */
+  function signalMissingElementAccess(art, location) {
+    const err = message( 'ref-expected-element', location,
+                         { '#': 'magicVar', id: art.name.id } );
+    // Mapping for better valid names: from -> $at.from
+    const valid = Object.keys(art.elements || {}).reduce((prev, curr) => {
+      prev[`${ art.name.id }.${ curr }`] = true;
+      return prev;
+    }, Object.create(null));
+    attachAndEmitValidNames(err, valid);
+  }
+
   /**
    * Attaches a dictionary of valid names to the given compiler message.
    * In test mode, an info message is emitted with a list of valid names.
    *
-   * @param {CSN.Message} msg CDS Compiler message
+   * @param {CompileMessage} msg CDS Compiler message
    * @param  {...object} validDicts One ore more artifact dictionaries such as in `_block`.
    */
   function attachAndEmitValidNames(msg, ...validDicts) {
@@ -804,14 +861,10 @@ function fns( model ) {
     }
   }
 
-  // Resolve all annotation assignments for the node `art`.  Set `art.@` to all
-  // flattened assignments.  This function might issue error message for
-  // duplicate assignments.
-  // TODOs:
-  // * do something for extensions by CSN or Properties parsers
-  // * make sure that we do not issue repeated warnings due to flattening if an
-  //   annotation definition is missing
-  function defineAnnotations( construct, art, block, priority = 'define' ) {
+  // Set _block links for annotations (necessary for layering).
+  // Issue messages for annotations on namespaces and builtins (TODO: really here?)
+  // Also copy annotations from `construct` to `art` (TODO: separate that functionality).
+  function defineAnnotations( construct, art, block, priority = false ) {
     if (!options.parseCdl && construct.kind === 'annotate') {
       // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
       // they can still be applied. Namespace annotations are extracted in to-csn.js
@@ -829,76 +882,28 @@ function fns( model ) {
               'Builtin types should not be annotated. Use custom type instead' );
       }
     }
-    // TODO: block should be construct._block
-    if (construct.$annotations && construct.$annotations.doc )
-      art.doc = construct.$annotations.doc; // e.g. through `annotate` statement in CDL
-    else if (construct.doc)
+    if (construct.doc)
       art.doc = construct.doc; // e.g. through `extensions` array in CSN
-    if (!construct.$annotations) {
-      if (!block || block.$frontend !== 'json')
-        return;                 // namespace, or in CDL source without @annos:
-      // CSN input: set _block and $priority, shallow-copy from extension
-      for (const annoProp in construct) {
-        if (annoProp.charAt(0) === '@') {
-          let annos = construct[annoProp];
-          if (!(Array.isArray(annos)))
-            annos = [ annos ];
-          for (const a of annos) {
-            setLink( a, '_block', block );
-            a.$priority = priority;
-            if (construct !== art)
-              addAnnotation( art, annoProp, a );
-          }
-        }
-      }
-      return;
-    }
-    for (const anno of construct.$annotations) {
-      const ref = anno.name;
-      const name = resolveUncheckedPath( ref, 'annotation', { _block: block } );
-      const annoProp = (anno.name.variant)
-        ? `@${ name }#${ anno.name.variant.id }`
-        : `@${ name }`;
-      flatten( ref.path, annoProp, anno.value || {}, anno.name.variant, anno.name.location );
-    }
-    return;
-
-    function flatten( path, annoProp, value, iHaveVariant, location ) {
-      // Be robust if struct value has duplicate element names
-      if (Array.isArray(value)) // TODO: do that differently in CDL parser
-        return;                 // discard duplicates in flattened form
-
-      if (value.literal === 'struct') {
-        for (const item of value._struct || []) {
-          let prop = pathName(item.name.path);
-          if (item.name.variant) {
-            if (iHaveVariant) {
-              error( 'anno-duplicate-variant', [ item.name.variant.location, construct ],
-                     {},      // TODO: params
-                     'Annotation variant has been already provided' );
-            }
-            prop = `${ prop }#${ item.name.variant.id }`; // TODO: check for double variants
+    // set _block (for layering) and $priority, shallow-copy from extension
+    // TODO: think of removing $priority, then
+    // no _block: define, _block: annotate/extend/edmx
+    // would fit with extending defs with props like length
+    for (const annoProp in construct) {
+      if (annoProp.charAt(0) === '@') {
+        let annos = construct[annoProp];
+        if (!(Array.isArray(annos)))
+          annos = [ annos ];
+        for (const a of annos) {
+          setLink( a, '_block', block );
+          a.$priority = priority; // is now: undefined (auto-set) | false | 'annotate' | 'extend'
+          if (construct !== art)
+            addAnnotation( art, annoProp, a );
+          if (!priority && annotationHasEllipsis( a )) {
+            error( 'anno-unexpected-ellipsis',
+                   [ a.name.location, art ], { code: '...' } );
           }
-          flatten( [ ...path, ...item.name.path ], `${ annoProp }.${ prop }`, item, iHaveVariant || item.name.variant);
-        }
-        for (const prop in value.struct) {
-          const item = value.struct[prop];
-          flatten( [ ...path, item.name ], `${ annoProp }.${ prop }`, item, iHaveVariant );
         }
-        return;
       }
-      const anno = Object.assign( {}, value ); // shallow copy
-      anno.name = {
-        path,
-        location: location ||
-          value.name && value.name.location ||
-          value.path && value.path.location,
-      };
-      setLink( anno, '_block', block );
-      // TODO: _parent, _main is set later (if we have ElementRef), or do we
-      // set _artifact?
-      anno.$priority = priority;
-      addAnnotation( art, annoProp, anno );
     }
   }
 }

package/lib/compiler/tweak-assocs.js

@@ -39,7 +39,7 @@ function tweakAssocs( model ) {
   const { environment } = model.$volatileFunctions;
 
   // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
   // TODO: we should get rid of noElementsExpansion soon; both
   // beta.nestedProjections and beta.universalCsn do not work with it.
 
@@ -95,15 +95,14 @@ function tweakAssocs( model ) {
     if (!target || target._service) // assoc to other service is OK
       return;
     if (!elem.$inferred) {      // && !elem.target.$inferred
-      // TODO: spec meeting 2021-01-22: no warning
-      warning( 'assoc-target-not-in-service', [ elem.target.location, elem ],
-               { target, '#': (elem._main.query ? 'select' : 'define') }, {
-                 std: 'Target $(TARGET) of association is outside any service', // not used
-                 // eslint-disable-next-line max-len
-                 define: 'Target $(TARGET) of explicitly defined association is outside any service',
-                 // eslint-disable-next-line max-len
-                 select: 'Target $(TARGET) of explicitly selected association is outside any service',
-               } );
+      info( 'assoc-target-not-in-service', [ elem.target.location, elem ],
+            { target, '#': (elem._main.query ? 'select' : 'define') }, {
+              std: 'Target $(TARGET) of association is outside any service', // not used
+              // eslint-disable-next-line max-len
+              define: 'Target $(TARGET) of explicitly defined association is outside any service',
+              // eslint-disable-next-line max-len
+              select: 'Target $(TARGET) of explicitly selected association is outside any service',
+            } );
     }
     else {
       info( 'assoc-outside-service', [ elem.target.location, elem ],
@@ -459,7 +458,13 @@ function tweakAssocs( model ) {
           if (!forKeys)
             break;
           setArtifactLink( item, null );
-          error( 'rewrite-undefined-key', [ weakLocation( (elem.target || elem).location ), assoc ],
+          const culprit = elem.target && !elem.target.$inferred && elem.target ||
+                          (elem.value && elem.value.path &&
+                           elem.value.path[elem.value.path.length - 1]) ||
+                          elem;
+          // TODO: probably better to collect the non-projected foreign keys
+          // and have one message for all
+          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), assoc ],
                  { id: item.id, art: alias._main },
                  'Foreign key $(ID) has not been found in target $(ART)' );
           return null;

package/lib/compiler/utils.js

@@ -31,6 +31,10 @@ function annotationVal( anno ) {
 function annotationIsFalse( anno ) {                   // falsy, but not null (unset)
   return anno && (anno.val === false || anno.val === 0 || anno.val === '');
 }
+function annotationHasEllipsis( anno ) {
+  const { val } = anno || {};
+  return Array.isArray( val ) && val.some( v => v.literal === 'token' && v.val === '...' );
+}
 
 /**
  * Set compiler-calculated annotation value.
@@ -381,6 +385,7 @@ module.exports = {
   pushLink,
   annotationVal,
   annotationIsFalse,
+  annotationHasEllipsis,
   annotateWith,
   setLink,
   setArtifactLink,

package/lib/edm/annotations/genericTranslation.js

@@ -4,15 +4,16 @@ const edmUtils = require('../edmUtils.js');
 const preprocessAnnotations = require('./preprocessAnnotations.js');
 const oDataDictionary = require('../../gen/Dictionary.json');
 const { forEachDefinition } = require('../../model/csnUtils');
+const { forEach } = require("../../utils/objectUtils");
 
 
-/* Vocabulary overview as of January 2020:
-
+/*
    OASIS: https://github.com/oasis-tcs/odata-vocabularies/tree/master/vocabularies
    Aggregation (published)
    Authorization (published)
    Capabilities (published)
    Core (published)
+   JSON (published)
    Measures (published)
    Repeatability (published)
    Temporal (not published, not yet finalized)
@@ -23,8 +24,9 @@ const { forEachDefinition } = require('../../model/csnUtils');
    CodeList (published)
    Common (pubished)
    Communication (published)
+   DataIntegration (published)
    Graph (published, experimental)
-   Hierarchy (not published, still experimental)
+   Hierarchy (published, experimental)
    HTML5 (published, experimental)
    ODM (published, experimental)
    PersonalData (published)
@@ -73,16 +75,31 @@ const vocabularyDefinitions = {
     'inc': { Alias: 'Core', Namespace: 'Org.OData.Core.V1' },
     'int': { filename: 'Core.xml' }
   },
+  'DataIntegration': {
+    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/DataIntegration.xml' },
+    'inc': { Alias: 'DataIntegration', Namespace: 'com.sap.vocabularies.DataIntegration.v1' },
+    'int': { filename: 'DataIntegration.xml' }
+  },
   'Graph': {
     'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Graph.xml' },
     'inc': { Alias: 'Graph', Namespace: 'com.sap.vocabularies.Graph.v1' },
     'int': { filename: 'Graph.xml' }
   },
+  'Hierarchy': {
+    'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/Hierarchy.xml' },
+    'inc': { Alias: 'Hierarchy', Namespace: 'com.sap.vocabularies.Hierarchy.v1' },
+    'int': { filename: 'Hierarchy.xml' }
+  },
   'HTML5': {
     'ref': { Uri: 'https://sap.github.io/odata-vocabularies/vocabularies/HTML5.xml' },
     'inc': { Alias: 'HTML5', Namespace: 'com.sap.vocabularies.HTML5.v1' },
     'int': { filename: 'HTML5.xml' }
   },
+  'JSON': {
+    'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.JSON.V1.xml' },
+    'inc': { Alias: 'JSON', Namespace: 'Org.OData.JSON.V1' },
+    'int': { filename: 'JSON.xml' }
+  },
   'Measures': {
     'ref': { Uri: 'https://oasis-tcs.github.io/odata-vocabularies/vocabularies/Org.OData.Measures.V1.xml' },
     'inc': { Alias: 'Measures', Namespace: 'Org.OData.Measures.V1' },
@@ -316,7 +333,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   function handleNestedElements(objname, baseElemName, elementsObj) {
     if(!elementsObj) return;
     Object.entries(elementsObj).forEach(([elemName, element]) => {
-      if (Object.keys(element).filter( x => x.substr(0,1) === '@' ).filter(filterKnownVocabularies).length > 0) {
+      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}`);
       }
 
@@ -414,17 +431,23 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
     // do nothing
 
     if(!isEdmPropertyRendered(carrier, options) ||
-      (isV2() && (edmUtils.isDerivedType(carrier) || carrier['@Core.MediaType']))) {
+      (isV2() && (edmUtils.isDerivedType(carrier)))) {
       return;
     }
 
     // Filter unknown toplevel annotations
     // Final filtering of all annotations is done in handleTerm
-    const annoNames = Object.keys(carrier).filter( x => x.substr(0,1) === '@' );
+    
+    let annoNames = Object.keys(carrier).filter( x => x[0] === '@' );
     const nullWhitelist = [ '@Core.OperationAvailable' ];
-    const knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
+    let knownAnnos = annoNames.filter(filterKnownVocabularies).filter(x => carrier[x] !== null || nullWhitelist.includes(x));
     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));
+      if (knownAnnos.length === 0) return;
+    }
     const prefixTree = createPrefixTree();
 
     // usually, for a given carrier there is one target
@@ -593,6 +616,51 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       */
     }
 
+    function rewriteInnerAnnotations() {
+      let rc = false;
+      for (let a of knownAnnos) {
+        const [ prefix, innerAnnotation ] = a.split('.@');
+        /*
+          New inner annotation (de-)structuring of the core compiler to make
+          $value arrays extendable via ellipsis
+          @anno: { $value: [ ... ], @innerAnno: ... } is now cracked up by
+          the core compiler into:
+          @anno: [ ...]
+          @anno.@innerAnno: ...
+
+          Conflict handling if $value is present:
+          @anno
+          @anno.$value
+          @anno.@innerAnno
+
+          @anno has precedence (as it was before this change) but now
+          @anno.$value is overwritten with @anno and the inner annotations
+          are applied.
+
+          Trigger is always the inner annotation, if no inner annotation
+          is available, @anno has precedence.
+
+          Insert $value into $edmJson with inner annotation as well.
+        */
+        if(innerAnnotation) {
+          if(carrier[prefix]) {
+            const valPrefix = prefix + '.$value';
+            carrier[valPrefix] = carrier[prefix];
+            delete carrier[prefix];
+            rc = true;
+          }
+          const edmJsonPrefix = prefix + '.$edmJson';
+          if(carrier[edmJsonPrefix]) {
+            const valPrefix = prefix + '.$value.$edmJson';
+            carrier[valPrefix] = carrier[edmJsonPrefix];
+            delete carrier[edmJsonPrefix];
+            rc = true;
+          }
+        }
+      }
+      return rc;
+    }
+
     function createPrefixTree() {
       // in csn, all annotations are flattened
       // => values can be - primitive values (string, number)
@@ -602,6 +670,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       //   by building a "prefix tree" for the annotations attached to the carrier
       //   see example at definition of function mergePathStepsIntoPrefixTree
       const prefixTree = {};
+
       for (let a of knownAnnos) {
       // remove leading @ and split at "."
       //   stop splitting at ".@" (used for nested annotations)
@@ -663,7 +732,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           }
           mergePathStepsIntoPrefixTree(tree[name], pathSteps, index+1, carrier);
         }
-        else {
+        else if(typeof tree === 'object' ){
           tree[name] = carrier['@' + pathSteps.join('.')];
         }
       }
@@ -714,9 +783,10 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
      * @type {object}
      * */
     let newAnno = undefined;
-    const nullWhitelist = [ 'Core.OperationAvailable' ];
+    const omissions = { 'Aggregation.default':1 };
+    const nullList = { 'Core.OperationAvailable':1 };
     const voc = termName.slice(0, termName.indexOf('.'));
-    if(vocabularyDefinitions[voc] && annoValue !== null || nullWhitelist.includes(termName)) {
+    if(vocabularyDefinitions[voc] && annoValue !== null && !omissions[termName]|| nullList[termName]) {
       newAnno = new Edm.Annotation(v, termName);
 
     // termName may contain a qualifier: @UI.FieldGroup#shippingStatus
@@ -729,8 +799,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           message(error, context,
                 `OData annotation qualifier "${ p[1] }" must start with a letter or underscore, followed by at most 127 letters, underscores or digits`);
         }
-        newAnno.Term = termNameWithoutQualifiers;
-        newAnno.Qualifier = p[1];
+        newAnno.setEdmAttribute('Term', termNameWithoutQualifiers);
+        newAnno.setEdmAttribute('Qualifier', p[1]);
       }
       if (p.length>2) {
         message(warning, context, `multiple qualifiers (${ p[1] },${ p[2] }${ p.length > 3 ? ',...' : '' })`);
@@ -827,7 +897,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         // "pseudo-structure" used for embedding a piece of JSON that represents "OData CSDL, JSON Representation"
         oTarget.append(handleEdmJson(cAnnoValue['$edmJson'], context));
       }
-      else if ( Object.keys(cAnnoValue).filter( x => x.substr(0,1) !== '@' ).length === 0) {
+      else if ( Object.keys(cAnnoValue).filter( x => x[0] !== '@' ).length === 0) {
         // object consists only of properties starting with "@"
         message(warning, context, 'nested annotations without corresponding base annotation');
       }
@@ -934,6 +1004,8 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
   //      Edm.Decimal -> Decimal
   //      integer tpye -> Int
   function handleSimpleValue(val, dTypeName, context) {
+    // 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);
 
@@ -971,12 +1043,12 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         message(warning, context, `found String, but expected enum type ${ dTypeName }`);
         typeName = 'EnumMember';
       }
-      else if (dTypeName && dTypeName.startsWith('Edm.') && dTypeName !== 'Edm.PrimitiveType') {
+      else if (dTypeName && dTypeName.startsWith('Edm.') && !castToXmlString.includes(dTypeName)) {
         // this covers also all paths
         typeName = dTypeName.substring(4);
       }
       else {
-        if(dTypeName == undefined || dTypeName === 'Edm.PrimitiveType')
+        if(dTypeName == undefined || castToXmlString.some(t => t === dTypeName))
           dTypeName = 'Edm.String';
         // TODO
         //message(warning, context, "type is not yet handled: found String, expected type: " + dTypeName);
@@ -1072,7 +1144,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         // 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.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else if (dTypeName && !isDerivedFrom(actualTypeName, dTypeName)) {
         // this type doesn't fit the expected one
@@ -1080,7 +1152,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         }' is not derived from expected type '${ dTypeName }'`);
         actualTypeName = dTypeName;
         // explicitly mentioned type, render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else if (isAbstractType(actualTypeName)) {
         // this type is abstract
@@ -1088,7 +1160,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         if(dTypeName)
           actualTypeName = dTypeName;
         // set to definition name and render in XML and JSON
-        newRecord.Type = actualTypeName;
+        newRecord.setEdmAttribute('Type', actualTypeName);
       }
       else {
         // ok
@@ -1251,7 +1323,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
           const props = Object.create(null);
           Object.entries(obj).forEach(([k, val]) => {
             if(k === '@type') {
-              edmNode.Type = val;
+              edmNode.setEdmAttribute('Type', val);
             }
             else {
               let child = undefined;
@@ -1297,14 +1369,14 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
       edmNode = exprDef.create(obj);
 
       // iterate over each obj.property and translate expression into EDM
-      Object.entries(obj).forEach(([name, val]) => {
+      forEach(obj, (name, val) => {
         if(exprDef) {
           if(exprDef.anno && name[0] === '@') {
             edmNode.append(handleTerm(name.slice(1), val, context));
           }
           else if (exprDef.attr && exprDef.attr.includes(name)) {
             if (name[0] === '$') {
-              edmNode[name.slice(1)] = val;
+              edmNode.setEdmAttribute(name.slice(1), val);
             }
           }
           else if (exprDef.jsonAttr && exprDef.jsonAttr.includes(name)) {