@sap/cds-compiler 5.8.0 → 5.9.0

package/lib/api/options.js

@@ -20,6 +20,7 @@ const publicOptionsNewAPI = [
   'defaultBinaryLength',
   'defaultStringLength',
   'csnFlavor',
+  'compositionIncludes',
   // DB
   'sqlDialect',
   'sqlMapping',
@@ -33,6 +34,7 @@ const publicOptionsNewAPI = [
   'fewerLocalizedViews',
   'withHanaAssociations',
   'standardDatabaseFunctions',
+  'booleanEquality',
   // ODATA
   'odataOpenapiHints',
   'edm4OpenAPI',
@@ -48,6 +50,9 @@ const publicOptionsNewAPI = [
   'odataNoCreator',
   'service',
   'serviceNames',
+  // to.cdl
+  'renderCdlDefinitionNesting',
+  'renderCdlCommonNamespace',
   //
   'dictionaryPrototype',
   // for.effective
@@ -66,7 +71,7 @@ const publicOptionsNewAPI = [
 const privateOptions = [
   // Not callable via cdsc, keep private for now until we are sure that we want this
   'filterCsn',
-  'lintMode',
+  'lintMode', // for cdsse only
   'traceFs',
   'traceParser',
   'traceParserAmb',
@@ -134,7 +139,7 @@ function translateOptions( input = {}, defaults = {}, hardRequire = {},
   reclassifyErrorsForOpenApi( options );
 
   // Convenience for $user -> $user.id replacement
-  if (options.variableReplacements && options.variableReplacements.$user && typeof options.variableReplacements.$user === 'string')
+  if (options.variableReplacements?.$user && typeof options.variableReplacements?.$user === 'string')
     options.variableReplacements.$user = { id: options.variableReplacements.$user };
 
   return options;
@@ -158,11 +163,21 @@ function reclassifyErrorsForOpenApi( options ) {
 
 module.exports = {
   to: {
-    cdl: options => translateOptions(options, undefined, undefined, undefined, undefined, 'to.cdl'),
+    cdl: (options) => {
+      // TODO(v6): Change defaults to 'true'
+      const defaultOptions = {
+        renderCdlDefinitionNesting: false,
+        renderCdlCommonNamespace: false,
+      };
+      return translateOptions(options, defaultOptions, undefined, undefined, undefined, 'to.cdl');
+    },
     sql: (options) => {
       const hardOptions = { src: 'sql', toSql: true, forHana: true };
       const defaultOptions = {
-        sqlMapping: 'plain', sqlDialect: 'plain', withHanaAssociations: true,
+        sqlMapping: 'plain',
+        sqlDialect: 'plain',
+        withHanaAssociations: true,
+        booleanEquality: false,
       };
       const processed = translateOptions(options, defaultOptions, hardOptions, undefined, [ 'sql-dialect-and-naming' ], 'to.sql');
 
@@ -172,14 +187,21 @@ module.exports = {
       const hardOptions = { src: 'hdi', toSql: true, forHana: true };
       // TODO: sqlDialect should be a hard option!
       const defaultOptions = {
-        sqlMapping: 'plain', sqlDialect: 'hana', withHanaAssociations: true,
+        sqlMapping: 'plain',
+        sqlDialect: 'hana',
+        withHanaAssociations: true,
+        booleanEquality: false,
       };
       return translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdi');
     },
     hdbcds: (options) => {
       const hardOptions = { forHana: true };
       // TODO: sqlDialect should be a hard option!
-      const defaultOptions = { sqlMapping: 'plain', sqlDialect: 'hana' };
+      const defaultOptions = {
+        sqlMapping: 'plain',
+        sqlDialect: 'hana',
+        booleanEquality: false,
+      };
       return translateOptions(options, defaultOptions, hardOptions, { sqlDialect: generateStringValidator([ 'hana' ]) }, undefined, 'to.hdbcds');
     },
     edm: (options) => {

package/lib/base/message-registry.js

@@ -76,6 +76,8 @@ const centralMessages = {
 
   'type-invalid-items': { severity: 'Error' }, // not supported yet
   'assoc-as-type':  { severity: 'Error' }, // TODO: allow more, but not all
+  // the following is not really an error in v6, but gets a different semantics:
+  'assoc-incomplete-to-many': { severity: 'Warning', errorFor: [ 'v6' ] },
   'def-unexpected-nested-proj': { severity: 'Error', configurableFor: 'v4' },
   'def-unexpected-paramview-assoc': { severity: 'Error' },
   'def-unexpected-calcview-assoc': { severity: 'Error' },
@@ -93,7 +95,7 @@ const centralMessages = {
 
   'ref-deprecated-orderby': { severity: 'Error', configurableFor: true },
   'ref-deprecated-self-element': { severity: 'Error', configurableFor: true },
-  'ref-deprecated-variable': { severity: 'Warning', errorFor: [ 'v6' ] },
+  'ref-deprecated-variable': { severity: 'Warning' },
   'ref-invalid-type': { severity: 'Error' },
   'ref-unexpected-self': { severity: 'Error' },
   'ref-invalid-include': { severity: 'Error' },
@@ -163,15 +165,16 @@ const centralMessages = {
   // fallback, but then parse.cdl is not supposed to work correctly (it can
   // then either issue an error or produce a CSN missing some annotations):
   'syntax-duplicate-annotate': { severity: 'Error' },
-  'syntax-duplicate-clause': { severity: 'Error', configurableFor: 'v6' },
+  'syntax-duplicate-clause': { severity: 'Error', configurableFor: [ 'v6' ] },
   // remark: a hard syntax error in new parser for `null` together with `not null`
   'syntax-duplicate-equal-clause': { severity: 'Warning', errorFor: [ 'v6' ] },
   'syntax-invalid-name': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
-  'syntax-missing-proj-semicolon': { severity: 'Warning', errorFor: [ 'v6' ] },
+  'syntax-missing-proj-semicolon': { severity: 'Warning' },
   'syntax-unexpected-after': { severity: 'Warning', errorFor: [ 'v6' ] },
   'syntax-unexpected-filter': { severity: 'Warning', errorFor: [ 'v6' ] },
   'syntax-unexpected-many-one': { severity: 'Error', configurableFor: true }, // TODO: remove `configurableFor` soon, latest v6
+  'syntax-deprecated-ref-virtual': { severity: 'Warning', errorFor: [ 'v6' ] },
   'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
   'syntax-unsupported-masked': { severity: 'Error', configurableFor: 'deprecated' },
@@ -268,6 +271,9 @@ const centralMessageTexts = {
     type: 'Expected option $(OPTION) to be of type $(VALUE). Found: $(OTHERVALUE)',
     forbidden: 'Option $(OPTION) can\'t be used with API function $(MODULE)',
   },
+  'def-upcoming-virtual-change': {
+    std: 'This select item will be a new element in cds-compiler v6, without referencing $(NAME); prepend a table alias if you want to keep the virtual element as a reference; see https://cap.cloud.sap/docs/cds/compiler/messages#def-upcoming-virtual-change for details',
+  },
 
   'api-invalid-variable-replacement': {
     std: 'Option $(OPTION) does not support $(NAME)',
@@ -385,6 +391,11 @@ const centralMessageTexts = {
   },
   'syntax-unexpected-filter': 'Unexpected filter on the result of a function call',
   'syntax-unexpected-many-one': 'Replace $(CODE) with $(DELIMITED) to avoid an ambiguity with managed compositions of anonymous aspects',
+  'syntax-deprecated-ref-virtual': {
+    std: 'Use $(DELIMITED) at the beginning of the column expression',
+    ref: 'Use $(DELIMITED) to refer to the element $(NAME) at the beginning of the column expression',
+    func: 'Use $(DELIMITED) when calling the function $(NAME) at the beginning of the column expression',
+  },
   'syntax-invalid-name': {
     std: 'Identifier must consist of at least one character', // only via delimited id
     // as: 'String in property $(PROP) must not be empty', // expecting non-empty string is ok
@@ -900,12 +911,12 @@ const centralMessageTexts = {
   },
   'def-unexpected-localized': {
     std: 'Unexpected $(KEYWORD)',
-    struct: 'Unexpected $(KEYWORD) for structured type',
     map: 'Unexpected $(KEYWORD) for map type',
     elements: '$(ART) can\'t have localized elements',
     // TODO: Better message?
     include:  '$(ART) can\'t have localized elements (through include)',
   },
+  'def-unexpected-localized-struct': '$(KEYWORD) is not fully supported for structures',
   'def-unexpected-localized-anno': 'Annotations can\'t have localized elements',
   'type-unexpected-structure': {
     std: 'Unexpected structured type', // unused variant

package/lib/checks/validator.js

@@ -52,6 +52,7 @@ const {
 } = require('./sql-snippets');
 const assertNoAssocUsageOutsideOfService = require('./assocOutsideService');
 const featureFlags = require('./featureFlags');
+const { timetrace } = require('../utils/timetrace');
 
 const forRelationalDBMemberValidators
 = [
@@ -156,7 +157,9 @@ function _validate( csn, that,
                     artifactValidators = [],
                     queryValidators = [],
                     iterateOptions = {} ) {
+  timetrace.start('Enrich CSN');
   const { cleanup } = enrichCsn(csn, that.options);
+  timetrace.stop('Enrich CSN');
   // TODO: Don't know if that's feasible? Do we really need to enrich annotations always?
   // const { cleanup } = enrich(csn, { processAnnotations: that.options.tranformation === 'odata' });
 

package/lib/compiler/base.js

@@ -75,7 +75,7 @@ function propExists( prop, parent ) {
  * `element`.  The following code makes use of the fact that only member extensions
  * have a "sparse" name structure.
  *
- * @param {XSN.Artifact} art
+ * @param {XSN.Artifact & XSN.Using} art
  * @returns {XSN.Name}
  */
 function getArtifactName( art ) {

package/lib/compiler/checks.js

@@ -21,6 +21,7 @@ const {
 const { typeParameters } = require('./builtins');
 const { propagationRules } = require('../base/builtins');
 const { annotationVal } = require('./utils');
+const { functionsWithoutParentheses } = require('../parsers/identifiers');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -131,7 +132,6 @@ function check( model ) {
   }
 
   function checkElement( elem, parentProps ) {
-    checkLocalizedSubElement( elem );
     checkKey( elem, parentProps );
     checkLocalizedElement( elem );
 
@@ -274,10 +274,13 @@ function check( model ) {
   function checkLocalizedElement( elem ) {
     if (elem.localized?.val) {
       const type = elem._effectiveType;
-      if (type?.category === 'map' ||
-         (type?.elements && isBetaEnabled( model.options, 'v6preview' ))) {
+      if (type?.category === 'map') {
         error( 'def-unexpected-localized', [ elem.localized.location, elem ],
-               { keyword: 'localized', '#': type.category === 'map' ? 'map' : 'struct' } );
+               { keyword: 'localized', '#': 'map' } );
+      }
+      else if (type?.elements) { // warning only, as we want to support it in the future
+        warning( 'def-unexpected-localized-struct', [ elem.localized.location, elem ],
+                 { keyword: 'localized' } );
       }
       else if (!type || !type.builtin || type.category !== 'string') {
         // See discussion issue #6520: should we allow all scalar types?
@@ -287,9 +290,10 @@ function check( model ) {
       }
     }
 
-    // TODO: This check should be moved to localized.js
+    // TODO: This check should be moved to localized.js - WHY?
     // "key" keyword at localized element in SELECT list.
     // TODO: not in inferred elements, but also inside aspects
+    // TODO: `localized` is not necessarily at _origin, but the _origin chain
     if (elem.key?.val && elem._main?.query) {
       // either the element was casted to localized (no `_origin`) or
       // original element is localized but not key, as that would have
@@ -472,47 +476,6 @@ function check( model ) {
     }
   }
 
-  /**
-   * TODO: check inside compiler as it is a compiler restriction - improve
-   * TODO: Recursive check; use "parentProps" as other member checks
-   *
-   * Non-recursive check if sub-elements have a "localized" keyword since this is
-   * not yet supported.
-   *
-   * This check is not recursive to avoid a runtime overhead. Because of this it fails
-   * to detect scenarios with indirections, e.g.
-   *   ```cds
-   *   type L : localized String;
-   *   type L1 : L;
-   *   type L2 : L1;
-   *
-   *   entity E {
-   *     struct : {
-   *       subElement : L2;
-   *     }
-   *   }
-   *   ```
-   *
-   * @param {XSN.Artifact} element
-   */
-  function checkLocalizedSubElement( element ) {
-    if (element._parent?.kind !== 'element')
-      return;
-
-    const isLocalizedSubElement = element.localized?.val;
-    if (isLocalizedSubElement || element.type?._artifact?.localized?.val) {
-      const loc = isLocalizedSubElement ? element.localized.location : element.type.location;
-      warning( 'localized-sub-element', [ loc, element ], {
-        type: element.type?._artifact || '',
-        '#': isLocalizedSubElement ? 'std' : 'type',
-        keyword: 'localized',
-      }, {
-        std: 'Keyword $(KEYWORD) is ignored for sub elements',
-        type: 'Keyword $(KEYWORD) in type $(TYPE) is ignored for sub elements',
-      } );
-    }
-  }
-
   /**
    * Check that min and max cardinalities of 'art' have legal values
    *
@@ -615,13 +578,22 @@ function check( model ) {
       }
     }
 
-    // TODO(v6): Also reject default for structures (#13154), i.e. add `|| !!art.….elements`
-    const isStructured = art._effectiveType?.name.id === 'cds.Map';
-    if (isStructured) {
+    const isMap = art._effectiveType?.name.id === 'cds.Map';
+    if (isMap) {
       error( 'type-unexpected-default', [ defaultValue.location, art ], {
         '#': 'map', keyword: 'default', type: 'cds.Map',
       } );
     }
+    else if (art._effectiveType?.elements) {
+      warning( 'type-unexpected-default-struct', [ defaultValue.location, art ], {
+        '#': art.kind, keyword: 'default',
+      }, {
+        std: 'Unexpected $(KEYWORD) for a structure',
+        param: 'Unexpected $(KEYWORD) for a structured parameter',
+        type: 'Unexpected $(KEYWORD) for a structured type definition',
+        element: 'Unexpected $(KEYWORD) for a structured element',
+      } );
+    }
   }
 
   function getBinaryOp( cond ) {
@@ -673,7 +645,7 @@ function check( model ) {
       const element = def.elements[name];
       // Element is new in `art`, not expanded; we can't check for !element._origin, due
       // to calculated elements such as `a = b`.
-      if (element.$inferred !== 'include') {
+      if (element.$inferred !== 'include' && element.$inferred !== 'aspect-composition') {
         for (const include of def.includes) {
           if (include._artifact?.elements?.[name] !== undefined)
             checkElementOverride( element, include._artifact.elements[name] );
@@ -780,6 +752,7 @@ function check( model ) {
 
   function checkSelectItemValue( elem ) {
     checkExpressionAssociationUsage( elem.value, elem, false );
+    checkVirtualSelectItemChangeForV6( elem );
     // To avoid duplicate messages, only run this check if the type wasn't inferred from
     // the cast, as otherwise we will check it twice (once here, once via element).
     if (elem.value?.op?.val === 'cast' && elem.type?.$inferred !== 'cast') {
@@ -792,6 +765,40 @@ function check( model ) {
     } );
   }
 
+  /**
+   * In v6, there will be a change in semantics for following example:
+   *
+   * ```cds
+   * view V as select from E {
+   *   virtual b, // -> warning: will be new element, not reference in v6
+   * }
+   * ```
+   *
+   * We allow users to define _new_ elements using `virtual`.  But all such references
+   * in v5 are valid, resolvable references. Hence, the semantics will change in v6.
+   * Let users know about it.
+   *
+   * @param elem
+   */
+  function checkVirtualSelectItemChangeForV6( elem ) {
+    if (
+        !elem.virtual?.val || elem.virtual.$inferred || // not explicitly marked virtual
+        elem.type && !elem.type.$inferred ||            // has explicit type
+        elem.value.path?.length > 1 ||                  // multi-path step, i.e. no new definition
+        !elem.name.$inferred                            // has explicit alias
+    )
+      return;
+
+    if ((!elem.value.path || !elem.value._artifact) &&
+        !isFunctionWithoutParentheses( elem ))
+      return; // not a reference nor function without parentheses
+
+    if (elem.value.path?.some(ps => ps.args || ps.where))
+      return; // not a simple reference
+
+    warning('def-upcoming-virtual-change', [ elem.virtual.location, elem ], { name: elem.name.id });
+  }
+
   function checkCalculatedElementValue( elem ) {
     const isStored = elem.value.stored?.val;
     visitExpression( elem.value, elem, (xpr, user) => {
@@ -1378,4 +1385,17 @@ function isComplexView( art ) {
   return (!art.query.from?._artifact || art.query.from._artifact.kind === 'element');
 }
 
+/**
+ * @param {XSN.Element} elem
+ * @returns {boolean}
+ */
+function isFunctionWithoutParentheses( elem ) {
+  const func = elem.value?.func;
+  if (!func?.path || elem.value.args)
+    return false;
+  if (func.path.length !== 1)
+    return false;
+  return functionsWithoutParentheses.includes(func.path[0].id.toUpperCase());
+}
+
 module.exports = check;

package/lib/compiler/extend.js

@@ -1400,7 +1400,7 @@ function layeredExtensions( extensions ) {
  *   at least two files are involved
  *
  * @param {Record<string, object>} layered Structure as returned by layeredExtensions()
- * @returns {{assignments, issue: boolean|string}}
+ * @returns {{highest, issue: boolean|string}}
  */
 function extensionsOfHighestLayers( layered ) {
   const layerNames = Object.keys( layered );

package/lib/compiler/generate.js

@@ -35,6 +35,7 @@ function generate( model ) {
     extendArtifactBefore,
     applyIncludes,
   } = model.$functions;
+  model.$functions.hasTruthyProp = hasTruthyProp;
 
   const addTextsLanguageAssoc = checkTextsLanguageAssocOption( model, options );
   const useTextsAspect = checkTextsAspect();
@@ -530,7 +531,7 @@ function generate( model ) {
           return false;
         name = (art._main || art)?.name?.id;
       }
-      else if (art.type && art._block && art.type.scope !== 'typeOf') {
+      else if (art.type) {
         // TODO: also do something special for TYPE OF inside `art`s own elements
         // TODO: check for own - add test case with Type:elem (not TYPE OF elem)
         name = resolveUncheckedPath( art.type, 'type', art );
@@ -563,7 +564,7 @@ function generate( model ) {
         const elem = base.elements[name];
         if (elem.$duplicates)
           return false;           // no composition-of-type unfold with redefined elems
-        if (elem.key && elem.key.val)
+        if (elem.key?.val)
           k[name] = elem;
       }
       return k;
@@ -695,6 +696,8 @@ function generate( model ) {
       $inferred: 'composition-entity',
     };
     if (target.name) {          // named target aspect
+      if (options.compositionIncludes !== false) // default is 'true'  since v5.9
+        art.includes = [ createInclude( target.name.id, location ) ];
       setLink( art, '_origin', target );
       setLink( art, '_upperAspects', [ target, ...(elem._main._upperAspects || []) ] );
     }
@@ -749,6 +752,9 @@ function generate( model ) {
     extendArtifactBefore( art );
     // Copy persistence annotations from aspect.
     copyPersistenceAnnotations( art, target ); // after extendArtifactBefore()
+
+    if (options.compositionIncludes !== false && art.includes)
+      applyIncludes( art, art ); // for actions
     return art;
   }
 

package/lib/compiler/index.js

@@ -124,7 +124,7 @@ function parserForFile( source, ext, options ) {
 // 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
+//  - Truthy `lintMode`: do not do propagation
 //  - many others - TODO
 
 // This function returns a Promise and can be used with `await`.  For an example

package/lib/compiler/lsp-api.js

@@ -168,7 +168,7 @@ function* artifactTokens( art ) {
     if (artifactActions[prop])
       yield* artifactActions[prop](art[prop], art);
     else if (prop.charAt(0) === '@')
-      yield* artifactActions['@'](art[prop], art);
+      yield* artifactActions['@'](art[prop]);
   }
 
   return null;

package/lib/compiler/propagator.js

@@ -366,10 +366,10 @@ function propagate( model ) {
       return;
     for (const item of path) {
       const art = item && item._artifact;
-      if (art && art.virtual && art.virtual.val) {
+      if (art?.virtual?.val) {
         warning( 'def-missing-virtual', [ item.location, elem ], { art, keyword: 'virtual' },
                  // eslint-disable-next-line @stylistic/js/max-len
-                 'Prepend $(KEYWORD) to current select item - referred element $(ART) is virtual which is not inherited' );
+                 'Prepend $(KEYWORD) to current select item - containing element $(ART) is virtual' );
         return;
       }
     }

package/lib/compiler/resolve.js

@@ -64,6 +64,7 @@ const {
   linkToOrigin,
   compositionTextVariant,
   targetCantBeAspect,
+  userParam,
 } = require('./utils');
 
 const detectCycles = require('./cycle-detector');
@@ -96,6 +97,7 @@ function resolve( model ) {
     effectiveType,
     getOrigin,
     getInheritedProp,
+    hasTruthyProp,              // limited inheritance
     resolveTypeArgumentsUnchecked,
   } = model.$functions;
   Object.assign( model.$functions, {
@@ -509,7 +511,7 @@ function resolve( model ) {
 
         // Check if relational type is missing its target or if it's used directly.
         if (elemtype.category === 'relation' &&
-          !obj.target && !obj.targetAspect) {
+            !obj.target && !obj.targetAspect) {
           const isCsn = (obj._block && obj._block.$frontend === 'json');
           error( 'type-missing-target', [ obj.type.location, obj ],
                  { '#': isCsn ? 'csn' : 'std', type: elemtype }, {
@@ -582,6 +584,35 @@ function resolve( model ) {
       }
     }
 
+    // Set '@Core.Computed' in the Core Compiler to have it propagated...
+    if (art.kind !== 'element' || art['@Core.Computed'])
+      return;
+
+    // For events and types, elements can't be @Core.Computed, as values are only used
+    // to infer the element signature.  For virtual, we keep @Core.Computed, as it's
+    // always been that way, even before type projections.
+    const elementsCanBeComputed = art._main?.kind !== 'type' && art._main?.kind !== 'event';
+
+    if (art.virtual?.val ||
+        elementsCanBeComputed && art.value &&
+        (!art.value._artifact || !art.value.path || // in localization view: _artifact, but no path
+         art.value.stored?.val || // calculated elements on-write are always computed
+         art.value._artifact.kind === 'builtin' ||
+         art.value._artifact.kind === 'param' ||
+         art.value.scope === 'param' )) {
+      art['@Core.Computed'] = {
+        name: {
+          path: [ { id: 'Core.Computed', location: art.location } ],
+          location: art.location,
+        },
+        $inferred: '$generated',
+      };
+    }
+
+    if (art.kind === 'element' && art._effectiveType)
+      checkLocalizedElement( art );
+    return;
+
     /**
      * Check whether the signature of the specified element matches that of the inferred one.
      *
@@ -619,11 +650,11 @@ function resolve( model ) {
       }
       // If specified type is `null`, type could not be resolved.
       else if (!compToAssoc && sType && sType !== iType &&
-        // Special case for $recompilation: allow one level of type indirection. See #12113.
-        (!options.$recompile || sType !== iType.type?._artifact)) {
+               // Special case for $recompilation: allow one level of type indirection. See #12113.
+               (!options.$recompile || sType !== iType.type?._artifact)) {
         const typeName = !iTypeArt && 'typeExtra' ||  // no inferred type prop
-          iType?.name && sType?.name && 'typeName' || // both types are named
-          'type';                                     // unknown type names
+              iType?.name && sType?.name && 'typeName' || // both types are named
+              'type';                                     // unknown type names
         const othertype = typeName !== 'type' && iType || '';
         error( 'query-mismatched-element', [
           specifiedElement.type.location || specifiedElement.location, user,
@@ -639,7 +670,7 @@ function resolve( model ) {
       // This relies on (element) expansion!  Check that both sides have the following properties.
       // On the inferred side, they are likely expanded.
       if (!hasXorPropMismatch( 'elements' ) && !hasXorPropMismatch( 'items' ) &&
-        !hasXorPropMismatch( 'target' ) && !hasXorPropMismatch( 'enum' )) {
+          !hasXorPropMismatch( 'target' ) && !hasXorPropMismatch( 'enum' )) {
         // Element are already traversed via elements$ merging.
 
         // only check items, if the specified one is not expanded/inferred
@@ -789,7 +820,7 @@ function resolve( model ) {
         //   This property is directly in the `value` property, but not part of `inferredElement`
         //   which has a `type` property, but no `enum`.
         if (!inferredElement[prop] !== !specifiedElement[prop] &&
-          !inferredElement.value?.[prop] !== !specifiedElement[prop]) {
+            !inferredElement.value?.[prop] !== !specifiedElement[prop]) {
           error( 'query-mismatched-element', [ specifiedElement.location, specifiedElement ], {
             '#': specifiedElement[prop] ? 'extra' : 'missing', name: user.name.id, prop,
           } );
@@ -812,31 +843,41 @@ function resolve( model ) {
         return element.cardinality || ref?.[ref.length - 1]?.cardinality;
       }
     }
+  }
 
-
-    // Set '@Core.Computed' in the Core Compiler to have it propagated...
-    if (art.kind !== 'element' || art['@Core.Computed'])
-      return;
-
-    // For events and types, elements can't be @Core.Computed, as values are only used
-    // to infer the element signature.  For virtual, we keep @Core.Computed, as it's
-    // always been that way, even before type projections.
-    const elementsCanBeComputed = art._main?.kind !== 'type' && art._main?.kind !== 'event';
-
-    if (art.virtual?.val ||
-       elementsCanBeComputed && art.value &&
-        (!art.value._artifact || !art.value.path || // in localization view: _artifact, but no path
-          art.value.stored?.val || // calculated elements on-write are always computed
-          art.value._artifact.kind === 'builtin' ||
-          art.value._artifact.kind === 'param' ||
-          art.value.scope === 'param' )) {
-      art['@Core.Computed'] = {
-        name: {
-          path: [ { id: 'Core.Computed', location: art.location } ],
-          location: art.location,
-        },
-        $inferred: '$generated',
-      };
+  /**
+   * Issue warnings for restrictions concerning `localized`, i.e. for situations
+   * where a (later) inherited `localized` does not lead to the texts entity
+   * (element) being created, because the inherited info was not available then,
+   * or would involve more work (localized sub elements).
+   */
+  function checkLocalizedElement( art ) {
+    const parent = art._parent;
+    if (!parent)
+      return;                   // with duplicate defs
+    const isSubElem = (parent.kind === 'element' || art._outer);
+    if (isSubElem) {            // sub element or in MANY
+      // Localized sub elements in types, aspects, parameters and non-query
+      // entities are not problematic.  They are just not really useful there →
+      // just report direct (not inherited) `localized` usage in non-inferred
+      // elements then.  For non-query entities, always report.
+      if (art._main?.kind !== 'entity' || art._main?.query || userParam( parent )
+          ? !art.$inferred && art.localized?.val && art._main?.kind !== 'annotation'
+          : getInheritedProp( art, 'localized' )) {
+        const loc = (art.localized || art.type || art.value)?.location || art.location;
+        warning( 'type-unsupported-localized', [ loc, art ], {},
+                 'Localized sub elements are not supported' );
+      }
+    }
+    else if (parent.kind === 'entity' && !art._main?.query &&
+             art.$syntax !== 'calc' &&
+             getInheritedProp( art, 'localized' )?.val &&
+             // no inherited `localized` which wasn't known in generate.js
+             // TODO: should we set `localized` to null otherwise?
+             !hasTruthyProp( art, 'localized' )) {
+      const loc = (art.localized || art.type)?.location || art.location;
+      warning( 'type-missing-localized', [ loc, art ], { keyword: 'localized' },
+               'Add keyword $(KEYWORD), can\'t derive early enough that the element is localized' );
     }
   }
 
@@ -1132,6 +1173,12 @@ function resolve( model ) {
   }
 
   function addImplicitForeignKeys( art, obj, target ) {
+    const max = art.cardinality?.targetMax;
+    if (max && (typeof max.val !== 'number' || max.val > 1) &&
+        !art.$inferred && !art.virtual?.val) {
+      warning( 'assoc-incomplete-to-many', [ max.location, art ], null,
+               'Provide an ON-condition or foreign keys to this to-many association' );
+    }
     obj.foreignKeys = Object.create( null );
     forEachInOrder( target, 'elements', ( elem, name ) => {
       if (elem.key?.val) {