@sap/cds-compiler 2.15.4 → 3.0.0

package/lib/compiler/resolve.js

@@ -49,13 +49,13 @@ const { dictAdd } = require('../base/dictionaries');
 const { dictLocation } = require('../base/location');
 const { searchName, weakLocation } = require('../base/messages');
 const { combinedLocation } = require('../base/location');
-const { forEachValue } = require('../utils/objectUtils');
 const { typeParameters } = require('./builtins');
 
 const { kindProperties } = require('./base');
 const {
   setLink,
   setArtifactLink,
+  annotationHasEllipsis,
   pathName,
   linkToOrigin,
   setMemberParent,
@@ -73,9 +73,6 @@ const layers = require('./moduleLayers');
 
 const $location = Symbol.for('cds.$location');
 
-const annotationPriorities = {
-  define: 1, extend: 2, annotate: 2, edmx: 3,
-};
 const $inferred = Symbol.for('cds.$inferred');
 
 // Export function of this file.  Resolve type references in augmented CSN
@@ -107,7 +104,7 @@ function resolve( model ) {
   /** @type {any} may also be a boolean */
 
   // behavior depending on option `deprecated`:
-  const enableExpandElements = !isDeprecatedEnabled( options, 'noElementsExpansion' );
+  const enableExpandElements = !isDeprecatedEnabled( options, '_noElementsExpansion' );
   // TODO: we should get rid of noElementsExpansion soon; both
   // beta.nestedProjections and beta.universalCsn do not work with it.
 
@@ -211,9 +208,9 @@ function resolve( model ) {
       info( 'query-from-many', [ toMany.location, query ], { art: toMany },
             {
               // eslint-disable-next-line max-len
-              std: 'Selecting from to-many association $(ART) - key properties are not propagated',
+              std: 'Key properties are not propagated because a to-many association $(ART) is selected',
               // eslint-disable-next-line max-len
-              element: 'Selecting from to-many association $(MEMBER) of $(ART) - key properties are not propagated',
+              element: 'Key properties are not propagated because a to-many association $(MEMBER) of $(ART) is selected',
             } );
     }
     // Check that all keys from the source are projected:
@@ -714,241 +711,219 @@ function resolve( model ) {
   }
 
   function chooseAssignment( annoName, art ) {
-    // TODO: getPath an all names
-    const anno = art[annoName];
-    if (!Array.isArray(anno)) { // just one assignment -> use it
-      if (removeEllipsis( anno )) {
-        error( 'anno-unexpected-ellipsis',
-               [ anno.name.location, art ], { code: '...' } );
+    let anno = art[annoName];
+    if (!Array.isArray( anno )) { // just one assignment -> use it
+      if (!annotationHasEllipsis( anno ))
+        return;
+      anno = [ anno ];
+    }
+    // console.log('ASSIGN:',art.name.absolute,annoName)
+    const scheduledAssignments = [];
+    // sort assignment according to layer (define is bottom layer):
+    const layeredAnnos = layeredAssignments( anno );
+    let cont = true;
+    while (cont) {
+      const { assignments, issue } = assignmentsOfHighestLayers( layeredAnnos );
+      let index = assignments.length;
+      cont = !!index;           // safety
+      while (--index >= 0) {
+        const a = assignments[index];
+        scheduledAssignments.push( a );
+        if (!annotationHasEllipsis( a )) {
+          cont = false;
+          break;
+        }
       }
-      return;
-    }
-    // sort assignment according to layer
-    const layerAnnos = Object.create(null);
-    for (const a of anno) {
-      const layer = layers.layer( a._block );
+      if (issue) {
+        // eslint-disable-next-line no-nested-ternary
+        const msg = (issue === true)
+          ? 'anno-duplicate'
+          : (index >= 0) ? 'anno-duplicate-unrelated-layer' : 'anno-unstable-array';
+        for (const a of assignments) {
+          if (!a.$errorReported)
+            message( msg, [ a.name.location, art ], { anno: annoName } );
+        }
+      }
+      // else if (index > 0)  -- if we allow multiple assignments in one file - the last wins
+    }
+    // Now apply the assignments - all but the first have a '...'
+    let result = null;
+    scheduledAssignments.reverse();
+    for (const a of scheduledAssignments)
+      result = applyAssignment( result, a, art, annoName );
+    art[annoName] = result.name ? result
+      : Object.assign( {}, scheduledAssignments[scheduledAssignments.length - 1], result );
+  }
+
+  // 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
+  function layeredAssignments( assignment ) {
+    const layered = Object.create(null);
+    for (const a of assignment) {
+      const layer = a.$priority && layers.layer( a );
+      // just consider layer if Extend/Annotate, not Define
       const name = (layer) ? layer.realname : '';
-      const done = layerAnnos[name];
+      const done = layered[name];
       if (done)
-        done.annos.push( a );
+        done.assignments.push( a );
       else
-        layerAnnos[name] = { layer, annos: [ a ] };
+        layered[name] = { name, layer, assignments: [ a ] };
+      // TODO: file - if set: unique in layer
     }
-    mergeArrayInSCCs();
-    art[annoName] = mergeLayeredArrays( findLayerCandidate( ) );
-    return;
+    return layered;
+  }
 
-    // Merge annotations in each layer, i.e. multiple annotations in the same layer are
-    // stored in an array and need to be merged before different layers can be merged.
-    function mergeArrayInSCCs( ) {
-      let pos = 0;
-      forEachValue(layerAnnos, (layer) => {
-        const mergeSource = layer.annos.find(v => (v.$priority === undefined ||
-           annotationPriorities[v.$priority] === annotationPriorities.define));
-        if (mergeSource) {
-          // If the source annotation (at 'define' level) contains an ellipsis,
-          // there is no base to apply to.
-          if (removeEllipsis( mergeSource )) {
-            error( 'anno-unexpected-ellipsis',
-                   [ mergeSource.name.location, art ], { code: '...' } );
-          }
-          // merge source into ellipsis array annotates
-          layer.annos.forEach( (mergeTarget) => {
-            if (mergeTarget.$priority &&
-                annotationPriorities[mergeTarget.$priority] > annotationPriorities.define) {
-              pos = findEllipsis( mergeTarget );
-              if (pos > -1) {
-                if (mergeSource.literal !== 'array') {
-                  error( 'anno-mismatched-ellipsis',
-                         [ mergeSource.name.location, art ], { code: '...' } );
-                  return;
-                }
-                mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
-              }
-            }
-          });
-        }
-      });
-    }
-
-    function mergeLayeredArrays( mergeTarget ) {
-      if (mergeTarget.literal === 'array') {
-        let layer = layers.layer( mergeTarget._block );
-        delete layerAnnos[(layer) ? layer.realname : ''];
-        let pos = findEllipsis( mergeTarget );
-        let hasRun = false;
-        while (pos > -1 && Object.keys( layerAnnos ).length ) {
-          hasRun = true;
-          const mergeSource = findLayerCandidate();
-          if (mergeSource.literal !== 'array') {
-            error( 'anno-mismatched-ellipsis',
-                   [ mergeSource.name.location, art ], { code: '...' } );
-            return mergeTarget;
-          }
-          mergeTarget.val = mergeArrayValues( mergeSource.val, mergeTarget.val );
-          layer = layers.layer( mergeSource._block );
-          delete layerAnnos[(layer) ? layer.realname : ''];
-          pos = findEllipsis( mergeTarget );
-        }
-        // All layers were processed. Remove excess ellipsis.
-        if (removeEllipsis( mergeTarget, pos ) && hasRun) {
-          // There shouldn't be any ellipsis or we don't have a base annotation.
-          // But only if the loop above has run. Otherwise the in-layer merge
-          // already warned about this case.
-          message( 'anno-unexpected-ellipsis-layers',
-                   [ mergeTarget.name.location, art ], { code: '...' } );
-        }
+  // Return assignments of the highest layers.
+  // Also return 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
+  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 );
       }
-      return mergeTarget;
     }
+    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 mergeArrayValues( previousValue, arraySpec ) {
-      let prevPos = 0;
-      const result = [];
-      for (const item of arraySpec) {
-        const ell = item && item.literal === 'token' && item.val === '...';
-        if (!ell) {
-          result.push( item );
-        }
-        else {
-          let upToSpec = item.upTo && checkUpToSpec( item.upTo, true );
-          while (prevPos < previousValue.length) {
-            const prevItem = previousValue[prevPos++];
-            result.push( prevItem );
-            if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
-              upToSpec = false;
-              break;
-            }
-          }
-          if (upToSpec) {       // non-matched UP TO
-            warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
-                     'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+  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);
+  }
+
+  function applyAssignment( previousAnno, anno, art, annoName ) {
+    if (!previousAnno) {
+      if (!annotationHasEllipsis( anno ))
+        return anno;
+      if (anno.$priority) {   // already complained about with Define
+        message( 'anno-unexpected-ellipsis-layers', // TODO: better location
+                 [ anno.name.location, art ], { code: '...' } );
+      }
+      previousAnno = { val: [] };
+    }
+    else if (previousAnno.literal !== 'array') {
+      error( 'anno-mismatched-ellipsis', // TODO: better location
+             [ anno.name.location, art ], { code: '...' } );
+      previousAnno = { val: [] };
+    }
+    const previousValue = previousAnno.val;
+    let prevPos = 0;
+    const result = [];
+    for (const item of anno.val) {
+      const ell = item && item.literal === 'token' && item.val === '...';
+      if (!ell) {
+        result.push( item );
+      }
+      else {
+        let upToSpec = item.upTo && checkUpToSpec( item.upTo, art, annoName, true );
+        while (prevPos < previousValue.length) {
+          const prevItem = previousValue[prevPos++];
+          result.push( prevItem );
+          if (upToSpec && prevItem && equalUpTo( prevItem, item.upTo)) {
+            upToSpec = false;
+            break;
           }
         }
+        if (upToSpec) {       // non-matched UP TO
+          warning( null, [ item.upTo.location, art ], { anno: annoName, code: '... up to' },
+                   'The $(CODE) value does not match any item in the base annotation $(ANNO)' );
+        }
       }
-      return result;
     }
+    // console.log('TP:',previousValue.map(se),anno.val.map(se),'->',result.map(se))
+    return { val: result, literal: 'array' };
+  }
+  // function se(a) { return a.upTo ? [a.val,a.upTo.val] : a.val ; }
 
-    function checkUpToSpec( upToSpec, trueIfFullUpTo ) {
-      const { literal } = upToSpec;
-      if (trueIfFullUpTo !== true) { // inside struct of UP TO
-        if (literal !== 'struct' && literal !== 'array' )
-          return true;
-      }
-      else if (literal === 'struct') {
-        return Object.values( upToSpec.struct ).every( checkUpToSpec );
-      }
-      else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
+  function checkUpToSpec( upToSpec, art, annoName, isFullUpTo ) {
+    const { literal } = upToSpec;
+    if (!isFullUpTo) {          // inside struct of UP TO
+      if (literal !== 'struct' && literal !== 'array' )
         return true;
-      }
-      error( null, [ upToSpec.location, art ],
-             { anno: annoName, code: '... up to', '#': literal },
-             {
-               std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
-               array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
-               // eslint-disable-next-line max-len
-               struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
-               boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
-               null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
-             } );
-      return false;
     }
+    else if (literal === 'struct') {
+      return Object.values( upToSpec.struct ).every( v => checkUpToSpec( v, art, annoName ) );
+    }
+    else if (literal !== 'array' && literal !== 'boolean' && literal !== 'null') {
+      return true;
+    }
+    error( null, [ upToSpec.location, art ],
+           { anno: annoName, code: '... up to', '#': literal },
+           {
+             std: 'Unexpected $(CODE) value type in the assignment of $(ANNO)',
+             array: 'Unexpected array as $(CODE) value in the assignment of $(ANNO)',
+             // eslint-disable-next-line max-len
+             struct: 'Unexpected structure as $(CODE) structure property value in the assignment of $(ANNO)',
+             boolean: 'Unexpected boolean as $(CODE) value in the assignment of $(ANNO)',
+             null: 'Unexpected null as $(CODE) value in the assignment of $(ANNO)',
+           } );
+    return false;
+  }
 
-    function equalUpTo( previousItem, upToSpec ) {
-      if (!previousItem)
-        return false;
-      if ('val' in upToSpec) {
-        if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
-          return true;
-        const typeUpTo = typeof upToSpec.val;
-        const typePrev = typeof previousItem.val;
-        if (typeUpTo === 'number')
-          return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
-        if (typePrev === 'number')
-          return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
-      }
-      else if (upToSpec.path) {
-        return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
-      }
-      else if (upToSpec.sym) {
-        return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
-      }
-      else if (upToSpec.struct && previousItem.struct) {
-        return Object.entries( upToSpec.struct )
-          .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
-      }
+  function equalUpTo( previousItem, upToSpec ) {
+    if (!previousItem)
       return false;
+    if ('val' in upToSpec) {
+      if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
+        return true;
+      const typeUpTo = typeof upToSpec.val;
+      const typePrev = typeof previousItem.val;
+      if (typeUpTo === 'number')
+        return typePrev === 'string' && previousItem.val === upToSpec.val.toString();
+      if (typePrev === 'number')
+        return typeUpTo === 'string' && upToSpec.val === previousItem.val.toString();
     }
-
-    function normalizeRef( node ) { // see to-csn.js
-      const ref = pathName( node.path );
-      return node.variant ? `${ ref }#${ node.variant.id }` : ref;
-    }
-
-    function removeEllipsis(a, pos = findEllipsis( a )) {
-      let count = 0;
-      while (a.literal === 'array' && pos > -1) {
-        count++;
-        a.val.splice(pos, 1);
-        pos = findEllipsis( a );
-      }
-      return count;
-    }
-
-    function findEllipsis(a) {
-      return (a.literal === 'array' && a.val)
-        ? a.val.findIndex(v => v.literal === 'token' && v.val === '...') : -1;
+    else if (upToSpec.path) {
+      return previousItem.path && normalizeRef( previousItem ) === normalizeRef( upToSpec );
     }
-
-    function findLayerCandidate() {
-      // collect assignments of upper layers (are in no _layerExtends)
-      const exts = Object.keys( layerAnnos ).map( layerExtends );
-      const allExtends = Object.assign( Object.create(null), ...exts );
-      const collected = [];
-      for (const name in layerAnnos) {
-        if (!(name in allExtends))
-          collected.push( prioritizedAnnos( layerAnnos[name].annos ) );
-      }
-      // inspect collected assignments - choose the one or signal error
-      const justOnePerLayer = collected.every( annos => annos.length === 1);
-      if (!justOnePerLayer || collected.length > 1) {
-        for (const annos of collected) {
-          for (const a of annos ) {
-          // Only the message ID is different.
-            if (justOnePerLayer) {
-              message( 'anno-duplicate-unrelated-layer',
-                       [ a.name.location, art ], { anno: annoName },
-                       'Duplicate assignment with $(ANNO)' );
-            }
-            else {
-              message( 'anno-duplicate', [ a.name.location, art ], { anno: annoName } );
-            }
-          }
-        }
-      }
-      return collected[0][0];  // just choose any one with error
+    else if (upToSpec.sym) {
+      return previousItem.sym && previousItem.sym.id === upToSpec.sym.id;
     }
-
-    function layerExtends( name ) {
-      const { layer } = layerAnnos[name];
-      return layer && layer._layerExtends;
+    else if (upToSpec.struct && previousItem.struct) {
+      return Object.entries( upToSpec.struct )
+        .every( ([ n, v ]) => equalUpTo( previousItem.struct[n], v ) );
     }
+    return false;
   }
 
-  function prioritizedAnnos( annos ) {
-    let prio = 0;
-    let r = [];
-    for (const a of annos) {
-      const p = annotationPriorities[a.$priority] || annotationPriorities.define;
-      if (p === prio) {
-        r.push(a);
-      }
-      else if (p > prio) {
-        r = [ a ];
-        prio = p;
-      }
-    }
-    return r;
+  function normalizeRef( node ) { // see to-csn.js
+    const ref = pathName( node.path );
+    return node.variant ? `${ ref }#${ node.variant.id }` : ref;
   }
 
   // Phase 4 - queries and associations --------------------------------------

package/lib/compiler/shared.js

@@ -11,6 +11,7 @@ const {
   setArtifactLink,
   dependsOn,
   pathName,
+  annotationHasEllipsis,
 } = require('./utils');
 
 function artifactsEnv( art ) {
@@ -512,7 +513,7 @@ function fns( model ) {
     if (args.length > 0) {
       const loc = [ args[args.length - 1].location, user ];
       if (typeArtifact.builtin)
-        warning( 'type-ignoring-argument', loc, { art: typeArtifact } );
+        message( 'type-ignoring-argument', loc, { art: typeArtifact } );
       else
         error( 'type-unexpected-argument', loc, { '#': 'std', art: typeArtifact });
     }
@@ -673,6 +674,9 @@ function fns( model ) {
         art = item._artifact;
         if (Array.isArray(art))
           return false;
+        if (art.$requireElementAccess && path.length === 1)
+          // Path with only one item, but we expect an element, e.g. `$at.from`.
+          signalMissingElementAccess(art, [ item.location, user ]);
         continue;
       }
 
@@ -808,11 +812,30 @@ function fns( model ) {
       attachAndEmitValidNames(err, ...valid.reverse());
   }
 
+  /**
+   * Emit a 'ref-expected-element' error for magic variable references
+   * that require element accesses but don't do.
+   * For example: `$at`, but `$at.from` or `$at.to` is required.
+   *
+   * @param {object} art
+   * @param {any} location
+   */
+  function signalMissingElementAccess(art, location) {
+    const err = message( 'ref-expected-element', location,
+                         { '#': 'magicVar', id: art.name.id } );
+    // Mapping for better valid names: from -> $at.from
+    const valid = Object.keys(art.elements || {}).reduce((prev, curr) => {
+      prev[`${ art.name.id }.${ curr }`] = true;
+      return prev;
+    }, Object.create(null));
+    attachAndEmitValidNames(err, valid);
+  }
+
   /**
    * Attaches a dictionary of valid names to the given compiler message.
    * In test mode, an info message is emitted with a list of valid names.
    *
-   * @param {CSN.Message} msg CDS Compiler message
+   * @param {CompileMessage} msg CDS Compiler message
    * @param  {...object} validDicts One ore more artifact dictionaries such as in `_block`.
    */
   function attachAndEmitValidNames(msg, ...validDicts) {
@@ -838,14 +861,10 @@ function fns( model ) {
     }
   }
 
-  // Resolve all annotation assignments for the node `art`.  Set `art.@` to all
-  // flattened assignments.  This function might issue error message for
-  // duplicate assignments.
-  // TODOs:
-  // * do something for extensions by CSN or Properties parsers
-  // * make sure that we do not issue repeated warnings due to flattening if an
-  //   annotation definition is missing
-  function defineAnnotations( construct, art, block, priority = 'define' ) {
+  // Set _block links for annotations (necessary for layering).
+  // Issue messages for annotations on namespaces and builtins (TODO: really here?)
+  // Also copy annotations from `construct` to `art` (TODO: separate that functionality).
+  function defineAnnotations( construct, art, block, priority = false ) {
     if (!options.parseCdl && construct.kind === 'annotate') {
       // Namespaces cannot be annotated in CSN but because they exist as XSN artifacts
       // they can still be applied. Namespace annotations are extracted in to-csn.js
@@ -863,76 +882,28 @@ function fns( model ) {
               'Builtin types should not be annotated. Use custom type instead' );
       }
     }
-    // TODO: block should be construct._block
-    if (construct.$annotations && construct.$annotations.doc )
-      art.doc = construct.$annotations.doc; // e.g. through `annotate` statement in CDL
-    else if (construct.doc)
+    if (construct.doc)
       art.doc = construct.doc; // e.g. through `extensions` array in CSN
-    if (!construct.$annotations) {
-      if (!block || block.$frontend !== 'json')
-        return;                 // namespace, or in CDL source without @annos:
-      // CSN input: set _block and $priority, shallow-copy from extension
-      for (const annoProp in construct) {
-        if (annoProp.charAt(0) === '@') {
-          let annos = construct[annoProp];
-          if (!(Array.isArray(annos)))
-            annos = [ annos ];
-          for (const a of annos) {
-            setLink( a, '_block', block );
-            a.$priority = priority;
-            if (construct !== art)
-              addAnnotation( art, annoProp, a );
+    // set _block (for layering) and $priority, shallow-copy from extension
+    // TODO: think of removing $priority, then
+    // no _block: define, _block: annotate/extend/edmx
+    // would fit with extending defs with props like length
+    for (const annoProp in construct) {
+      if (annoProp.charAt(0) === '@') {
+        let annos = construct[annoProp];
+        if (!(Array.isArray(annos)))
+          annos = [ annos ];
+        for (const a of annos) {
+          setLink( a, '_block', block );
+          a.$priority = priority; // is now: undefined (auto-set) | false | 'annotate' | 'extend'
+          if (construct !== art)
+            addAnnotation( art, annoProp, a );
+          if (!priority && annotationHasEllipsis( a )) {
+            error( 'anno-unexpected-ellipsis',
+                   [ a.name.location, art ], { code: '...' } );
           }
         }
       }
-      return;
-    }
-    for (const anno of construct.$annotations) {
-      const ref = anno.name;
-      const name = resolveUncheckedPath( ref, 'annotation', { _block: block } );
-      const annoProp = (anno.name.variant)
-        ? `@${ name }#${ anno.name.variant.id }`
-        : `@${ name }`;
-      flatten( ref.path, annoProp, anno.value || {}, anno.name.variant, anno.name.location );
-    }
-    return;
-
-    function flatten( path, annoProp, value, iHaveVariant, location ) {
-      // Be robust if struct value has duplicate element names
-      if (Array.isArray(value)) // TODO: do that differently in CDL parser
-        return;                 // discard duplicates in flattened form
-
-      if (value.literal === 'struct') {
-        for (const item of value._struct || []) {
-          let prop = pathName(item.name.path);
-          if (item.name.variant) {
-            if (iHaveVariant) {
-              error( 'anno-duplicate-variant', [ item.name.variant.location, construct ],
-                     {},      // TODO: params
-                     'Annotation variant has been already provided' );
-            }
-            prop = `${ prop }#${ item.name.variant.id }`; // TODO: check for double variants
-          }
-          flatten( [ ...path, ...item.name.path ], `${ annoProp }.${ prop }`, item, iHaveVariant || item.name.variant);
-        }
-        for (const prop in value.struct) {
-          const item = value.struct[prop];
-          flatten( [ ...path, item.name ], `${ annoProp }.${ prop }`, item, iHaveVariant );
-        }
-        return;
-      }
-      const anno = Object.assign( {}, value ); // shallow copy
-      anno.name = {
-        path,
-        location: location ||
-          value.name && value.name.location ||
-          value.path && value.path.location,
-      };
-      setLink( anno, '_block', block );
-      // TODO: _parent, _main is set later (if we have ElementRef), or do we
-      // set _artifact?
-      anno.$priority = priority;
-      addAnnotation( art, annoProp, anno );
     }
   }
 }