@sap/cds-compiler 5.4.2 → 5.5.0

package/lib/gen/Dictionary.json

@@ -1089,8 +1089,7 @@
       "Type": "Core.Tag",
       "AppliesTo": [
         "EntityContainer"
-      ],
-      "$experimental": true
+      ]
     },
     "Common.mediaUploadLink": {
       "Type": "Edm.String",
@@ -4475,6 +4474,7 @@
       "$kind": "ComplexType",
       "BaseType": "UI.DataFieldAbstract",
       "Properties": {
+        "ID": "Edm.String",
         "Actions": "Collection(UI.DataFieldForActionAbstract)",
         "Label": "Edm.String",
         "Criticality": "UI.CriticalityType",

package/lib/json/to-csn.js

@@ -1202,7 +1202,9 @@ function exprInternal( node, xprParens ) {
   }
   if (node.path) {
     const ref = node.path.map( pathItem );
-    if (node.path.$prefix)      // auto-corrected ORDER BY refs without table alias
+    // auto-corrected ORDER BY refs without table alias, or EXTEND … WITH COLUMN
+    // refs to source element shadowed by alias name:
+    if (node.path.$prefix)
       ref.unshift( node.path.$prefix );
     // we would need to consider node.global here if we introduce that
     return extra( { ref }, node );

package/lib/language/antlrParser.js

@@ -17,11 +17,6 @@ const { XsnSource } = require('../compiler/xsn-model');
 const Parser = require('../gen/languageParser').default;
 const Lexer = require('../gen/languageLexer').default;
 
-const CdlLexer = require( '../parsers/Lexer' );
-const CdlParser = require( '../gen/CdlParser' );
-const { createMessageFunctions } = require( '../base/messages' );
-const { CompilerAssertion } = require( '../base/error' );
-
 // Error listener used for ANTLR4-generated parser
 class ErrorListener extends antlr4.error.ErrorListener {
   // method which is called by generated parser with --trace-parser[-amg]:
@@ -125,18 +120,7 @@ function tokenTypeOf( recognizer, literalName ) {
 // the AST locations and error messages.  If provided, `options` are compile
 // options.
 
-const rules = {
-  cdl: { func: 'start', returns: 'source', $frontend: 'cdl' },
-  query: { func: 'queryEOF', returns: 'query' },
-  expr: { func: 'conditionEOF', returns: 'cond' }, // yes, condition
-};
-
-function parse( source, filename = '<undefined>.cds',
-                options = {}, messageFunctions = null,
-                rule = 'cdl' ) {
-  if (options.newParser)
-    return parseWithNewParser( source, filename, options, messageFunctions, rule );
-
+function parse( source, filename, options, messageFunctions, rulespec ) {
   const lexer = new Lexer( new antlr4.InputStream(source) );
   const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
@@ -179,10 +163,9 @@ function parse( source, filename = '<undefined>.cds',
     parser.addParseListener(options.parseListener);
 
 
-  const rulespec = rules[rule];
   let tree;
   try {
-    tree = rule && parser[rulespec.func]();
+    tree = parser[rulespec.func]();
   }
   catch (e) {
     if (e instanceof RangeError && e.message.match(/Maximum.*exceeded$/i)) {
@@ -219,96 +202,4 @@ function parse( source, filename = '<undefined>.cds',
   return ast;
 }
 
-function parseWithNewParser( source, filename, options, messageFunctions, rule ) {
-  if (CdlParser.tracingParser)  // tracing → direct console output of message
-    messageFunctions = createMessageFunctions( {}, 'parse', {} );
-  const lexer = new CdlLexer( filename, source );
-  const parser = new CdlParser( lexer, options, messageFunctions ).init();
-  parser.filename = filename;   // LSP compatibility
-
-  const { parseListener, attachTokens } = options;
-  if (parseListener || attachTokens) {
-    const combined = [];
-    const { tokens, comments, docComments } = parser;
-    const length = tokens.length + comments.length + docComments.length;
-    let tokenIdx = 0;
-    let commentIdx = 0;
-    let docCommentIdx = 0;
-    for (let index = 0; index < length; ++index) {
-      if (tokens[tokenIdx].location.tokenIndex === index) // EOF has largest tokenIndex
-        combined.push( tokens[tokenIdx++] );
-      else if (comments[commentIdx]?.location.tokenIndex === index)
-        combined.push( comments[commentIdx++] );
-      else
-        combined.push( docComments[docCommentIdx++] );
-    }
-    if (!combined.at( -1 ))
-      throw new CompilerAssertion( 'Invalid values for `tokenIndex`' );
-    for (const tok of combined)
-      tok.start = lexer.characterPos( tok.location.line, tok.location.col );
-
-    parser._input = { tokens: combined, lexer }; // lexer for characterPos() in cdshi.js
-    parser.getTokenStream = function getTokenStream() {
-      return this._input;
-    };
-  }
-  // LSP feature: provide parse listener with ANTLR-like context:
-  if (parseListener) {
-    // TODO LSP: we could also call different listener methods: then LSP could
-    // have dedicated methods for ANTLR-based and new parser
-    parser.rule_ = function rule_( ...args ) {
-      CdlParser.prototype.rule_.apply( this, args );
-      let state = this.s;
-      while (typeof this.table[--state] !== 'string')
-        ;
-      const $ctx = {    // TODO LSP: more to add?
-        parser: this,   // set in generated ANTLR parser for each rule context
-        ruleName: this.table[state], // instead of ruleIndex
-        start: this.la(),       // set in Parser#enterRule
-        stop: null,
-      };
-      parser.stack.at( -1 ).$ctx = $ctx;
-      parseListener.enterEveryRule( $ctx );
-    };
-    parser.exit_ = function exit_( ...args ) {
-      const { $ctx } = parser.stack.at( -1 );
-      // TODO: what should we do in case of errors?
-      $ctx.stop = this.lb();
-      parseListener.exitEveryRule( $ctx );
-      return CdlParser.prototype.exit_.apply( this, args );
-    };
-    parser.c = function c( ...args ) { // consume
-      const symbol = this.la();
-      const result = CdlParser.prototype.c.apply( this, args );
-      if (result)
-        parseListener.visitTerminal( { symbol } );
-      return result;
-    };
-    parser.skipToken_ = function skipToken_( ...args ) { // skip token in error recovery
-      const symbol = this.la();
-      CdlParser.prototype.skipToken_.apply( this, args ); // = `++this.tokenIdx`
-      parseListener.visitErrorNode( { symbol } );
-    };
-  }
-  const result = {};
-  const rulespec = rules[rule];
-  if (rulespec) {
-    try {
-      parser[rulespec.func]( result );
-    }
-    catch (e) {
-      if (!(e instanceof RangeError && /Maximum.*exceeded$/i.test( e.message )))
-        throw e;
-      messageFunctions.error('syntax-invalid-source', { file: filename },
-                             { '#': 'cdl-stackoverflow' } );
-      result[rulespec.returns] = undefined;
-    }
-  }
-  const ast = result[rulespec?.returns] || (rule === 'cdl' ? new XsnSource( 'cdl' ) : {} );
-  ast.options = options;
-  if (attachTokens === true || attachTokens === filename)
-    ast.tokenStream = parser._input;
-  return ast;
-}
-
 module.exports = parse;

package/lib/main.js

@@ -1,19 +1,23 @@
-// Main entry point for the CDS Compiler
+// Main entry point for the CDS Compiler (API)
 //
-// File for external usage = which is read in other modules with
-//   require('cdsv');
+// Other NPM modules must not require any other files than this one.
 
 // Proposed intra-module lib dependencies:
 //  - lib/base/<file>.js: can be required by all others, requires no other
-//    of this project
+//    of this project, except a lib/base/<other-file>.js
+//  - lib/util/<file>.js: TODO - clarify diff to lib/base/
 //  - lib/<dir>/<file>.js: can be required by other files lib/<dir>/,
-//    can require other files lib/<dir>/ and lib/base/<file>.js
+//    can require other files in lib/<dir>/ and lib/base/<file>.js,
+//    and lib/<other-dir>/ (the index.js in <other-dir>).
 //  - lib/main.js (this file): can be required by none in lib/ (only in
 //    bin/ and test/), can require any other
 
 'use strict';
 
+const lazyload = require('./base/lazyload')( module );
+
 const { traceApi } = require('./api/trace');
+
 const snapi = lazyload('./api/main');
 const csnUtils = lazyload('./model/csnUtils');
 const model_api = lazyload('./model/api');
@@ -22,7 +26,7 @@ const sqlIdentifier = lazyload('./sql-identifier');
 const keywords = lazyload( './base/keywords' );
 const toCdl = lazyload('./render/toCdl');
 
-const parseLanguage = lazyload('./language/antlrParser');
+const parsers = lazyload('./parsers');
 const compiler = lazyload('./compiler');
 const shared = lazyload('./compiler/shared');
 const define = lazyload('./compiler/define');
@@ -43,8 +47,8 @@ function parseCdl( cdlSource, filename, options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse', model );
   model.$messageFunctions = messageFunctions;
 
-  const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
-                             messageFunctions );
+  const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
+                                messageFunctions );
   sources[filename] = xsn;
   shared.fns( model );
   define( model );
@@ -55,16 +59,16 @@ function parseCdl( cdlSource, filename, options = {} ) {
 
 function parseCql( cdlSource, filename = '<query>.cds', options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse' );
-  const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
-                             messageFunctions, 'query' );
+  const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
+                                messageFunctions, 'query' );
   messageFunctions.throwWithError();
   return toCsn.compactQuery( xsn );
 }
 
 function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
   const messageFunctions = messages.createMessageFunctions( options, 'parse' );
-  const xsn = parseLanguage( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
-                             messageFunctions, 'expr' );
+  const xsn = parsers.parseCdl( cdlSource, filename, Object.assign( { parseOnly: true }, options ),
+                                messageFunctions, 'expr' );
   messageFunctions.throwWithError();
   return toCsn.compactExpr( xsn );
 }
@@ -191,28 +195,3 @@ module.exports = {
     isInReservedNamespace: (...args) => builtins.isInReservedNamespace(...args),
   },
 };
-
-/**
- * Load the module on-demand and not immediately.
- *
- * @param {string} moduleName Name of the module to load - like with require
- * @returns {object} A Proxy that handles the on-demand loading
- */
-function lazyload(moduleName) {
-  let module;
-  return new Proxy(((...args) => {
-    if (!module)
-      module = require(moduleName);
-
-    if (module.apply && typeof module.apply === 'function')
-      return module.apply(this, args);
-    return module; // for destructured calls
-  }), {
-    get(target, name) {
-      if (!module)
-        module = require(moduleName);
-
-      return module[name];
-    },
-  });
-}

package/lib/modelCompare/utils/filter.js

@@ -61,6 +61,7 @@ module.exports = {
 function getFilterObject( options, dialect, extensionCallback, migrationCallback, removeConstraintsCallback, primaryKeyCallback ) {
   const context = { hasLossyChanges: false };
   const raiseErrorOrMarkAsLossy = getSafeguardManager(context, options);
+  const messageVariant = options.script ? 'script' : 'std';
   return {
     // will be called with a simple Array.filter, as we need to filter constraint `ADD` for SQLite
     extension: ({
@@ -69,7 +70,7 @@ function getFilterObject( options, dialect, extensionCallback, migrationCallback
       let returnValue = true;
       forEach(elements, (name, element) => {
         if (dialect !== 'sqlite' && isKey(element))
-          message('type-unsupported-key-change', [ 'definitions', extend, 'elements', name ], { id: name, '#': 'std' } );
+          message('migration-unsupported-key-change', [ 'definitions', extend, 'elements', name ], { id: name, '#': 'std' } );
         else if (extensionCallback && !extensionCallback(extend, name, element, { error, warning }))
           returnValue = false;
       });
@@ -82,23 +83,31 @@ function getFilterObject( options, dialect, extensionCallback, migrationCallback
     // will be called with a Array.forEach
     migration: (migrations, { error, warning, message }) => {
       forEach(migrations.remove, (name, migration) => {
-        raiseErrorOrMarkAsLossy(migration, () => error('def-unsupported-element-drop', [ 'definitions', migrations.migrate, 'elements', name ], {}, 'Dropping elements is not supported'));
+        raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-element-drop', id => message(id, [ 'definitions', migrations.migrate, 'elements', name ], { '#': messageVariant }));
       });
 
       forEach(migrations.change, (name, migration) => {
         const loc = [ 'definitions', migrations.migrate, 'elements', name ];
-        if (migration.new.type === migration.old.type && migration.new.length < migration.old.length)
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-length-change', loc, { id: name }, 'Changed element $(ID) is a length reduction and is not supported'));
-        else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale)
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-scale-change', loc, { id: name }, 'Changed element $(ID) is a scale change and is not supported'));
-        else if (migration.new.type === migration.old.type && migration.new.precision !== migration.old.scale)
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-precision-change', loc, { id: name }, 'Changed element $(ID) is a precision change and is not supported'));
-        else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type))
-          raiseErrorOrMarkAsLossy(migration, () => error('type-unsupported-change', loc, { id: name, name: migration.old.type, type: migration.new.type }, 'Changed element $(ID) is a lossy type change from $(NAME) to $(TYPE) and is not supported'));
-        else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
-          raiseErrorOrMarkAsLossy(migration, () => message('type-unsupported-key-change', [ 'definitions', migrations.migrate, 'elements', name ], { id: name, '#': 'changed' } ));
-        else if (migrationCallback)
+        if (migration.new.type === migration.old.type && migration.new.length < migration.old.length) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-length-change', id => message(id, loc, { '#': messageVariant, id: name }));
+        }
+        else if (migration.new.type === migration.old.type && migration.new.scale !== migration.old.scale) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-scale-change', id => message(id, loc, { '#': messageVariant, id: name }));
+        }
+        else if (migration.new.type === migration.old.type && migration.new.precision !== migration.old.scale) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-precision-change', id => message(id, loc, { '#': messageVariant, id: name }));
+        }
+        else if (migration.new.type !== migration.old.type && typeChangeIsNotCompatible(dialect, migration.old.type, migration.new.type)) {
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-change', id => message(id, loc, {
+            '#': messageVariant, id: name, name: migration.old.type, type: migration.new.type,
+          }));
+        }
+        else if (dialect !== 'sqlite' && isKey(migration.new) && !isKey(migration.old)) { // key added/changed - pg, hana and sqlite do not support it, h2 probably also - issues when data is in the table already
+          raiseErrorOrMarkAsLossy(name, migration, 'migration-unsupported-key-change', id => message( id, [ 'definitions', migrations.migrate, 'elements', name ], { id: name, '#': 'changed' } ));
+        }
+        else if (migrationCallback) {
           migrationCallback(migrations.migrate, name, migration, migrations.change, error);
+        }
 
         if (options.script && migration.lossy && migrationCallback)
           migrationCallback(migrations.migrate, name, migration, migrations.change, error);
@@ -115,9 +124,9 @@ function getFilterObject( options, dialect, extensionCallback, migrationCallback
         });
       }
     },
-    deletion: ([ artifactName, artifact ], error) => {
+    deletion: ([ artifactName, artifact ], { message }) => {
       if (isPersistedAsTable(artifact))
-        raiseErrorOrMarkAsLossy(artifact, () => error('def-unsupported-table-drop', [ 'definitions', artifactName ], 'Dropping tables is not supported'));
+        raiseErrorOrMarkAsLossy(artifactName, artifact, 'migration-unsupported-table-drop', id => message(id, [ 'definitions', artifactName ], { '#': messageVariant }));
     },
     changedPrimaryKeys: (changedPrimaryKeyArtifactName) => {
       if (primaryKeyCallback)
@@ -191,13 +200,30 @@ function filterCsn( csn ) {
 }
 
 function getSafeguardManager( context, options ) {
-  return function raiseErrorOrMarkAsLossy(migration, raiseError) {
-    if (!options.script) {
-      raiseError();
-    }
-    else {
-      migration.lossy = true;
+  return function raiseErrorOrMarkAsLossy(name, migration, id, raiseMessage) {
+    raiseMessage(id);
+
+    if (options.script) {
+      migration.details = getDetails(id, name);
+      migration.lossy = id !== 'migration-unsupported-key-change';
       context.hasLossyChanges = true;
     }
   };
 }
+
+const details = {
+  'migration-unsupported-element-drop': 'drop of element',
+  'migration-unsupported-length-change': 'length reduction of element',
+  'migration-unsupported-scale-change': 'scale reduction of element',
+  'migration-unsupported-precision-change': 'precision reduction of element',
+  'migration-unsupported-change': 'incompatible type change of element',
+  'migration-unsupported-key-change': 'key property change of element',
+  'migration-unsupported-table-drop': 'drop of entity',
+};
+
+function getDetails(id, name) {
+  if (details[id])
+    return `${details[id] } "${ name }" - check warnings for details`;
+
+  return null;
+}

package/lib/parsers/AstBuildingParser.js

@@ -70,37 +70,31 @@ class AstBuildingParser extends BaseParser {
     return this.$messageFunctions.info( id, location?.location || location, args, text );
   }
 
-  expectingArray( token ) {
-    const expecting = this._expecting( token );
-    let array = Object.keys( expecting );
-    // compatibility: replace true+false by Boolean
-    if (expecting.true && expecting.false)
+  expectingArray() {
+    let array = this.expectingArray_();
+    // compatibility: replace true+false by Boolean - TODO: delete
+    if (array.includes( 'true' ))
       array = [ 'Boolean', ...array.filter( n => n !== 'true' && n !== 'false' ) ];
     return array.map( antlrName )
       .sort( (a, b) => (tokenPrecedence(a) < tokenPrecedence(b) ? -1 : 1) );
   }
 
-  reportUnexpectedToken_( token ) {
-    const expecting = this.expectingArray( token );
+  reportUnexpectedToken_() {
+    const token = this.la();
+    const expecting = this.expectingArray();
     const err = this.error( 'syntax-unexpected-token', token,
                             { offending: antlrName( token ), expecting } );
     // No 'unwanted' variant, no 'syntax-missing-token'
     err.expectedTokens = expecting;
   }
-  reportReservedWord_( token ) {
+  reportReservedWord_() {
+    const token = this.la();
     const err = this.message( 'syntax-unexpected-reserved-word', token,
                               { code: token.text, delimited: token.text } );
     // TODO: at least if one expected keyword is similar, mention expected set
     err.expectedTokens = this.expectingArray();
   }
 
-  reportInternalError_( token ) {
-    this.error( null, token, { offending: antlrName( token ) },
-                'Mismatched $(OFFENDING); skipped one token' );
-    // TMP: should not happen anymore → remove method in redepage
-    throw new Error( 'Repeated error reporting with same token' );
-  }
-
   tableWithoutAs() {
     // TODO TOOL: if the tool properly creates `default: this.giR()`, this
     // condition method is most likely not necessary
@@ -180,7 +174,7 @@ class AstBuildingParser extends BaseParser {
     return this.lGenericIntroOrExpr( false );
   }
 
-  lGenericSeparator() {
+  lGenericSeparator() {         // TODO: { keyword, type } as arg ?
     const { keyword, type } = this.la();
     // TODO: use lower-case in specialFunctions
     const text = typeof keyword === 'string' ? keyword.toUpperCase() : type;
@@ -191,7 +185,7 @@ class AstBuildingParser extends BaseParser {
   translateParserToken_( tokenName ) {
     const realTokens = this.dynamic_.generic?.[parserTokens[tokenName]];
     // TODO: avoid parserTokens dict, use lower-case in specialFunctions
-    return realTokens?.map( s => s.toLowerCase() ) ?? [];
+    return realTokens?.map( s => s.toLowerCase() ) ?? [ tokenName ];
   }
 
   inSelectItem( _test, arg ) {  // only as action
@@ -211,14 +205,14 @@ class AstBuildingParser extends BaseParser {
       return true;
     // TODO: it would be best to set this.dynamic_.inSelectItem to null in filters
     // (as <prepare>)
-    const next = this.tokens[this.tokenIdx + 1].type;
+    const next = this.tokens[this.tokenIdx + 1]?.type;
     return next !== '*' && next !== '{';
   }
 
   // <prec=10, postfix=once> + test that the next token is not `null`; TODO: code
   // completion for `… default 3 not ~;` → currently just `null` but hey
   isNegatedRelation( _test, prec ) {
-    return this.tokens[this.tokenIdx + 1].keyword !== 'null' &&
+    return this.tokens[this.tokenIdx + 1]?.keyword !== 'null' &&
       this.precNone_( _test, prec );
   }
 
@@ -261,13 +255,13 @@ class AstBuildingParser extends BaseParser {
    *
    * Called as <prepare=…>:
    *
-   * - <…, arg=default> in `returnsSpec`: after `returns`
-   *   disallow `default` in `typeExpression`
    * - <…,arg=elem> in `elementDef` (before calling `typeExpression`):
    *   allow `default`/`= calcExpr` with final annotation assignments,
    *   delay final doc comment
+   * - <…, arg=default> in `returnsSpec`: after `returns`
+   *   disallow `default` in `typeExpression`
    * - <…, arg=calc> in `typeExpression` (with associations, etc)
-   *   now disallow `= calcExpr` (with annotation assignments) in `elementDef`,
+   *   now disallow `= calcExpr` in `elementDef`,
    *   do not delay final doc comments anymore
    * - <…, arg=anno> in `typeExpression` after enums:
    *   now disallow annotation assignments after `= calcExpr`,
@@ -275,25 +269,48 @@ class AstBuildingParser extends BaseParser {
    *
    * Called as <cond=…>:
    *
-   * - <…, arg=default> in `nullabilityAndDefault`:
-   *   is `default` allowed?  If used, disallow calc (with anno assignments)
+   * - <…, arg=default> in `typeExpression` and `typeProperties`
+   *   is `default` allowed?  If used, disallow calc and further DEFAULT
+   * - <…, arg=notNull> in `typeExpression` and `typeProperties`
+   *   is `null`/`not null` allowed? ensures that it is only used once
    * - <…, arg=calc> in `elementDef`:
-   *   is `= calcExpr` allowed?  If so, check for final doc
+   *   is `= calcExpr` allowed? not with struct, assoc or MANY…
    * - <…, arg=anno> in `elementDef`:
-   *   are annotation assignments after `= calcExpr` allowed?
+   *   are annotation assignments after `= calcExpr` allowed? not with ENUM…
+   *
+   * The value of the dynamic var `elementCtx` looks like [REJECTED, DEFAULT,
+   * NOTNULL] where
+   *
+   * - REJECTED is the string containing a to-be-rejected test `arg`
+   * - DEFAULT: true if `default` had been provided
+   * - NOTNULL: true if `null` or `not null` had been provided
    */
   elementRestriction( test, arg ) {
-    const { elementCtx } = this.dynamic_;
+    let { elementCtx } = this.dynamic_;
     if (test) {
-      if (!elementCtx || elementCtx[0] === arg)
-        return !elementCtx;
+      if (elementCtx?.[0] === arg)
+        return false;
+      if (!elementCtx) { // with type, param, or annotation defs
+        // eslint-disable-next-line no-multi-assign
+        elementCtx = this.dynamic_.elementCtx = [ null, false, false ];
+      }
       if (arg === 'default') {
+        if (elementCtx[1])
+          return false;
+        elementCtx[1] = true;
         elementCtx[0] = 'calc';
         this.prec_ = PRECEDENCE_OF_EQUAL; // only expressions for DEFAULT expr
       }
+      else if (arg === 'notNull') {
+        if (elementCtx[2]) {
+          if (this.la().keyword !== elementCtx[2] || test === 'M') // TODO v6: always error
+            return false;       // error if different nullibility specification
+        }
+        elementCtx[2] = this.la().keyword;
+      }
     }
     else if (arg === 'elem' || arg === 'default') {
-      this.dynamic_.elementCtx = [ arg ];
+      this.dynamic_.elementCtx = [ arg, false, false ];
     }
     else if (elementCtx) {
       elementCtx[0] = arg;
@@ -737,22 +754,10 @@ class AstBuildingParser extends BaseParser {
    *  - misplaced doc comments would lead to a parse error (incompatible),
    *  - would influence the prediction and error recovery,
    *  - is only slightly "more declarative" in the grammar.
-   *
-   * With argument `delayed`, potentially delay the doc processing.
-   * See also `elementRestriction`.
    */
-  docComment( art, delayed = undefined ) {
-    if (delayed !== this.dynamic_?.[0]) {
-      if (delayed === 'type')
-        return;
-    }
-    else if (delayed === 'elem') {
-      this.dynamic_[0] = 'type';
-      return;
-    }
-
+  docComment( art ) {
     const { line: prevLine, col: prevCol } = this.lb()?.location ?? { line: 0, col: 0 };
-    const { line: currLine, col: currCol } = this.la().location;
+    const { line: currLine, col: currCol } = (this.la() ?? this.lb()).location;
     let token;
     for (;;) {
       token = this.docComments[this.docCommentIndex];
@@ -801,13 +806,16 @@ class AstBuildingParser extends BaseParser {
   setNullability( art, val, location = this.lb().location ) {
     const notNull = { val, location };
     if (art.notNull) {
-      this.reportDuplicateClause( 'notNull', art.notNull, notNull,
+      // complain about the second
+      this.reportDuplicateClause( 'notNull', notNull, art.notNull,
                                   (val ? 'not null' : 'null') );
     }
-    art.notNull = notNull;
+    else {
+      art.notNull = notNull;
+    }
   }
 
-  setAssocAndComposition( art, assoc, card, target ) {
+  setAssocAndComposition( art, assoc, card, target = {} ) {
     const { location } = assoc;
     art.type = {
       path: [ { id: keywordTypeNames[assoc.keyword], location } ],
@@ -816,7 +824,7 @@ class AstBuildingParser extends BaseParser {
     };
     art.target = target;
     if (!card)
-      return;
+      return target;
 
     const targetMax = (card.keyword === 'one')
       ? { val: 1, literal: 'number', location: card.location }
@@ -829,6 +837,7 @@ class AstBuildingParser extends BaseParser {
     else {
       art.cardinality = { targetMax, location: targetMax.location };
     }
+    return target;
   }
 
   reportExpandInline( column, isInline ) {
@@ -868,9 +877,10 @@ class AstBuildingParser extends BaseParser {
       col: chosen.location.col,
     };
     if (erroneous.val === chosen.val) {
+      // TODO v6: duplicate clause = error, independently whether it is the same
       this.warning( 'syntax-duplicate-equal-clause', erroneous.location, args );
     }
-    else {
+    else if (prop !== 'notNull') { // already via guard in grammar
       if (literalValIfNotEq)
         args.code = chosen.val;
       this.message( 'syntax-duplicate-clause', erroneous.location, args );