@sap/cds-compiler 4.3.2 → 4.4.0

package/lib/json/from-csn.js

@@ -44,9 +44,11 @@
  *     Use this message variant instead of the default one.
  *     Allows more precise and detailed error messages.
  *
- * @property {string|string[]|false}  [requires]
- *     If the value is a string, then the given sub-property is required. If 'undefined', then at
- *     least one property is required. If false the no sub-properties are required.
+ * @property {string|string[]|Function|false}  [requires]
+ *     If the value is a(n array of) string, then (one of) the given sub-property is required.
+ *     If a function, that function issues its own message.
+ *     If `undefined` (default), then at least one property is required.
+ *     If false, then no sub-properties are required.
  *
  * @property {boolean}  [noPrefix]
  *     Only used for '#' at the moment. Signals that the entry should not be used for keys
@@ -117,7 +119,8 @@
  */
 
 const { dictAdd } = require('../base/dictionaries');
-const { quotedLiteralPatterns } = require('../compiler/builtins');
+// TODO: move parts of lib/compiler/builtins to some lib/base/…:
+const { isAnnotationExpression, quotedLiteralPatterns } = require('../compiler/builtins');
 const { CompilerAssertion } = require('../base/error');
 const { XsnSource, CsnLocation } = require('../compiler/classes');
 
@@ -171,17 +174,6 @@ const xorGroups = {
   // quantifiers 'some' and 'any are 'xpr' token strings in CSN v1.0
 };
 
-/**
- * Properties that are required next to `=` to make an annotation value an actual expression
- * and not some foreign structure.
- *
- * @type {string[]}
- */
-const xprInAnnoProperties = [
-  'ref', 'xpr', 'list', 'literal', 'val',
-  '#', 'func', 'args', 'SELECT', 'SET',
-];
-
 // Functions reading properties which do not count for the message
 // 'Object in $(PROP) must have at least one property'
 const functionsOfIrrelevantProps = [ ignore, extra, explicitName ];
@@ -661,7 +653,11 @@ const schema = compileSchema( {
       '-expr': { // '-expr' and '-' must not exist top-level
         prop: '@‹anno›',
         type: object,
-        optional: [ '=', '#', 'xpr', 'ref', 'val', 'list', 'literal', 'func', 'args', 'param' ],
+        optional: [
+          '=', '#', 'xpr', 'ref', 'val', 'list',
+          'literal', 'func', 'args', 'param',
+          'cast',
+        ],
         schema: {
           '=': {
             type: renameTo( '$tokenTexts', string ),
@@ -1440,7 +1436,6 @@ function annoValue( val, spec ) {
     // An object with `=` is an expression if and only if:
     //  - there is exactly one property ('=')
     //  - there is at least one other expression property (e.g. "xpr")
-    // TODO: Have xprInAnnoProperties centrally for other backends to use as well (toCdl)
     const valKeys = Object.keys( val );
     if (valKeys.length === 1) {
       ++virtualLine;
@@ -1448,7 +1443,7 @@ function annoValue( val, spec ) {
       ++virtualLine;
       return r;
     }
-    else if (xprInAnnoProperties.some( prop => val[prop] !== undefined) ) {
+    else if (isAnnotationExpression( val )) {
       const s = schema['@'].schema['-expr'];
       const r = { location: location() };
       Object.assign( r, object( val, s ) );

package/lib/json/to-csn.js

@@ -45,7 +45,8 @@ const $inferred = Symbol.for('cds.$inferred');
 const inferredAsGenerated = {
   autoexposed: 'exposed',
   'localized-entity': 'localized',
-  localized: 'localized',       // on elements (texts, localized)
+  localized: 'localized',       // on elements (texts, localized, language)
+  // remark: not on 'localize-origin' = other elements of inferred base entity
   'composition-entity': 'composed', // ('aspect-composition' on element not in CSN)
 };
 
@@ -675,9 +676,9 @@ function dollarSyntax( node, csn ) {
 function ignore() { /* no-op: ignore property */ }
 
 function location( loc, csn, xsn ) {
-  if (xsn.kind && xsn.kind.charAt(0) !== '$' && xsn.kind !== 'select' &&
-      (!xsn.$inferred || !xsn._main)) { // TODO: also for 'select'
-    // Also include $location for elements in queries (if not via '*')
+  if (xsn.kind && xsn.kind.charAt(0) !== '$' && xsn.kind !== 'select' && // TODO: also for 'select'
+      (!xsn.$inferred || !xsn._main)) {
+    // Also include $location for elements in queries (if not via '*' except for autoexposed)
     addLocation( xsn.name && xsn.name.location || loc, csn );
   }
 }
@@ -768,7 +769,8 @@ function definition( art, _csn, _node, prop ) {
   if (art.kind === 'key') {      // foreignkey
     const key = addExplicitAs( { ref: art.targetElement.path.map( pathItem ) },
                                art.name, neqPath( art.targetElement ) );
-    addLocation( art.targetElement.location, key );
+    if (!art.$inferred)
+      addLocation( art.targetElement.location, key );
     return extra( key, art );
   }
   const c = standard( art );
@@ -1191,8 +1193,9 @@ function value( node ) {
   if (!node)
     return true;                // `@aBool` short for `@aBool: true`
   if (universalCsn && node.$inferred) {
+    // TODO: return undefined for all values of node.$inferred (except 'NULL')?
     if (node.$inferred === 'prop' || node.$inferred === '$generated' || // via propagator.js
-      node.$inferred === 'parent-origin')
+        node.$inferred === 'parent-origin')
       return undefined;
     else if (node.$inferred === 'NULL')
       return null;
@@ -1250,6 +1253,8 @@ function condition( node ) {
 }
 
 function expression( node ) {
+  if (node?.$inferred && (gensrcFlavor || universalCsn || node.$inferred === 'NULL'))
+    return undefined; // Note: No `null` for universal CSN at the moment
   const expr = exprInternal( node, 'no' );
   return (Array.isArray( expr ))
     ? { xpr: flattenInternalXpr( expr, node.op?.val ) }

package/lib/language/antlrParser.js

@@ -126,7 +126,6 @@ function parse( source, filename = '<undefined>.cds',
   // comment the following 2 lines if you want to output the parser errors directly:
   parser.messageErrorListener = errorListener;
   parser._errHandler = new errorStrategy.KeywordErrorStrategy();
-  parser.match = errorStrategy.match;
   parser._interp.predictionMode = antlr4.atn.PredictionMode.SLL;
   // parser._interp.predictionMode = antlr4.atn.PredictionMode.LL_EXACT_AMBIG_DETECTION;
 

package/lib/language/docCommentParser.js

@@ -39,7 +39,7 @@ function parseDocComment( comment ) {
     // Remove "/***/" and trim white space and asterisks.
     const content = lines[0]
       .replace(/^\/[*]{2,}/, '')
-      .replace(/\*+\/$/, '')
+      .replace(/\**\/$/, '') // for `/*****/`, only `/` remains
       .replace('*\\/', '*/') // escape sequence
       .trim();
     return isWhitespaceOrNewLineOnly(content) ? null : content;

package/lib/language/errorStrategy.js

@@ -45,27 +45,6 @@ const keywordRegexp = /^[a-zA-Z]+$/; // we don't have keywords with underscore
 let SEMI = null;
 let RBRACE = null;
 
-// Match current token against token type `ttype` and consume it if successful.
-// Also allow to match keywords as identifiers.  This function should be set as
-// property `match` to the parser (prototype).  See also `recoverInline()`.
-function match( ttype ) {
-  const identType = this.constructor.Identifier;
-  if (ttype !== identType)
-    return antlr4.Parser.prototype.match.call( this, ttype );
-
-  const token = this.getCurrentToken();
-  if (token.type === identType || !keywordRegexp.test( token.text ))
-    return antlr4.Parser.prototype.match.call( this, ttype );
-  // This is very likely to be dead code: we do not use a simple Identifier
-  // without alternatives in the grammar.  With alternatives, recoverInline() is
-  // the place to go.  (But this code should work with a changed grammar…)
-  this.message( 'syntax-unexpected-reserved-word', token,
-                { code: token.text, delimited: token.text } );
-  this._errHandler.reportMatch(this);
-  this.consume();
-  return token;
-}
-
 // Class which adapts ANTLR4s standard error strategy: do something special
 // with (non-reserved) keywords.
 //
@@ -85,6 +64,7 @@ class KeywordErrorStrategy extends DefaultErrorStrategy {
 // TODO: Use actual methods
 Object.assign( KeywordErrorStrategy.prototype, {
   sync,
+  singleTokenDeletion,
   reportNoViableAlternative,
   reportInputMismatch,
   reportUnwantedToken,
@@ -102,6 +82,7 @@ Object.assign( KeywordErrorStrategy.prototype, {
 // Attempt to recover from problems in subrules, except if rule has defined a
 // local variable `_sync` with value 'nop'
 // TODO: consider performance - see #8800
+// See DefaultErrorStrategy#sync
 function sync( recognizer ) {
   // If already recovering, don't try to sync
   if (this.inErrorRecoveryMode(recognizer))
@@ -176,6 +157,8 @@ function sync( recognizer ) {
         this.consumeUntil( recognizer, nextTokens );
         return;
       }
+      // TODO: at least with STAR_LOOP_ENTRY, we might want to do s/th similar as
+      // with LOOP_BACK (syncing to “expected tokens” -> the separator)
       throw new InputMismatchException(recognizer);
 
     case ATNState.PLUS_LOOP_BACK: // 11
@@ -184,15 +167,93 @@ function sync( recognizer ) {
       this.reportUnwantedToken(recognizer);
       const expecting = new IntervalSet();
       expecting.addSet(recognizer.getExpectedTokens());
+
+      // First try some ',' insertion (TODO does not work yet):
+      if (trySeparatorInsertion( recognizer, expecting, "','" ))
+        return;
+
+      // We then try syncing only to the loop-cont (`,`) / loop-end (`}`) token set,
+      // but only for the current or next line (and not consuming `;`s):
+      const prevToken = recognizer.getTokenStream().LT(-1);
+      if (token.line <= prevToken.line + 1 && // in same or next line
+          this.consumeAndMarkUntil( recognizer, expecting, true ))
+        break;
+      // console.log(token.text,JSON.stringify(intervalSetToArray(recognizer,expecting)))
+
+      // If that fails, we also sync to all tokens which are in the follow set of
+      // the current rule and all outer rules
       const whatFollowsLoopIterationOrRule = expecting.addSet(this.getErrorRecoverySet(recognizer));
       this.consumeUntil(recognizer, whatFollowsLoopIterationOrRule);
-      break;
+      // console.log(JSON.stringify(intervalSetToArray(recognizer,expecting)))
+      if (recognizer._ctx._sync === 'recover' || // in start rule: no exception
+          nextTokens.contains( recognizer.getTokenStream().LA(1) ))
+        return;
+      throw new InputMismatchException(recognizer);
     }
     default:
     // do nothing if we can't identify the exact kind of ATN state
   }
 }
 
+
+function trySeparatorInsertion( recognizer, expecting, separatorName ) {
+  // Remark: this function does not really work, because it is based on
+  // singleTokenInsertion, which also does not really work… (see below).
+  // But we might improve it in the future…
+  const separator = recognizer.literalNames.indexOf( separatorName );
+  if (!expecting.contains( separator ))
+    return false;
+
+  const currentSymbolType = recognizer.getTokenStream().LA(1);
+  // if current token is consistent with what could come after current
+  // ATN state, then we know we're missing a token; error recovery
+  // is free to conjure up and insert the missing token
+  const { atn } = recognizer._interp;
+  const currentState = atn.states[recognizer.state];
+  const next = separatorTransition( currentState.transitions, separator ).target;
+  // While this is an improvement to the default ANTLR code for
+  // singleTokenInsertion(), it still does not help, as we navigate along an
+  // epsilon transition, i.e. we still see ',', etc
+  const expectingAtLL2 = atn.nextTokens(next, recognizer._ctx);
+  if (!expectingAtLL2.contains(currentSymbolType))
+    return false;
+
+  this.reportMissingToken(recognizer);
+  return getMissingSymbol( recognizer, separator );
+}
+
+function separatorTransition( transitions, separator ) {
+  for (const tr of transitions) {
+    if (tr.matches( separator ))
+      return tr;
+  }
+  return transitions[0];
+}
+
+function singleTokenDeletion( recognizer ) {
+  const token = recognizer.getCurrentToken();
+  if (!token || token.text === '}')
+    return null;
+
+  const nextTokenType = recognizer.getTokenStream().LA(2);
+  const { Number } = recognizer.constructor;
+  if (nextTokenType > Number && // next token is Id|Unreserved|IllegalToken
+      token.type <= Number)     // current token is not
+    return null;
+
+  const expecting = this.getExpectedTokens(recognizer);
+  if (!expecting.contains(nextTokenType))
+    return null;
+
+  this.reportUnwantedToken(recognizer);
+  recognizer.consume(); // simply delete extra token
+  // we want to return the token we're actually matching
+  const matchedSymbol = recognizer.getCurrentToken();
+  this.reportMatch( recognizer ); // we know current token is correct
+  return matchedSymbol;
+}
+
+
 // singleTokenInsertion called by recoverInline (called by match / in else),
 // calls reportMissingToken
 
@@ -234,14 +295,14 @@ function reportInputMismatch( recognizer, e, deadEnds ) {
 }
 
 // Report unwanted token when the parser `recognizer` tries to recover/sync
-function reportUnwantedToken( recognizer ) {
+function reportUnwantedToken( recognizer, expecting ) {
   if (this.inErrorRecoveryMode(recognizer))
     return;
   this.beginErrorCondition(recognizer);
 
   const token = recognizer.getCurrentToken();
   token.$isSkipped = 'offending';
-  const expecting = this.getExpectedTokensForMessage( recognizer, token );
+  expecting ??= this.getExpectedTokensForMessage( recognizer, token );
   const offending = this.getTokenDisplay( token, recognizer );
   // Just text variant, no other message id!  Would depend on ANTLR-internals
   const err = recognizer.error( 'syntax-unexpected-token', token,
@@ -323,14 +384,19 @@ function consumeUntil( recognizer, set ) {
   }
 }
 
-function consumeAndMarkUntil( recognizer, set ) {
-  let t = recognizer.getTokenStream().LT(1);
+function consumeAndMarkUntil( recognizer, set, onlyInSameLine ) {
+  const stream = recognizer.getTokenStream();
+  let t = stream.LT(1);
+  const { line } = t;
   while (t.type !== antlr4.Token.EOF && !set.contains( t.type )) {
+    if (onlyInSameLine && (t.line !== line || t.text === ';' || t.text === '}' ))
+      return false;              // early exit
     if (!t.$isSkipped)
       t.$isSkipped = true;
     recognizer.consume();
-    t = recognizer.getTokenStream().LT(1);
+    t = stream.LT(1);
   }
+  return true;
 }
 
 // As the `match` function of the parser `recognizer` does not allow to check
@@ -363,8 +429,8 @@ function recoverInline( recognizer ) {
 // Conjure up a missing token during error recovery in parser `recognizer`.  If
 // an identifier is expected, create one.
 // Think about: we might want to prefer one of '}]);,'.
-function getMissingSymbol( recognizer ) {
-  const expectedTokenType = this.getExpectedTokens(recognizer).first(); // get any element
+function getMissingSymbol( recognizer, expectedTokenType ) {
+  expectedTokenType ??= this.getExpectedTokens(recognizer).first(); // get any element
   const current = recognizer.getCurrentToken();
   return recognizer.getTokenFactory().create(
     current.source,             // do s/th special if EOF like in DefaultErrorStrategy ?
@@ -556,6 +622,5 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
 }
 
 module.exports = {
-  match,
   KeywordErrorStrategy,
 };

package/lib/language/genericAntlrParser.js

@@ -130,6 +130,7 @@ Object.assign(GenericAntlrParser.prototype, {
   checkTypeFacet,
   checkTypeArgs,
   csnParseOnly,
+  markAsSkippedUntilEOF,
   noAssignmentInSameLine,
   noSemicolonHere,
   setLocalToken,
@@ -249,6 +250,25 @@ function setLocalTokenForId( offset, tokenNameMap ) {
 //     // throw new antlr4.error.InputMismatchException(this);
 // }
 
+function markAsSkippedUntilEOF() {
+  let t = this.getCurrentToken();
+  if (t.type === antlr4.Token.EOF)
+    return;
+  if (!t.$isSkipped && !this._errHandler.inErrorRecoveryMode( this )) {
+    // If not already done, we should report an error if we do not see EOF.  We cannot
+    // use match() here, because these would consume tokens without marking them.
+    this._errHandler.reportUnwantedToken( this, [ '<EOF>' ] );
+    t.$isSkipped = 'offending';
+    this.consume();
+    t = this.getCurrentToken();
+  }
+  while (t.type !== antlr4.Token.EOF) {
+    t.$isSkipped = true;
+    this.consume();
+    t = this.getCurrentToken();
+  }
+}
+
 function noAssignmentInSameLine() {
   const t = this.getCurrentToken();
   if (t.text === '@' && t.line <= this._input.LT(-1).line) {
@@ -928,12 +948,12 @@ function signedExpression( args, expr ) {
 function numberLiteral( token, sign, text = token.text ) {
   let location = this.tokenLocation( token );
   if (sign) {
-    // TODO: warning for space in between
     const { endLine, endCol } = location;
     location = this.startLocation( sign );
     location.endLine = endLine;
     location.endCol = endCol;
     text = sign.text + text;
+    this.reportUnexpectedSpace( sign, this.tokenLocation( token ) );
   }
 
   const num = Number.parseFloat( text || '0' ); // not Number.parseInt() !

package/lib/main.js

@@ -13,6 +13,7 @@
 
 'use strict';
 
+const { traceApi } = require('./api/trace');
 const snapi = lazyload('./api/main');
 const csnUtils = lazyload('./model/csnUtils');
 const model_api = lazyload('./model/api');
@@ -75,9 +76,18 @@ function parseExpr( cdlSource, filename = '<expr>.cds', options = {} ) {
 module.exports = {
   // Compiler
   version,
-  compile: (...args) => compiler.compileX(...args).then( toCsn.compactModel ), // main function
-  compileSync: (filenames, dir, options, fileCache) => toCsn.compactModel( compiler.compileSyncX(filenames, dir, options, fileCache) ), // main function
-  compileSources: (sourcesDict, options) => toCsn.compactModel( compiler.compileSourcesX(sourcesDict, options) ), // main function
+  compile: (filenames, dir, options, fileCache) => { // main function
+    traceApi( 'compile', options );
+    return compiler.compileX(filenames, dir, options, fileCache).then(toCsn.compactModel);
+  },
+  compileSync: (filenames, dir, options, fileCache) => { // main function
+    traceApi('compileSync', options);
+    return toCsn.compactModel(compiler.compileSyncX(filenames, dir, options, fileCache));
+  },
+  compileSources: (sourcesDict, options) => { // main function
+    traceApi('compileSources', options);
+    return toCsn.compactModel(compiler.compileSourcesX(sourcesDict, options));
+  },
   compactModel: csn => csn,     // for easy v2 migration
   get CompilationError() {
     Object.defineProperty(this, 'CompilationError', {

package/lib/model/csnRefs.js

@@ -194,6 +194,7 @@
 const BUILTIN_TYPE = {};
 const { locationString } = require('../base/location');
 const { ModelError, CompilerAssertion } = require('../base/error');
+const { isAnnotationExpression } = require('../compiler/builtins');
 
 // Properties in which artifact or members are defined - next property in the
 // "csnPath" is the name or index of that property; 'args' (its value can be a
@@ -221,6 +222,8 @@ const referenceSemantics = {
   inline: { lexical: justDollar, dynamic: 'inline' },   // ...using baseEnv
   ref_where: { lexical: justDollar, dynamic: 'ref-target' }, // ...using baseEnv
   on: { lexical: justDollar, dynamic: 'query' }, // assoc defs, redirected to
+  annotation: { lexical: justDollar, dynamic: 'query' }, // anno top-level `ref`
+  annotationExpr: { lexical: justDollar, dynamic: 'query' }, // annotation assignment
   // there are also 'on_join' and 'on_mixin' with default semantics
   orderBy_ref: { lexical: query => query, dynamic: 'query' },
   orderBy_expr: { lexical: query => query, dynamic: 'source' }, // ref in ORDER BY expression
@@ -467,6 +470,16 @@ function csnRefs( csn, universalReady ) {
     return art[property];
   }
 
+  function boundActionOrMain( art ) {
+    while (art.kind !== 'action' && art.kind !== 'function') {
+      const p = getCache( art, '_parent' );
+      if (!p)
+        return art;
+      art = p;
+    }
+    return art;
+  }
+
   function initDefinition( main ) {
     // TODO: some --test-mode check that the argument is in ‹csn›.definitions ?
     if (getCache( main, '$queries' ) !== undefined) // already computed
@@ -572,13 +585,16 @@ function csnRefs( csn, universalReady ) {
     const path = (typeof ref === 'string') ? [ ref ] : ref.ref;
     if (!Array.isArray( path ))
       throw new ModelError( 'References must look like {ref:[...]}' );
-
-    const head = pathId( path[0] );
     if (main)                   // TODO: improve, for csnpath starting with art
       initDefinition( main );
-    if (ref.param)
-      return resolvePath( path, main.params[head], main, 'param' );
 
+    const head = pathId( path[0] );
+    if (ref.param) {
+      const boundOrMain = (query || !main.actions || parent === main)
+        ? main               // shortcut (would also have been return by function)
+        : boundActionOrMain( parent );
+      return resolvePath( path, boundOrMain.params[head], boundOrMain, 'param' );
+    }
     const semantics = referenceSemantics[refCtx] || {};
     if (semantics.$initOnly)
       return undefined;
@@ -644,6 +660,7 @@ function csnRefs( csn, universalReady ) {
 
       if (semantics.dynamic === 'query') {
         // TODO: for ON condition in expand, would need to use cached _element
+        // TODO: test and implement - Issue #11792!
         return resolvePath( path, qcache.elements[head], null, 'query' );
       }
       for (const name in qcache.$aliases) {
@@ -1002,7 +1019,7 @@ function startCsnPath( csnPath, csn ) {
     throw new CompilerAssertion( 'References outside definitions and vocabularies not supported yet');
   const art = csn[csnPath[0]][csnPath[1]];
   return {
-    index: 2, main: art, parent: null, art,
+    index: 2, main: art, parent: art, art,
   };
 }
 
@@ -1033,10 +1050,23 @@ function analyseCsnPath( csnPath, csn, resolve ) {
       break;
 
     const prop = csnPath[index];
+    if (refCtx === 'annotation' && typeof obj === 'object') {
+      // we do not know yet whether the annotation value is a expression or not →
+      // loop over outer array and records (structure values):
+      if (Array.isArray( obj ) || !isAnnotationExpression( obj )) {
+        obj = obj[prop];
+        continue;
+      }
+      refCtx = 'annotationExpr';
+    }
     // array item, name/index of artifact/member, (named) argument
     if (isName || Array.isArray( obj ) || prop === 'returns') {
       // TODO: call some kind of resolve.setOrigin()
-      if (typeof isName === 'string' || prop === 'returns') {
+      if (isName === 'actions') {
+        art = obj[prop];
+        parent = art;   // param refs in annos for actions are based on the action, not the entity
+      }
+      else if (typeof isName === 'string' || prop === 'returns') {
         parent = art;
         art = obj[prop];
       }
@@ -1058,7 +1088,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
           resolve( '', '$init', main );
         main = obj;
         art = obj;
-        parent = null;
+        parent = obj;
       }
       isName = prop;
       // if we want to allow auto-redirect of user-provided target with renamed keys:
@@ -1106,7 +1136,11 @@ function analyseCsnPath( csnPath, csn, resolve ) {
     else if (prop === 'orderBy') {
       refCtx = 'orderBy';
     }
-    else if (prop !== 'xpr') {
+    else if (prop.charAt(0) === '@') {
+      refCtx = 'annotation';
+    }
+    else if (prop !== 'xpr' && prop !== 'list') {
+      // 'xpr' and 'list' do not change the ref context, all other props do:
       refCtx = prop;
     }
     obj = obj[prop];

package/lib/model/csnUtils.js

@@ -1162,18 +1162,20 @@ function moveAnnotationsAndDoc( sourceNode, targetNode, overwrite = false ) {
  * @todo Does _not_ apply param/action/... annotations.
  *
  * @param {CSN.Model} csn
- * @param {{notFound?: (name: string, index: number) => void, override?: boolean, filter?: (name: string) => boolean}} config
+ * @param {{notFound?: (name: string, index: number) => void, override?: boolean, filter?: (name: string) => boolean, applyToElements?: boolean}} config
  *       notFound: Function that is called if the referenced definition can't be found.
  *                 Second argument is index in `csn.extensions` array.
  *       override: Whether to ignore existing annotations.
  *       filter:   Positive filter. If it returns true, annotations for the referenced artifact
  *                 will be applied.
+ *       applyToElements: Wether to apply annotations to elements or only to artifacts
  */
 function applyAnnotationsFromExtensions( csn, config ) {
   if (!csn.extensions)
     return;
 
   const filter = config.filter || (_name => true);
+  const applyToElements = config.applyToElements ?? true;
   for (let i = 0; i < csn.extensions.length; ++i) {
     const ext = csn.extensions[i];
     const name = ext.annotate || ext.extend;
@@ -1181,7 +1183,10 @@ function applyAnnotationsFromExtensions( csn, config ) {
       const def = csn.definitions[name];
       if (def) {
         moveAnnotationsAndDoc(ext, def, config.override);
-        applyAnnotationsToElements(ext, def);
+        if (applyToElements)
+          applyAnnotationsToElements(ext, def);
+        if (Object.keys(ext).length <= 1)
+          csn.extensions[i] = undefined;
       }
       else if (config.notFound) {
         config.notFound(name, i);
@@ -1189,6 +1194,8 @@ function applyAnnotationsFromExtensions( csn, config ) {
     }
   }
 
+  csn.extensions = csn.extensions.filter(ext => ext);
+
   function applyAnnotationsToElements( ext, def ) {
     // Only the definition is arrayed but the extension is not since
     // `items` is not expected in `extensions` by the CSN frontend and not
@@ -1204,8 +1211,13 @@ function applyAnnotationsFromExtensions( csn, config ) {
       if (targetElem) {
         moveAnnotationsAndDoc(sourceElem, targetElem, config.override);
         applyAnnotationsToElements(sourceElem, targetElem);
+        if (Object.keys(sourceElem).length === 0)
+          delete ext.elements[key];
       }
     });
+
+    if (Object.keys(ext.elements).length === 0)
+      delete ext.elements;
   }
 }