@sap/cds-compiler 6.8.0 → 6.9.1

package/lib/compiler/utils.js

@@ -292,6 +292,8 @@ 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`.
+ *
+ * This function assumes that the reference has already been resolved.
  */
 function withAssociation( ref, test = testFunctionPlaceholder, alsoTestLast = false ) {
   for (const item of ref.path || []) {
@@ -528,6 +530,11 @@ function forEachExprArray( query, array, refContext, exprContext, callback ) {
 // i.e. is necessary to calculate the elements of the query
 // except "real ones": operands of UNION etc, JOIN with ON, and sub queries in FROM
 // NOTE: does not run on non-referred sub queries!  Consider using ‹main›.$queries instead!
+//
+// Argument `simpleOnly`:
+// - truthy: only simple queries + sub query in from = do not traverse join and union args
+// - false, '', 0: all, but not right of union/intersect/etc
+// - null, undefined: all, including right side of union/intersect/etc
 function traverseQueryPost( query, simpleOnly, callback ) {
   if (!query)                   // parser error
     return;
@@ -538,7 +545,7 @@ function traverseQueryPost( query, simpleOnly, callback ) {
   }
   if (simpleOnly) {
     const { from } = query;
-    if (!from || from.join)     // parse error or join
+    if (!from || from.join)     // parse error or join or union etc
       return;                   // ok are: path or simple sub query (!)
   }
   if (query.from) {             // SELECT
@@ -548,7 +555,7 @@ function traverseQueryPost( query, simpleOnly, callback ) {
     // console.log('FE:')
   }
   else if (query.args) {             // JOIN, UNION, INTERSECT
-    if (!query.join && simpleOnly == null) {
+    if (!query.join && simpleOnly != null) {
       // enough for elements: traverse only first args for UNION/INTERSECT
       // TODO: we might use this also when we do not rewrite associations
       // in non-referred sub queries
@@ -576,7 +583,7 @@ function traverseQueryExtra( main, callback ) {
   if (!main.$queries)
     return;
   // with a top-level UNION, $queries[0] is just the left
-  traverseQueryPost( main.query, false, (q) => { // also with right of UNION (to be compatible)
+  traverseQueryPost( main.query, null, (q) => { // also into right of UNION (to be compatible)
     setLink( q, '_status', 'extra' );
     callback( q );
   } );
@@ -584,7 +591,7 @@ function traverseQueryExtra( main, callback ) {
     if (query._status === 'extra' || query._parent.kind === '$tableAlias')
       continue; // if parent is alias, query is FROM source -> run by traverseQueryPost
     // we are now in the top-level (parent is entity) or a non-referred query (parent is query)
-    traverseQueryPost( query, null, callback );
+    traverseQueryPost( query, false, callback ); // not into right of UNION
   }
 }
 
@@ -602,15 +609,18 @@ function viewFromPrimary( view ) {
 /**
  * About Helper property $expand for faster the XSN-to-CSN transformation
  * - null/undefined: artifact, member, items does not contain expanded members
- * - 'origin': all expanded (sub) elements have no new target/on and no new annotations
+ * - 'origin': all expanded (sub) elements have no associations and no new annotations
  *             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
+ * - 'target': all expanded (sub) elements might only have associations, but
  *             no individual annotations on any (sub) member
  *             when set, traverse all parents where the value has been 'origin' before
+ *             TODO: only set if `target` or `on` has changed during redirection/rewrite
  * - 'annotate': at least one inferred (sub) member has an individual annotation,
  *               not counting propagated ones; set up to the definition (main artifact)
- *               (only set with anno on $inferred elem), annotate “beats” target
+ *               (only set with anno on $inferred elem), 'annotate' beats 'target'
+ * - 'extend': at least one member has been added, 'extend' beats 'annotate'
+ *
  * Usage according to CSN flavor:
  * - gensrc: do not render inferred elements (including expanded elements),
  *           collect annotate statements with value 'annotate'
@@ -619,22 +629,16 @@ function viewFromPrimary( view ) {
  *           (might sometimes render the elements unnecessarily, which is not wrong)
  * - universal: do not render expanded sub elements if $expand = 'origin'
  */
-function setExpandStatus( elem, status ) {
-  // set on element
-  while (elem._main) {
-    elem = elem._parent;
-    if (status === 'annotate' ? elem.$expand === 'annotate' : elem.$expand !== 'origin')
-      return;
-    elem.$expand = status;    // meaning: expanded, containing assocs
-    for (let line = elem.items; line; line = line.items)
-      line.$expand = status; // to-csn just uses the innermost $expand
-  }
-}
+const expandStatusLevel = {
+  origin: 1,
+  target: 2,
+  annotate: 3,
+  extend: 4,
+};
 
-function setExpandStatusAnnotate( elem, status ) {
-  for (;;) {
-    if (elem.$expand === status)
-      return;                 // already set
+function setExpandStatus( elem, status ) {
+  const statusLevel = expandStatusLevel[status];
+  while (!elem.$expand || expandStatusLevel[elem.$expand] < statusLevel) {
     elem.$expand = status;    // meaning: expanded, containing annos
     for (let line = elem.items; line; line = line.items)
       line.$expand = status; // to-csn just uses the innermost $expand
@@ -862,7 +866,6 @@ module.exports = {
   traverseQueryExtra,
   viewFromPrimary,
   setExpandStatus,
-  setExpandStatusAnnotate,
   isDirectComposition,
   targetCantBeAspect,
   userQuery,

package/lib/compiler/xpr-rewrite.js

@@ -148,7 +148,7 @@ const { weakLocation } = require('../base/location');
 const {
   setArtifactLink,
   setLink,
-  setExpandStatusAnnotate,
+  setExpandStatus,
 } = require('./utils');
 const { CompilerAssertion } = require('../base/error');
 const { isBetaEnabled } = require('../base/specialOptions');
@@ -550,7 +550,7 @@ function xprRewriteFns( model ) {
 
     stripAbsolutePathPrefix( expr, config.expandedRootType );
     prependRootPath( config.expandedRootType, config.expandedRoot, expr );
-    setExpandStatusAnnotate( config.destination, 'annotate' );
+    setExpandStatus( config.destination, 'annotate' );
 
     config.destination[config.anno].$inferred = 'anno-rewrite';
     // $self-paths via type expansion always need to be rewritten.

package/lib/edm/EdmPrimitiveTypeDefinitions.js

@@ -244,7 +244,10 @@ const EdmPrimitiveTypeMap = {
     exact: 0,
     desc: 'Abstract meta type',
   },
-  // 'Edm.Untyped': { v4: true, desc: 'Abstract void type' },
+  'Edm.Untyped': {
+    v4: true,
+    desc: 'Abstract void type',
+  },
 };
 const EdmPathTypeMap = {
   'Edm.AnnotationPath': 1,

package/lib/edm/annotations/genericTranslation.js

@@ -891,13 +891,18 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   //   oTarget: the result object (o: odata)
   //   oTermName: current term
   //   dTypeNameArg: expected type of cAnnoValue according to dictionary, may be null (d: dictionary)
-  function handleValue( cAnnoValue, oTarget, oTermName, dTypeNameArg, msg ) {
+  //   dTypeDef: the whole object definition of the typefrom the dictionary, needed for DerivedTypeConstraints for Edm.Untyped
+  // @ts-ignore
+  function handleValue( cAnnoValue, oTarget, oTermName, dTypeNameArg, msg/* , dTypeDef = undefined */ ) {
     // this function basically only figures out what kind of annotation value we have
     //   (can be: array, expression, enum, pseudo-record, record, simple value),
     //   then calls a more specific function to deal with it and puts
     //   the result into the oTarget object
 
-    const [ dTypeName, dTypeIsACollection ] = stripCollection(dTypeNameArg);
+    const [ dTypeName, dTypeIsACollection/* , dTypeIsUntyped */ ] = stripCollectionAndgetIsCollectionOrUntyped(dTypeNameArg);
+
+    // if (dTypeIsUntyped)
+    //   validateUntypedAnnotationValue(cAnnoValue, typeof dTypeNameArg === 'object' ? dTypeNameArg : dTypeDef, msg);
 
     if (Array.isArray(cAnnoValue)) {
       if (isEnumType(dTypeName)) {
@@ -915,7 +920,12 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       if ('=' in cAnnoValue) {
         if (dTypeIsACollection) {
           message('odata-anno-value', msg.location,
-                  { anno: msg.anno(), str: 'path', '#': 'incompval' });
+                  {
+                    anno: msg.anno(),
+                    type: dTypeName,
+                    str: 'path',
+                    '#': 'incompval',
+                  });
         }
         // expression
         const res = handleExpression(cAnnoValue['='], dTypeName);
@@ -1081,6 +1091,30 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
       // concatenate all the enums to a string, separated by spaces
       return cAnnoValue.filter( x => x['#']).map( x => (forXml ? `${ dTypeName }/` : '') + x['#'] ).join(forXml ? ' ' : ',');
     }
+
+    // --------------------- Edm.Untyped helper function ----------------------
+
+    // // eslint-disable-next-line no-shadow
+    // function validateUntypedAnnotationValue( cAnnoValue, dTypeDef, msg ) {
+    //   if (!dTypeDef?.DerivedTypeConstraint)
+    //     return;
+    //   // if the annotation value is a path, but no path is allowed for this annotation, issue a message,
+    //   // for example the UI.DataField.Value annotation
+    //   if (cAnnoValue.$edmJson?.$Path/* || cAnnoValue['=']) -> this is handled in handleValue */ &&
+    //     !(dTypeDef.DerivedTypeConstraint.some(type => EdmPathTypeMap[type]) ||
+    //     dTypeDef.DerivedTypeConstraint.includes('Edm.EntityType') ||
+    //     dTypeDef.DerivedTypeConstraint.includes('Edm.ComplexType'))
+    //   ) {
+    //     message('odata-anno-value', msg.location,
+    //             {
+    //               anno: msg.anno(),
+    //               str: 'path',
+    //               type: 'Edm.Untyped',
+    //               '#': 'incompval',
+    //             });
+    //   }
+    // }
+    // ----------------------------------------------------------------------
   }
 
   // found an expression value ("=") "expr"
@@ -1418,7 +1452,7 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
   function generateCollection( annoValue, termName, dTypeName, dTypeIsACollection, msg ) {
     const newCollection = new Edm.Collection(v);
 
-    if (dTypeName && !dTypeIsACollection) {
+    if (dTypeName && !dTypeIsACollection && dTypeName !== 'Edm.Untyped') {
       message('odata-anno-value', msg.location,
               {
                 anno: msg.anno(), str: 'collection', type: dTypeName, '#': 'incompval',
@@ -1721,14 +1755,23 @@ function csn2annotationEdm( reqDefs, reqDefsUtils, csnVocabularies, serviceName,
     return dTypeName;
   }
 
-  function stripCollection( typeName ) {
-    if (typeName) {
+  function stripCollectionAndgetIsCollectionOrUntyped( typeName ) {
+    if (typeName && typeof typeName === 'string') {
       const match = typeName.match(/^Collection\((.+)\)/);
       if (match)
         return [ match[1], true ];
+        // return [ match[1], true, match[1] === 'Edm.Untyped' ];
     }
 
+    // in the Dictionary.json, if a certain element or type has type 'Edm.Untyped', we also store
+    // a 'DerivedTypeConstraint' property containing the possible types for this element or type.
+    // Therefore, the type is not just a string but an object: { Type: 'Edm.Untyped', DerivedTypeConstraint: [...] }
+    if (typeName && typeof typeName === 'object')
+      return [ typeName.Type, typeName.DerivedTypeConstraint.every(type => type.startsWith('Collection(')) ];
+      // return [ typeName.Type, typeName.DerivedTypeConstraint.some(type => type.startsWith('Collection(')), true ];
+
     return [ typeName, false ];
+    // return [ typeName, false, typeName === 'Edm.Untyped' ];
   }
 
   function isPrimitiveType( typeName ) {

package/lib/edm/csn2edm.js

@@ -472,8 +472,10 @@ function csn2edmAll( _csn, _options, serviceNames, messageFunctions ) {
 
       navigationProperties.forEach((np) => {
         if (options.isV4()) {
-        // V4: No referential constraints for Containment Relationships
-          if ((!np.isContainment() || (options.renderForeignKeys)) && !np.isToMany())
+        // V4: No referential constraints for Containment Relationships or
+        // unmanaged Compositions without a partner
+          const isUnmanagedCompositionWithoutPartner = np._csn.type === 'cds.Composition' && np._csn.on && !np._csn._constraints._partnerCsn;
+          if ((!np.isContainment() || (options.renderForeignKeys)) && !np.isToMany() && !isUnmanagedCompositionWithoutPartner)
             np.addReferentialConstraintNodes();
         }
         else {

package/lib/edm/edm.js

@@ -1053,11 +1053,14 @@ function getEdm( options ) {
           delete this._edmAttributes.Nullable;
         }
         // we have exactly one selfReference or the default partner
-
-        if ( !csn.$noPartner) {
+        // $noPartner can be set when a second projection creates an ambiguous backlink, but if exactly
+        // one self-reference targets the same entity as this association, that unambiguous partner still applies.
+        const selfRefsToTarget = csn._selfReferences.filter(ref => ref.$abspath[0] === csn._target?.name);
+        const isPartner = selfRefsToTarget.length === 1 && selfRefsToTarget[0]._constraints?._partnerCsn === csn;
+        if (!csn.$noPartner || isPartner) {
           const partner = csn._selfReferences.length === 1
             ? csn._selfReferences[0]
-            : csn._constraints._partnerCsn;
+            : selfRefsToTarget[0] || csn._constraints._partnerCsn;
           if (partner && partner['@odata.navigable'] !== false && this._csn._edmParentCsn.kind !== 'type') {
             // $abspath[0] is main entity
             this._edmAttributes.Partner = partner.$abspath.slice(1).join('/');

package/lib/gen/BaseParser.js

@@ -1,4 +1,4 @@
-// Base class for generated parser, for redepage v0.3.4
+// Base class for generated parser, for redepage v0.4.0
 
 'use strict';
 
@@ -24,7 +24,6 @@ recoverTokenIdx = -1;
 reuseErrorTokenIdx = null;
 fixKeywordTokenIdx = -1;
 conditionStackLength = -1;
-nextTokenAsId = false;
 
 s = null;
 errorState = null;
@@ -32,7 +31,7 @@ stack = [];
 dynamic_ = {};
 prec_ = null;
 $hasErrors = null;
-leanConditions = {};
+hardGuards = {};
 _trace = [];
 
 constructor( lexer, keywords, table ) {
@@ -103,22 +102,30 @@ return this.tokens[this.stack[this.stack.length - 1].tokenIdx];
 
 
 
-l() {
+lt() {
 return this.la().type;
 }
 
 
 lk() {
 const la = this.la();
-if (!this.nextTokenAsId)
 return la.keyword || la.type;
+}
 
-this.nextTokenAsId = false;
-return la.type;
+l() {
+let cmd = this.table[this.s];
+let { keyword, type } = this.la();
+const kb = keyword && cmd[keyword];
+if (Array.isArray( kb ) &&
+(!kb[2] || this.fixKeywordTokenIdx === this.tokenIdx || this._predictKeyword( kb[2] )))
+return (kb[3] && this._rejectCond( kb[3], kb[4] )) ? '' : keyword;
+const tb = cmd[type];
+return (!tb || tb[3] && this._rejectCond( tb[3], tb[4] )) ? '' : type;
 }
 
 e() {
 const la = this.la();
+this.s = null;
 
 if (this.errorTokenIdx === this.tokenIdx &&
 (this.reuseErrorTokenIdx == null && this.reuseErrorTokenIdx < this.tokenIdx))
@@ -140,21 +147,11 @@ return false;
 }
 
 
-ei() {
-if (!this.la().keyword)
-return this.e();
-this.nextTokenAsId = true;
-return false;
-}
-
-
 
 
 gr( follow ) {
-if (this.stack[this.stack.length - 1].tokenIdx === this.tokenIdx)
-
-return this.e();
-this.s = 0;
+if (!this.g( 0 ))
+return false;
 
 
 const { type, keyword } = this.tokens[this.tokenIdx];
@@ -172,35 +169,11 @@ return (match ?? true) || this.e();
 }
 
 
-g( state, follow ) {
-if (!(state == null ? this.e() : state || this.gr( follow )))
-return false;
+g( state ) {
 this.s = state;
-return true
-}
-
-
-giA( state, follow ) {
-if (!this.tokens[this.tokenIdx].keyword)
-return this.g( state, follow );
-this.nextTokenAsId = true;
-return false;
-}
-
-
-gi( state, follow ) {
-const lk = this.tokens[this.tokenIdx].keyword;
-
-
-if (!lk || this.keywords[lk])
-return this.g( state, follow );
-this.nextTokenAsId = true;
-return false;
-}
-
-
-gP( state, follow ) {
-return this.lP( follow ) && this.g( state );
+return (state || this.stack[this.stack.length - 1].tokenIdx < this.tokenIdx)
+? true
+: this.e();
 }
 
 
@@ -219,9 +192,9 @@ return (this.tokens[this.tokenIdx].type === 'Id')
 }
 
 
-miA( state, ident = true ) {
+my( state, ident = true ) {
 return (this.tokens[this.tokenIdx].type === 'Id')
-? this.ciA( state, ident )
+? this.cy( state, ident )
 : this.e();
 }
 
@@ -247,7 +220,7 @@ return this.e();
 const la = this.tokens[this.tokenIdx];
 
 
-if (this.keywords[la.keyword]) {
+if (this.keywords[la.keyword] && this.errorTokenIdx !== this.tokenIdx) {
 
 if (this._runTransparently( () => {
 ++this.tokenIdx;
@@ -264,7 +237,7 @@ return this.c( state, ident )
 }
 
 
-ciA( state, ident = 'ident' ) {
+cy( state, ident = 'ident' ) {
 return this.c( state, ident )
 }
 
@@ -274,12 +247,7 @@ return this.c( state, 'keyword' )
 }
 
 
-ckP( state, first2 ) {
-return this.lP( first2 ) && this.ck( state );
-}
-
-
-ckA( state ) {
+cx( state ) {
 
 return this.c( state, (this.l() === 'Id' ? 'keyword' : 'token') );
 }
@@ -295,15 +263,11 @@ reuseToken_() {
 
 
 
-
-
-
-
-gc( state, cond, arg ) {
+_rejectCond( cond, arg ) {
 if (this.conditionTokenIdx === this.tokenIdx &&
 this.conditionStackLength == null &&
 !this[cond].afterError)
-return true
+return false
 
 
 
@@ -314,7 +278,8 @@ const fail = this[cond]( arg, true );
 
 
 
-if (fail) {
+if (!fail)
+return false;
 
 
 
@@ -326,17 +291,13 @@ const { keyword } = this.la();
 if (keyword && this.table[this.s][keyword])
 this.fixKeywordTokenIdx = this.tokenIdx;
 this.conditionTokenIdx = this.tokenIdx;
+
 this.conditionStackLength = this.stack.length;
 this.conditionName = cond;
 
 
 this.conditionFailure = fail;
-}
-return !fail || this.g( state ) && false;
-}
-
-ec( cond, arg ) {
-return this.gc( null, cond, arg );
+return true;
 }
 
 
@@ -382,13 +343,10 @@ return true;
 }
 
 
+_predictKeyword( first2 ) {
 
-
-
-lP( first2 ) {
-
-const { keyword: lk1 } = this.tokens[this.tokenIdx];
-if (!lk1 || this.keywords[lk1] !== 0 || this.fixKeywordTokenIdx === this.tokenIdx)
+const { keyword: lk1 } = this.la();
+if (this.keywords[lk1] !== 0)
 return true;
 
 
@@ -404,10 +362,7 @@ if (this._walkPred( this.table[this.s][lk1], lk1, lt2, lk2 ))
 return true;
 
 const choice = this.table[this.s];
-if (!this._walkPred( choice.Id || choice[''], null, lt2, lk2 ))
-return true;
-this.nextTokenAsId = true;
-return false;
+return !this._walkPred( choice.Id || choice[''], null, lt2, lk2 );
 }
 
 _walkPred( cmd, lk1, lt2, lk2 ) {
@@ -483,9 +438,9 @@ cmd = !(c && this._rejectCondition( c, mode, lean )) && c || cmd[''];
 const state = this.s;
 this.s = cmd[1];
 switch (cmd[0]) {
-case 'c': case 'ck': case 'ckA':
+case 'c': case 'ck': case 'cx':
 return true;
-case 'ciA':
+case 'cy':
 return mode !== 'F';
 
 
@@ -494,6 +449,8 @@ case 'ci':
 if (!keyword ||
 !this.keywords[keyword] && this.fixKeywordTokenIdx !== this.tokenIdx)
 return mode !== 'F';
+
+
 cmd = this.table[state][''];
 this.s = cmd[1];
 break;
@@ -503,7 +460,7 @@ case 'mi':
 return type === 'Id' && mode !== 'F' &&
 (!keyword ||
 !this.keywords[keyword] && this.fixKeywordTokenIdx !== this.tokenIdx);
-case 'miA':
+case 'my':
 return type === 'Id' && mode !== 'F';
 case 'mk':
 return keyword === cmd[2];
@@ -553,7 +510,7 @@ return (hasMatchedToken ?? this.tokenIdx > this.stack.at( -1 ).tokenIdx)
 
 _rejectCondition( cmd, mode, lean ) {
 const cond = cmd[3];
-if (!cond || lean && !this.leanConditions[cond])
+if (!cond || lean && !this.hardGuards[cond])
 return false;
 if (!this.constructor.tracingParser)
 return !!this[cond]( cmd[4], mode );
@@ -580,9 +537,6 @@ this.s = this.stack[depth].followState;
 
 match = this._pred_next( type, keyword, mode );
 
-
-
-
 }
 this.dynamic_ = dynamic_;
 this.s = savedState;
@@ -660,12 +614,16 @@ cmd ??= this.table[this.s];
 if (!Array.isArray( cmd )) {
 const lookahead = cmd[' lookahead'];
 const dict = cmd;
+cmd = dict[''];
 for (const prop in dict) {
 if (prop && Object.hasOwn( dict, prop ) && prop !== 'Id' &&
-!Object.hasOwn( expecting, prop ) && prop.charAt(0) !== ' ')
+!Object.hasOwn( expecting, prop ) && prop.charAt(0) !== ' ') {
+
+const ad = dict[prop];
+if (ad[1] !== cmd[1] || ad[0] !== 'g')
 this.addTokenToSet_( expecting, prop, val, collectKeywordsAndIdOnly, lookahead );
 }
-cmd = dict[''];
+}
 if (dict.Id) {
 
 if (cmd[0] === 'e') {
@@ -684,13 +642,13 @@ switch (cmd[0]) {
 case 'm': case 'mk':
 this.addTokenToSet_( expecting, cmd[2], val, collectKeywordsAndIdOnly );
 break loop;
-case 'ci': case 'ciA': case 'mi': case 'miA':
+case 'ci': case 'cy': case 'mi': case 'my':
 this.addTokenToSet_( expecting, 'Id', val, false );
 
 
 
 break loop;
-case 'g': case 'gi': case 'e':
+case 'g': case 'e':
 break;
 default:
 if (typeof cmd[0] !== 'number')
@@ -914,17 +872,21 @@ return table;
 for (const line of table) {
 if (typeof line !== 'object' || Array.isArray( line ))
 continue;
-const cache = Object.create( null );
-for (const prop of Object.keys( line )) {
-const alt = line[prop];
-if (!Array.isArray( alt ) && prop.charAt(0) !== ' ')
-line[prop] = (typeof alt === 'string') ? line[alt] : (cache[alt] ??= [ 'g', alt ]);
-}
+for (const prop of Object.keys( line ))
+compileTableItem( line, prop );
 if (!line[''])
 line[''] = [ 'e' ];
 }
 table.$compiled = true;
 return table;
 }
+function compileTableItem( line, prop ) {
+const alt = line[prop];
+if (typeof alt === 'number')
+return line[prop] = [ 'g', alt ];
+else if (typeof alt === 'string' && prop.charAt(0) !== ' ')
+return line[prop] = compileTableItem( line, alt );
+return alt;
+}
 BaseParser.prototype.isNoKeywordInRuleFollow.afterError = true;
 module.exports = BaseParser;

package/lib/gen/CdlGrammar.checksum

@@ -1 +1 @@
-1802b89cdce8e878cb15384d6731099a
+43e8ba55fd2a4f645dcbc0928d83528b