@sap/cds-compiler 3.0.0 → 3.1.2

package/lib/language/language.g4

@@ -385,10 +385,9 @@ artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent`
       }
       // #ATN: EXTEND elem, while CONTEXT, ENTITY etc are not reserved
       ( extendContext[ $art, $outer ]
-      | extendEntity[ $art, $outer ]
+      | extendEntity[ $art, $outer ] // or aspect
       | extendProjection[ $art, $outer ]
       | extendType[ $art, $outer ]
-      | extendAspect[ $art, $outer ]
       // Streamlined Syntax
       | extendArtifact[ $art, $outer ]
       )
@@ -398,6 +397,7 @@ artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent`
           this.error( 'syntax-extend-context', $annotate,
                       { code: 'ANNOTATE artifact', kind: defOnly },
                       'No $(CODE) within $(KIND) extensions' );
+        if (!$outer.extensions) $outer.extensions = [];
         this.meltKeywordToIdentifier();
       }
       annotateArtifact[ $art, $outer ] // not kind-specific
@@ -543,11 +543,12 @@ projectionExclusion[ outer ] locals[ art = {} ]
     { this.addDef( $art, $outer, 'excludingDict', '', $name.id ); }
   ;
 
+// also used for aspect
 extendEntity[ art, outer ] locals[ name = {} ]
 @after { /* #ATN 1 */ this.attachLocation( $art ); }
   :
-    ENTITY simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'entity'; $art.name = $name;
+    kind=(ASPECT | ENTITY) simplePath[ $name, 'Extend' ]
+    { $art.expectedKind = $kind.text.toLowerCase(); $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
     (
@@ -555,7 +556,7 @@ extendEntity[ art, outer ] locals[ name = {} ]
       annotationAssignment_ll1[ $art ]*
       // ATN: the ref can start with ACTIONS
       (
-        includeRef[ $art ]
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
         extendForEntity[ $art ]
@@ -753,17 +754,6 @@ extendType[ art, outer ] locals[ name = {} ]
     extendWithOptElements[ $art, $art ]
   ;
 
-extendAspect[ art, outer ] locals[ name = {} ]
-@after { this.attachLocation( $art ); }
-  :
-    // aspects are types, i.e. kind is 'type' for aspects
-    ASPECT simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'aspect'; $art.name = $name;
-      this.addItem( $art, $outer, 'extensions', 'extend' );
-    }
-    extendWithOptElements[ $art, $art ]
-  ;
-
 annotationDef[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
@@ -793,6 +783,7 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -803,12 +794,13 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       // #ATN: DEFINITIONS, COLUMNS, ACTIONS etc are not reserved and could be identifiers (ref).
       // TODO: exclude "expected" according to disallowElementExtension()
       (
-        includeRef[ $art ]
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -834,17 +826,18 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       |
         { this.disallowElementExtension( $elemName, $outer, 'actions' ); }
         ACTIONS '{' { $art.actions = this.createDict(); }
-        actionFunctionDef[ $art ]*
+        actionFunctionDef[ $art ]* // TODO: no EXTEND in actions? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.actions ); }
         optionalSemi
       |
         ELEMENTS '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         ENUM '{' { $art.enum = this.createDict(); }
-        enumSymbolDef[ $art ]*
+        enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.enum ); }
         optionalSemi
       )
@@ -856,12 +849,13 @@ extendWithOptElements[ art ]
     WITH { this.noSemicolonHere(); this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
-      includeRef[ $art ]
+      includeRef[ $art ] ( ',' includeRef[ $art ] )*
       requiredSemi
     |
       '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -873,6 +867,7 @@ extendWithOptElements[ art ]
       '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -892,11 +887,13 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       (
         ACTIONS
         '{' { $art.actions = this.createDict(); }
         annotateAction[ $art ]*
         '}' { this.finalizeDictOrArray( $art.actions ); }
+      { this.checkExtensionDict( $art.actions ); }
       )?
       optionalSemi
     |
@@ -904,6 +901,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       '{' { $art.actions = this.createDict(); }
       annotateAction[ $art ]*
       '}' { this.finalizeDictOrArray( $art.actions ); }
+      { this.checkExtensionDict( $art.actions ); }
       optionalSemi
     |
       '(' { $art.params = this.createDict(); }
@@ -912,11 +910,13 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         annotateParam[ $art ]
       )*
       ')' { this.finalizeDictOrArray( $art.params ); }
+      { this.checkExtensionDict( $art.params ); }
       (
         RETURNS { $art['$'+'syntax'] = 'returns'; }
         '{' { $art.elements = this.createDict(); }
         annotateElement[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -926,6 +926,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
 
     |
@@ -946,6 +947,7 @@ annotateElement[ outer ] locals[ art = {} ]
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -968,11 +970,13 @@ annotateAction [ outer ] locals [ art = {} ]
         annotateParam[ $art ]
       )*
       ')' { this.finalizeDictOrArray( $art.params ); }
+      { this.checkExtensionDict( $art.params ); }
     )?
     (
       RETURNS '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -1543,46 +1547,14 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
     |
       // alt lookahead includes MANY '{'
       { $art.type = {}; }
+      // Can't use typeRefOptArgs because of clash with include rule below (ATN would change)
       simplePath[ $art.type, 'artref' ]
       (
-        typeRefArgs[ $art ]
-        { this.docComment( $art ); }
-        annotationAssignment_ll1[ $art ]*
-        (
-          ENUM '{' { $art.enum = this.createDict(); }
-          enumSymbolDef[ $art ]*
-          '}' { this.finalizeDictOrArray( $art.enum ); }
-          (
-            optionalSemi
-          |
-            defaultValue[ $art ]
-            requiredSemi
-          )
-        |
-          defaultValue[ $art ]?
-          requiredSemi
-        )
-      |
-        ':' // with element, e.g. `type T : E:elem enum { ... }`
-        { $art.type.scope = $art.type.path.length; }
-        simplePath[ $art.type, 'ref']
-        { this.docComment( $art ); }
-        annotationAssignment_ll1[ $art ]*
-        (
-          ENUM '{' { $art.enum = this.createDict(); }
-          enumSymbolDef[ $art ]*
-          '}' { this.finalizeDictOrArray( $art.enum ); }
-          (
-            optionalSemi
-          |
-            defaultValue[ $art ]
-            requiredSemi
-          )
-        |
-          defaultValue[ $art ]?
-          requiredSemi
-        )
-      |
+        ( typeRefArgs[ $art ]
+        | ':' // with element, e.g. `type T : E:elem enum { ... }`
+          { $art.type.scope = $art.type.path.length; }
+          simplePath[ $art.type, 'ref']
+        )?
         { this.docComment( $art ); }
         annotationAssignment_ll1[ $art ]*
         (
@@ -1831,7 +1803,7 @@ typeNamedArg[ art ] locals[ arg = '' ]
   :
     name=ident['paramname']
     ':'
-    { if (this.checkTypeFacet( $art, $name.id ))
+    { if ($name.id && this.checkTypeFacet( $art, $name.id ))
         $arg = $name.id.id;
     }
     (
@@ -1868,10 +1840,10 @@ queryExpression returns[ query ] // QLSubqueryComplex, SubqueryComplex
       | op=MINUS  q=DISTINCT?
       )
       qt=queryTerm
-      { $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
+      { if ($qt.query) $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
     )*
-    ( ob=orderByClause[ $query ] { $query = $ob.query; } ) ?
-    ( lc=limitClause[ $query ]   { $query = $lc.query; } ) ?
+    ( ob=orderByClause[ $query ] { if ($ob.query) $query = $ob.query; } ) ?
+    ( lc=limitClause[ $query ]   { if ($lc.query) $query = $lc.query; } ) ?
   ;
 
 orderByClause[ inQuery ] returns [ query ]
@@ -2075,7 +2047,7 @@ tableExpression returns[ table ] // TableOrJoin
       ON cond=condition { $table.on = $cond.cond; }
     |
       crj=CROSS jn=JOIN tt=tableTerm
-      { $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
+      { if (!$table) { $table = {}; } $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
     )*
   ;
 
@@ -2257,9 +2229,11 @@ conditionTerm returns [ cond ]
     |
       { $cond = { args: [ $expr.expr ] }; }
       NOT predicate[ $cond, true ]
+      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
     |
       { $cond = { args: [ $expr.expr ] }; }
       predicate[ $cond, false ]
+      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
     )?                          // optional: for conditions in parentheses
   ;
 
@@ -2464,7 +2438,12 @@ pathArguments[ pathStep, considerSpecial ]
     '('                         // dict or array, see below
     // Make sure that we do not introduce A:B paths in expressions!
     // Need to avoid adaptPredict(), otherwise Generic keywords won't work in funcExpression
-    { this.setLocalTokenForId( { ':': 'HelperToken1', '=>': 'HelperToken2' } ); }
+    //
+    // For code completion, we need to handle generic tokens directly after the
+    // '('.  To avoid invalidating an assoc `trim` to an entity with parameter
+    // `leading` (ok, a bit constructed), we do not do it with named parameters.
+    { if (!this.setLocalTokenForId( { ':': 'HelperToken1', '=>': 'HelperToken2' } ))
+        this.prepareGenericKeywords( $considerSpecial ); }
     (
       { $pathStep.args = this.createDict(); $pathStep['$'+'syntax'] = ':'; }
       id=HelperToken1 ':'
@@ -2687,10 +2666,7 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
 flattenedValue[ assignment ] locals[ val = { name: {} } ]
   :
     at='@'? annotationPath[ $val.name, 'name', $at ]
-    (
-      '#' { this.meltKeywordToIdentifier(); }
-      variant=ident['variant'] { $val.name.variant = $variant.id; }
-    )?
+    ( annotationPathVariant[ $val.name ] )?
     (
       ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
       annoValue[ $val ]
@@ -2739,10 +2715,7 @@ annoSubValue returns[ val = {} ]
     { Object.assign( $val, this.numberLiteral( $num, $plus||$min ) ); }
   |
     at='@'? annotationPath[ $val, 'ref', $at ]
-    (
-      '#' { this.meltKeywordToIdentifier(); }
-      variant=ident['variant'] { $val.variant = $variant.id; }
-    )?
+    ( annotationPathVariant[ $val ] )?
   ;
 
 literalValue returns[ val ] locals[ tok ]
@@ -2800,12 +2773,12 @@ annotationPath[ art, category, headat = null ] locals[ _sync = 'nop' ]
     )*
   ;
 
-annotationPathVariant[ art ]
+annotationPathVariant[ art ] locals[ variant = {} ]
 @after { this.attachLocation($art); }
   :
     // TODO: warning for space after '#'
     '#' { this.meltKeywordToIdentifier(); }
-    variant=ident['variant'] { $art.variant = $variant.id; }
+    simplePath[ $variant, 'variant' ] { $art.variant = $variant; }
   ;
 
 // Identifier and non-reserved keywords --------------------------------------

package/lib/main.d.ts

@@ -896,6 +896,7 @@ declare namespace compiler {
      * but not `cds.foundation.*`.
      *
      * @param definitionName Top-level definition name of the artifact.
+     * @since v2.14.0
      */
     function isInReservedNamespace(definitionName: string): boolean;
   }

package/lib/model/api.js

@@ -11,7 +11,7 @@
  * Each function in `userFunctions` and `defaultFunctions` is called with:
  * - `userFunctions`
  * - the current CSN node, i.e. ‹parent node›.‹property name›
- * - the the ‹parent node›
+ * - the ‹parent node›
  * - the ‹property name› (might be useful if the same function is used for several props)
  */
 const defaultFunctions = {

package/lib/model/csnRefs.js

@@ -210,8 +210,11 @@ const referenceSemantics = {
   ref_where: { lexical: justDollar , dynamic: 'ref-target'}, // ...using baseEnv
   on: { lexical: justDollar, dynamic: 'query' }, // assoc defs, redirected to
   // there are also 'on_join' and 'on_mixin' with default semantics
-  orderBy: { lexical: query => query, dynamic: 'query' },
-  orderBy_set: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
+  orderBy_ref: { lexical: query => query, dynamic: 'query' },
+  orderBy_expr: { lexical: query => query, dynamic: 'source' }, // ref in ORDER BY expression
+  orderBy_set_ref: { lexical: query => query.$next, dynamic: 'query' }, // to outer SELECT (from UNION)
+  // refs in ORDER BY expr in UNION not really allowed - only with table alias (of outer queries) or $self
+  orderBy_set_expr: { lexical: query => query.$next, dynamic: false },
   // default: { lexical: query => query, dynamic: 'source' }
 }
 
@@ -551,37 +554,39 @@ function csnRefs( csn, universalReady ) {
       }
     }
     // now the dynamic environment: ------------------------------------------
-    if (semantics.dynamic === 'target') { // ref in keys
-      const target = assocTarget( parent, refCtx );
-      return resolvePath( path, target.elements[head], target, 'target' );
-    }
-    if (baseEnv)                // ref-target (filter condition), expand, inline
-      return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
-    if (!query) {                // outside queries - TODO: items?
-      let art = parent.elements[head];
-      // Ref to up_ in anonymous aspect
-      if (!art && head === 'up_') {
-        const up = getCache( parent, '_parent' );
-        const target = up && typeof up.target === 'string' && csn.definitions[up.target];
-        if (target && target.elements) {
-          initDefinition( target );
-          art = target.elements.up_;
+    if (semantics.dynamic !== false) {
+      if (semantics.dynamic === 'target') { // ref in keys
+        const target = assocTarget( parent, refCtx );
+        return resolvePath( path, target.elements[head], target, 'target' );
+      }
+      if (baseEnv)                // ref-target (filter condition), expand, inline
+        return resolvePath( path, baseEnv.elements[head], baseEnv, semantics.dynamic );
+      if (!query) {                // outside queries - TODO: items?
+        let art = parent.elements[head];
+        // Ref to up_ in anonymous aspect
+        if (!art && head === 'up_') {
+          const up = getCache( parent, '_parent' );
+          const target = up && typeof up.target === 'string' && csn.definitions[up.target];
+          if (target && target.elements) {
+            initDefinition( target );
+            art = target.elements.up_;
+          }
         }
+        return resolvePath( path, art, parent, 'parent' );
       }
-      return resolvePath( path, art, parent, 'parent' );
-    }
 
-    if (semantics.dynamic === 'query')
-      // TODO: for ON condition in expand, would need to use cached _element
-      return resolvePath( path, qcache.elements[head], null, 'query' );
-    for (const name in qcache.$aliases) {
-      const alias = qcache.$aliases[name];
-      const found = alias.elements[head];
-      if (found)
-        return resolvePath( path, found, alias._ref, 'source', name )
+      if (semantics.dynamic === 'query')
+        // TODO: for ON condition in expand, would need to use cached _element
+        return resolvePath( path, qcache.elements[head], null, 'query' );
+      for (const name in qcache.$aliases) {
+        const alias = qcache.$aliases[name];
+        const found = alias.elements[head];
+        if (found)
+          return resolvePath( path, found, alias._ref, 'source', name )
+      }
     }
     // console.log(query.SELECT,qcache,qcache.$next,main)
-    throw new ModelError ( `Path item ${ 0 }=${ head } refers to nothing, refCtx: ${ refCtx }` );
+    throw new ModelError ( `Path item 0=${ head } refers to nothing, refCtx: ${ refCtx }` );
   }
 
   /**
@@ -907,6 +912,7 @@ function startCsnPath( csnPath, csn ) {
 /**
  * @param {CSN.Path} csnPath
  * @param {CSN.Model} csn
+ * @param {any} resolve
  */
 function analyseCsnPath( csnPath, csn, resolve ) {
   /** @type {object} */
@@ -932,6 +938,15 @@ function analyseCsnPath( csnPath, csn, resolve ) {
         parent = art;
         art = obj[prop];
       }
+      else if (refCtx === 'orderBy') {
+        const isSelect = isSelectQuery( query );
+        // use _query_ elements with direct refs (consider sub-optimal CSN,
+        // representation of the CAST function), otherwise source elements:
+        if (obj[prop].ref && !obj[prop].cast)
+          refCtx = (isSelect ? 'orderBy_ref' : 'orderBy_set_ref');
+        else
+          refCtx = (isSelect ? 'orderBy_expr' : 'orderBy_set_expr');
+      }
       isName = false;
     }
     else if (artifactProperties.includes( String(prop) )) {
@@ -982,7 +997,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
       refCtx = prop;
     }
     else if (prop === 'orderBy') {
-      refCtx = (query.SET ? 'orderBy_set' : 'orderBy');
+      refCtx = 'orderBy';
     }
     else if (prop !== 'xpr') {
       refCtx = prop;
@@ -995,6 +1010,18 @@ function analyseCsnPath( csnPath, csn, resolve ) {
   return resolve( obj, refCtx, main, query, parent, baseEnv );
 }
 
+// A SELECT which is (unnecessarily) put into parentheses, the CSN
+// representation uses SET without `op` and args of length 1:
+function isSelectQuery( query ) {
+  while (query.SET) {
+    const { args } = query.SET;
+    if (args.length !== 1)
+      return false;
+    query = args[0];
+  }
+  return true;
+}
+
 module.exports = {
   csnRefs,
   traverseQuery,

package/lib/model/csnUtils.js

@@ -492,15 +492,18 @@ function getUtils(model, universalReady) {
 
   /**
    * Resolve to the final type of a type, that means follow type chains, references, etc.
-   * Input is a type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
+   * Input is a fully qualified type name, i.e. string, or type ref, i.e. `{ ref: [...] }`.
    *
    * Returns `null` if the type can't be resolved or if the referenced element has no type,
    * e.g. `typeof V:calculated`.
    * Otherwise, if scalar, returns an object that has a `type` property and all collected type
    * properties, or the type object with `elements` or `items` property if structured/arrayed.
    *
-   * Caches type lookups.  If the CSN changes drastically, you will need to re-call `csnUtils()`
-   * and use the newly returned `getFinalBaseTypeWithProps()`.
+   * Notes:
+   *   - Caches type lookups.  If the CSN changes drastically, you will need to re-call
+   *    `csnUtils()` and use the newly returned `getFinalBaseTypeWithProps()`.
+   *   - Does _not_ return the underlying type definition! It is an object with all relevant
+   *     type properties collected while traversing the type chain!
    *
    * @param {string|object} type Type as string or type ref, i.e. `{ ref: [...] }`
    * @returns {object|null}
@@ -517,7 +520,7 @@ function getUtils(model, universalReady) {
 
     // We differentiate between ref and type to avoid collisions due to dict key.
     // Delimiter chosen arbitrarily; just one that is rarely used.
-    const resolvedKey = (typeof type === 'object') ? `ref:${type.ref.join('\\')}` : `type:${type}`;
+    const resolvedKey = (typeof type === 'object') ? `ref[${type.ref.length}]:${type.ref.join('\\')}` : `type:${type}`;
 
     if (finalBaseTypeCache[resolvedKey]) {
       if (finalBaseTypeCache[resolvedKey] === true)
@@ -786,10 +789,12 @@ function forEachGeneric( construct, prop, callback, path = [], iterateOptions =
     executeCallbacks( dictObj, name );
   }
   function executeCallbacks(o, name ) {
+    const p = iterateOptions.pathWithoutProp ? [ name ] : [ prop, name ];
+
     if (Array.isArray(callback))
-      callback.forEach(cb => cb( o, name, prop, path.concat([prop, name]), construct ));
+      callback.forEach(cb => cb( o, name, prop, path.concat(p), construct ));
     else
-      callback( o, name, prop, path.concat([prop, name]), construct )
+      callback( o, name, prop, path.concat(p), construct )
   }
 }
 
@@ -1056,7 +1061,7 @@ function isValidMappingDialectCombi(sqlDialect, sqlMapping) {
  */
 // eslint-disable-next-line no-unused-vars
 function getElementDatabaseNameOf(elemName, sqlMapping, sqlDialect='plain') {
-  isValidMappingDialectCombi(sqlMapping, sqlDialect)
+  isValidMappingDialectCombi(sqlDialect, sqlMapping)
   if (sqlMapping === 'hdbcds') {
     return elemName;
   }
@@ -1280,19 +1285,29 @@ function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
  * @todo Does _not_ apply param/action/... annotations.
  *
  * @param {CSN.Model} csn
- * @param {{overwrite?: boolean, filter?: (name: string) => boolean}} config
+ * @param {{notFound?: (name: string, index: number) => void, override?: boolean, filter?: (name: string) => 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.
  */
 function applyAnnotationsFromExtensions(csn, config) {
   if (!csn.extensions)
     return;
 
   const filter = config.filter || ((_name) => true);
-  for (const ext of csn.extensions) {
+  for (let i = 0; i < csn.extensions.length; ++i) {
+    const ext = csn.extensions[i];
     const name = ext.annotate || ext.extend;
-    const def = csn.definitions[name];
-    if (name && def && filter(name)) {
-      copyAnnotationsAndDoc(ext, def, config.overwrite);
-      applyAnnotationsToElements(ext, def);
+    if (name && filter(name)) {
+      const def = csn.definitions[name];
+      if (def) {
+        copyAnnotationsAndDoc(ext, def, config.override);
+        applyAnnotationsToElements(ext, def);
+      } else if (config.notFound) {
+        config.notFound(name, i);
+      }
     }
   }
 
@@ -1309,7 +1324,7 @@ function applyAnnotationsFromExtensions(csn, config) {
     forEach(ext.elements, (key, sourceElem) => {
       const targetElem = def.elements[key];
       if (targetElem) {
-        copyAnnotationsAndDoc(sourceElem, targetElem, config.overwrite);
+        copyAnnotationsAndDoc(sourceElem, targetElem, config.override);
         applyAnnotationsToElements(sourceElem, targetElem);
       }
     });

package/lib/model/revealInternalProperties.js

@@ -58,7 +58,6 @@ function tableAliasAsLink( art, parent, name ) {
  *
  * @param {XSN.Model} model
  * @param {string} [nameOrPath]
- * @returns {string}
  */
 function revealInternalProperties( model, nameOrPath ) {
   const transformers = {
@@ -131,7 +130,10 @@ function revealInternalProperties( model, nameOrPath ) {
 
     path = path.split('/');
     if (path.length === 1) {
-      return reveal( xsn.definitions[path] || xsn.vocabularies && xsn.vocabularies[path] );
+      const def = xsn.definitions?.[path[0]] || xsn.vocabularies?.[path[0]];
+      if (!def)
+        throw new Error(`reveal xsn: Unknown definition: “${path[0]}”`)
+      return reveal( def );
     }
 
     // with the code below, we might miss the right transformer function
@@ -296,8 +298,8 @@ function revealInternalProperties( model, nameOrPath ) {
 function array( node, fn ) {
   const r = node.map( n => fn( n, node ) );
   if (node[$location])
-    r.push( { $location: locationString( node[$location] ) } );
-  return r;
+    r.push( { '[$location]': locationString( node[$location] ) } );
+  return (node.$prefix) ? [ { $prefix: node.$prefix }, ...node ] : r;
 }
 
 function artifactIdentifier( node, parent ) {

package/lib/modelCompare/compare.js

@@ -169,6 +169,9 @@ function getElementComparator(otherArtifact, addedElementsDict = null, changedEl
       }
       if (relevantTypeChange(element.type, otherElement.type) || typeParametersChanged(element, otherElement)) {
         // Type or parameters, e.g. association target, changed.
+        if(otherElement.notNull && element.notNull === undefined) {
+          element.$notNull = false; // Explictily set notNull to the implicit default so we render the correct ALTER
+        }
         changedElementsDict[name] = changedElement(element, otherElement);
       }