@sap/cds-compiler 2.10.4 → 2.11.0

package/lib/compiler/shared.js

@@ -1,86 +1,33 @@
 // Compiler functions and utilities shared across all phases
-
+// TODO: rename to paths.js and move non resolve-paths functions to somewhere else
 
 'use strict';
 
 const { searchName } = require('../base/messages');
-const { dictAdd, dictAddArray, pushToDict } = require('../base/dictionaries');
+const { dictAddArray } = require('../base/dictionaries');
 const { setProp } = require('../base/model');
 
-const dictKinds = {
-  definitions: 'absolute',
-  elements: 'element',
-  enum: 'enum',
-  foreignKeys: 'key',
-  actions: 'action',
-  params: 'param',
-};
-
-const kindProperties = {
-  // TODO: also foreignKeys ?
-  namespace: { artifacts: true }, // on-the-fly context
-  context: { artifacts: true, normalized: 'namespace' },
-  service: { artifacts: true, normalized: 'namespace' },
-  entity: { elements: true, actions: true, params: () => false },
-  select: { normalized: 'select', elements: true },
-  $join: { normalized: 'select' },
-  $tableAlias: { normalized: 'alias' }, // table alias in select
-  $self: { normalized: 'alias' }, // table alias in select
-  $navElement: { normalized: 'element' },
-  $inline: { normalized: 'element' }, // column with inline property
-  event: { elements: true },
-  type: { elements: propExists, enum: propExists },
-  aspect: { elements: propExists },
-  annotation: { elements: propExists, enum: propExists },
-  enum: { normalized: 'element' },
-  element: { elements: propExists, enum: propExists, dict: 'elements' },
-  mixin: { normalized: 'alias' },
-  action: {
-    params: () => false, elements: () => false, enum: () => false, dict: 'actions',
-  }, // no extend params, only annotate
-  function: {
-    params: () => false, elements: () => false, enum: () => false, normalized: 'action',
-  }, // no extend params, only annotate
-  key: { normalized: 'element' },
-  param: { elements: () => false, enum: () => false, dict: 'params' },
-  source: { artifacts: true },  // TODO -> $source
-  using: {},
-  extend: {
-    isExtension: true,
-    noDep: 'special',
-    elements: true, /* only for parse-cdl */
-    actions: true,  /* only for parse-cdl */
-  },
-  annotate: {
-    isExtension: true, noDep: 'special', elements: true, enum: true, actions: true, params: true,
-  },
-  builtin: {},                  // = CURRENT_DATE, TODO: improve
-  $parameters: {},              // $parameters in query entities
-};
-
-function propExists( prop, parent ) {
-  const obj = parent.returns || parent;
-  return (obj.items || obj.targetAspect || obj)[prop];
-}
+const { setLink, dependsOn } = require('./utils');
 
 function artifactsEnv( art ) {
   return art._subArtifacts || Object.create(null);
 }
 
 /**
- * Main export function of this file.  Return "resolve" functions shared for phase
- * "define" and "resolve".  Argument `model` is the augmented CSN.  Optional
- * argument `environment` is a function which returns the search environment
- * defined by its argument - it defaults to the dictionary of subartifacts of
- * the argument.
+ * Main export function of this file.  Attach "resolve" functions shared for phase
+ * "define" and "resolve" to `model.$functions`, where argument `model` is the XSN.
+ *
+ * Before calling these functions, make sure that the following function
+ * in model.$volatileFunctions is set:
+ * - `environment`: a function which returns the search environment defined by
+ *    its argument, e.g. a function which returns the dictionary of subartifacts.
  *
  * @param {XSN.Model} model
- * @param {(a, b?, c?) => any} environment
- * @returns {object} Commonly used "resolve" functions.
  */
-function fns( model, environment = artifactsEnv ) {
+// TODO: yes, this function will be renamed
+function fns( model ) {
   /** @type {CSN.Options} */
-  const options = model.options || {};
+  const { options } = model;
   const {
     info, warning, error, message,
   } = model.$messageFunctions;
@@ -204,13 +151,15 @@ function fns( model, environment = artifactsEnv ) {
     },
   };
 
-  return {
+  const VolatileFns = model.$volatileFunctions;
+  Object.assign( model.$functions, {
     resolveUncheckedPath,
     resolvePath,
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  };
+  } );
+  return;
 
   function checkConstRef( art ) {
     return ![ 'builtin', 'param' ].includes( art.kind );
@@ -257,7 +206,7 @@ function fns( model, environment = artifactsEnv ) {
     // TODO: better error location if error for main
     if (elem._main.kind !== 'entity' )
       return true;              // elem not starting at entity
-    environment( art );         // sets _effectiveType on art
+    VolatileFns.environment( art );         // sets _effectiveType on art
     return !(art._effectiveType || art).target;
   }
 
@@ -345,7 +294,7 @@ function fns( model, environment = artifactsEnv ) {
                   // first step: only use _combined of real query - TODO:
                   // reject if not visible, but not allow more (!)
                   (query._combined || query._parent._combined) ||
-                  environment( user._main ? user._parent : user );
+                  VolatileFns.environment( user._main ? user._parent : user );
       }
     }
 
@@ -439,7 +388,7 @@ function fns( model, environment = artifactsEnv ) {
       }
       else {
         dependsOn( user, art._main, location );
-        environment( art, location, user );
+        VolatileFns.environment( art, location, user );
       // Without on-demand resolve, we can simply signal 'undefined "x"'
       // instead of 'illegal cycle' in the following case:
       //    element elem: type of elem.x;
@@ -513,7 +462,7 @@ function fns( model, environment = artifactsEnv ) {
   function getPathRoot( path, spec, user, env, extDict, msgArt ) {
     if (!spec.envFn && user._pathHead) {
       // TODO: not necessarily for explicit ON condition in expand
-      environment( user._pathHead ); // make sure _origin is set
+      VolatileFns.environment( user._pathHead ); // make sure _origin is set
       return user._pathHead._origin;
     }
     const head = path[0];
@@ -570,8 +519,10 @@ function fns( model, environment = artifactsEnv ) {
     if (extDict && (!spec.dollar || head.id[0] !== '$')) {
       const r = extDict[head.id];
       if (Array.isArray(r)) {
-        if (r[0].kind === '$navElement') {
-          const names = r.filter( e => !e.$duplicates)
+        if (r[0].kind === '$navElement' && r.every( e => !e._parent.$duplicates )) {
+          // only complain about ambiguous source elements if we do not have
+          // duplicate table aliases, only mention non-ambiguous source elems
+          const names = r.filter( e => !e.$duplicates )
             .map( e => `${ e.name.alias }.${ e.name.element }` );
           if (names.length) {
             error( 'ref-ambiguous', [ head.location, user ], { id: head.id, names },
@@ -658,7 +609,7 @@ function fns( model, environment = artifactsEnv ) {
         continue;
       }
 
-      const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : environment;
+      const fn = (spec.envFn && artItemsCount >= 0) ? spec.envFn : VolatileFns.environment;
       const env = fn( art, item.location, user, spec.assoc );
 
       // do not check any elements of the path, e.g. $session - but still don't return path-head
@@ -847,7 +798,9 @@ function fns( model, environment = artifactsEnv ) {
     }
     // TODO: block should be construct._block
     if (construct.$annotations && construct.$annotations.doc )
-      art.doc = construct.$annotations.doc;
+      art.doc = construct.$annotations.doc; // e.g. through `annotate` statement in CDL
+    else 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:
@@ -923,132 +876,6 @@ function pathName(path) {
   return (path.broken) ? '' : path.map( id => id.id ).join('.');
 }
 
-// The link (_artifact,_effectiveType,...) usually has the artifact as value.
-// Falsy values are:
-// - undefined: not computed yet, parse error, no ref
-// - null: no valid reference, param:true if that is not allowed
-// - false (only complete ref): multiple definitions, rejected
-// - 0 (for _effectiveType only): circular reference
-function setLink( obj, value = null, prop = '_artifact' ) {
-  Object.defineProperty( obj, prop, { value, configurable: true, writable: true } );
-  return value;
-}
-
-function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
-  const elem = {
-    name: { location: location || origin.name.location, id: name },
-    kind: origin.kind,
-    location: location || origin.location,
-  };
-  if (origin.name.$inferred)
-    elem.name.$inferred = origin.name.$inferred;
-  if (parent)
-    setMemberParent( elem, name, parent, prop ); // TODO: redef in template
-  setProp( elem, '_origin', origin );
-  // TODO: should we use silent dependencies also for other things, like
-  // included elements?  (Currently for $inferred: 'expand-element' only)
-  if (silentDep)
-    dependsOnSilent( elem, origin );
-  else
-    dependsOn( elem, origin, location );
-  return elem;
-}
-
-function setMemberParent( elem, name, parent, prop ) {
-  if (prop) {              // extension or structure include
-    // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
-    const p = parent.items || parent.targetAspect || parent;
-    if (!(prop in p))
-      p[prop] = Object.create(null);
-    dictAdd( p[prop], name, elem );
-  }
-  if (parent._outer)
-    parent = parent._outer;
-  setProp( elem, '_parent', parent );
-  setProp( elem, '_main', parent._main || parent );
-  elem.name.absolute = elem._main.name.absolute;
-  if (name == null)
-    return;
-  const normalized = kindProperties[elem.kind].normalized || elem.kind;
-  [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
-    if (normalized === kind)
-      elem.name[kind] = (parent.name[kind] != null && kind !== 'select' && kind !== 'alias') ? `${ parent.name[kind] }.${ name }` : name;
-
-    else if (parent.name[kind] != null)
-      elem.name[kind] = parent.name[kind];
-
-    else
-      delete elem.name[kind];
-  });
-  // try { throw new Error('Foo') } catch (e) { elem.name.stack = e; };
-}
-
-/**
- * Adds a dependency user -> art with the given location.
- *
- * @param {XSN.Artifact} user
- * @param {XSN.Artifact} art
- * @param {XSN.Location} location
- */
-function dependsOn( user, art, location ) {
-  if (!user._deps)
-    setProp( user, '_deps', [] );
-  user._deps.push( { art, location } );
-}
-
-/**
- * Same as "dependsOn" but the dependency from user -> art is silent,
- * i.e. not reported to the user.
- *
- * @param {XSN.Artifact} user
- * @param {XSN.Artifact} art
- */
-function dependsOnSilent( user, art ) {
-  if (!user._deps)
-    setProp( user, '_deps', [] );
-  user._deps.push( { art } );
-}
-
-function storeExtension( elem, name, prop, parent, block ) {
-  if (prop === 'enum')
-    prop = 'elements';
-  setProp( elem, '_block', block );
-  const kind = `_${ elem.kind }`; // _extend or _annotate
-  if (!parent[kind])
-    setProp( parent, kind, {} );
-  // if (name === '' && prop === 'params') {
-  //   pushToDict( parent[kind], 'returns', elem ); // not really a dict
-  //   return;
-  // }
-  if (!parent[kind][prop])
-    parent[kind][prop] = Object.create(null);
-  pushToDict( parent[kind][prop], name, elem );
-}
-
-/** @type {(a: any, b: any) => boolean} */
-const testFunctionPlaceholder = () => true;
-
-// Return path step if the path navigates along an association whose final type
-// satisfies function `test`; "navigates along" = last path item not considered
-// without truthy optional argument `alsoTestLast`.
-function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
-  for (const item of ref.path || []) {
-    const art = item && item._artifact; // item can be null with parse error
-    if (art && art._effectiveType && art._effectiveType.target && test( art._effectiveType, item ))
-      return (alsoTestLast || item !== ref.path[ref.path.length - 1]) && item;
-  }
-  return false;
-}
-
 module.exports = {
-  dictKinds,
-  kindProperties,
   fns,
-  setLink,
-  linkToOrigin,
-  dependsOn,
-  dependsOnSilent,
-  setMemberParent,
-  storeExtension,
-  withAssociation,
 };

package/lib/compiler/utils.js

@@ -8,6 +8,9 @@
 
 'use strict';
 
+const { dictAdd, pushToDict } = require('../base/dictionaries');
+const { kindProperties } = require('./base');
+
 // for links, i.e., properties starting with an underscore '_':
 
 function pushLink( obj, prop, value ) {
@@ -38,10 +41,180 @@ function annotateWith( art, anno, location = art.location, val = true, literal =
   };
 }
 
+// TODO: define setLink() like the current setProp(), we might have setArtifactLink()
+// Do not share this function with CSN processors!
+
+// The link (_artifact,_effectiveType,...) usually has the artifact as value.
+// Falsy values are:
+// - undefined: not computed yet, parse error, no ref
+// - null: no valid reference, param:true if that is not allowed
+// - false (only complete ref): multiple definitions, rejected
+// - 0 (for _effectiveType only): circular reference
+function setLink( obj, value = null, prop = '_artifact' ) {
+  Object.defineProperty( obj, prop, { value, configurable: true, writable: true } );
+  return value;
+}
+
+/**
+ * Like `obj.prop = value`, but not contained in JSON / CSN
+ * It's important to set enumerable explicitly to false (although 'false' is the default),
+ * as else, if the property already exists, it keeps the old setting for enumerable.
+ *
+ * @param {object} obj
+ * @param {string} prop
+ * @param {any} value
+ */
+function setProp(obj, prop, value) {
+  const descriptor = {
+    value,
+    configurable: true,
+    writable: true,
+    enumerable: false,
+  };
+  Object.defineProperty( obj, prop, descriptor );
+  return value;
+}
+
+function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
+  const elem = {
+    name: { location: location || origin.name.location, id: name },
+    kind: origin.kind,
+    location: location || origin.location,
+  };
+  if (origin.name.$inferred)
+    elem.name.$inferred = origin.name.$inferred;
+  if (parent)
+    setMemberParent( elem, name, parent, prop ); // TODO: redef in template
+  setProp( elem, '_origin', origin );
+  // TODO: should we use silent dependencies also for other things, like
+  // included elements?  (Currently for $inferred: 'expand-element' only)
+  if (silentDep)
+    dependsOnSilent( elem, origin );
+  else
+    dependsOn( elem, origin, location );
+  return elem;
+}
+
+function setMemberParent( elem, name, parent, prop ) {
+  if (prop) {              // extension or structure include
+    // TODO: consider nested ARRAY OF and RETURNS, COMPOSITION OF type
+    const p = parent.items || parent.targetAspect || parent;
+    if (!(prop in p))
+      p[prop] = Object.create(null);
+    dictAdd( p[prop], name, elem );
+  }
+  if (parent._outer)
+    parent = parent._outer;
+  setProp( elem, '_parent', parent );
+  setProp( elem, '_main', parent._main || parent );
+  elem.name.absolute = elem._main.name.absolute;
+  if (name == null)
+    return;
+  const normalized = kindProperties[elem.kind].normalized || elem.kind;
+  [ 'element', 'alias', 'select', 'param', 'action' ].forEach( ( kind ) => {
+    if (normalized === kind)
+      elem.name[kind] = (parent.name[kind] != null && kind !== 'select' && kind !== 'alias') ? `${ parent.name[kind] }.${ name }` : name;
+
+    else if (parent.name[kind] != null)
+      elem.name[kind] = parent.name[kind];
+
+    else
+      delete elem.name[kind];
+  });
+  // try { throw new Error('Foo') } catch (e) { elem.name.stack = e; };
+}
+
+/**
+ * Adds a dependency user -> art with the given location.
+ *
+ * @param {XSN.Artifact} user
+ * @param {XSN.Artifact} art
+ * @param {XSN.Location} location
+ */
+function dependsOn( user, art, location ) {
+  if (!user._deps)
+    setProp( user, '_deps', [] );
+  user._deps.push( { art, location } );
+}
+
+/**
+ * Same as "dependsOn" but the dependency from user -> art is silent,
+ * i.e. not reported to the user.
+ *
+ * @param {XSN.Artifact} user
+ * @param {XSN.Artifact} art
+ */
+function dependsOnSilent( user, art ) {
+  if (!user._deps)
+    setProp( user, '_deps', [] );
+  user._deps.push( { art } );
+}
+
+function storeExtension( elem, name, prop, parent, block ) {
+  if (prop === 'enum')
+    prop = 'elements';
+  setProp( elem, '_block', block );
+  const kind = `_${ elem.kind }`; // _extend or _annotate
+  if (!parent[kind])
+    setProp( parent, kind, {} );
+  // if (name === '' && prop === 'params') {
+  //   pushToDict( parent[kind], 'returns', elem ); // not really a dict
+  //   return;
+  // }
+  if (!parent[kind][prop])
+    parent[kind][prop] = Object.create(null);
+  pushToDict( parent[kind][prop], name, elem );
+}
+
+/** @type {(a: any, b: any) => boolean} */
+const testFunctionPlaceholder = () => true;
+
+// Return path step if the path navigates along an association whose final type
+// satisfies function `test`; "navigates along" = last path item not considered
+// without truthy optional argument `alsoTestLast`.
+function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
+  for (const item of ref.path || []) {
+    const art = item && item._artifact; // item can be null with parse error
+    if (art && art._effectiveType && art._effectiveType.target && test( art._effectiveType, item ))
+      return (alsoTestLast || item !== ref.path[ref.path.length - 1]) && item;
+  }
+  return false;
+}
+
+/**
+ * Generates an XSN path out of the given name. Path segments are delimited by a dot.
+ * Each segment will have the given location assigned.
+ *
+ * @param {CSN.Location} location
+ * @param {string} name
+ * @returns {XSN.Path}
+ */
+function splitIntoPath( location, name ) {
+  return name.split('.').map( id => ({ id, location }) );
+}
+
+/**
+ * @param {CSN.Location} location
+ * @param  {...any} args
+ */
+function augmentPath( location, ...args ) {
+  return { path: args.map( id => ({ id, location }) ), location };
+}
+
 
 module.exports = {
   pushLink,
   annotationVal,
   annotationIsFalse,
   annotateWith,
+  setLink,
+  setProp,
+  linkToOrigin,
+  dependsOn,
+  dependsOnSilent,
+  setMemberParent,
+  storeExtension,
+  withAssociation,
+  augmentPath,
+  splitIntoPath,
 };

package/lib/edm/annotations/genericTranslation.js

@@ -1119,7 +1119,7 @@ function csn2annotationEdm(csn, serviceName, Edm = undefined, options=undefined,
         let dictPropertyTypeName = null;
         if (dictProperties) {
           dictPropertyTypeName = dictProperties[i];
-          if (!dictPropertyTypeName){
+          if (!dictPropertyTypeName && !getDictType(actualTypeName).OpenType){
             message(warning, context, `record type '${ actualTypeName }' doesn't have a property '${ i }'`);
           }
         }

package/lib/edm/csn2edm.js

@@ -142,7 +142,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         definitions: Object.create(null)
       }
     };
-    
+
     if(options.isV4()) {
       // tunnel schema xref and servicename in options to edm.Typebase to rectify
       // type references that are eventually also prefixed with the service schema name.
@@ -304,6 +304,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         warning('odata-spec-violation-namespace',
                 [ 'definitions', schema.name ], { names: reservedNames });
       }
+      /** @type {any} */
       const Schema = new Edm.Schema(v, schema.name, undefined /* unset alias */, schema._csn, /* annotations */ [], schema.container);
       const EntityContainer = Schema._ec || (LeadSchema && LeadSchema._ec);
       // now namespace and alias are used to create the fullQualified(name)
@@ -390,7 +391,7 @@ function csn2edmAll(_csn, _options, serviceNames=undefined) {
         if(properties.length === 0) {
           warning(null, loc, { type }, 'EDM EntityType $(TYPE) has no properties');
         } else if(entityCsn.$edmKeyPaths.length === 0) {
-          warning(null, loc, { type }, 'EDM EntityType $(TYPE) has no primary key');
+          message('odata-spec-violation-no-key', loc);
         }
         properties.forEach(p => {
           const pLoc = [...loc, 'elements', p.Name];

package/lib/edm/edmPreprocessor.js

@@ -54,7 +54,7 @@ function initializeModel(csn, _options, messageFunctions)
   let options = validateOptions(_options);
 
   // Fetch service definitions
-  const serviceRoots = Object.keys(csn.definitions).reduce((serviceRoots, artName) => {
+  const serviceRoots = Object.keys(csn.definitions || {}).reduce((serviceRoots, artName) => {
     const art = csn.definitions[artName];
     if(art.kind === 'service') {
       serviceRoots[artName] = Object.assign(art, { name: artName });
@@ -67,6 +67,9 @@ function initializeModel(csn, _options, messageFunctions)
   function whatsMyServiceRootName(n, self=true) {
     return serviceRootNames.reduce((rc, sn) => !rc && n && n.startsWith(sn + '.') || (n === sn && self) ? sn : rc, undefined);
   }
+  if(serviceRootNames.length === 0) {
+    return [serviceRoots, Object.create(null), whatsMyServiceRootName, options];
+  }
 
   // Structural CSN inbound QA checks
   inboundQualificationChecks();
@@ -594,6 +597,16 @@ function initializeModel(csn, _options, messageFunctions)
       if(element['@cds.valid.from']) {
         validFrom.push(element);
       }
+      //forward annotations from managed association element to its foreign keys
+      const elements = construct.items && construct.items.elements || construct.elements;
+      forAll(elements[element['@odata.foreignKey4']], (attr, attrName) => {
+        if(attrName[0] === '@') {
+          element[attrName] = attr;
+        }
+      });
+      // and eventually remove some afterwards:)
+      if(options.isV2())
+        setSAPSpecificV2AnnotationsToAssociation(element);
 
       // initialize an association
       if(isAssociationOrComposition(element)) {
@@ -602,20 +615,6 @@ function initializeModel(csn, _options, messageFunctions)
         assignProp(element._target, '$proxies', []);
         // $abspath is used as partner path
         assignProp(element, '$abspath', $path2path(element.$path));
-
-        //forward annotations from managed association element to its foreign keys
-        if(element.keys && options.isFlatFormat) {
-          const elements = construct.items && construct.items.elements || construct.elements;
-          for(let fk of element.keys) {
-            forAll(element, (attr, attrName) => {
-              if(attrName[0] === '@' && fk.$generatedFieldName && elements && elements[fk.$generatedFieldName]) {
-                elements[fk.$generatedFieldName][attrName] = attr;
-              }
-            });
-          }
-        }
-        // and afterwards eventually remove some :)
-        setSAPSpecificV2AnnotationsToAssociation(options, element, def);
       }
 
       // Collect keys
@@ -2159,19 +2158,17 @@ function setSAPSpecificV2AnnotationsToEntitySet(options, carrier) {
   }
 }
 
-function setSAPSpecificV2AnnotationsToAssociation(options, carrier, struct) {
-  if(!options.isV2())
-    return;
+function setSAPSpecificV2AnnotationsToAssociation(carrier) {
   // documented in https://wiki.scn.sap.com/wiki/display/EmTech/SAP+Annotations+for+OData+Version+2.0
   const SetAttributes = {
     // Applicable to NavProp and foreign keys, add to AssociationSet
-    '@sap.creatable' : (struct, c,pn, pv) => { addToSetAttr(struct, c, pn, pv, false); },
+    '@sap.creatable' : (c, pn, pv) => { addToAssociationSet(c, pn, pv, false); },
     // Not applicable to NavProp, applicable to foreign keys, add to AssociationSet
-    '@sap.updatable' : addToSetAttr,
+    '@sap.updatable' : addToAssociationSet,
     // Not applicable to NavProp, not applicable to foreign key, add to AssociationSet
-    '@sap.deletable': (struct, c, pn, pv) => {
-      addToSetAttr(struct, c, pn, pv);
-      removeFromForeignKey(struct, c, pn);
+    '@sap.deletable': (c, pn, pv) => {
+      addToAssociationSet(c, pn, pv);
+      removeFromForeignKey(c, pn);
     },
     // applicable to NavProp, not applicable to foreign keys, not applicable to AssociationSet
     '@sap.creatable.path': removeFromForeignKey,
@@ -2179,24 +2176,22 @@ function setSAPSpecificV2AnnotationsToAssociation(options, carrier, struct) {
   };
 
   Object.entries(carrier).forEach(([p, v]) => {
-    (SetAttributes[p] || function() {/* no-op */})(struct, carrier, p, v);
+    (SetAttributes[p] || function() {/* no-op */})(carrier, p, v);
   });
 
-  function addToSetAttr(struct, carrier, propName, propValue, removeFromType=true) {
-    assignProp(carrier, '_SetAttributes', Object.create(null));
-    assignAnnotation(carrier._SetAttributes, propName, propValue);
-    if(removeFromType) {
-      delete carrier[propName];
+  function addToAssociationSet(carrier, propName, propValue, removeFromType=true) {
+    if(isAssociationOrComposition(carrier)) {
+      assignProp(carrier, '_SetAttributes', Object.create(null));
+      assignAnnotation(carrier._SetAttributes, propName, propValue);
+      if(removeFromType) {
+        delete carrier[propName];
+      }
     }
   }
 
-  function removeFromForeignKey(struct, carrier, propName) {
-    if(carrier.target && carrier.keys) {
-      struct.elements && Object.values(struct.elements).forEach(e => {
-        if(e['@odata.foreignKey4'] === carrier.name) {
-          delete e[propName];
-        }
-      });
+  function removeFromForeignKey(carrier, propName) {
+    if(carrier['@odata.foreignKey4'] && carrier[propName] !== undefined) {
+      delete carrier[propName];
     }
   }
 }