@sap/cds-compiler 6.5.0 → 6.6.0

package/lib/compiler/extend.js

@@ -78,6 +78,7 @@ function extend( model ) {
     extendArtifactBefore,
     extendArtifactAfter,
     extendForeignKeys,
+    withLocalizedData,
     applyIncludes,              // TODO: re-check
   } );
 
@@ -864,19 +865,18 @@ function extend( model ) {
     }
     else if (!dict?.[name]) {
       // TODO: make variant `returns` an auto-variant for ($ART) ?
-      const inReturns = parent._parent?.returns && parent._parent;
-      const art = inReturns || parent;
+      const inReturns = parent._parent?.returns;
       switch (prop) {
         case 'elements':
           if (canBeDraftMember( name, parent, draftElements ))
             break;
           notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
-                    { '#': (inReturns ? 'returns' : 'element'), art, name },
+                    { '#': (inReturns ? 'returns' : 'element'), name },
                     parent.elements );
           break;
         case 'enum':            // TODO: extra msg id?
           notFound( `ext-undefined-element${ securityRelevant }`, ext.name.location, ext,
-                    { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
+                    { '#': (inReturns ? 'enum-returns' : 'enum'), name },
                     parent.enum );
           break;
         case 'foreignKeys':
@@ -885,14 +885,14 @@ function extend( model ) {
           break;
         case 'params':
           notFound( `ext-undefined-param${ securityRelevant }`, ext.name.location, ext,
-                    { '#': 'param', art: parent, name },
+                    { '#': 'param', name },
                     parent.params );
           break;
         case 'actions':
           if (canBeDraftMember( name, parent, draftBoundActions ))
             break;
           notFound( `ext-undefined-action${ securityRelevant }`, ext.name.location, ext,
-                    { '#': 'action', art: parent, name },
+                    { '#': 'action', name },
                     parent.actions );
           break;
         default:
@@ -941,32 +941,28 @@ function extend( model ) {
   }
 
   function checkRemainingMainExtensions( art, ext ) {
-    const refCtx = ext.kind === 'annotate' && hasSecurityAnno( ext )
-      ? 'annotate-sec'
-      : ext.kind;
+    const refCtx = extensionRefContext( ext );
     if (!resolvePath( ext.name, refCtx, ext )) // error for extend, info for annotate
       return;
 
-    if (art?.builtin) {
+    if (art?.builtin) {                                       // TODO: do via accept
       info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
     }
-    else if (ext.kind === 'extend' && art?.kind === 'namespace') {
-      // `annotate` on namespaces already handled before
-      const hasAnnotations = Object.keys(ext).find(a => a.charAt(0) === '@');
-      const firstAnno = ext[hasAnnotations];
-      // In v5, extending namespaces is only allowed for `extend with definitions`.
-      // Neither annotations nor other extensions are allowed.
-      // Non-artifact extensions are reported in resolvePath() already (for v5).
-      // Because "namespaces" are the same as "unknown" artifacts in CSN, we don't report
-      // an error for `annotate`s.
-      // FIXME: The compiler generates empty `annotate` statements for
-      //        `extend ns with definitions {…}`. That's why we check the frontend.
-      if (hasAnnotations || (!ext.artifacts && ext._block.$frontend !== 'json')) {
-        error( 'ref-undefined-art', [ (firstAnno?.name || ext.name).location, ext ], {
-          '#': 'namespace', art: ext,
-        } );
-      }
+  }
+
+  function extensionRefContext( ext ) {
+    if (ext.kind === 'annotate') {
+      if (hasSecurityAnno( ext ))
+        return 'annotate-sec';
+    }
+    else if (ext.artifacts ||   // extend … with definitions
+             ext._block.$frontend === 'json' && !ext.elements && !ext.actions) {
+      // TODO: not for `extend context` and `extend service` → !ext.expectedKind
+      // TODO v7: also fully with CSN input
+      if (!ext.doc && !Object.keys( ext ).some( a => a.charAt(0) === '@') )
+        return 'annotate';      // TODO: or an extra refCtx ?
     }
+    return ext.kind;
   }
 
   // Issue messages for annotations on namespaces and builtins
@@ -1213,11 +1209,9 @@ function extend( model ) {
    *
    * If not for extensions: construct === parent
    *
-   * Param `initExtensions` is for parse.cdl - TODO delete
-   *
    * TODO: separate extension!
    */
-  function initMembers( construct, parent, block, initExtensions = false ) {
+  function initMembers( construct, parent, block ) {
     // TODO: split extend from init
     const main = parent._main || parent;
     const isQueryExtension = construct.kind === 'extend' && main.query;
@@ -1347,9 +1341,12 @@ function extend( model ) {
           elem.name = { id: name, location: elem.location };
         }
       }
+
+      if (!elem._block)
+        setLink( elem, '_block', block );
       // if (!kindProperties[ elem.kind ]) console.log(elem.kind,elem.name)
-      if ((elem.kind === 'extend' || elem.kind === 'annotate') && !initExtensions) {
-        storeExtension( elem, name, prop, parent, block );
+      if ((elem.kind === 'extend' || elem.kind === 'annotate')) {
+        storeExtension( elem, name, prop, parent );
         return;
       }
       if (isQueryExtension && elem.kind === 'element') {
@@ -1359,8 +1356,6 @@ function extend( model ) {
         return;
       }
 
-      const bl = elem._block || block;
-      setLink( elem, '_block', bl );
       const existing = parent[prop]?.[name];
       const add = construct !== parent && (!existing || elem.$inferred !== 'include');
       // don't dump with `entity T {}; extend T with { extend e {}; e {}; e {} };`:
@@ -1368,7 +1363,7 @@ function extend( model ) {
         elem.$duplicates = null;
       setMemberParent( elem, name, parent, add && prop );
       checkRedefinition( elem );
-      initMembers( elem, elem, bl, initExtensions );
+      initMembers( elem, elem, elem._block );
       if (elem.kind === 'action' || elem.kind === 'function')
         initBoundSelfParam( elem.params, elem._main );
 
@@ -1514,7 +1509,7 @@ function extend( model ) {
    * Sets `_ancestors` links on `art`.
    *
    * TODO: try to set `_ancestors` only to entities (but beware “intermediate”
-   * non-entities).
+   * non-entities - TODO: make intermediate non-entities stop chain).
    *
    * Examples:
    *   ext === art:  `entity E : F {}`  => add elements of F to E
@@ -1532,10 +1527,11 @@ function extend( model ) {
 
     if (!art._ancestors && !art.query)
       setLink( art, '_ancestors', [] ); // recursive array of includes
+    const shouldSetAncestors = art.kind === 'entity' && !art.query;
     for (const ref of ext.includes) {
       const template = resolvePath( ref, 'include', art );
       // !template -> non-includable, e.g. scalar type, or cyclic
-      if (template && !art.query) {
+      if (template?.kind === 'entity' && shouldSetAncestors) {
         if (template._ancestors)
           art._ancestors.push( ...template._ancestors );
         art._ancestors.push( template );
@@ -1583,8 +1579,17 @@ function extend( model ) {
         if (template[prop] && !ext[prop])
           ext[prop] = Object.create( null );
         const location = weakRefLocation( ref );
+
+        // prevent recompilation issue when localized entity is included in aspect or
+        // entity without keys (via shadowing):
+        const checkForLocalized = prop === 'elements' &&
+          template.kind === 'entity' && !template.query &&
+          withLocalizedData( template, ext );
+
         // eslint-disable-next-line no-loop-func
         forEachInOrder( template, prop, ( origin, name ) => {
+          if (checkForLocalized && (name === 'texts' || name === 'localized'))
+            return;
           if (members && members[name]) {
             if (!includesNonShadowedFirst && !ext[prop][name])
               dictAdd( ext[prop], name, members[name] ); // to keep order
@@ -1603,7 +1608,7 @@ function extend( model ) {
           if (origin.value && origin.$syntax === 'calc') {
             // TODO: If paths become invalid in the new artifact, should we mark
             //       all usages in the expressions? Possibly just the first one?
-            // TODO: Unify with coding in extend.js
+            // TODO: Unify with other code in extend.js
             elem.value = Object.assign( { $inferred: 'include' }, copyExpr( origin.value ));
             elem.$syntax = 'calc';
             createAndLinkCalcDepElement( elem );
@@ -1630,6 +1635,31 @@ function extend( model ) {
     }
   }
 
+  /**
+   * Return true if include (with `name` and `elements`) in `ext` highly likely
+   * contain elements `texts` and `localized` which are compiler-generated for
+   * localized data.  Due to recompilation, we cannot just check the `$inferred`
+   * property in the XSN, but need to apply an heuristics.
+   *
+   * It is as follows: the elements `texts` and `localized` in entity `‹E›` and
+   * the entity `‹E›.texts` are considered compiler-generated for Localized Data if
+   *
+   *  - `‹E›.texts` has a key element `locale`
+   *  - `texts` of `‹E›` is an unmanaged composition to `‹E›.texts`
+   *  - `localized` of `‹E›` is an unmanaged association to `‹E›.texts`
+   */
+  function withLocalizedData( { name, elements }, ext ) {
+    const textsEntityName = `${ name.id }.texts`;
+    if (!model.definitions[textsEntityName]?.elements?.locale?.key?.val)
+      return false;
+    const { texts, localized } = elements ?? {};
+    return texts?.target && localized?.target && texts.on && localized.on &&
+      resolveUncheckedPath( texts.target, 'target', ext ) === textsEntityName &&
+      resolveUncheckedPath( localized.target, 'target', ext ) === textsEntityName &&
+      resolveUncheckedPath( texts.type, 'type', ext ) === 'cds.Composition' &&
+      resolveUncheckedPath( localized.type, 'type', ext ) === 'cds.Association';
+  }
+
   /**
    * 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;`.

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

@@ -42,7 +42,7 @@ function finalizeParseCdl( model ) {
       for (const ext of late[name]._extensions) {
         ext.name.id = resolveUncheckedPath( ext.name, '_uncheckedExtension', ext );
         // Initialize members and define annotations in sub-elements.
-        initMembers( ext, true );
+        initMembers( ext );
         extensions.push( ext );
       }
     }

package/lib/compiler/generate.js

@@ -31,7 +31,7 @@ function generate( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
-    initArtifact,
+    initMainArtifact,
     extendArtifactBefore,
     applyIncludes,
   } = model.$functions;
@@ -173,8 +173,8 @@ function generate( model ) {
     const localized = localizedData( art, textsEntity, fioriEnabled );
     if (!localized)
       return;
-    if (textsEntity)            // expanded localized data in source
-      return;                   // -> make it idempotent
+    if (textsEntity && textsEntity.kind !== 'namespace')
+      return;                 //  expanded texts entity in source -> nothing to do
     createTextsEntity( art, textsName, localized, fioriEnabled );
     addTextsAssociations( art, textsName, localized );
   }
@@ -236,7 +236,10 @@ function generate( model ) {
       return false;
     }
 
-    if (textsEntity) {
+    if (textsEntity?.kind === 'namespace') { // namespace Base.texts
+      textsEntity = null;
+    }
+    else if (textsEntity) {
       if (textsEntity.$duplicates)
         return false;
       if (textsEntity.kind !== 'entity' || textsEntity.query ||
@@ -283,15 +286,19 @@ function generate( model ) {
    */
   function createTextsEntity( base, absolute, textElems, fioriEnabled ) {
     const location = weakLocation( base.elements[$location] || base.location );
-    const art = {
+    let art = {
       kind: 'entity',
       name: { id: absolute, location },
       location,
       elements: Object.create( null ),
       $inferred: 'localized-entity',
     };
+    const gap = model.definitions[absolute];
+    if (gap)
+      art = Object.assign( gap, art );
+    else
+      model.definitions[absolute] = art;
     setLink( art, '_block', model.$internal );
-    model.definitions[absolute] = art;
     extendArtifactBefore( art ); // having extensions here would be wrong
 
     if (!fioriEnabled) {
@@ -340,7 +347,12 @@ function generate( model ) {
     for (const orig of textElems)
       addElementToTextsEntity( orig, art, fioriEnabled, assertUniqueValue );
 
-    initArtifact( art );
+    initMainArtifact( art );
+    // do the kick-start relevant stuff: _service, there are no _ancestors,
+    // _descendants would have been set already for a gap artifact
+    setLink( art, '_service', art._parent._service );
+    model.$compositionTargets[absolute] = true;
+
     if (art.includes) {
       // add elements `locale`, etc. which are required below.
       applyIncludes( art, art ); // TODO: rethink - can we avoid this if only new extend?
@@ -641,7 +653,8 @@ function generate( model ) {
              'An aspect $(TARGET) with an element named $(NAME) can\'t be used as target' );
       return false;
     }
-    if (model.definitions[entityName]) {
+    const place = model.definitions[entityName];
+    if (place && place.kind !== 'namespace') {
       error( null, [ location, elem ], { art: entityName },
              // eslint-disable-next-line @stylistic/max-len
              'Target entity $(ART) can\'t be created as there is another definition with this name' );
@@ -687,7 +700,7 @@ function generate( model ) {
       $inferred: 'aspect-composition',
     };
 
-    const art = {
+    let art = {
       kind: 'entity',
       name: {
         id: entityName,
@@ -698,6 +711,12 @@ function generate( model ) {
       elements: Object.create( null ),
       $inferred: 'composition-entity',
     };
+    const gap = model.definitions[entityName];
+    if (gap)
+      art = Object.assign( gap, art );
+    else
+      model.definitions[entityName] = art;
+
     if (target.name) {          // named target aspect
       if (!isDeprecatedEnabled( options, 'noCompositionIncludes' )) {
         art.includes = [ createInclude( target.name.id, location ) ];
@@ -741,8 +760,12 @@ function generate( model ) {
     addProxyElements( art, target.elements, 'aspect-composition', enforceLocation && location );
 
     setLink( art, '_block', model.$internal );
-    model.definitions[entityName] = art;
-    initArtifact( art );
+    initMainArtifact( art );
+
+    // do the kick-start relevant stuff: _service, there are no _ancestors,
+    // _descendants would have been set already for a gap artifact
+    setLink( art, '_service', art._parent._service );
+    model.$compositionTargets[entityName] = true;
 
     // Apply annotations to generated artifact, prepare (not apply!) element
     // annotations (remark: adding elements is not allowed for generated artifacts):

package/lib/compiler/index.js

@@ -495,8 +495,8 @@ function compileDoXSync( model ) {
     return model;
   }
   extend( model );
-  generate( model );
   kickStart( model );
+  generate( model );
   populate( model );
 
   model.definitions = model.$functions.shuffleDict( model.definitions );
@@ -546,7 +546,7 @@ async function compileDoX( model ) {
     return model;
   }
 
-  for (const phase of [ extend, generate, kickStart, populate ]) {
+  for (const phase of [ extend, kickStart, generate, populate ]) {
     phase( model );
     // eslint-disable-next-line no-await-in-loop
     await checkAsyncAbortFlag( options.abortSignal );

package/lib/compiler/kick-start.js

@@ -2,6 +2,7 @@
 
 'use strict';
 
+const { builtinLocation } = require('../base/location');
 const { isBetaEnabled, forEachGeneric } = require('../base/model');
 const {
   setLink,
@@ -14,14 +15,12 @@ function kickStart( model ) {
   const { options } = model;
   const { message } = model.$messageFunctions;
 
-  const { resolveUncheckedPath, resolvePath } = model.$functions;
+  const { resolveUncheckedPath, initMainArtifact } = model.$functions;
 
   // 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;
 
 
@@ -32,6 +31,9 @@ function kickStart( model ) {
    *  - service: the artifact of the embedding service
    * This function must be called ordered: parent first
    *
+   * Remark: _service links are not already set in define.js, because we might
+   * have a @cds.redirection.service in the future
+   *
    * @param {string} name Artifact name
    */
   function setAncestorsAndService( name ) {
@@ -50,16 +52,12 @@ function kickStart( model ) {
       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 },
+      message( 'service-nested-service', [ art.name.location, art ], { art: service },
                '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 },
+      message( 'service-nested-context', [ art.name.location, art ], { art: service },
                'A context can\'t be nested within a service $(ART)' );
     }
   }
@@ -73,7 +71,9 @@ function kickStart( model ) {
     // Service1.E = projection on E
 
     // Remark: _ancestors are also set with includes, and there also for aspects,
-    // types and events.
+    // types and events (TODO: entity only)
+    //
+    // Remark: _ancestors are also tested in populate.js for minmal exposure
     const chain = [];
     const autoexposed = annotationVal( art['@cds.autoexposed'] );
     // no need to set preferredRedirectionTarget in the while loop as we would
@@ -84,7 +84,7 @@ function kickStart( model ) {
       chain.push( art );
       setLink( art, '_ancestors', 0 ); // avoid infloop with cyclic from
       const name = resolveUncheckedPath( art.query.from, 'from', art );
-      art = name && model.definitions[name];
+      art = name && (model.definitions[name] || createGapArtifact( name ));
       if (autoexposed)
         break;                  // only direct projection for auto-exposed
     }
@@ -97,6 +97,18 @@ function kickStart( model ) {
     }
   }
 
+  function createGapArtifact( name, location = builtinLocation() ) {
+    // TODO: make it probably part of define.js
+    // TODO: make it work without location (or value undefined/null)
+    // TODO: change the location later if overwritten
+    const art = {
+      kind: 'namespace', name: { id: name, location }, location,
+    };
+    model.definitions[name] = art;
+    initMainArtifact( art );
+    return art;
+  }
+
   function postProcessArtifact( art ) {
     tagCompositionTargets( art );
     if (art.$queries) {
@@ -127,40 +139,19 @@ function kickStart( model ) {
   }
 
   function tagCompositionTargets( elem ) {
+    // TODO: together with test for targetIsTargetAspect()
     if (elem.target && isDirectComposition( elem )) {
       // 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 );
+      const target = resolveUncheckedPath( elem.target, 'target', elem );
       if (target)
-        model.$compositionTargets[target.name.id] = true;
+        model.$compositionTargets[target] = true;
     }
     if (elem.targetAspect?.elements)
       elem = elem.targetAspect;
     forEachGeneric( elem, 'elements', tagCompositionTargets );
   }
-
-  // Resolve the using declarations in `using`.  Issue
-  // error message if the referenced artifact does not exist.
-  // TODO: think of moving this to resolve.js
-  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.id)
-        continue;               // using {...}, parse error
-      const art = model.definitions[def.name.absolute];
-      if (art && art.$duplicates)
-        continue;
-      const ref = def.extern;
-      const user = (topLevel ? def : src);
-      const from = user.fileDep;
-      if (art || !from || from.realname)   // no error for non-existing ref with non-existing module
-        resolvePath( ref, 'using', def ); // TODO: consider FROM for validNames
-    }
-  }
 }
 
 module.exports = kickStart;

package/lib/compiler/populate.js

@@ -75,7 +75,7 @@ function populate( model ) {
     resolvePath,
     nestedElements,
     attachAndEmitValidNames,
-    initArtifact,
+    initMainArtifact,
     extendArtifactBefore,
     extendArtifactAfter,
   } = model.$functions;
@@ -1113,9 +1113,7 @@ function populate( model ) {
   // To avoid repeated messages: if already tried to do autoexposure, return
   // auto-exposed entity when successful, or `target` otherwise (no/failed autoexposure)
   function minimalExposure( target, service, elemScope ) {
-    const descendants = scopedExposure( target._descendants &&
-                                        target._descendants[service.name.id] ||
-                                        [],
+    const descendants = scopedExposure( target._descendants?.[service.name.id] || [],
                                         elemScope, target );
     const preferred = descendants.filter( d => annotationVal( d['@cds.redirection.target'] ) );
     const exposed = preferred.length ? preferred : descendants;
@@ -1172,7 +1170,7 @@ function populate( model ) {
       kind: 'namespace', name: { id: autoScopeName, location }, location,
     };
     model.definitions[autoScopeName] = nullScope;
-    initArtifact( nullScope );
+    initMainArtifact( nullScope );
     return nullScope;
   }
 
@@ -1207,7 +1205,6 @@ function populate( model ) {
   function isDirectProjection( proj, base ) {
     return proj.kind === 'entity' && // not event
       // direct proj (TODO: or should we add them to another list?)
-      // TODO: delete ENTITY._from - maybe not...
       proj.query && proj.query.op && proj.query.op.val === 'SELECT' &&
       proj._from && proj._from.length === 1 &&
       base === resolvePath( proj._from[0], 'from', proj.query );
@@ -1354,7 +1351,7 @@ function populate( model ) {
     }
     setLink( art, '_service', service );
     setLink( art, '_block', model.$internal );
-    initArtifact( art, !!autoexposed );
+    initMainArtifact( art, !!autoexposed );
     effectiveType( art );
     // TODO: try to set locations of elements locations of orig target elements
     newAutoExposed.push( art );

package/lib/compiler/propagator.js

@@ -47,7 +47,7 @@ function propagate( model ) {
     precision: always,
     scale: always,
     srid: always,
-    localized: withKind,
+    localized,
     target: notWithExpand,
     targetAspect,
     cardinality: notWithExpand,
@@ -78,6 +78,7 @@ function propagate( model ) {
   const { rewriteAnnotationsRefs, rewriteRefsInExpression } = xprRewriteFns( model );
 
   const { message, throwWithError } = model.$messageFunctions;
+  const { withLocalizedData } = model.$functions;
 
   forEachDefinition( model, run );
   forEachGeneric( model, 'vocabularies', run );
@@ -336,6 +337,24 @@ function propagate( model ) {
       annotation( prop, target, source );
   }
 
+  /**
+   * Propagate `localized`, but not for a texts entity
+   * (as `null` in an Universal CSN).
+   */
+  function localized( prop, target, source ) {
+    const main = target._main;
+    if (target.kind === 'element' && main.kind === 'entity' && !main.query) {
+      const { id } = main.name;
+      const base = id.endsWith( '.texts' ) &&
+        model.definitions[id.slice( 0, -'.texts'.length )];
+      if (base && withLocalizedData( base, main )) {
+        target.localized = { $inferred: 'NULL', val: undefined }; // null in UCSN
+        return;
+      }
+    }
+    withKind( prop, target, source );
+  }
+
   function withKind( prop, target, source ) {
     if (target.kind === 'param' && source.kind === 'entity')
       return; // Don't propagate from entity types to parameters (+ return type).

package/lib/compiler/resolve.js

@@ -108,8 +108,32 @@ function resolve( model ) {
   const ignoreSpecifiedElements
     = isDeprecatedEnabled( options, 'ignoreSpecifiedQueryElements' );
 
+  forEachGeneric( model, 'sources', resolveUsings );
   return doResolve();
 
+  /**
+   * 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.id)
+        continue;               // using {...}, parse error
+      const art = model.definitions[def.name.absolute];
+      if (art && art.$duplicates)
+        continue;
+      const ref = def.extern;
+      const user = (topLevel ? def : src);
+      const from = user.fileDep;
+      if (art || !from || from.realname)   // no error for non-existing ref with non-existing module
+        resolvePath( ref, 'using', def ); // TODO: consider FROM for validNames
+    }
+  }
+
   function doResolve() {
     // Phase 1: check paths in `usings` has been moved to kick-start.js Phase 2:
     // calculate/init view elements & collect views in order:
@@ -1669,7 +1693,8 @@ function resolve( model ) {
     }
     const symbols = type && type.enum;
     if (!symbols) {
-      if (user.kind !== '$annotation') { // TODO: better type deduction for annotations
+      if ((user.kind ?? user._outer?.kind) !== '$annotation') {
+        // TODO: better type deduction for annotations
         const msg = (user.kind === 'enum') ? 'symbolDef' : type && 'invalidType';
         warning( 'ref-unexpected-enum', [ expr.location, user ],
                  { '#': msg || 'untyped', enum: sym.id, type: type || '' } );