@sap/cds-compiler 4.2.2 → 4.3.0

package/lib/compiler/extend.js

@@ -2,7 +2,8 @@
 
 'use strict';
 
-const { searchName, weakLocation } = require('../base/messages');
+const { weakLocation } = require('../base/location');
+const { searchName } = require('../base/messages');
 const {
   forEachInOrder,
   forEachDefinition,
@@ -66,7 +67,7 @@ function extend( model ) {
   // TMP:
   function tagIncludes( art ) {
     if (art.includes)
-      extensionsDict[art.name.absolute] = [];
+      extensionsDict[art.name.id] = [];
   }
 
   //-----------------------------------------------------------------------------
@@ -86,10 +87,10 @@ function extend( model ) {
     if (!art._main && !art._outer && art._extensions === undefined &&
         art.name && // TODO: probably just a workaround, check with TODO in getOriginRaw()
         art.kind !== 'namespace') {
-      const { absolute } = art.name;
-      setLink( art, '_extensions', model.$collectedExtensions[absolute]?._extensions || null );
+      const { id } = art.name;
+      setLink( art, '_extensions', model.$collectedExtensions[id]?._extensions || null );
       if (art._extensions && !art.builtin) { // keep extensions for builtin in $collectedExtensions
-        delete model.$collectedExtensions[absolute];
+        delete model.$collectedExtensions[id];
         // TODO: if the extension mechanism has been completed, we could uncomment:
         // art._extensions.forEach( ext => resolvePath( ext.name, ext.kind, ext )); // for LSP
         // for now, we do that at the end of createRemainingAnnotateStatements()
@@ -182,8 +183,8 @@ function extend( model ) {
       return;
     for (const ext of source.extensions ) {
       const { name } = ext;
-      if (name?.absolute && name._artifact === undefined) {
-        const refCtx = (name.absolute.startsWith( 'localized.' )) ? '_extensions' : ext.kind;
+      if (name?.id && name._artifact === undefined) {
+        const refCtx = (name.id.startsWith( 'localized.' )) ? '_extensions' : ext.kind;
         resolvePath( name, refCtx, ext ); // for LSP
       }
     }
@@ -361,10 +362,10 @@ function extend( model ) {
                'You can\'t use EXTEND on the generated $(ART)' );
       }
       else if (art.kind !== 'annotate' && !art._outer) { // not with elem extension in targetAspect
-        const { absolute } = art.name;
-        const dict = extensionsDict[absolute] || (extensionsDict[absolute] = []);
+        const { id } = art.name;
+        const dict = extensionsDict[id] || (extensionsDict[id] = []);
         dict.push( ext ); // TODO: change
-        // console.log( 'ASI:',prop,art.name,ext,extensionsDict[absolute])
+        // console.log( 'ASI:',prop,art.name,ext,extensionsDict[id])
       }
       // art[prop] = (art[prop]) ? art[prop].concat( ext[prop] ) : ext[prop];
     }
@@ -491,7 +492,8 @@ function extend( model ) {
 
   function normalizeRef( node ) { // see to-csn.js
     const ref = pathName( node.path );
-    return node.variant ? `${ ref }#${ node.variant.id }` : ref;
+    // TODO: get rid of name.variant (induces a wrong structure anyway)
+    return node.variant ? `${ ref }#${ pathName( node.variant.path ) }` : ref;
   }
 
   // For extendArtifactAfter(): -------------------------------------------------
@@ -507,7 +509,7 @@ function extend( model ) {
   // - 'ext-unexpected-type-argument' (TODO) if the artifact does not have the prop
   // - 'ext-invalid-type-argument' if the value is wrong for extend (no overwrite)
   //
-  // TODO v4: do not allow `extend … with (precision: …)` alone if original def also has `scale`
+  // TODO v5: do not allow `extend … with (precision: …)` alone if original def also has `scale`
   function applyTypeExtensions( art, ext, prop, scaleDiff ) {
     // console.log('ATE:',art?.[prop],ext?.[prop],scaleDiff)
     if (!ext?.[prop])
@@ -652,9 +654,9 @@ function extend( model ) {
     if (art._main)
       return annotateFor( art._parent, kindProperties[art.kind].dict, art.name.id );
 
-    const { absolute } = art.name;
-    return model.$collectedExtensions[absolute] ||
-           annotateCreate( model.$collectedExtensions, absolute );
+    const { id } = art.name;
+    return model.$collectedExtensions[id] ||
+           annotateCreate( model.$collectedExtensions, id );
   }
 
   function annotateCreate( dict, id, parent, prop ) {
@@ -668,9 +670,6 @@ function extend( model ) {
       setLink( annotate, '_parent', parent );
       setLink( annotate, '_main', parent._main || parent );
     }
-    else {
-      annotate.name.absolute = id; // TODO later (if all names are sparse): delete absolute
-    }
     dict[prop || id] = annotate;
     return annotate;
   }
@@ -774,9 +773,9 @@ function extend( model ) {
   function createSuperAnnotate( annotate ) {
     const extensions = annotate._extensions;
     if (extensions && !annotate._main) {
-      const { absolute } = annotate.name;
-      const isLocalized = absolute.startsWith( 'localized.' ); // TODO: && anno
-      const art = model.definitions[absolute];
+      const { id } = annotate.name;
+      const isLocalized = id.startsWith( 'localized.' ); // TODO: && anno
+      const art = model.definitions[id];
       for (const ext of extensions)
         checkRemainingMainExtensions( art, ext, isLocalized );
       if (art?.builtin && art.kind !== 'namespace') { // TODO: do not set `builtin` on cds, cds.hana
@@ -799,7 +798,7 @@ function extend( model ) {
   }
 
   function checkRemainingMainExtensions( art, ext, localized ) {
-    if (localized)              // TODO v4: ignore only for annotate
+    if (localized)              // TODO v5: ignore only for annotate
       return;
     if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
       return;
@@ -1035,13 +1034,16 @@ function extend( model ) {
    * @param {object} validDict
    */
   function extendNothing( extensions, prop, name, art, validDict ) {
+    // TODO: probably too much magic in the creation of artName…
+    const extMain = { ...(art._main || art) };
     const artName = searchName( art, name, dictKinds[prop] );
+    setLink( artName, '_main', extMain );
     for (const ext of extensions) {
       // TODO: use shared functionality with notFound in resolver.js
       const { location } = ext.name;
-      const extName = { ...artName, kind: ext.kind };
+      extMain.kind = ext.kind;
       const msg
-        = error( 'extend-undefined', [ location, extName ],
+        = error( 'extend-undefined', [ location, artName ],
                  { art: artName },
                  {
                    std: 'Unknown $(ART) - nothing to extend',
@@ -1210,7 +1212,7 @@ function extend( model ) {
    * Report duplicates in parent[prop] that happen due to multiple includes having the
    * same member.  Covers `entity G : E, G {};` but not `entity G : E {};  extend G with F;`.
    *
-   * TODO(v4): Make this a hard error; see checkRedefinition(); maybe combine both;
+   * TODO(v5): Make this a hard error; see checkRedefinition(); maybe combine both;
    */
   function checkRedefinitionThroughIncludes( parent, prop ) {
     if (!parent[prop])

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

@@ -40,7 +40,7 @@ function finalizeParseCdl( model ) {
     // TODO: why not just use the extensions as they are from the first source?
     for (const name in late) {
       for (const ext of late[name]._extensions) {
-        ext.name.absolute = resolveUncheckedPath( ext.name, '_extensions', ext );
+        ext.name.id = resolveUncheckedPath( ext.name, '_extensions', ext );
         // Initialize members and define annotations in sub-elements.
         initMembers( ext, ext, ext._block, true );
         extensions.push( ext );

package/lib/compiler/generate.js

@@ -14,11 +14,10 @@ const {
   linkToOrigin,
   setMemberParent,
   augmentPath,
-  splitIntoPath,
   isDirectComposition,
   copyExpr,
 } = require('./utils');
-const { weakLocation } = require('../base/messages');
+const { weakLocation } = require('../base/location');
 
 function generate( model ) {
   const { options } = model;
@@ -165,7 +164,7 @@ function generate( model ) {
     const fioriAnno = art['@fiori.draft.enabled'];
     const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || fioriAnno.val);
 
-    const textsName = `${ art.name.absolute }.texts`;
+    const textsName = `${ art.name.id }.texts`;
     const textsEntity = model.definitions[textsName];
     const localized = localizedData( art, textsEntity, fioriEnabled );
     if (!localized)
@@ -278,20 +277,45 @@ function generate( model ) {
    * @param {boolean} fioriEnabled
    */
   function createTextsEntity( base, absolute, textElems, fioriEnabled ) {
-    const art = useTextsAspect
-      ? createTextsEntityWithInclude( base, absolute, fioriEnabled )
-      : createTextsEntityWithDefaultElements( base, absolute, fioriEnabled );
-    // both functions are rather similar...
-
     const { location } = base.name;
+    const art = {
+      kind: 'entity',
+      name: { id: absolute, location },
+      location: base.location,
+      elements: Object.create( null ),
+      $inferred: 'localized-entity',
+    };
+    setLink( art, '_block', model.$internal );
+    model.definitions[absolute] = art;
+    extendArtifactBefore( art ); // having extensions here would be wrong
+
+    if (!fioriEnabled) {
+      // To be compatible, we switch off draft without @fiori.draft.enabled
+      setAnnotation( art, '@odata.draft.enabled', art.location, false );
+    }
+    else {
+      const textId = {
+        name: { location, id: 'ID_texts' },
+        kind: 'element',
+        key: { val: true, location },
+        type: linkMainArtifact( location, 'cds.UUID' ),
+        location,
+      };
+      dictAdd( art.elements, 'ID_texts', textId );
+    }
+
+    const enrich = useTextsAspect
+      ? enrichTextsEntityWithInclude
+      : enrichTextsEntityWithDefaultElements;
+    enrich( art, base, absolute, fioriEnabled );
 
     if (addTextsLanguageAssoc) {
       const language = {
         name: { location, id: 'language' },
         kind: 'element',
         location,
-        type: augmentPath( location, 'cds.Association' ),
-        target: augmentPath( location, 'sap.common.Languages' ),
+        type: linkMainArtifact( location, 'cds.Association' ),
+        target: linkMainArtifact( location, 'sap.common.Languages' ),
         on: {
           op: { val: '=', location },
           args: [
@@ -362,46 +386,25 @@ function generate( model ) {
   }
 
   /**
-   * Create the `.texts` entity for the given base artifact.
+   * Enrich the `.texts` entity for the given base artifact.
    * In contrast to createTextsEntityWithDefaultElements(), this one creates
    * an include for `sap.common.TextsAspect`.
    *
    * Does NOT apply the include!
    *
+   * @param {XSN.Artifact} art
    * @param {XSN.Artifact} base
    * @param {string} absolute
    * @param {boolean} fioriEnabled
    */
-  function createTextsEntityWithInclude( base, absolute, fioriEnabled ) {
+  function enrichTextsEntityWithInclude( art, base, absolute, fioriEnabled ) {
     const textsAspectName = 'sap.common.TextsAspect';
     const textsAspect = model.definitions['sap.common.TextsAspect'];
-    const elements = Object.create( null );
-    const { location } = base.name;
-    const art = {
-      kind: 'entity',
-      name: { path: splitIntoPath( location, absolute ), absolute, location },
-      includes: [ createInclude( textsAspectName, base.location ) ],
-      location: base.location,
-      elements,
-      $inferred: 'localized-entity',
-    };
+    const { location } = art.name;
 
-    if (!fioriEnabled) {
-      // To be compatible, we switch off draft without @fiori.draft.enabled
-      setAnnotation( art, '@odata.draft.enabled', art.location, false );
-    }
-    else {
-      // @fiori.draft.enabled artifacts need default elements ID_texts and locale.
-      // `locale` is copied from `sap.common.TextsAspect`, but without "key".
-      const textId = {
-        name: { location, id: 'ID_texts' },
-        kind: 'element',
-        key: { val: true, location },
-        type: augmentPath( location, 'cds.UUID' ),
-        location,
-      };
-      dictAdd( art.elements, 'ID_texts', textId );
+    art.includes = [ createInclude( textsAspectName, base.location ) ];
 
+    if (fioriEnabled) {
       // "Early" include; only for element `locale`, which has its `key` property
       // removed (or rather: it is not copied).
       linkToOrigin( textsAspect.elements.locale, 'locale', art, 'elements', location );
@@ -410,61 +413,31 @@ function generate( model ) {
     if (addTextsLanguageAssoc && art.elements.language)
       art.elements.language = undefined; // TODO: Message? Ignore?
     // TODO: what is this necessary?  We do not create a text entity in this case
-
-    setLink( art, '_block', model.$internal );
-    model.definitions[absolute] = art;
-    extendArtifactBefore( art ); // having extensions here would be wrong
-    return art;
   }
 
   /**
+   * @param {XSN.Artifact} art
    * @param {XSN.Artifact} base
    * @param {string} absolute
    * @param {boolean} fioriEnabled
    */
-  function createTextsEntityWithDefaultElements( base, absolute, fioriEnabled ) {
-    const elements = Object.create( null );
-    const { location } = base.name;
-    const art = {
-      kind: 'entity',
-      name: { path: splitIntoPath( location, absolute ), absolute, location },
-      location: base.location,
-      elements,
-      $inferred: 'localized-entity',
-    };
+  function enrichTextsEntityWithDefaultElements( art, base, absolute, fioriEnabled ) {
     // If there is a type `sap.common.Locale`, then use it as the type for the element `locale`.
     // If not, use the default `cds.String` with a length of 14.
     const hasLocaleType = model.definitions['sap.common.Locale']?.kind === 'type';
+    const { location } = art.name;
     const locale = {
       name: { location, id: 'locale' },
       kind: 'element',
-      type: augmentPath( location, hasLocaleType ? 'sap.common.Locale' : 'cds.String' ),
+      type: linkMainArtifact( location, hasLocaleType ? 'sap.common.Locale' : 'cds.String' ),
       location,
     };
     if (!hasLocaleType)
       locale.length = { literal: 'number', val: 14, location };
 
-    if (!fioriEnabled) {
+    if (!fioriEnabled)
       locale.key = { val: true, location };
-      // To be compatible, we switch off draft without @fiori.draft.enabled
-      setAnnotation( art, '@odata.draft.enabled', art.location, false );
-    }
-    else {
-      const textId = {
-        name: { location, id: 'ID_texts' },
-        kind: 'element',
-        key: { val: true, location },
-        type: augmentPath( location, 'cds.UUID' ),
-        location,
-      };
-      dictAdd( art.elements, 'ID_texts', textId );
-    }
     dictAdd( art.elements, 'locale', locale );
-
-    setLink( art, '_block', model.$internal );
-    model.definitions[absolute] = art;
-    extendArtifactBefore( art ); // having extensions here would be wrong
-    return art;
   }
 
   /**
@@ -482,9 +455,9 @@ function generate( model ) {
       kind: 'element',
       location,
       $inferred: 'localized',
-      type: augmentPath( location, 'cds.Composition' ),
+      type: linkMainArtifact( location, 'cds.Composition' ),
       cardinality: { targetMax: { literal: 'string', val: '*', location }, location },
-      target: augmentPath( location, textsName ),
+      target: linkMainArtifact( location, textsName ),
       on: augmentEqual( location, 'texts', keys ),
     };
     setMemberParent( texts, 'texts', art, 'elements' );
@@ -497,8 +470,8 @@ function generate( model ) {
       kind: 'element',
       location,
       $inferred: 'localized',
-      type: augmentPath( location, 'cds.Association' ),
-      target: augmentPath( location, textsName ),
+      type: linkMainArtifact( location, 'cds.Association' ),
+      target: linkMainArtifact( location, textsName ),
       on: augmentEqual( location, 'localized', keys ),
     };
     setMemberParent( localized, 'localized', art, 'elements' );
@@ -537,7 +510,7 @@ function generate( model ) {
    */
   function hasTruthyProp( art, prop ) {
     const processed = Object.create( null ); // avoid infloops with circular refs
-    let name = art.name.absolute;        // is ok, since no recursive type possible
+    let name = (art._main || art).name.id; // is ok, since no recursive type possible
     while (art && !processed[name]) {
       if (art[prop])
         return art[prop].val;
@@ -546,7 +519,7 @@ function generate( model ) {
         art = art._origin;
         if (!art.name)          // anonymous aspect
           return false;
-        name = art && art.name.absolute;
+        name = (art._main || art)?.name?.id;
       }
       else if (art.type && art._block && art.type.scope !== 'typeOf') {
         // TODO: also do something special for TYPE OF inside `art`s own elements
@@ -599,7 +572,7 @@ function generate( model ) {
         target = resolvePath( origin.targetAspect, 'targetAspect', origin );
       if (!target || !target.elements)
         return;
-      const entityName = `${ base.name.absolute }.${ elem.name.id }`;
+      const entityName = `${ base.name.id }.${ elem.name.id }`;
       const entity = allowAspectComposition( target, elem, keys, entityName ) &&
             createTargetEntity( target, elem, keys, entityName, base );
       elem.target = {
@@ -615,7 +588,7 @@ function generate( model ) {
         // already has an _origin (when the managed composition is included)
         if (up_)
           setLink( up_, '_origin', entity.elements.up_ );
-        model.$compositionTargets[entity.name.absolute] = true;
+        model.$compositionTargets[entity.name.id] = true;
         processAspectComposition( entity );
         processLocalizedData( entity );
       }
@@ -674,7 +647,7 @@ function generate( model ) {
 
     if (elem.type && !isDirectComposition( elem )) {
       // Only issue warning for direct usages, not for projections, includes, etc.
-      // TODO: Make it configurable error; v4: error
+      // TODO: Make it configurable error; v5: error
       warning( 'def-expected-comp-aspect', [ elem.type.location, elem ],
                { prop: 'Composition of', otherprop: 'Association to' },
                'Expected $(PROP), but found $(OTHERPROP) for composition of aspect' );
@@ -698,8 +671,7 @@ function generate( model ) {
     const art = {
       kind: 'entity',
       name: {
-        path: splitIntoPath( location, entityName ),
-        absolute: entityName,
+        id: entityName,
         // for code navigation (e.g. via `extend`s): point to the element's name
         location: elem.name.location,
       },
@@ -724,8 +696,8 @@ function generate( model ) {
       kind: 'element',
       location: upLocation,
       $inferred: 'aspect-composition',
-      type: augmentPath( upLocation, 'cds.Association' ),
-      target: augmentPath( upLocation, base.name.absolute ),
+      type: linkMainArtifact( upLocation, 'cds.Association' ),
+      target: linkMainArtifact( upLocation, base.name.id ),
       cardinality: {
         targetMin: { val: 1, literal: 'number', location: upLocation },
         targetMax: { val: 1, literal: 'number', location: upLocation },
@@ -755,9 +727,11 @@ function generate( model ) {
     model.definitions[entityName] = art;
     initArtifact( art );
 
-    extendArtifactBefore( art ); // having extensions here would be wrong
+    // Apply annotations to generated artifact, prepare (not apply!) element
+    // annotations (remark: adding elements is not allowed for generated artifacts):
+    extendArtifactBefore( art );
     // Copy persistence annotations from aspect.
-    copyPersistenceAnnotations( art, target ); // after chooseAnnotation()
+    copyPersistenceAnnotations( art, target ); // after extendArtifactBefore()
     return art;
   }
 
@@ -808,6 +782,12 @@ function generate( model ) {
         target[anno] = { ...source[anno], $inferred: 'parent-origin' };
     }
   }
+
+  function linkMainArtifact( location, absolute ) {
+    const r = { location };
+    setArtifactLink( r, model.definitions[absolute] );
+    return r;
+  }
 }
 
 function augmentEqual( location, assocname, relations, prefix = '' ) {

package/lib/compiler/kick-start.js

@@ -105,7 +105,7 @@ function kickStart( model ) {
     const service = art._service;
     if (!service)
       return;
-    const sname = service.name.absolute;
+    const sname = service.name.id;
     art._ancestors.forEach( expose );
     return;
 
@@ -122,14 +122,16 @@ function kickStart( model ) {
   }
 
   function tagCompositionTargets( elem ) {
-    const type = elem.type && elem.type.path;
-    if (elem.target && type && type[0] && type[0].id === 'cds.Composition') {
+    const { type } = elem;
+    if (elem.target && type &&
+        (type._artifact === model.definitions['cds.Composition'] ||
+         type.path?.[0].id === 'cds.Composition')) {
       // A target aspect would have already moved to property `targetAspect` in
       // define.js (hm... more something for kick-start.js...)
       // TODO: for safety, just use resolveUncheckedPath()
       const target = resolvePath( elem.target, 'target', elem );
       if (target)
-        model.$compositionTargets[target.name.absolute] = true;
+        model.$compositionTargets[target.name.id] = true;
     }
     forEachGeneric( elem, 'elements', tagCompositionTargets );
   }
@@ -143,7 +145,7 @@ function kickStart( model ) {
     for (const def of src.usings) {
       if (def.usings)           // using {...}
         resolveUsings( def );
-      if (!def.name || !def.name.absolute)
+      if (!def.name || !def.name.id)
         continue;               // using {...}, parse error
       const art = model.definitions[def.name.absolute];
       if (art && art.$duplicates)