@sap/cds-compiler 3.0.2 → 3.1.0

package/lib/compiler/populate.js

@@ -73,14 +73,8 @@ function populate( model ) {
   /** @type {any} may also be a boolean */
   let newAutoExposed = [];
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
   const scopedRedirections
-        = enableExpandElements &&
-          !isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ) &&
-          !isDeprecatedEnabled( options, '_shortAutoexposed' ) &&
+        = !isDeprecatedEnabled( options, '_shortAutoexposed' ) &&
           !isDeprecatedEnabled( options, '_longAutoexposed' ) &&
           !isDeprecatedEnabled( options, '_noInheritedAutoexposeViaComposition' ) &&
           !isDeprecatedEnabled( options, '_noScopedRedirections' );
@@ -109,6 +103,8 @@ function populate( model ) {
   function traverseElementEnvironments( art ) {
     populateView( art );
     environment( art );
+    if (art.elements$)
+      mergeSpecifiedElements(art);
     forEachMember( art, traverseElementEnvironments );
   }
 
@@ -165,7 +161,7 @@ function populate( model ) {
     // console.log(message( null, art.location, art, {}, 'Info','FT').toString())
     const chain = [];
     while (art && !('_effectiveType' in art) &&
-           (art.type || art._origin || art.value && art.value.path) &&
+           (art.type || art._origin || art.value?.path || art.value?.type) &&
            // TODO: really stop at art.enum? See #8942
            !art.target && !art.enum && !art.elements && !art.items) {
       chain.push( art );
@@ -195,7 +191,7 @@ function populate( model ) {
       let eType = art;
       if (eType._outer)
         eType = effectiveType( eType._outer );
-      // collect the "latest" cardinality (calculate lazyly if necessary)
+      // collect the "latest" cardinality (calculate lazily if necessary)
       let cardinality = art.cardinality ||
           art._effectiveType && (() => getCardinality( art._effectiveType ));
       let prev = art;
@@ -222,10 +218,12 @@ function populate( model ) {
       return art._origin;
     if (art.type)
       return resolveType( art.type, art );
+    if (art.value?.type)
+      return resolveType( art.value.type, art );
     // console.log( 'EXPR-IN', art.kind, refString(art.name) )
     if (!art._main || !art.value || !art.value.path)
       return undefined;
-    if (art._pathHead && art.value) {
+    if (art._pathHead && art.value.path) {
       setLink( art, '_origin', resolvePath( art.value, 'expr', art, null ) );
       return art._origin;
     }
@@ -295,7 +293,7 @@ function populate( model ) {
 
 
   function expandItems( art, origin, eType ) {
-    if (!enableExpandElements || art.items)
+    if (art.items)
       return false;
     if (isInParents( art, eType )) {
       art.items = 0;            // circular
@@ -312,8 +310,6 @@ function populate( model ) {
   }
 
   function expandElements( art, struct, eType ) {
-    if (!enableExpandElements)
-      return false;
     if (art.elements || art.kind === '$tableAlias' ||
         // no element expansions for "non-proper" types like
         // entities (as parameter types) etc:
@@ -347,7 +343,7 @@ function populate( model ) {
   }
 
   function expandEnum( art, origin ) {
-    if (!enableExpandElements || art.enum)
+    if (art.enum)
       return false;
     const ref = art.type || art.value || art.name;
     const location = weakLocation( ref && ref.location || art.location );
@@ -427,8 +423,6 @@ function populate( model ) {
         setLink( view, '_status', '_query' );
         // must be run in order “sub query in FROM first”:
         traverseQueryPost( view.query, null, populateQuery );
-        if (view.elements$)     // specified elements
-          mergeSpecifiedElements( view );
         if (!view.$entity) {
           model._entities.push( view );
           view.$entity = ++model.$entity;
@@ -437,14 +431,25 @@ function populate( model ) {
     }
   }
 
-  function mergeSpecifiedElements( view ) {
+  /**
+   * Merge _specified_ elements with _inferred_ elements in the given view/element,
+   * where specified elements can appear through CSN.
+   *
+   * We only copy annotations, since they are not part of `columns`,
+   * but only appear in `elements` in CSN.
+   *
+   * This is important to ensure re-compilability.
+   *
+   * @param art
+   */
+  function mergeSpecifiedElements( art ) {
     // Later we use specified elements as proxies to inferred of leading query
     // (No, we probably do not.)
-    for (const id in view.elements) {
-      const ielem = view.elements[id];  // inferred element
-      const selem = view.elements$[id]; // specified element
+    for (const id in art.elements) {
+      const ielem = art.elements[id];  // inferred element
+      const selem = art.elements$[id]; // specified element
       if (!selem) {
-        info( 'query-missing-element', [ ielem.name.location, view ], { id },
+        info( 'query-missing-element', [ ielem.name.location, art ], { id },
               'Element $(ID) is missing in specified elements' );
       }
       else {
@@ -454,10 +459,14 @@ function populate( model ) {
             ielem[prop] = selem[prop];
         }
         selem.$replacement = true;
+        if (selem.elements) {
+          setLink(ielem, 'elements$', selem.elements);
+          delete selem.elements;
+        }
       }
     }
-    for (const id in view.elements$) {
-      const selem = view.elements$[id]; // specified element
+    for (const id in art.elements$) {
+      const selem = art.elements$[id]; // specified element
       if (!selem.$replacement) {
         error( 'query-unspecified-element', [ selem.name.location, selem ], { id },
                'Element $(ID) does not result from the query' );
@@ -474,8 +483,6 @@ function populate( model ) {
     forEachGeneric( query, '$tableAliases', resolveTabRef );
 
     initFromColumns( query, query.columns );
-    // TODO: already in definer: complain about EXCLUDING with no wildcard
-    // (would have been automatically with a good CDL syntax: `* without (...)`)
     if (query.excludingDict) {
       for (const name in query.excludingDict)
         resolveExcluding( name, query._combined, query.excludingDict, query );
@@ -1039,8 +1046,6 @@ function populate( model ) {
   // which is not a context/service/namespace, or the definition itself.
   // If inside service, it is the direct child of the (most inner) service.
   function definitionScope( art ) {
-    if (art._base)              // with deprecated.generatedEntityNameWithUnderscore
-      return art._base;
     let base = art;
     while (art._parent) {
       if (art._parent.kind === 'service')
@@ -1112,10 +1117,8 @@ function populate( model ) {
       // the name for dependent entities have already been created using `_` then
       return `${ service.name.absolute }.${ name }`;
     }
-    if (isDeprecatedEnabled( options, '_longAutoexposed' )) {
-      const dedot = isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' );
-      return `${ service.name.absolute }.${ dedot ? absolute.replace( /\./g, '_' ) : absolute }`;
-    }
+    if (isDeprecatedEnabled( options, '_longAutoexposed' ))
+      return `${ service.name.absolute }.${ absolute }`;
     const base = definitionScope( target );
     if (base === target)
       return `${ service.name.absolute }.${ absolute.substring( absolute.lastIndexOf('.') + 1 ) }`;

package/lib/compiler/propagator.js

@@ -1,4 +1,10 @@
-//
+// Propagate properties in XSN
+
+// See also internalDoc/PropagatedCsn.md.
+// As opposed to that document, the propagator here works on XSN, not CSN.
+// We also do not deep-copy member dictionaries here, but create proxy members
+// which get their properties via propagation: we use function `onlyViaParent`
+// if that property would not be propagated otherwise.
 
 'use strict';
 
@@ -11,6 +17,7 @@ const {
 const { setLink, linkToOrigin, withAssociation } = require('./utils');
 // const { refString } = require( '../base/messages')
 
+// Note that propagation here is also used for deep-copying (function `onlyViaParent`)
 function propagate( model ) {
   const props = {
     '@com.sap.gtt.core.CoreModel.Indexable': never,
@@ -56,7 +63,6 @@ function propagate( model ) {
     returns,
   };
   const { options } = model;
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
   // eslint-disable-next-line max-len
   const oldVirtualNotNullPropagation = isDeprecatedEnabled( options, '_oldVirtualNotNullPropagation' );
 
@@ -189,7 +195,7 @@ function propagate( model ) {
     if (!type || type._main)
       return false;
     // We do not consider the $expand status, as elements are already expanded
-    // by the resolve(), and if not due to deprecated._noElementsExpansion
+    // by the resolve()
     run( type );
     return type[prop];
   }
@@ -313,11 +319,10 @@ function propagate( model ) {
 
   function items( prop, target, source ) {
     // usually considered expensive, except:
-    // - array of Entity (smooth upgrade: array of String(3), array of DerivedScalar)
+    // - array of Entity
     const line = availableAtType( prop, target, source );
     if (!line ||
-        line.type && line.type._artifact && line.type._artifact.kind === 'entity' ||
-        !line.elements && !line.enum && !line.items && !enableExpandElements)
+        line.type && line.type._artifact && line.type._artifact.kind === 'entity')
       returns( prop, target, source, true );
   }
 }

package/lib/compiler/resolve.js

@@ -87,6 +87,7 @@ function resolve( model ) {
   } = model.$messageFunctions;
   const {
     resolvePath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
     lateExtensions,
@@ -103,11 +104,6 @@ function resolve( model ) {
 
   /** @type {any} may also be a boolean */
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
-
   return doResolve();
 
   function doResolve() {
@@ -314,7 +310,7 @@ function resolve( model ) {
     if (obj.type)             // TODO: && !obj.type.$inferred ?
       resolveTypeExpr( obj, art );
     const type = effectiveType( obj ); // make sure implicitly redirected target exists
-    if (!obj.items && type && type.items && enableExpandElements) {
+    if (!obj.items && type && type.items) {
       // TODO: shouldn't be this part of populate.js ?
       const items = {
         location: weakLocation( (obj.type || obj).location ),
@@ -327,8 +323,7 @@ function resolve( model ) {
     }
     if (obj.items) {            // TODO: make this a while in v2 (also items proxy)
       obj = obj.items || obj; // the object which has type properties
-      if (enableExpandElements)
-        effectiveType(obj);
+      effectiveType(obj);
     }
     if (obj.type) {             // TODO: && !obj.type.$inferred ?
       if (obj !== (art.returns || art)) // not already checked
@@ -516,6 +511,8 @@ function resolve( model ) {
       setArtifactLink( ext.name, art );
 
       if (art) {
+        if (art.kind === 'annotate')
+          checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // eslint-disable-next-line no-shadow
         forEachMember( ext, ( elem, name, prop ) => {
@@ -538,7 +535,7 @@ function resolve( model ) {
         }
         else if (prop === 'actions') {
           if (!feature) {
-            warning( 'anno-unexpected-actions', [ ext.name.location, art ], {},
+            warning( 'anno-unexpected-actions', [ ext.name.location, art._parent || art ], {},
                      'Actions and functions only exist top-level and for entities' );
           }
           else {
@@ -569,7 +566,7 @@ function resolve( model ) {
       // Currently(?), effectiveType() does not calculate the effective type of
       // its line item:
       effectiveType( obj );
-      if (art._annotate.elements)
+      if (art._annotate.elements) // explicit $expand on aor needed
         setExpandStatusAnnotate( aor, 'annotate' );
       annotate( obj, 'element', 'elements', 'enum', art );
       annotate( art, 'action', 'actions' );
@@ -593,6 +590,8 @@ function resolve( model ) {
     // eslint-disable-next-line no-shadow
     function annotate( obj, kind, prop, altProp, parent = obj ) {
       const dict = art._annotate[prop];
+      if (dict && art._annotate[prop])
+        setExpandStatusAnnotate( art, 'annotate' );
       const env = obj[prop] || altProp && obj[altProp] || null;
       for (const n in dict)
         annotateMembers( env && env[n], dict[n], prop, n, parent, kind );
@@ -615,7 +614,7 @@ function resolve( model ) {
 
   function expandParameters( action ) {
     // see also expandElements()
-    if (!enableExpandElements || !effectiveType( action ))
+    if (!effectiveType( action ))
       return;
     const chain = [];
     // Should we be able to consider params and returns separately?
@@ -956,7 +955,7 @@ function resolve( model ) {
       resolveBy( query.$orderBy, 'order-by-union', query.elements, query._parent );
     if (query.orderBy) {       // ORDER BY
     // search in `query.elements` after having checked table aliases of the current query
-      resolveBy( query.orderBy, 'expr', query.elements );
+      resolveBy( query.orderBy, 'order-by', query.elements );
       // TODO: disallow resulting element ref if in expression!
       // Necessary to check it in the compiler as it might work with other semantics on DB!
       // (we could downgrade it to a warning if name is equal to unique source element name)
@@ -1264,7 +1263,7 @@ function resolve( model ) {
     const typeArt = resolveType( art.type, user );
     if (typeArt) {
       resolveTypeArgumentsUnchecked( art, typeArt, user );
-      checkTypeArguments( art );
+      checkTypeArguments( art, typeArt );
     }
   }
 
@@ -1272,13 +1271,13 @@ function resolve( model ) {
    * Check the type arguments on `artWithType`.
    * If the effective type is an array or structured type, an error is emitted.
    */
-  function checkTypeArguments( artWithType ) {
+  function checkTypeArguments( artWithType, typeArt ) {
     // Note: `_effectiveType` may point to `artWithType` itself, if the type is structured.
     //       Also: For enums, it points to the enum type, which is why this trick is needed.
     // TODO(#8942): May not be necessary if effectiveType() is adapted.  Furthermore, the enum
     //              trick may be removed if effectiveType() does not stop at enums.
     const cyclic = new Set();
-    let effectiveTypeArt = effectiveType( artWithType );
+    let effectiveTypeArt = effectiveType( typeArt );
     while (effectiveTypeArt && effectiveTypeArt.enum && !cyclic.has(effectiveTypeArt)) {
       cyclic.add(effectiveTypeArt);
       const underlyingEnumType = directType(effectiveTypeArt);

package/lib/compiler/shared.js

@@ -5,6 +5,7 @@
 
 const { searchName } = require('../base/messages');
 const { dictAddArray } = require('../base/dictionaries');
+const { isDeprecatedEnabled } = require('../base/model');
 
 const {
   setLink,
@@ -144,6 +145,13 @@ function fns( model ) {
     rewrite: {
       next: '_$next', dollar: true, escape: 'param', noDep: true, rewrite: true,
     }, // TODO: assertion that there is no next/escape used
+    'order-by': {
+      next: '_$next',
+      dollar: true,
+      escape: 'param',
+      assoc: 'nav',
+      deprecatedSourceRefs: true,
+    },
     'order-by-union': {
       next: '_$next', dollar: true, escape: 'param', noDep: true, noExt: true,
     },
@@ -160,6 +168,7 @@ function fns( model ) {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
     resolvePath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
   } );
@@ -602,6 +611,21 @@ function fns( model ) {
       else if (r) {
         return setArtifactLink( head, r );
       }
+      else if (spec.deprecatedSourceRefs && env._combined &&
+               isDeprecatedEnabled( options, 'autoCorrectOrderBySourceRefs' )) {
+        // User has provided a source element without table alias where a query
+        // element is expected.  Possible on many DBs (and compiler v1), in CAP
+        // only with table alias.  Auto-correct it if no duplicate.
+        // TODO: we could use that info also in messages when the deprecated flag is not set
+        const s = env._combined[head.id];
+        if (s && !Array.isArray(s)) {
+          path.$prefix = s.name.alias; // pushing it to path directly could be problematic
+          warning( null, [ head.location, user ],
+                   { id: head.id, newcode: `${ s.name.alias }.${ head.id }` },
+                   'Replace source element reference $(ID) by $(NEWCODE); auto-corrected' );
+          return setArtifactLink( head, s );
+        }
+      }
     }
     if (spec.noMessage || msgArt === true && extDict === model.definitions)
       return null;
@@ -861,35 +885,38 @@ function fns( model ) {
     }
   }
 
+  // Issue messages for annotations on namespaces and builtins
+  // (TODO: really here?, probably split main artifacts vs returns)
+  // see also lateExtensions() where similar messages are reported
+  function checkAnnotate( construct, art ) {
+    // 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
+    // In parseCdl mode USINGs and other unknown references are generated as
+    // namespaces which would lead to false positives.
+    // TODO: should this really be different to annotate-unknown?
+    if (art.kind === 'namespace') {
+      info( 'anno-namespace', [ construct.name.location, construct ], {},
+            'Namespaces can\'t be annotated' );
+    }
+    // Builtin annotations would also get lost. Same as for namespaces:
+    // extracted in to-csn.js
+    else if (art.builtin === true) {
+      info( 'anno-builtin', [ construct.name.location, construct ], {},
+            'Builtin types should not be annotated. Use custom type instead' );
+    }
+    else if (construct.$syntax === 'returns' && art._block && art.kind !== 'action' &&
+             art.kind !== 'function' ) {
+      // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
+      // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
+      // `art._block` ensures that `art` is a defined def.
+      warning('anno-unexpected-returns', [ construct.name.location, construct ],
+              { keyword: 'returns', kind: art.kind }, 'Unexpected $(KEYWORD) for $(KIND)');
+    }
+  }
+
   // 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
-      // In parseCdl mode USINGs and other unknown references are generated as
-      // namespaces which would lead to false positives.
-      // TODO: should this really be different to annotate-unknown?
-      if (art.kind === 'namespace') {
-        info( 'anno-namespace', [ construct.name.location, construct ], {},
-              'Namespaces can\'t be annotated' );
-      }
-      // Builtin annotations would also get lost. Same as for namespaces:
-      // extracted in to-csn.js
-      else if (art.builtin === true) {
-        info( 'anno-builtin', [ construct.name.location, construct ], {},
-              'Builtin types should not be annotated. Use custom type instead' );
-      }
-      else if (construct.$syntax === 'returns' && art._block && art.kind !== 'action' &&
-        art.kind !== 'function' ) {
-        // `annotate ABC with returns {}` is handled just like `elements`. Warn if it is used
-        // for non-actions.  We can't only check for !art.returns, because `action A();` is valid.
-        // `art._block` ensures that `art` is a defined def.
-        warning('anno-unexpected-returns', [ construct.name.location, construct ],
-                { keyword: 'returns', kind: art.kind }, 'Unexpected $(KEYWORD) for $(KIND)');
-      }
-    }
     if (construct.doc)
       art.doc = construct.doc; // e.g. through `extensions` array in CSN
 

package/lib/compiler/tweak-assocs.js

@@ -3,7 +3,6 @@
 'use strict';
 
 const {
-  isDeprecatedEnabled,
   forEachDefinition,
   forEachGeneric,
   forEachInOrder,
@@ -26,7 +25,6 @@ const $location = Symbol.for('cds.$location');
 
 // Export function of this file.
 function tweakAssocs( model ) {
-  const { options } = model;
   // Get shared functionality and the message function:
   const {
     info, warning, error,
@@ -38,11 +36,6 @@ function tweakAssocs( model ) {
   } = model.$functions;
   const { environment } = model.$volatileFunctions;
 
-  // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
-  // TODO: we should get rid of noElementsExpansion soon; both
-  // beta.nestedProjections and beta.universalCsn do not work with it.
-
   // Phase 5: rewrite associations
   forEachDefinition( model, rewriteSimple );
   // TODO: sequence not good enough with derived type of structure with
@@ -113,7 +106,7 @@ function tweakAssocs( model ) {
 
   function rewriteAssociationCheck( element ) {
     const elem = element.items || element; // TODO v2: nested items
-    if (elem.elements && enableExpandElements)
+    if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociationCheck );
     if (!elem.target)
       return;
@@ -207,7 +200,7 @@ function tweakAssocs( model ) {
 
   function rewriteAssociation( element ) {
     let elem = element.items || element; // TODO v2: nested items
-    if (elem.elements && enableExpandElements)
+    if (elem.elements)
       forEachGeneric( elem, 'elements', rewriteAssociation );
     if (!originTarget( elem ))
       return;
@@ -286,7 +279,7 @@ function tweakAssocs( model ) {
     // same (TODO later: set status whether rewrite changes anything),
     // especially problematic are refs starting with $self:
     setExpandStatus( elem, 'target' );
-    if (enableExpandElements && elem._parent && elem._parent.kind === 'element') {
+    if (elem._parent && elem._parent.kind === 'element') {
       // managed association as sub element not supported yet
       error( null, [ elem.location, elem ], {},
         // eslint-disable-next-line max-len
@@ -369,7 +362,8 @@ function tweakAssocs( model ) {
       const item = expr.path[root.kind === '$self' ? 1 : 0];
       if (!item)
         return;                                   // just $self
-      const elem = assoc._main.elements[item.id]; // corresponding elem in including structure
+      // corresponding elem in including structure
+      const elem = (assoc._main.items || assoc._main).elements[item.id];
       if (!(Array.isArray(elem) ||              // no msg for redefs
             elem === item._artifact ||          // redirection for explicit def
             elem._origin === item._artifact)) {

package/lib/compiler/utils.js

@@ -95,6 +95,14 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   return elem;
 }
 
+/**
+ * Set the member `elem` to have a _parent link to `parent` and a corresponding
+ * _main link.  Also set the member's name accordingly, where argument `name`
+ * is most often the property `elem.name.id`.
+ *
+ * If argument `prop` is provided, add `elem` to the dictionary of that name,
+ * e.g. `elements`.
+*/
 function setMemberParent( elem, name, parent, prop ) {
   if (prop) {              // extension or structure include
     // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
@@ -107,9 +115,10 @@ function setMemberParent( elem, name, parent, prop ) {
     parent = parent._outer;
   setLink( elem, '_parent', parent );
   setLink( elem, '_main', parent._main || parent );
-  const parentName = parent.name || parent._outer.name;
-  elem.name.absolute = parentName.absolute;
-  if (name == null)
+  const parentName = parent.name || parent._outer?.name;
+  if (parentName) // may not be available in e.g. cast() - TODO recheck (#9503)
+    elem.name.absolute = parentName.absolute;
+  if (!parentName || name == null)
     return;
   const normalized = kindProperties[elem.kind].normalized || elem.kind;
   [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
@@ -357,7 +366,7 @@ function traverseQueryExtra( main, callback ) {
 //             that value is only on elements, types, and params -> no other members
 //             when set, only on elem/art with expanded elements
 // - 'target': all expanded (sub) elements might only have new target/on, but
-//             no indivual annotations on any (sub) member
+//             no individual annotations on any (sub) member
 //             when set, traverse all parents where the value has been 'origin' before
 // - 'annotate': at least one inferred (sub) member has an individual annotation,
 //               not counting propagated ones; set up to the definition (main artifact)

package/lib/edm/annotations/preprocessAnnotations.js

@@ -58,7 +58,7 @@ function preprocessAnnotations(csn, serviceName, options) {
     let art = null;
 
     forEachDefinition(csn, (artifact, artifactName) => {
-      if(artifactName == serviceName || artifactName.startsWith(serviceName + '.')) {
+      if(artifactName === serviceName || artifactName.startsWith(serviceName + '.')) {
         art = artifactName;
         handleAnnotations(artifactName, artifact);
         artifact.elements && Object.entries(artifact.elements).forEach(([elementName, element]) => {
@@ -164,7 +164,7 @@ function preprocessAnnotations(csn, serviceName, options) {
             }
             else if (aNameWithoutQualifier === '@Common.ValueList.entity') {
               // if both annotations are present, ignore 'entity' and raise a message
-              if (annoNames.map(x=>x.split('#')[0]).find(x=>(x=='@Common.ValueList.viaAssociation'))) {
+              if (annoNames.map(x=>x.split('#')[0]).find(x=>(x==='@Common.ValueList.viaAssociation'))) {
                 warning(null, null, `in annotation preprocessing/@Common.ValueList: 'entity' is ignored, as 'viaAssociation' is present, ${ctx}`);
                 return false;
               }
@@ -296,8 +296,12 @@ function preprocessAnnotations(csn, serviceName, options) {
 
           //change the scalar anno into a "pseudo-structured" one
           // TODO should be flattened, but then alphabetical order is destroyed
-          let newTextAnno = { '$value': textAnno, '@UI.TextArrangement': value };
-          carrier['@Common.Text'] = newTextAnno;
+
+          // Do not overwrite existing nested annotation values, instead give existing
+          // nested annotation precedence and remove outer annotation (always)
+          if(!carrier['@Common.Text.@UI.TextArrangement'] && textAnno) {
+            carrier['@Common.Text'] = { '$value': textAnno, '@UI.TextArrangement': value };
+          }
           delete carrier[aName];
         }
       }

package/lib/edm/csn2edm.js

@@ -7,7 +7,7 @@ const NAVPROP_TRENNER = '_';
 const VALUELIST_NAVPROP_PREFIX = '';
 
 const edmUtils = require('./edmUtils.js')
-const { initializeModel, assignAnnotation } = require('./edmPreprocessor.js');
+const { initializeModel } = require('./edmPreprocessor.js');
 const translate = require('./annotations/genericTranslation.js');
 const { setProp } = require('../base/model');
 const { cloneCsnNonDict, isEdmPropertyRendered, isBuiltinType } = require('../model/csnUtils');
@@ -326,7 +326,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
 
       /* create the entitytypes and sets
         Do not create an entity set if:
-            V4 containment: _containerEntity is set and not equal with the artifact name
+            V4 containment: $containerNames is set and not equal with the artifact name
             Entity starts with 'localserviceNameized.' or ends with '_localized'
       */
       edmUtils.foreach(schemaCsn.definitions,
@@ -433,7 +433,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         // CDXCORE-CDXCORE-173
         if(options.isV2() && hasStream) {
           attributes['m:HasStream'] = true;
-          assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
+          edmUtils.assignAnnotation(entityCsn, '@Core.MediaType', hasStream);
         }
 
         Schema.append(new Edm.EntityType(v, attributes, properties, entityCsn));

package/lib/edm/edm.js

@@ -3,6 +3,7 @@
 const edmUtils = require('./edmUtils.js');
 const { isBuiltinType } = require('../model/csnUtils.js');
 const { forEach } = require("../utils/objectUtils");
+const { isBetaEnabled } = require('../base/model.js');
 
 // facet definitions, optional could either be true or array of edm types
 // remove indicates wether or not the canonic facet shall be removed when applying @odata.Type
@@ -754,7 +755,14 @@ function getEdm(options, messageFunctions) {
     }
   }
 
-  class ComplexType extends TypeBase { }
+  class ComplexType extends TypeBase { 
+    constructor(v, details, csn) {
+      super(v, details, csn);
+      if(this.v4 && !!csn['@open'] && isBetaEnabled(options, 'odataOpenType')) {
+        this._edmAttributes['OpenType'] = true;
+      }
+    }
+  }
   class EntityType extends ComplexType
   {
     constructor(v, details, properties, csn)