@sap/cds-compiler 6.9.2 → 7.0.1

package/lib/compiler/tweak-assocs.js

@@ -5,6 +5,7 @@
 const { dictLocation, weakLocation, weakRefLocation } = require('../base/location');
 
 const {
+  pushLink,
   setLink,
   setArtifactLink,
   linkToOrigin,
@@ -28,7 +29,7 @@ const $inferred = Symbol.for( 'cds.$inferred' );
 function tweakAssocs( model ) {
   // Get shared functionality and the message function:
   const {
-    info, warning, error,
+    info, warning, error, message,
   } = model.$messageFunctions;
   const {
     traverseExpr,
@@ -42,6 +43,7 @@ function tweakAssocs( model ) {
     navigationEnv,
     redirectionChain,
     resolveExprInAnnotations,
+    checkBacklinkPartner,
   } = model.$functions;
 
   Object.assign(model.$functions, {
@@ -52,15 +54,18 @@ function tweakAssocs( model ) {
   // Phase 5: rewrite associations
   model._entities.forEach( rewriteArtifact ); // _entities contains all definitions, sorted.
   // Think hard whether an on condition rewrite can lead to a new cyclic
-  // dependency.  If so, we need other messages anyway.  TODO: probably dox
+  // dependency.  If so, we need other messages anyway.  TODO: probably do
   // another cyclic check with testMode.js
   forEachUserArtifact( model, 'definitions', function check( art ) {
-    checkOnCondition( art.on, (art.kind !== 'mixin' ? 'on' : 'mixin-on'), art );
+    if (art.on && !art.on.$inferred)
+      checkOnCondition( art.on, (art.kind !== 'mixin' ? 'on' : 'mixin-on'), art );
     checkExpr( art.value, (art.$syntax === 'calc' ? 'calc' : 'column'), art );
 
     if (art.kind === 'select')
       forEachQueryExpr( art, checkExpr );
   } );
+  if (model._associations)
+    model._associations.forEach( rewriteBacklink );
 
 
   // create “super” ANNOTATE statements for annotations on unknown artifacts:
@@ -281,8 +286,12 @@ function tweakAssocs( model ) {
       forEachGeneric( elem, 'elements', rewriteAssociation );
     if (elem.targetAspect?.elements)
       forEachGeneric( elem.targetAspect, 'elements', rewriteAssociation );
-    if (!originTarget( elem ))
+
+    if (!originTarget( elem )) {
+      if (elem.$backlink?._redirected)
+        pushLink( model, '_associations', elem );
       return;
+    }
 
     // console.log(message( null, elem.location, elem,
     // {art:assoc,target,ftype:JSON.stringify(ftype)}, 'Info','RA').toString())
@@ -304,13 +313,22 @@ function tweakAssocs( model ) {
       if (!elem || elem.builtin) // safety
         return;
     }
+    // console.log('PBI:',elem.kind,elem._main?.name.id,elem.name.id,!!elem.$backlink)
+    if (elem.$backlink?._redirected)
+      pushLink( model, '_associations', elem );
+
     chain.reverse();
     for (const art of chain) {
+      // console.log('PBC:',art.kind,art._main.name.id,art.name.id,elem.name.id)
       setLink( elem, '_status', null );
-      if (elem.on)
+      if (elem.on) {
         rewriteCondition( art, elem );
-      else if (elem.foreignKeys)
+        if (elem.$backlink?._redirected && art.on)
+          propagateBacklink( art, elem );
+      }
+      else if (elem.foreignKeys) {
         rewriteKeys( art, elem );
+      }
 
       if (art.on)
         removeManagedPropsFromUnmanaged( art );
@@ -319,6 +337,52 @@ function tweakAssocs( model ) {
     }
   }
 
+  function propagateBacklink( assoc, _originAssoc ) {
+    // const origin = originAssoc.$backlink;
+    // if (assoc.target._artifact === originAssoc.target._artifact) {
+    //   // no redirection → backlink is the same → no need to traverse ON-condition
+    //   const backlink = { location: weakLocation( origin.location ), target: {} };
+    //   setLink( backlink, '_origin', origin._origin );
+    //   setLink( backlink, '_outer', assoc );
+    //   assoc.$backlink = backlink;
+    //   // TODO: _redirected
+    // }
+    // else {
+    checkBacklinkPartner( assoc );
+    // console.log('PB:',assoc._main.name.id,assoc.name.id,originAssoc.name.id,
+    //             !!originAssoc.on,!!assoc.on,!!assoc.$backlink)
+    // TODO check: there should no reason for a new message (we might need to
+    // omit calling checkBacklinkPartner() if rewriting the ON-condition failed)
+    model._associations.push( assoc );
+  }
+
+  function rewriteBacklink( elem ) {
+    const backlink = elem.$backlink;
+    // console.log('RW:',elem._main?.name?.id,elem.name.id,!!backlink)
+    if (!backlink)
+      return;
+    setLink( backlink.target, '_artifact', elem._main ); // TODO: mixin
+    // already the fkeys/ON of the backlink association checks that all matches:
+    const origin = backlink._origin;
+    if (origin.$backlink) {
+      message( 'ref-invalid-backlink', [ backlink.location, elem ],
+               { '#': 'backlink', art: origin } );
+      setLink( backlink, '_redirected', null ); // no further processing
+      return;
+    }
+    if (backlink._redirected?.length === 0)
+      return;
+    // all of the following necessary?
+    setLink( backlink, '_main', elem._main );
+    setLink( backlink, '_parent', elem._parent );
+    setLink( backlink, '_effectiveType', backlink );
+    backlink.name = origin.name;
+    if (origin.on)
+      rewriteCondition( backlink, origin );
+    else if (origin.foreignKeys)
+      rewriteKeys( backlink, origin );
+  }
+
   /**
    * Remove properties from unmanaged association `elem` that are only valid
    * on managed associations.  Only set to `NULL` (special value for propagator),
@@ -395,12 +459,12 @@ function tweakAssocs( model ) {
           elem;
           // TODO: probably better to collect the non-projected foreign keys
           // and have one message for all
-          error('rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
-            '#': 'std',
+          error( 'rewrite-undefined-key', [ weakLocation( culprit.location ), elem ], {
+            '#': (elem.name ? 'std' : 'backlink'),
             id: targetElement.path.map(p => p.id).join('.'),
             target: alias._main,
-            name: elem.name.id,
-          });
+            name: elem.name?.id,
+          } );
           return null;
         }
       }
@@ -442,6 +506,7 @@ function tweakAssocs( model ) {
   // TODO: re-check $self rewrite (with managed composition of aspects),
   // and actually also $self inside anonymous aspect definitions
   // (not entirely urgent as we do not analyse it further, at least sole "$self")
+  // `assoc` is the "origin" association whose ON-condition we rewrite
   function rewriteCondition( elem, assoc ) {
     // the ON condition might need to be rewritten even if the target stays the
     // same (TODO later: set status whether rewrite changes anything),
@@ -464,6 +529,8 @@ function tweakAssocs( model ) {
     const nav = (elem._main?.query && elem.value)
       ? pathNavigation( elem.value ) // redirected source elem or mixin
       : { navigation: assoc };       // redirected user-provided
+    // console.log('RC:',elem._main.name.id,(elem._outer||elem).name.id,
+    //             assoc.name.id,!!nav.navigation,elem._redirected?.length)
     elem.on = copyExpr( assoc.on,
       // replace location in ON except if from mixin element
                         nav.tableAlias && elem.name.location );
@@ -722,18 +789,19 @@ function tweakAssocs( model ) {
   }
 
   /**
-   * @param expr
-   * @param assoc
-   * @param tableAlias
-   * @param navEnv Navigation element / table alias, used to traverse/rewrite the path.
+   * Rewrite reference `expr` in-place (this function does nothing if `expr` is
+   * not a reference).  `expr` is part of the potentially to-be-rewritten
+   * ON-condition of the element `assoc`.  `assoc` can be:
+   *
+   *  - a column  projecting an association of a query source: then `tableAlias`
+   *    is the table alias for that query source
+   *  - a column projecting a mixin definition
+   *  - an included element (the "copy")
+   *  - a backlink with an imaginary redirection to the current entity
+   *
+   * TODO: describe when `navEnv` is different to `tableAlias`.
    */
   function rewriteExpr( expr, assoc, tableAlias, navEnv = tableAlias ) {
-    // Rewrite ON condition (resulting in outside perspective) for association
-    // 'assoc' in query or including entity from ON cond of mixin element /
-    // element in included structure / element in source ref/d by table alias.
-
-    // TODO: complain about $self (unclear semantics)
-
     if (!expr.path || !expr._artifact)
       return;
     if (!assoc._main)
@@ -749,6 +817,17 @@ function tweakAssocs( model ) {
 
       rewritePathForEnv( expr, navEnv, assoc );
     }
+    else if (assoc._outer?.$backlink === assoc) { // backlink proxy
+      const root = expr.path[0]._navigation || expr.path[0]._artifact;
+      if (root.builtin || root.kind !== '$self' && root.kind !== 'element')
+        return;
+      const item = expr.path[root.kind === '$self' ? 1 : 0];
+      if (!item)
+        return;     // just $self
+      // console.log('REB:',assoc.name?.id,expr.path.map(i=>i.id))
+      if (item.id === assoc.name.id)
+        rewritePath( expr, item, assoc, assoc, null );
+    }
     else if (assoc._main.query) { // from ON cond of mixin element in query
       // here also $calc
       const root = expr.path[0]._navigation || expr.path[0]._artifact;
@@ -963,8 +1042,8 @@ function tweakAssocs( model ) {
 
   /**
    * Rewrite the reference `ref` with first elem/mixin ref item `item` for user
-   * `assoc` (the query element), `elem` is the first (or preferred) query element
-   * for item.
+   * `assoc` (the query element).  `elem` is usually the first (or preferred)
+   * query element for item.
    */
   function rewritePath( ref, item, assoc, elem, location ) {
     const { path } = ref;
@@ -1035,6 +1114,7 @@ function tweakAssocs( model ) {
    * @param assoc Published association of query.
    */
   function rewriteItem( elem, item, assoc, noError ) {
+    // console.log('RPI:',elem._redirected?.map(r=>`${r.name.id}@${r._main?.name?.id||''}`))
     if (!elem._redirected)
       return true;
     let name = item.id;

package/lib/compiler/utils.js

@@ -111,7 +111,7 @@ function linkToOrigin( origin, name, parent, prop, location, silentDep ) {
   return elem;
 }
 
-function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDeprecated ) {
+function proxyCopyMembers( art, dictProp, originDict, location, kind ) {
   art[dictProp] = Object.create( null );
   // TODO: set $inferred ? for dict?
   for (const name in originDict) {
@@ -121,13 +121,10 @@ function proxyCopyMembers( art, dictProp, originDict, location, kind, tmpDepreca
                                    location || origin.location, true );
       member.$inferred = 'expanded';
       // TODO throughout the compiler: do not set art.‹prop›.$inferred if art.$inferred
-      if (kind)
+      if (kind)                 // e.g. for dictionary of '$navElement's
         member.kind = kind;
-      else if (origin.key && !tmpDeprecated)
-        // TODO(v6): remove tmpDeprecated once `_noKeyPropagationWithExpansions` is removed
+      else if (origin.key)
         member.key = Object.assign( { $inferred: 'expanded' }, origin.key );
-      if (kind && origin.masked)  // TODO: remove!
-        member.masked = Object.assign( { $inferred: 'nav' }, origin.masked );
     }
   }
 }
@@ -183,7 +180,7 @@ function createAndLinkCalcDepElement( elem ) {
   setLink( r, '_outer', elem );
 }
 
-function initExprAnnoBlock( art, block ) {
+function initExprAnnoBlock( art, block, error ) {
   // remark: `art` could also be the extension
   for (const prop in art) {
     if (prop.charAt(0) !== '@')
@@ -192,10 +189,23 @@ function initExprAnnoBlock( art, block ) {
     // _block links needed for `cast( … as Type )`, `[ ..., cast( … as Type ) ]`
     if (anno.literal === 'array') {
       anno.kind = '$annotation';
-      for (const item of anno.val)
+      for (const item of anno.val) {
         setLink( item, '_block', block );
+        if (item.literal !== 'token' || item.val !== '...' || item.$errorReported != null)
+          continue;
+        item.$errorReported = art.kind && art.kind !== 'annotate' && art.kind !== 'extend';
+        if (item.$errorReported) {
+          error( null, [ item.location, art ], { offending: '...' },
+                 'Unexpected $(OFFENDING) in the array of an annotation on a definition' );
+          item.$errorReported = 'syntax';
+        }
+        else if (item.upTo) {
+          item.$errorReported
+            = !checkUpToSpec( item.upTo, art, prop, true, error ) && 'syntax';
+        }
+      }
     }
-    else if (anno.$tokenTexts) {
+    else if (anno.$tokenTexts || anno.sym || anno.struct) {
       // remark: it wouldn't hurt to set it always...
       anno.kind = '$annotation';
       setLink( anno, '_block', block );
@@ -203,6 +213,34 @@ function initExprAnnoBlock( art, block ) {
   }
 }
 
+function checkUpToSpec( upToSpec, art, annoName, noBoolOrNull, error ) {
+  const { literal, path } = upToSpec;
+  if (literal === 'struct') {
+    return Object.values( upToSpec.struct )
+      .reduce( ( ok, v ) => checkUpToSpec( v, art, annoName, false, error ) && ok, true );
+    // .reduce instead of .every because we want to see every sub error
+  }
+  else if (literal
+           ? literal !== 'array' &&
+           (!noBoolOrNull || literal !== 'boolean' && literal !== 'null')
+           : path && !upToSpec.scope && !path.some( hasSpecialPathItemProp )) {
+    return true;
+  }
+  error( null, [ upToSpec.location, art ],
+         { anno: annoName, code: '... up to', '#': literal || (path ? 'ref' : 'expr') },
+         {
+           std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
+           array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
+           // eslint-disable-next-line @stylistic/max-len
+           struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
+           boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
+           null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
+           ref: 'Unexpected complex reference as $(CODE) value in the assignment of $(ANNO)',
+           expr: 'Unexpected expression as $(CODE) value in the assignment of $(ANNO)',
+         } );
+  return false;
+}
+
 function initDollarSelf( art ) {
   // TODO: use setMemberParent() ?
   // TODO: also on 'namespace's?  (test with annotation with checked ref on them)
@@ -314,6 +352,13 @@ function pathName( path ) {
   return (path && !path.broken) ? path.map( id => id.id ).join( '.' ) : '';
 }
 
+function hasSpecialPathItemProp( item ) {
+  return item.args ||
+    item.where || item.groupBy || item.having || item.limit || item.orderBy ||
+    item.cardinality || item.$extra || item.$syntax;
+}
+
+
 /**
  * Generates an XSN path out of the given name. Path segments are delimited by a dot.
  * Each segment will have the given location assigned.
@@ -459,10 +504,9 @@ function forEachUserArtifact( model, prop, callback ) { // not enums
 function forEachUserElementAndFKey( art, callback ) {
   while (art.items)
     art = art.items;
-  if (art.target) {
+  if (art.target)
     forEachUserDict( art, 'foreignKeys', callback );
-    return;
-  }
+
   if (art.targetAspect)
     art = art.targetAspect;
   forEachUserDict( art, 'elements', function element( elem ) {
@@ -855,6 +899,7 @@ module.exports = {
   initBoundSelfParam,
   withAssociation,
   pathName,
+  hasSpecialPathItemProp,
   augmentPath,
   splitIntoPath,
   copyExpr,

package/lib/compiler/xpr-rewrite.js

@@ -152,7 +152,6 @@ const {
 } = require('./utils');
 const { CompilerAssertion } = require('../base/error');
 const { isBetaEnabled } = require('../base/specialOptions');
-const { isSimpleCdlIdentifier } = require('../parsers/identifiers');
 
 // Config object passed around all "rewrite" functions.
 class AnnoRewriteConfig {
@@ -276,7 +275,7 @@ function xprRewriteFns( model ) {
       const struct = Object.values(expr.struct);
       return !!struct.find(val => rewriteAnnotationExpr( val, config ));
     }
-    else if (expr.$tokenTexts) {
+    else if (expr.$tokenTexts) { // no expr.sym check needed here
       // used to set `$tokenText` to true in case of rewritten annotation
       config.tokenExpr = expr;
       return traverseExpr( expr, 'annoRewrite', config.destination,
@@ -329,18 +328,6 @@ function xprRewriteFns( model ) {
     if (hasError)
       return traverseExpr.STOP;
 
-    if (expr.$tokenTexts === true) {
-      // TODO: do not do with Universal-CSN (and gensrc, but that does not matter)
-      // We rewrite the string value for backward compatibility with "old-school" tools that
-      // only understand the string representation.  But we only do so for simple strings, which
-      // is the case if this path expression has $tokenTexts. It then is of the form `@a: (path)`.
-      const isSimpleStep = step => !step.where && !step.args && isSimpleCdlIdentifier( step.id );
-      if (expr.path.every(isSimpleStep)) {
-        expr.$tokenTexts = (expr.scope === 'param' ? ':' : '') +
-                            expr.path.map( step => step.id ).join('.');
-      }
-    }
-
     if (model.options.testMode) {
       // re-resolve the modified path; all paths steps must match what we rewrote
       const ref = { ...expr, path: [ ...expr.path.map(item => ({ ...item })) ] };
@@ -758,7 +745,7 @@ function isReturnParam( art ) {
 
 /**
  * Gets the artifact (e.g. element) that was expanded.
- * `destination` is a sub-artifact of that root and is an expanded element.
+ * `destination` is a sub artifact of that root and is an expanded element.
  *
  * - expandedRoot:     Top-most structure that was expanded.
  * - expandedRootType: The type of expandedRoot.

package/lib/edm/annotations/edmJson.js

@@ -307,7 +307,7 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions, generi
   // LITERALS
   transform.val = (parent, prop, xpr, csnPath, parentParent, parentProp) => {
     if (xpr === null)
-      parent.$Null = true;
+      parentParent[parentProp] = { $Null: true };
     else
       parentParent[parentProp] = xpr;
   };
@@ -852,16 +852,20 @@ function xpr2edmJson( carrier, anno, location, options, messageFunctions, generi
     delete parent[prop];
   };
 
+  const exprHandler = (parent, _prop, _xpr, csnPath, parentParent, parentProp) => {
+    if (isAnnotationExpression(parent)) {
+      const edmJson = preTransformXpr(parent);
+      // csnPath to this certain expression is passed inside of the 'ctx' variable, in case it is needed for resolving types from the
+      // dictionary, for instance in enum symbols resolving, see transform['#']
+      parentParent[parentProp] = transformExpression({ $edmJson: edmJson }, undefined, transform, csnPath, { xprCsnPath: csnPath });
+    }
+  };
   return transformExpression(carrier, anno, {
-    '=': (parent, prop, xpr, csnPath, parentParent, parentProp) => {
-      if (isAnnotationExpression(parent)) {
-        delete parent['='];
-        const edmJson = preTransformXpr(parent);
-        // csnPath to this certain expression is passed inside of the 'ctx' variable, in case it is needed for resolving types from the
-        // dictionary, for instance in enum symbols resolving, see transform['#']
-        parentParent[parentProp] = transformExpression({ $edmJson: edmJson }, undefined, transform, csnPath, { xprCsnPath: csnPath });
-      }
-    },
+    ref: exprHandler,
+    xpr: exprHandler,
+    list: exprHandler,
+    val: exprHandler,
+    func: exprHandler,
   }, location);
 
   /**

package/lib/edm/annotations/genericTranslation.js

@@ -855,7 +855,9 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       const qualifier = i >= 0 ? termName.substring(i + 1) : undefined;
 
       termNameWithoutQualifiers.split('.').forEach((id) => {
-        if (!edmUtils.isODataSimpleIdentifier(id))
+        if (isV2() && !edmUtils.isODataV2SimpleIdentifier(id))
+          message('odata-invalid-name-v2', msg.location, { id });
+        else if (!edmUtils.isODataSimpleIdentifier(id))
           message('odata-invalid-name', msg.location, { id });
       });
       newAnno = new Edm.Annotation(v, termNameWithoutQualifiers);

package/lib/edm/annotations/preprocessAnnotations.js

@@ -30,24 +30,6 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
     return options.v && options.v[0];
   }
 
-  // return value can be null is target has no key
-  function getKeyOfTargetOfManagedAssoc( anno, assoc ) {
-    // assoc.target can be the name of the target or the object itself
-    const targetName = (typeof assoc.target === 'object') ? assoc.target.name : assoc.target;
-    const target = (typeof assoc.target === 'object') ? assoc.target : csn.definitions[assoc.target];
-
-    const keyNames = Object.keys(target.elements).filter(x => target.elements[x].key && !target.elements[x].target);
-    if (keyNames.length === 0) {
-      keyNames.push('MISSING');
-      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'nokey' } );
-    }
-    else if (keyNames.length > 1) {
-      message('odata-anno-preproc', assoc.$path, { anno, name: targetName, '#': 'multkeys' });
-    }
-
-    return keyNames[0];
-  }
-
   // ----------------------------------------------------------------------------------------------
   // main annotation processors
   // ----------------------------------------------------------------------------------------------
@@ -143,6 +125,11 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
               return false;
             }
 
+            // If carrier is an association, do nothing, as the anno only applies to Property, not to NavigationProperty.
+            // For a managed association, the anno has also been propagated to the generated FKs, which are processed here, too.
+            if (carrier.target)
+              return false;
+
             // check on "type"? e.g. if present, it must be #fixed ... ?
 
             // value list entity
@@ -200,14 +187,8 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
             const label = carrier['@Common.ValueList.Label'] ||
                         carrier['@Common.Label'] || vlEntity['@Common.Label'] || enameShort;
 
-            // localDataProp
-            //   name of the element carrying the value help annotation
-            //   if this is a managed assoc, use fk field instead (if there is a single one)
+            // localDataProp = name of the element carrying the value help annotation
             let localDataProp = carrierName.split('/').pop();
-            if (carrier.target && carrier.on === undefined) {
-              localDataProp = localDataProp + fkSeparator +
-                getKeyOfTargetOfManagedAssoc(anno, carrier);
-            }
 
             // if this carrier is a generated foreign key field and the association is marked @cds.api.ignore
             // rename the localDataProp to be 'assocName/key'
@@ -218,9 +199,11 @@ function preprocessAnnotations( csn, serviceName, options, messageFunctions ) {
             }
 
             // valueListProp: the (single) key field of the value list entity
+            //   ignore the artificial key "IsActiveEntity" for draft-enabled entities
             //   if no key or multiple keys -> message
             let valueListProp = null;
-            const keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key && !vlEntity.elements[x].target );
+            const keys = Object.keys(vlEntity.elements).filter( x => vlEntity.elements[x].key && !vlEntity.elements[x].target &&
+              !(vlEntity['@odata.draft.enabled'] && x === 'IsActiveEntity'));  // ignore added key for draft entities
             if (keys.length === 0) {
               message('odata-anno-preproc', [ ...location, anno ], { anno, name: enameFull, '#': 'vhlnokey' });
               return false;

package/lib/edm/csn2edm.js

@@ -412,7 +412,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
       }
       else {
         schema.name.split('.').forEach((id) => {
-          if (!edmUtils.isODataSimpleIdentifier(id))
+          if (options.isV2() && !edmUtils.isODataV2SimpleIdentifier(id))
+            message('odata-invalid-name-v2', loc, { id });
+          else if (!edmUtils.isODataSimpleIdentifier(id))
             message('odata-invalid-name', loc, { id });
         });
       }
@@ -420,6 +422,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
       /** @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);
+      if (options.isV2() && EntityContainer && !edmUtils.isODataV2SimpleIdentifier(EntityContainer._edmAttributes.Name))
+        message('odata-invalid-name-v2', loc, { id: EntityContainer._edmAttributes.Name });
       // now namespace and alias are used to create the fullQualified(name)
       const schemaNamePrefix = `${ schema.name }.`;
       const schemaAliasPrefix = schemaNamePrefix;
@@ -526,7 +530,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         else if (entityCsn.$hasEntitySet && entityCsn.$edmKeyPaths.length === 0 && !isSingleton)
           message('odata-missing-key', location);
 
-        if (!edmUtils.isODataSimpleIdentifier(EntityTypeName))
+        if (options.isV2() && !edmUtils.isODataV2SimpleIdentifier(EntityTypeName))
+          message('odata-invalid-name-v2', location, { id: EntityTypeName });
+        else if (!edmUtils.isODataSimpleIdentifier(EntityTypeName))
           message('odata-invalid-name', location, { id: EntityTypeName });
 
         properties.forEach((p) => {
@@ -538,18 +544,10 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           if (options.isV2() && p.$isCollection && !p._csn.target)
             message('odata-unexpected-array', pLoc, { version: '2.0' });
 
-          if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name)) {
+          if (options.isV2() && !edmUtils.isODataV2SimpleIdentifier(p._edmAttributes.Name))
+            message('odata-invalid-name-v2', pLoc, { id: p._edmAttributes.Name });
+          else if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
             message('odata-invalid-name', pLoc, { id: p._edmAttributes.Name });
-          }
-          else if (options.isV2() && /^(_|\d)/.test(p._edmAttributes.Name)) {
-            // FIXME: Rewrite signalIllegalIdentifier function to be more flexible
-            message('odata-invalid-name', pLoc, {
-              '#': 'v2firstChar',
-              prop: p._edmAttributes.Name[0],
-              id: p._edmAttributes.Name,
-              version: '2.0',
-            });
-          }
         });
 
         // construct EntityType attributes
@@ -605,7 +603,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         const properties = createProperties(elementsCsn, structuredTypeCsn)[0];
         const location = [ 'definitions', structuredTypeCsn.name ];
 
-        if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
+        if (options.isV2() && !edmUtils.isODataV2SimpleIdentifier(attributes.Name))
+          message('odata-invalid-name-v2', location, { id: attributes.Name });
+        else if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
           message('odata-invalid-name', location, { id: attributes.Name });
 
         properties.forEach((p) => {
@@ -614,7 +614,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           if (p._edmAttributes.Name === complexType._edmAttributes.Name)
             message('odata-invalid-property-name', pLoc, { meta: structuredTypeCsn.kind });
 
-          if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
+          if (options.isV2() && !edmUtils.isODataV2SimpleIdentifier(p._edmAttributes.Name))
+            message('odata-invalid-name-v2', pLoc, { id: p._edmAttributes.Name });
+          else if (!edmUtils.isODataSimpleIdentifier(p._edmAttributes.Name))
             message('odata-invalid-name', pLoc, { id: p._edmAttributes.Name });
 
           if (options.isV2()) {
@@ -740,7 +742,6 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
           : [ 'definitions', actionCsn.name ];
 
-
         if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
           message('odata-invalid-name', location, { id: attributes.Name });
 
@@ -893,8 +894,8 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
           ? [ 'definitions', entityCsn.name, 'actions', actionCsn.name ]
           : [ 'definitions', actionCsn.name ];
 
-        if (!edmUtils.isODataSimpleIdentifier(attributes.Name))
-          message('odata-invalid-name', location, { id: attributes.Name });
+        if (options.isV2() && !edmUtils.isODataV2SimpleIdentifier(attributes.Name))
+          message('odata-invalid-name-v2', location, { id: attributes.Name });
 
         const rt = actionCsn.returns && ((actionCsn.returns.items && actionCsn.returns.items.type) || actionCsn.returns.type);
         if (rt) { // add EntitySet attribute only if return type is an entity
@@ -951,8 +952,9 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
               const param = new Edm.Parameter(v, { Name: parameterName }, parameterCsn, 'In' );
               collectUsedType(parameterCsn);
               edmTypeCompatibilityCheck(param, pLoc);
-              if (!edmUtils.isODataSimpleIdentifier(parameterName))
-                message('odata-invalid-name', pLoc, { id: parameterName });
+
+              if (options.isV2() && !edmUtils.isODataV2SimpleIdentifier(parameterName))
+                message('odata-invalid-name-v2', pLoc, { id: parameterName });
 
               // only scalar or structured type in V2 (not entity)
               if (param._type &&
@@ -1096,6 +1098,11 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
         if (reuseAssoc)
           return;
 
+        const assocLocation = [ 'definitions', navigationProperty._csn._edmParentCsn.name,
+          'elements', navigationProperty._edmAttributes.Name ];
+        if (!edmUtils.isODataV2SimpleIdentifier(assocName))
+          message('odata-invalid-name-v2', assocLocation, { id: assocName });
+
         // Create Association and AssociationSet if this is not a backlink association.
         // Store association at navigation property because in case the Ends must be modified
         // later by the partner (backlink) association