@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/compiler/extend.js

@@ -22,7 +22,8 @@ const {
   augmentPath,
   splitIntoPath,
 } = require('./utils');
-const { compareLayer, layer } = require('./moduleLayers');
+const layers = require('./moduleLayers');
+const { typeParameters } = require('./builtins');
 
 function extend( model ) {
   const { options } = model;
@@ -34,7 +35,8 @@ function extend( model ) {
     resolvePath,
     resolveUncheckedPath,
     checkAnnotate,
-    defineAnnotations,
+    initAnnotations,
+    copyAnnotationsForExtensions,
     attachAndEmitValidNames,
     checkDefinitions,
     initArtifact,
@@ -44,6 +46,9 @@ function extend( model ) {
 
   Object.assign( model.$functions, {
     lateExtensions,
+    layeredAssignments,
+    assignmentsOfHighestLayers,
+    applyTypeExtensions,
   } );
 
   applyExtensions();
@@ -74,6 +79,9 @@ function extend( model ) {
   }
 
   /**
+   * Propagate the given `prop` (e.g. annotation) early, i.e. copy it from all `.includes`
+   * if they have the property.
+   *
    * @param {XSN.Definition} art
    * @param {string} prop
    */
@@ -156,6 +164,7 @@ function extend( model ) {
   }
 
   function extendContext( name, art ) {
+    // TODO: remove this function - add remains to define.js
     // (ext.expectedKind == art.kind) already checked by parser except for context/service
     if (!kindProperties[art.kind].artifacts) {
       // no context or service => warn about context extensions
@@ -163,10 +172,10 @@ function extend( model ) {
         if (ext.expectedKind === 'context' || ext.expectedKind === 'service') {
           const loc = ext.name.location;
           // TODO: warning is enough
-          error( 'extend-with-artifacts', [ loc, ext ], { name, '#': ext.expectedKind }, {
-            std: 'Cannot extend non-context / non-service $(NAME) with artifacts',
-            service: 'Cannot extend non-service $(NAME) with artifacts',
-            context: 'Cannot extend non-context $(NAME) with artifacts',
+          error( 'extend-with-artifacts', [ loc, ext ], { name, '#': ext.expectedKind, keyword: `EXTEND ${ ext.expectedKind }` }, {
+            std: 'Can\'t extend non-context / non-service $(NAME) with $(KEYWORD)',
+            service: 'Can\'t extend non-service $(NAME) with $(KEYWORD)',
+            context: 'Can\'t extend non-context $(NAME) with $(KEYWORD)',
           });
         }
       }
@@ -182,9 +191,8 @@ function extend( model ) {
       checkDefinitions( ext, art, 'columns');
       if (ext.includes)
         applyIncludes( ext, art ); // emits error if `includes` is set
-      if (ext.kind === 'annotate')
-        checkAnnotate( ext, art );
-      defineAnnotations( ext, art, ext._block, ext.kind );
+      checkAnnotate( ext, art );
+      copyAnnotationsForExtensions( ext, art );
     }
     return true;
   }
@@ -200,7 +208,8 @@ function extend( model ) {
    * @param {boolean|'gen'} [noIncludes=false]
    */
   function extendArtifact( extensions, art, noIncludes = false) {
-    if (!noIncludes && !(canApplyIncludes( art ) && extensions.every( canApplyIncludes )))
+    if (!noIncludes && !(canApplyIncludes( art, art ) &&
+        extensions.every( ext => canApplyIncludes(ext, art) )))
       return false;
     if (!art.query) {
       model._entities.push( art ); // add structure with includes in dep order
@@ -221,7 +230,8 @@ function extend( model ) {
   function extendMembers( extensions, art, noExtend ) {
     // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
-    extensions.sort( compareLayer );
+    extensions.sort( layers.compareLayer );
+    // TODO: use same sequence as in chooseAssignment() - better: use common code with that fn
     for (const ext of extensions) {
       // console.log(message( 'id', [ext.location, ext], { art: ext.name._artifact },
       //                      'Info', 'EXT').toString())
@@ -243,18 +253,19 @@ function extend( model ) {
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
         }
-        if (ext.kind === 'annotate')
-          checkAnnotate( ext, art );
-        defineAnnotations( ext, art, ext._block, ext.kind );
+        checkAnnotate( ext, art );
+        initAnnotations( ext, ext._block, ext.kind ); // TODO: do in define.js
+        copyAnnotationsForExtensions( ext, art );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
+        storeTypeExtension( ext, art );
         dependsOnSilent(art, ext); // art depends silently on ext (inverse to normal dep!)
       }
       for (const name in ext.elements) {
         const elem = ext.elements[name];
         if (elem.kind === 'element') { // i.e. not extend or annotate
           elemExtensions.push( elem );
-          break;
+          break;                // more than one elem in same EXTEND is fine
         }
       }
 
@@ -263,6 +274,8 @@ function extend( model ) {
     }
     if (elemExtensions.length > 1)
       reportUnstableExtensions( elemExtensions );
+    if (art._extendType && art._extendType.length > 0)
+      reportTypeExtensionsInSameLayer( art._extendType );
 
     [ 'elements', 'actions' ].forEach( (prop) => {
       const dict = art._extend && art._extend[prop];
@@ -291,9 +304,6 @@ function extend( model ) {
   function extendColumns( ext, art ) {
     // TODO: consider reportUnstableExtensions
 
-    for (const col of ext.columns)
-      defineAnnotations( col, col, ext._block, ext.kind );
-
     const { location } = ext.name;
     const { query } = art;
     if (!query) {
@@ -315,14 +325,115 @@ function extend( model ) {
     }
   }
 
+  /**
+   * Similar to chooseAssignment for annotations, this function applies type extensions in order,
+   * such that hierarchies are respected.
+   * Order already set in `extendMembers()` using `compareLayers()`.
+   *
+   * @param art
+   */
+  function applyTypeExtensions(art) {
+    /**
+     * Contains the previous extension for each property that was applied
+     * successfully.
+     */
+    const previousSuccess = Object.create(null);
+    const allowedBuiltinCategories = [ 'string', 'decimal', 'integer', 'binary' ];
+    const artType = art.type?._artifact;
+
+    for (const ext of art._extendType) {
+      if (art.$inferred) {
+        // Only report first extension for $inferred artifact. Reduces noise.
+        error('ref-expected-scalar-type', [ ext.name.location, ext ], { '#': 'inferred' } );
+        break;
+      }
+
+      const baseType = art._effectiveType; // may be an ENUM
+      if (!artType || (art.kind !== 'type' && art.kind !== 'element') || !baseType?.builtin) {
+        // Only report first extension for non-scalar base type. Reduces noise.
+        error('ref-expected-scalar-type', [ ext.name.location, ext ], { } );
+        break;
+      }
+      else if (!allowedBuiltinCategories.includes(baseType.category)) {
+        // Only report first extension for non-scalar type. Reduces noise.
+        error('ref-expected-scalar-type', [ ext.name.location, ext ],
+              { '#': 'unsupported', prop: baseType.category });
+        continue;
+      }
+
+      for (const prop of typeParameters.list) {
+        if (!ext[prop])
+          continue;
+
+        if (!baseType.parameters?.includes(prop)) {
+          // For `extend T with type (length:10)` where T does not expect a length.
+          error( 'type-unexpected-argument', [ ext[prop].location, ext ], {
+            '#': 'type', prop, art, type: baseType,
+          });
+          break; // one error for first property is enough
+        }
+        else if (!art[prop]) {
+          // Can only extend properties that exist directly on the artifact.
+          error('ext-invalid-type-property', [ ext[prop].location, ext ],
+                { prop, '#': 'new-prop' });
+          break; // one error for first property is enough
+        }
+        else if (art[prop].val === ext[prop].val) {
+          // Ignore extensions with same value
+        }
+        else if (art[prop].literal === 'string' || ext[prop].literal === 'string' ) {
+          // Users can't change from/to string value for property,
+          // e.g. `variable`/`floating` for Decimal
+          error( 'ext-invalid-type-property', [ ext[prop].location, ext ],
+                 { '#': 'string', prop } );
+        }
+        else if (art[prop].val > ext[prop].val) {
+          // TODO: Future: Sub-message that points to previous extension?
+          error( 'ext-invalid-type-property', [ ext[prop].location, ext ], {
+            prop,
+            value: ext[prop].val,
+            number: art[prop].val,
+            '#': previousSuccess[prop] ? 'ext-smaller' : 'smaller',
+          } );
+          break; // one error for first property is enough
+        }
+        else if (art[prop].val < ext[prop].val) {
+          art[prop] = ext[prop];
+          previousSuccess[prop] = ext;
+        }
+      }
+
+      // If `scale` is increased, but `precision` is not, data may be lost in a migration.
+      // e.g. `Decimal(4,2)` allows `12.34`. Increasing scale to 3 would make this value
+      // invalid and only allow `1.234`.
+      // TODO: Should we actually check that the increase is correct?
+      if (ext.scale && !ext.precision) {
+        error('ext-invalid-type-property', [ ext.scale.location, ext ], {
+          prop: 'scale',
+          otherprop: 'precision',
+          '#': 'scale',
+        });
+      }
+    }
+  }
+
+  /**
+   * Report 'Warning: Unstable element order due to repeated extensions'
+   * except if all extensions are in the same file.
+   *
+   * @param {XSN.Extension[]} extensions
+   */
   function reportUnstableExtensions( extensions ) {
-    // Report 'Warning: Unstable element order due to repeated extensions'.
+    // No message if all extensions are in the same file:
+    const file = layers.realname( extensions[0] );
+    if (extensions.every( ( ext, i ) => !i || file === layers.realname( ext ) ))
+      return;
     // Similar to chooseAssignment(), TODO there: also extra intralayer message
     // as this is a modeling error
     let lastExt = null;
     let open = [];              // the "highest" layers
     for (const ext of extensions) {
-      const extLayer = layer( ext ) || { realname: '', _layerExtends: Object.create(null) };
+      const extLayer = layers.layer( ext ) || { realname: '', _layerExtends: Object.create(null) };
       if (!open.length) {
         lastExt = ext;
         open = [ extLayer.realname ];
@@ -346,6 +457,28 @@ function extend( model ) {
       }
     }
   }
+
+  /**
+   * Report type extensions in same layer, similar mechanism to chooseAssignment()
+   * for annotations.
+   *
+   * @param {XSN.Extension[]} extensions
+   */
+  function reportTypeExtensionsInSameLayer( extensions ) {
+    // Group assignments by layer
+    const extLayers = layeredAssignments( extensions );
+    // We only care about the highest layer
+    const { assignments, issue } = assignmentsOfHighestLayers( extLayers );
+
+    if (issue) {
+      const id = (issue === 'unrelated')
+        ? 'ext-duplicate-extend-type-unrelated-layer'
+        : 'ext-duplicate-extend-type';
+      for (const ext of assignments)
+        message( id, [ ext.name.location, ext ], { type: ext.name._artifact } );
+    }
+  }
+
   /**
    * @param {XSN.Extension[]} extensions
    * @param {string} prop
@@ -354,12 +487,14 @@ function extend( model ) {
    * @param {object} validDict
    */
   function extendNothing( extensions, prop, name, art, validDict ) {
+    const artName = searchName( art, name, dictKinds[prop] );
     for (const ext of extensions) {
       // TODO: use shared functionality with notFound in resolver.js
       const { location } = ext.name;
+      const extName = { ...artName, kind: ext.kind };
       const msg
-        = error( 'extend-undefined', [ location, ext ],
-                 { art: searchName( art, name, dictKinds[prop] ) },
+        = error( 'extend-undefined', [ location, extName ],
+                 { art: artName },
                  {
                    std: 'Unknown $(ART) - nothing to extend',
                    // eslint-disable-next-line max-len
@@ -444,12 +579,20 @@ function extend( model ) {
   // includes ----------------------------------------------------------------
 
   /**
+   * Returns true, if `art.includes` can be applied on `target`.
+   * They can't be applied if any of the artifacts referenced in
+   * `art.includes` are yet to be extended.
+   * `art !== target` if `art` is an extension.
+   *
    * @param {XSN.Definition} art
+   * @param {XSN.Artifact} target
+   * @returns {boolean}
    */
-  function canApplyIncludes( art ) {
+  function canApplyIncludes( art, target ) {
     if (art.includes) {
+      const isView = !!target.query;
       for (const ref of art.includes) {
-        const template = resolvePath( ref, 'include', art );
+        const template = resolvePath( ref, isView ? 'viewInclude' : 'include', art );
         if (template && template.name.absolute in extensionsDict)
           return false;
       }
@@ -458,50 +601,64 @@ function extend( model ) {
   }
 
   /**
+   * Apply all includes of `ext` on `ext`.  Checks that `art` allows includes.
+   * If `ext === art`, then includes of the artifact itself are applied.
+   * If `ext !== art`, applies includes on the extensions, not artifact.
+   * Sets `_ancestor` links on `art`.
+   *
+   * Examples:
+   *   ext === art:  `entity E : F {}`  => add elements of F to E
+   *   ext !== art:  `extend E with F`  => add elements of F to extension on E
+   *
    * @param {XSN.Extension} ext
    * @param {XSN.Artifact} art
    */
   function applyIncludes( ext, art ) {
     if (kindProperties[art.kind].include !== true) {
-      error('extend-unexpected-include', [ ext.includes[0]?.location, ext ], { kind: art.kind },
-            'Can\'t extend $(KIND) with includes');
+      error('extend-unexpected-include', [ ext.includes[0]?.location, ext ],
+            { kind: art.kind });
       return;
     }
 
     if (!art._ancestors)
       setLink( art, '_ancestors', [] ); // recursive array of includes
     for (const ref of ext.includes) {
-      const template = ref._artifact; // already resolved
+      const template = ref._artifact;
+      // !template -> non-includable, e.g. scalar type, or cyclic
       if (template) {
         if (template._ancestors)
           art._ancestors.push( ...template._ancestors );
         art._ancestors.push( template );
       }
     }
-    includeMembers( ext, 'elements', forEachInOrder, ext === art && art );
-    includeMembers( ext, 'actions', forEachGeneric, ext === art && art );
+    includeMembers( ext, art, 'elements' );
+    includeMembers( ext, art, 'actions' );
   }
 
   /**
+   * Add all members (e.g. elements or actions) of `ext.includes` to `ext[prop]`
+   * if `parent` is `false` or to `parent` with appropriate _origin links otherwise.
+   * Included members are prepended to existing ones.
+   *
    * @param {XSN.Extension} ext
+   * @param {XSN.Artifact} art
    * @param {string} prop
-   * @param {function} forEach
-   * @param {XSN.Artifact} parent
    */
-  function includeMembers( ext, prop, forEach, parent ) {
+  function includeMembers( ext, art, prop ) {
     // TODO two kind of messages:
     // Error 'More than one include defines element "A"' (at include ref)
     // Warning 'Overwrites definition from include "I" (at elem def)
+    const parent = ext === art && art;
     const members = ext[prop];
     ext[prop] = Object.create(null); // TODO: do not set actions property if there are none
     for (const ref of ext.includes) {
       const template = ref._artifact; // already resolved
       if (template) {           // be robust
-        forEach( template, prop, ( origin, name ) => {
+        forEachInOrder( template, prop, ( origin, name ) => {
           if (members && name in members)
             return;               // TODO: warning for overwritten element
           const elem = linkToOrigin( origin, name, parent, prop, weakLocation( ref.location ) );
-          if (!parent)          // not yet set for EXTEND foo WITH bar
+          if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );
           elem.$inferred = 'include';
           if (origin.masked)
@@ -514,7 +671,7 @@ function extend( model ) {
     }
     // TODO: expand elements having direct elements (if needed)
     if (members) {
-      forEach( { [prop]: members }, prop, ( elem, name ) => {
+      forEachInOrder( { [prop]: members }, prop, ( elem, name ) => {
         dictAdd( ext[prop], name, elem );
       });
     }
@@ -523,6 +680,9 @@ function extend( model ) {
   // localized texts entities
 
   /**
+   * Process localized data for `art`.  This includes creating `.texts` entities
+   * and `locale` associations.
+   *
    * @param {XSN.Artifact} art
    */
   function processLocalizedData( art ) {
@@ -542,9 +702,13 @@ function extend( model ) {
   }
 
   /**
+   * Returns `false`, if there is no localized data or an array of elements
+   * that are required for `.texts` entities such as keys and localized elements.
+   *
    * @param {XSN.Artifact} art
    * @param {XSN.Artifact|undefined} textsEntity
    * @param {boolean} fioriEnabled
+   * @returns {false|XSN.Element[]}
    */
   function localizedData( art, textsEntity, fioriEnabled ) {
     let keys = 0;
@@ -626,7 +790,7 @@ function extend( model ) {
   }
 
   /**
-   * TODO: set _parent also for main artifacts!
+   * Create the `.texts` entity for the given base artifact.
    *
    * @param {XSN.Artifact} base
    * @param {string} absolute
@@ -772,16 +936,20 @@ function extend( model ) {
   }
 
   /**
+   * Returns whether `art` directly or indirectly has the property 'prop',
+   * following the 'origin' and the 'type' (not involving elements).
+   *
+   * DON'T USE FOR ANNOTATIONS (see TODO below)
+   *
+   * TODO: we should issue a warning if we get localized via TYPE OF
+   * TODO: XSN: for anno short form, use { val: true, location, <no literal prop> }
+   *       ...then this function also works with annotations
+   *
    * @param {XSN.Artifact} art
    * @param {string} prop
+   * @returns {boolean}
    */
   function hasTruthyProp( art, prop ) {
-    // Returns whether art directly or indirectly has the property 'prop',
-    // following the 'origin' and the 'type' (not involving elements).
-    //
-    // TODO: we should issue a warning if we get localized via TYPE OF
-    // TODO XSN: for anno short form, use { val: true, location, <no literal prop> }
-    // ...then this function also works with annotations
     const processed = Object.create(null); // avoid infloops with circular refs
     let name = art.name.absolute;        // is ok, since no recursive type possible
     while (art && !processed[name]) {
@@ -1008,6 +1176,88 @@ function extend( model ) {
   }
 }
 
+/**
+ * Group assignments by their layers.  An assignment provided with a definition
+ * is considered to be provided in a layer named '', the lowest layer.
+ *
+ * TODO: make this usable for extend (elements), too =
+ *       do not use $priority, make assignments on define do not have own _block
+ *
+ * @param {object[]} assignments Array of assignments, e.g. extensions.
+ * @returns {Record<string, object>} key: layer name, value: {name, layer, assignments[]}`
+ */
+function layeredAssignments( assignments ) {
+  const layered = Object.create(null);
+  for (const a of assignments) {
+    const layer = a.$priority !== false && layers.layer( a );
+    // just consider layer if Extend/Annotate, not Define
+    const name = (layer) ? layer.realname : '';
+    const done = layered[name];
+    if (done)
+      done.assignments.push( a );
+    else
+      layered[name] = { name, layer, assignments: [ a ] };
+    // TODO: file - if set: unique in layer
+  }
+  return layered;
+}
+
+/**
+ * Return assignments of the highest layers.
+ * Also returns whether there could be an issue:
+ * - false: there is just one assignment
+ * - 'unrelated': there is just one assignment per layer
+ * - true: there is at least one layer with two or more assignments
+ * TODO: make this usable for extend (elements), too.
+ *
+ * @param {Record<string, object>} layeredAnnos Structure as returned by layeredAssignments()
+ * @returns {{assignments, issue: boolean|string}}
+ */
+function assignmentsOfHighestLayers( layeredAnnos ) {
+  const layerNames = Object.keys( layeredAnnos );
+  // console.log('HIB:',layerNames)
+  if (layerNames.length <= 1) {
+    const name = layerNames[0];
+    const { assignments } = layeredAnnos[name] || { assignments: [] };
+    delete layeredAnnos[name];
+    return { assignments, issue: assignments.length > 1 };
+  }
+
+  // collect all layers which are lower than another layer
+  const allExtends = Object.create(null);
+  allExtends[''] = {};        // the "Define" layer
+  for (const name of layerNames) {
+    if (name)                 // not the "Define" layer
+      Object.assign( allExtends, layeredAnnos[name].layer._layerExtends );
+  }
+  // console.log('HIE:',Object.keys(allExtends))
+  const assignments = [];
+  const highest = [];
+  for (const name of layerNames) {
+    if (!(name in allExtends)) {
+      const layer = layeredAnnos[name];
+      delete layeredAnnos[name];
+      highest.push( layer );
+      assignments.push( ...layer.assignments );
+    }
+  }
+  assignments.sort( compareAssignments );
+  const good = highest.every( layer => layer.assignments.length === 1 );
+  // TODO: use layer.file instead
+  const issue = !good || highest.length > 1 && 'unrelated';
+  // console.log('HI:',highest.map(l=>l.name),issue,issue&&assignments)
+  return { assignments, issue };
+}
+
+function compareAssignments( a, b ) {
+  const fileA = layers.realname( a._block );
+  const fileB = layers.realname( b._block );
+  if (fileA !== fileB)
+    return (fileA > fileB) ? 1 : -1;
+  return (a?.location?.line || 0) - (b?.location?.line || 0) ||
+    (a?.location?.col || 0) - (b?.location?.col || 0);
+}
+
 /**
  * Copy the annotations `@cds.persistence.skip`/`@cds.persistence.exists` from
  * source to target if present on source but not target.
@@ -1019,14 +1269,16 @@ function extend( model ) {
 function copyPersistenceAnnotations(target, source, options) {
   if (!source)
     return;
-  // Copy @cds.persistence.skip/exists annotation.
-  const noCopyExists = isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
-  const existsAnno = '@cds.persistence.exists';
-  const skipAnno = '@cds.persistence.skip';
-  if (!noCopyExists && source[existsAnno] && !target[existsAnno])
-    target[existsAnno] = source[existsAnno];
-  if (source[skipAnno] && !target[skipAnno])
-    target[skipAnno] = source[skipAnno];
+
+  const copyExists = !isDeprecatedEnabled( options, 'eagerPersistenceForGeneratedEntities' );
+  if (copyExists)
+    copy( '@cds.persistence.exists' );
+  copy( '@cds.persistence.skip' );
+
+  function copy(anno) {
+    if ( source[anno] && !target[anno] )
+      target[anno] = { ...source[anno], $inferred: 'parent-origin' };
+  }
 }
 
 function augmentEqual( location, assocname, relations, prefix = '' ) {
@@ -1054,4 +1306,21 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
   }
 }
 
+/**
+ * If the given extension is a `EXTEND <def> WITH TYPE` extension, store
+ * it in the given artifact.  resolve.js will resolve types and call
+ * `typeExtensions()` later.
+ *
+ * @param {XSN.Extension} ext
+ * @param {object} art
+ */
+function storeTypeExtension( ext, art ) {
+  // If there are no parameters to apply, don't store the extension.
+  if (!typeParameters.list.some( prop => ext[prop] !== undefined ))
+    return;
+  else if (!art._extendType)
+    setLink( art, '_extendType', [] );
+  art._extendType.push( ext );
+}
+
 module.exports = extend;

package/lib/compiler/finalize-parse-cdl.js

@@ -1,5 +1,16 @@
 // Things which needs to done for parse.cdl after define()
 
+// For transforming a single CDL file into CSN, parse.cdl resolves block-relative
+// _artifact_ references (in `type`, `includes`, `target`, `targetAspect`, `from`,
+// `extend`, `annotate`) to absolute names.  This is the task of the export
+// function of this file, which the compiler calls after the export function of
+// './define.js'.
+
+// There should be no need to do other things here – if you think there is,
+// consider adding it to './define.js'.  For “semantic locations” in error
+// messages, we set also “structural” links and names inside `extensions` (by
+// calling functions from './define.js').
+
 'use strict';
 
 const { dictAddArray } = require('../base/dictionaries');
@@ -18,7 +29,6 @@ function finalizeParseCdl( model ) {
   const {
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
-    defineAnnotations,
     initMembers,
     extensionsDict,
   } = model.$functions;
@@ -29,20 +39,13 @@ function finalizeParseCdl( model ) {
   function resolveTypesAndExtensionsForParseCdl() {
     const extensions = [];
 
-    // TODO: probably better to loop over extensions of all sources (there is just one)
     for (const name in extensionsDict) {
       for (const ext of extensionsDict[name]) {
         ext.name.absolute = resolveUncheckedPath( ext.name, 'extend', ext );
-        // Define annotations of this top-level extension
-        defineAnnotations( ext, ext, ext._block, 'extend' );
-        mergeAnnotatesForSameArtifact( ext );
+        mergeAnnotatesForSameArtifact( ext ); // TODO: should not be necessary anymore
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
         extensions.push( ext );
-        for (const col of ext.columns || []) {
-          // Note, no `priority` argument, since we don't apply the extension in the end.
-          defineAnnotations( col, col, ext._block );
-        }
       }
     }
 
@@ -50,6 +53,8 @@ function finalizeParseCdl( model ) {
     forEachGeneric(model, 'vocabularies', art => resolveTypesForParseCdl(art, art));
 
     if (extensions.length > 0) {
+      // TODO: do a sort based on the location in case there were two extensions
+      // on the same definition?
       model.extensions = extensions;
       model.extensions.forEach(ext => resolveTypesForParseCdl(ext, ext));
     }