@sap/cds-compiler 2.11.2 → 2.13.6

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

@@ -0,0 +1,231 @@
+// Things which needs to done for parse.cdl after define()
+
+'use strict';
+
+const { forEachGeneric, forEachMember } = require('../base/model');
+const { setLink, setArtifactLink } = require('./utils');
+
+
+// Used for resolving types in parseCdl mode.
+// See resolveTypesForParseCdl().
+const parseCdlSpeciallyHandledXsnProps = [ '$queries', 'mixin', 'columns', 'args', 'returns' ];
+const parseCdlIgnoredXsnProps = [ 'location', 'query', '$tableAliases' ];
+
+function finalizeParseCdl( model ) {
+  // Get simplified "resolve" functionality and the message function:
+  const { message, error } = model.$messageFunctions;
+  const {
+    resolveUncheckedPath,
+    resolveTypeArguments,
+    defineAnnotations,
+    initMembers,
+    extensionsDict,
+  } = model.$functions;
+
+  resolveTypesAndExtensionsForParseCdl();
+  return;
+
+  function resolveTypesAndExtensionsForParseCdl() {
+    if (!model.extensions)
+      model.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 );
+        mergeAnnotatesForSameArtifact( ext );
+        // Initialize members and define annotations in sub-elements.
+        initMembers( ext, ext, ext._block, true );
+        model.extensions.push( ext );
+      }
+    }
+
+    forEachGeneric(model, 'definitions', art => resolveTypesForParseCdl(art, art));
+    forEachGeneric(model, 'vocabularies', art => resolveTypesForParseCdl(art, art));
+    if (model.extensions)
+      model.extensions.forEach(ext => resolveTypesForParseCdl(ext, ext));
+  }
+
+  /**
+   * Resolve all types in parseCdl mode for the given artifact.
+   * `main` refers to the current user/scope, e.g. top-level definition, element, function, etc.
+   *
+   * @param {*} artifact
+   * @param {XSN.Artifact} main
+   */
+  function resolveTypesForParseCdl(artifact, main) {
+    if (!artifact || typeof artifact !== 'object')
+      return;
+
+    if (Array.isArray(artifact)) {
+      // e.g. `args` array
+      artifact.forEach(art => resolveTypesForParseCdl(art, main));
+      return;
+    }
+
+    if (artifact.kind === 'namespace' || artifact.kind === 'service' || artifact.kind === 'context')
+      // Services and context artifacts don't have any types.
+      return;
+
+    if (artifact.type)
+      resolveTypeUnchecked(artifact, main);
+
+    for (const include of artifact.includes || [])
+      resolveUncheckedPath(include, 'include', main);
+
+    if (artifact.target)
+      resolveUncheckedPath(artifact.target, 'target', main);
+
+    if (artifact.from) {
+      const { from } = artifact;
+      // Note: `_from` only contains sources necessary for calculating elements,
+      //       not e.g. those from the `where exists` clause.
+      resolveUncheckedPath(from, 'from', main);
+      resolveTypesForParseCdl(from, main);
+    }
+
+    if (artifact.targetAspect) {
+      if (artifact.targetAspect.path)
+        resolveUncheckedPath(artifact.targetAspect, 'target', main);
+      resolveTypesForParseCdl(artifact.targetAspect, main);
+    }
+
+    // Recursively go through all XSN properties.  There are a few that need to be
+    // handled specifically.  Refer to the code below this loop for details.
+    for (const prop in artifact) {
+      if (parseCdlSpeciallyHandledXsnProps.includes(prop) || parseCdlIgnoredXsnProps.includes(prop))
+        continue;
+
+      // define.js (and initMembers()) initializes annotations.  If there is a duplicate, the
+      // annotation is an array in XSN.
+      if (prop[0] === '@' && Array.isArray(artifact[prop]))
+        chooseAndReportDuplicateAnnotation(artifact, prop);
+
+      if (artifact[prop] && Object.getPrototypeOf(artifact[prop]) === null)
+        // Dictionary in XSN
+        forEachGeneric(artifact, prop, art => resolveTypesForParseCdl(art, art));
+      else
+        resolveTypesForParseCdl(artifact[prop], main);
+    }
+
+    // `$queries` has a flat structure that we can use instead of going through all `query`.
+    // For these query-related properties, we need to keep the reference to the artifact
+    // containing it.  Otherwise some type's aren't properly resolved.
+    // TODO: If resolveTypeUnchecked is reworked, we may be able to simplify this coding.
+    (artifact.$queries || []).forEach( art => resolveTypesForParseCdl(art, artifact) );
+    (artifact.columns || []).forEach( art => resolveTypesForParseCdl(art, artifact) );
+    forEachGeneric( artifact, 'mixin', art => resolveTypesForParseCdl(art, artifact) );
+
+    // For better error messages for `type of`s in `returns`, we pass the object as the new main.
+    resolveTypesForParseCdl(artifact.returns, artifact.returns);
+
+    // Because `args` can be used in different contexts with different semantics,
+    // it needs to be handled specifically.
+    if (artifact.args && typeof artifact.args === 'object') {
+      if (Array.isArray(artifact.args)) {
+        // `args` may either be an array (e.g. query 'from' args) ...
+        artifact.args.forEach((from) => {
+          // ... and could be either inside a `from` ...
+          if (from && from.kind === '$tableAlias')
+            resolveUncheckedPath(from, 'from', from._main);
+
+          // ... or only params ...
+          resolveTypesForParseCdl(from, main);
+        });
+      }
+      else {
+        // ... or dictionary (e.g. params)
+        forEachGeneric(artifact, 'args', obj => resolveTypesForParseCdl(obj, obj));
+      }
+    }
+  }
+
+  /**
+   * Resolves `artWithType.type` in an unchecked manner. Handles `type of` cases.
+   *
+   * @param {object} artWithType
+   * @param {XSN.Artifact} artifact
+   */
+  function resolveTypeUnchecked(artWithType, artifact) {
+    if (!artWithType.type)
+      return;
+    const root = artWithType.type.path && artWithType.type.path[0];
+    if (!root) // parse error
+      return;
+    // `scope` is only `typeOf` for `type of element` and not
+    // `type of Entity:element`. For the latter we can resolve the path
+    // without special treatment.
+    if (artWithType.type.scope !== 'typeOf') {
+      // elem: Type   or   elem: type of Artifact:elem
+      const name = resolveUncheckedPath(artWithType.type, 'type', artifact);
+      const def = name && model.definitions[name];
+      if (def)
+        resolveTypeArguments( artWithType, def, artifact );
+      return;
+    }
+    else if (!artifact._main) {
+      error( 'ref-undefined-typeof', [ artWithType.type.location, artifact ], {},
+             'Current artifact has no element to refer to as type' );
+      return;
+    }
+    else if (root.id === '$self' || root.id === '$projection') {
+      setArtifactLink( root, artifact._main );
+    }
+    else {
+      // For better error messages, check for invalid TYPE OFs similarly
+      // to how `resolveType()` does.
+      let struct = artWithType;
+      while (struct.kind === 'element')
+        struct = struct._parent;
+      if (struct.kind === 'select' || struct !== artifact._main) {
+        message( 'type-unexpected-typeof', [ artWithType.type.location, artifact ],
+                 { keyword: 'type of', '#': struct.kind } );
+        return;
+      }
+
+      const fake = { name: { absolute: artifact.name.absolute } };
+      // to-csn just needs a fake element whose absolute name and _parent/_main links are correct
+      setLink( fake, '_parent', artifact._parent );
+      setLink( fake, '_main', artifact._main ); // value does not matter...
+      setArtifactLink( root, fake );
+    }
+    resolveTypeArguments( artifact, {}, artifact ); // issue error for type args
+  }
+
+  function chooseAndReportDuplicateAnnotation(artifact, annoName) {
+    for (const anno of artifact[annoName])
+      message( 'anno-duplicate', [ anno.name.location, artifact ], { anno: annoName } );
+
+    // Choose any annotation, doesn't matter because of the error above.
+    artifact[annoName] = artifact[annoName][0];
+  }
+
+  /**
+   * For duplicate entries in `annotate {}` blocks, we de-duplicate the entries and merge them.
+   * Since it is allowed in "normal" compilations to have e.g.
+   * `annotate E with { @anno1 id, @anno2 id }`.
+   *
+   * @param {object} ext
+   */
+  function mergeAnnotatesForSameArtifact( ext ) {
+    if (!ext || typeof ext !== 'object')
+      return;
+
+    forEachMember(ext, sub => mergeAnnotatesForSameArtifact(sub));
+
+    if (ext.$annotations && Array.isArray(ext.$duplicates)) {
+      const annotates = ext.$duplicates.filter(val => (val.kind === 'annotate'));
+      for (const dup of annotates) {
+        ext.$annotations.push(...dup.$annotations);
+        delete dup.$annotations;
+      }
+      ext.$duplicates = ext.$duplicates.filter(val => (val.kind !== 'annotate'));
+      if (ext.$duplicates.length === 0)
+        delete ext.$duplicates;
+    }
+  }
+}
+
+module.exports = finalizeParseCdl;

package/lib/compiler/index.js

@@ -21,12 +21,16 @@ const parseCsn = require('../json/from-csn');
 const assertConsistency = require('./assert-consistency');
 const moduleLayers = require('./moduleLayers');
 const { fns } = require('./shared');
-const { define } = require('./definer');
-const resolve = require('./resolver');
+const define = require('./define');
+const finalizeParseCdl = require('./finalize-parse-cdl');
+const extend = require('./extend');
+const kickStart = require('./kick-start');
+const populate = require('./populate');
+const resolve = require('./resolve');
+const tweakAssocs = require('./tweak-assocs');
 const propagator = require('./propagator');
 const check = require('./checks');
 
-
 const { emptyWeakLocation } = require('../base/location');
 const { createMessageFunctions, deduplicateMessages } = require('../base/messages');
 const { promiseAllDoNotRejectImmediately } = require('../base/node-helpers');
@@ -35,6 +39,8 @@ const { cdsFs } = require('../utils/file');
 const fs = require('fs');
 const path = require('path');
 
+const csnExtensions = [ '.json', '.csn' ];
+const cdlExtensions = [ '.cds', '.hdbcds', '.hdbdd', '.cdl' ];
 
 // Class for command invocation errors.  Additional members:
 //  `errors`: vector of errors (file IO or ArgumentError)
@@ -57,21 +63,21 @@ class ArgumentError extends Error {
 
 /**
  * Parse the given source with the correct parser based on the file name's
- * extension. For example use edm2csn for `.xml` files and the CDL parser
- * for `.cds` files.
+ * extension. For example uses CDL parser for `.cds` files.
+ * Respects the value of `options.fallbackParser`.
  *
  * @param {string} source Source code of the file.
  * @param {string} filename Filename including its extension, e.g. "file.cds"
  * @param {object} options Compile options
  * @param {object} messageFunctions If not provided, parse errors will not lead to an exception
  */
-function parseX( source, filename, options = {}, messageFunctions ) {
+function parseX( source, filename, options = {}, messageFunctions = null ) {
   if (!messageFunctions)
     messageFunctions = createMessageFunctions( options, 'parse' );
   const ext = path.extname( filename ).toLowerCase();
-  if ([ '.json', '.csn' ].includes(ext) || options.fallbackParser === 'csn!')
+  if (csnExtensions.includes(ext) || options.fallbackParser === 'csn!')
     return parseCsn.parse( source, filename, options, messageFunctions );
-  if ([ '.cds', '.hdbcds', '.hdbdd', '.cdl' ].includes(ext))
+  if (cdlExtensions.includes(ext))
     return parseLanguage( source, filename, options, messageFunctions );
   if (options.fallbackParser === 'csn')
     return parseCsn.parse( source, filename, options, messageFunctions );
@@ -90,8 +96,8 @@ function parseX( source, filename, options = {}, messageFunctions ) {
 // Main function: Compile the sources from the files given by the array of
 // `filenames`.  As usual with the `fs` library, relative file names are
 // relative to the working directory `process.cwd()`.  With argument `dir`, the
-// file names are relative to `process.cwd()+dir`.  Options can have the
-// following properties:
+// file names are relative to `process.cwd()+dir` (or just `dir` if it is absolute).
+// Options can have the following properties:
 //  - Truthy `parseOnly`: stop compilation after parsing.
 //  - Truthy `lintMode`: do not do checks and propagation
 //  - many others - TODO
@@ -103,7 +109,7 @@ function parseX( source, filename, options = {}, messageFunctions ) {
 //
 // The promise is fulfilled if all files could be read and processed without
 // errors.  The fulfillment value is an augmented CSN (see
-// ./compiler/definer.js).
+// ./compiler/define.js).
 //
 // If there are errors, the promise is rejected.  If there was an invocation
 // error (repeated filenames or if the file could not be read), the rejection
@@ -144,36 +150,25 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   });
 
   // Read file `filename` and parse its content, return messages
-  function readAndParse( filename ) {
+  async function readAndParse( filename ) {
+    const { sources } = a;
     if ( filename === false )   // module which has not been found
       return [];
-    const rel = a.sources[filename] || path.relative( dir, filename );
+    const rel = sources[filename] || path.relative( dir, filename );
     if (typeof rel === 'object') // already parsed
       return [];                 // no further dependency processing
     // no parallel readAndParse with same resolved filename should read the file,
-    // also ensure deterministic sequence in a.sources:
-    a.sources[filename] = { location: { file: rel } };
+    // also ensure deterministic sequence in sources:
+    sources[filename] = { location: { file: rel } };
 
-    return new Promise( (fulfill, reject) => {
-      cdsFs( fileCache, options.traceFs ).readFile( filename, 'utf8', (err, source) => {
-        if (err) {
-          reject(err);
-        }
-        else {
-          try {
-            const ast = parseX( source, rel, options, model.$messageFunctions );
-            a.sources[filename] = ast;
-            ast.location = { file: rel };
-            ast.dirname = path.dirname( filename );
-            assertConsistency( ast, options );
-            fulfill( ast );
-          }
-          catch (e) {
-            reject( e );
-          }
-        }
-      });
-    });
+    const source = await cdsFs( fileCache, options.traceFs ).readFileAsync( filename, 'utf8' );
+    const ast = parseX( source, rel, options, model.$messageFunctions );
+    sources[filename] = ast;
+    ast.location = { file: rel };
+    ast.dirname = path.dirname( filename );
+    assertConsistency( ast, options );
+
+    return ast;
   }
 
   // Combine the parse results (if there are not file IO errors)
@@ -338,9 +333,10 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
 /**
  * Promise-less main functions: compile the given sources.
  *
- * Argument `sourcesDict` is a dictionary (it could actually be a ordinary object)
- * mapping filenames to either source texts (string) or XSN objects (AST-like
- * augmented CSNs).  It could also be a simple string, which is then considered
+ * Argument `sourcesDict` is a dictionary (it could actually be an ordinary object)
+ * mapping filenames to either source texts (string) or JS objects; the objects
+ * are usually CSNs, or XSNs (AST-like augmented CSNs) with option `$xsnObjects`.
+ * It could also be a simple string, which is then considered
  * to be the source text of a file named `<stdin>.cds`.
  *
  * See function `compileX` for the meaning of the argument `options`.  If there
@@ -368,9 +364,15 @@ function compileSourcesX( sourcesDict, options = {} ) {
       ast.location = { file: filename };
       assertConsistency( ast, options );
     }
-    else {                      // source is a XSN object (CSN/CDL parser output)
+    else if (options.$xsnObjects) { // source is a XSN object with option $xsnObjects
       sources[filename] = source;
     }
+    else {                      // source is a CSN object
+      const ast = parseCsn.augment( source, filename, options, model.$messageFunctions );
+      sources[filename] = ast;
+      ast.location = { file: filename };
+      assertConsistency( ast, options );
+    }
   }
   moduleLayers.setLayers( sources );
 
@@ -432,10 +434,15 @@ function compileDoX( model ) {
   // do not run the resolver in parse-cdl mode or we get duplicate annotations, etc.
   // TODO: do not use this function for parseCdl anyway…
   if (options.parseCdl) {
+    finalizeParseCdl( model );
     throwWithError();
     return model;
   }
+  extend( model );
+  kickStart( model );
+  populate( model );
   resolve( model );
+  tweakAssocs( model );
   assertConsistency( model );
   throwWithError();
   if (options.lintMode)

package/lib/compiler/kick-start.js

@@ -0,0 +1,190 @@
+// Kick-start: prepare to resolve all references
+
+'use strict';
+
+const { isBetaEnabled, forEachGeneric } = require('../base/model');
+const { setLink, annotationVal, annotationIsFalse } = require('./utils');
+
+function kickStart( model ) {
+  const { options } = model;
+  const { message } = model.$messageFunctions;
+
+  const { resolveUncheckedPath, resolvePath } = model.$functions;
+  Object.assign( model.$functions, { projectionAncestor } );
+
+  // Set _service link (sorted to set it on parent first).  Could be set
+  // directly, but beware a namespace becoming a service later.
+  Object.keys( model.definitions ).sort().forEach( setAncestorsAndService );
+  forEachGeneric( model, 'definitions', postProcessArtifact );
+
+  forEachGeneric( model, 'sources', resolveUsings );
+  return;
+
+
+  /**
+   * Set projection ancestors, and _service link for artifact with absolute name 'name':
+   *  - not set: internal artifact
+   *  - null: not within service
+   *  - service: the artifact of the embedding service
+   * This function must be called ordered: parent first
+   *
+   * @param {string} name Artifact name
+   */
+  function setAncestorsAndService( name ) {
+    const art = model.definitions[name];
+    if (!('_parent' in art))
+      return;                   // nothing to do for builtins and redefinitions
+    if (art._from && !('_ancestors' in art))
+      setProjectionAncestors( art );
+
+    let parent = art._parent;
+    if (parent === model.definitions.localized)
+      parent = model.definitions[name.substring( 'localized.'.length )];
+    const service = parent && (parent._service || parent.kind === 'service' && parent);
+    setLink( art, '_service', service );
+    if (!parent || !service)
+      return;
+    // To be removed when nested services are allowed
+    if (!isBetaEnabled(options, 'nestedServices') && art.kind === 'service') {
+      while (parent.kind !== 'service')
+        parent = parent._parent;
+      message( 'service-nested-service', [ art.name.location, art ], { art: parent },
+               'A service can\'t be nested within a service $(ART)' );
+    }
+    else if (art.kind === 'context') {
+      while (parent.kind !== 'service')
+        parent = parent._parent;
+      // TODO: remove this error
+      message( 'service-nested-context', [ art.name.location, art ], { art: parent },
+               'A context can\'t be nested within a service $(ART)' );
+    }
+  }
+
+  function setProjectionAncestors( art ) {
+    // Must be run after processLocalizedData() as we could have a projection
+    // on a generated entity.
+
+    // TODO: do not do implicit redirection across services, i.e. Service2.E is
+    // no redirection target for E if Service2.E = projection on Service1.E and
+    // Service1.E = projection on E
+    const chain = [];
+    const autoexposed = art.$generated || annotationVal( art['@cds.autoexposed'] );
+    const preferredRedirectionTarget = annotationVal( art['@cds.redirection.target'] );
+    // no need to set preferredRedirectionTarget in the while loop as we would
+    // use the projection having @cds.redirection.target anyhow instead of
+    // `art` anyway (if we do the no-x-service-implicit-redirection TODO above)
+    while (art && !('_ancestors' in art) &&
+           art._from && art._from.length === 1 &&
+           (preferredRedirectionTarget || !annotationIsFalse( art['@cds.redirection.target'] ) ) &&
+           art.query.op && art.query.op.val === 'SELECT') {
+      chain.push( art );
+      setLink( art, '_ancestors', null ); // avoid infloop with cyclic from
+      const name = resolveUncheckedPath( art._from[0], 'include', art ); // TODO: 'include'?
+      art = name && projectionAncestor( model.definitions[name], art.params );
+      if (autoexposed)
+        break;                  // only direct projection for auto-exposed
+    }
+    let ancestors = art && (!autoexposed && art._ancestors || []);
+    chain.reverse();
+    for (const a of chain) {
+      ancestors = (ancestors ? [ ...ancestors, art ] : []);
+      setLink( a, '_ancestors', ancestors );
+      art = a;
+    }
+  }
+
+  // Return argument `source` if entity `source` has parameters like `params`
+  // - same parameters, although `params` can contain a new optional one (with DEFAULT)
+  // - a parameter in `params` can be optional which is not in `source.params`, but not vice versa
+  // - exactly the same types (type argument do not matter)
+  function projectionAncestor( source, params ) {
+    if (!source)
+      return source;
+    if (!params)                // proj has no params => ok if source has no params
+      return !source.params && source;
+    const sourceParams = source.params || Object.create(null);
+    for (const n in sourceParams) {
+      if (!(n in params))       // source param is not projection param
+        return null;            // -> can't be used as implicit redirection target
+    }
+    for (const n in params) {
+      const pp = params[n];
+      const sp = sourceParams[n];
+      if (sp) {
+        if (sp.default && !pp.default) // param DEFAULT clause not supported yet
+          return null;          // param is not optional anymore
+        const pt = pp.type && resolveUncheckedPath( pp.type, 'type', pp );
+        const st = sp.type && resolveUncheckedPath( sp.type, 'type', sp );
+        if ((pt || null) !== (st || null))
+          return null;          // params have different type
+      }
+      else if (!pp.default) {
+        return null;
+      }        // non-optional param in projection, but not source
+    }
+    return source;
+  }
+
+  function postProcessArtifact( art ) {
+    tagCompositionTargets( art );
+    if (art.$queries) {
+      for (const query of art.$queries) {
+        if (query.mixin)
+          forEachGeneric( query, 'mixin', tagCompositionTargets );
+      }
+    }
+    if (!art._ancestors || art.kind !== 'entity')
+      return;                   // redirections only to entities
+    const service = art._service;
+    if (!service)
+      return;
+    const sname = service.name.absolute;
+    art._ancestors.forEach( expose );
+    return;
+
+    function expose( ancestor ) {
+      if (ancestor._service === service)
+        return;
+      const desc = ancestor._descendants ||
+            setLink( ancestor, '_descendants', Object.create(null) );
+      if (!desc[sname])
+        desc[sname] = [ art ];
+      else
+        desc[sname].push( art );
+    }
+  }
+
+  function tagCompositionTargets( elem ) {
+    const type = elem.type && elem.type.path;
+    if (elem.target && type && type[0] && type[0].id === 'cds.Composition') {
+      // A target aspect would have already moved to property `targetAspect` in
+      // define.js (hm... more something for kick-start.js...)
+      const target = resolvePath( elem.target, 'target', elem );
+      if (target)
+        model.$compositionTargets[target.name.absolute] = true;
+    }
+    forEachGeneric( elem, 'elements', tagCompositionTargets );
+  }
+
+  // Resolve the using declarations in `using`.  Issue
+  // error message if the referenced artifact does not exist.
+  function resolveUsings( src, topLevel ) {
+    if (!src.usings)
+      return;
+    for (const def of src.usings) {
+      if (def.usings)           // using {...}
+        resolveUsings( def );
+      if (!def.name || !def.name.absolute)
+        continue;               // using {...}, parse error
+      const art = model.definitions[def.name.absolute];
+      if (art && art.$duplicates)
+        continue;
+      const ref = def.extern;
+      const from = (topLevel ? def : src).fileDep;
+      if (art || !from || from.realname)   // no error for non-existing ref with non-existing module
+        resolvePath( ref, 'global', def ); // TODO: consider FROM for validNames
+    }
+  }
+}
+
+module.exports = kickStart;

package/lib/compiler/moduleLayers.js

@@ -3,14 +3,14 @@
 'use strict';
 
 const detectCycles = require('./cycle-detector');
-const { setProp } = require('../base/model');
+const { setLink } = require('./utils');
 
 function setLayers( sources ) {
   // set dependencies
   for (const name in sources) {
     const ast = sources[name];
     ast.realname = name;
-    setProp( ast, '_deps', [] );
+    setLink( ast, '_deps', [] );
     for (const d of ast.dependencies || []) {
       const art = sources[d.realname];
       if (art)
@@ -24,7 +24,7 @@ function setLayers( sources ) {
   // It is ensured that the representative is called last in SCC and that
   // dependent SCCs are called first
   function setExtends( node, representative, sccDeps = Object.create(null) ) {
-    setProp( node, '_layerRepresentative', representative );
+    setLink( node, '_layerRepresentative', representative );
     if (layerRepresentative !== representative) {
       layerRepresentative = representative;
       ++layerNumber;
@@ -40,7 +40,7 @@ function setLayers( sources ) {
     if (node === representative) {
       const exts = Object.keys( sccDeps ).map( name => sccDeps[name]._layerExtends );
       Object.assign( sccDeps, ...exts );
-      setProp( representative, '_layerExtends', sccDeps );
+      setLink( representative, '_layerExtends', sccDeps );
       // console.log ('SCC:', node.realname)
     }
     return sccDeps;