@sap/cds-compiler 2.7.0 → 2.11.2

package/lib/compiler/definer.js

@@ -88,7 +88,7 @@
 // Sub Phase 2 (initXYZ)
 //  - set _parent, _main (later: _service?) links, and _block links of members
 //  - add _subArtifacts dictionary and "namespace artifacts" for name resolution
-//  - duplicate checks (TODO - currently via preProcessArtifact in definer)
+//  - duplicate checks
 //  - structure checks ?
 //  - annotation assignments
 //  - POST: resolvePath() can be called for artifact references (if complete model)
@@ -101,9 +101,11 @@
 //    to avoid consequential or repeated errors.
 //  - But: The same artifact is added to multiple dictionaries.
 //  - Solution part 1: $duplicates as property of the artifact or member
-//    for 'definitions', '_artifacts' and member dictionaries.
-//  - Solution part 2: array value in dictionary for duplicates in CDL 'artifacts'
-//    dictionary, also used for `_combined` in query search dictionary.
+//    for `definitions`, `_artifacts`, member dictionaries, `vocabulary`
+//    dictionary of the whole model, `$tableAliases` dictionary of queries.
+//  - Solution part 2: array value in dictionary for duplicates in CDL `artifacts`
+//    dictionary, `_combined` dictionary for query search, `$tableAliases`
+//    of JOIN restrictions, `vocabulary` dictionary of a CDL input source.
 
 'use strict';
 
@@ -111,7 +113,7 @@ const { searchName, weakLocation } = require('../base/messages');
 const {
   isDeprecatedEnabled, isBetaEnabled,
   setProp, forEachGeneric, forEachInOrder,
-  forEachMember, forEachDefinition,
+  forEachDefinition,
   forEachMemberRecursivelyWithQuery,
 } = require('../base/model');
 const {
@@ -120,20 +122,20 @@ const {
 const {
   dictLocation,
 } = require('../base/location');
+const { kindProperties, dictKinds } = require('./base');
 const {
-  annotationVal, annotationIsFalse, annotateWith,
-} = require('./utils');
-const {
-  dictKinds,
-  kindProperties,
-  fns,
+  annotationVal,
+  annotationIsFalse,
+  annotateWith,
   linkToOrigin,
   setMemberParent,
   storeExtension,
   dependsOnSilent,
-} = require('./shared');
+  augmentPath,
+  splitIntoPath,
+} = require('./utils');
 const { compareLayer, layer } = require('./moduleLayers');
-const { initBuiltins } = require('./builtins');
+const { initBuiltins, isInReservedNamespace } = require('./builtins');
 const setLink = setProp;
 
 /**
@@ -148,7 +150,7 @@ const setLink = setProp;
  *
  * @param {XSN.Model} model Model with `sources` property that contain AST-like CSNs.
  */
-function getDefinerFunctions( model ) {
+function define( model ) {
   const { options } = model;
   // Get simplified "resolve" functionality and the message function:
   const {
@@ -160,24 +162,29 @@ function getDefinerFunctions( model ) {
     resolveTypeArguments,
     defineAnnotations,
     attachAndEmitValidNames,
-  } = fns( model );
-  const extensionsDict = Object.create(null);
-  let addTextsLanguageAssoc = false;
-
-  return {
-    define,
+  } = model.$functions;
+  Object.assign( model.$functions, {
     initArtifact,
     lateExtensions,
     projectionAncestor,
     hasTruthyProp,
+  } );
+  // During the definer, we can only resolve artifact references, i.e,
+  // after a `.`, we only search in the `_subArtifacts` dictionary:
+  model.$volatileFunctions.environment = function artifactsEnv( art ) {
+    return art._subArtifacts || Object.create(null);
   };
 
+  const extensionsDict = Object.create(null);
+  let addTextsLanguageAssoc = false;
+  return doDefine();
+
   /**
    * Main function of the definer.
    *
    * @returns {XSN.Model}
    */
-  function define() {
+  function doDefine() {
     if (options.deprecated &&
         messages.every( m => m.messageId !== 'api-deprecated-option' )) {
       warning( 'api-deprecated-option', {},
@@ -206,8 +213,6 @@ function getDefinerFunctions( model ) {
 
     if (options.parseCdl) {
       initExtensionsWithoutApplying();
-      // Check for redefinitions
-      Object.keys( model.definitions ).forEach( preProcessArtifact );
       // If no extensions shall be applied then we can skip further
       // artifact processing and return the model with an `extensions` property.
       return model;
@@ -215,8 +220,8 @@ function getDefinerFunctions( model ) {
 
     applyExtensions();
 
-    Object.keys( model.definitions ).forEach( preProcessArtifact );
-    const commonLanguagesEntity = isBetaEnabled( options, 'addTextsLanguageAssoc' ) &&
+    const commonLanguagesEntity // TODO: remove beta after a grace period
+        = (options.addTextsLanguageAssoc || isBetaEnabled( options, 'addTextsLanguageAssoc' )) &&
           model.definitions['sap.common.Languages'];
     addTextsLanguageAssoc = !!(commonLanguagesEntity && commonLanguagesEntity.elements &&
                                commonLanguagesEntity.elements.code);
@@ -237,13 +242,13 @@ function getDefinerFunctions( model ) {
    * @param {XSN.AST} src
    */
   function addSource( src ) {
-    // handle sub model from CSN parser
+    // handle sub model from parser
     if (!src.kind)
       src.kind = 'source';
 
     let namespace = src.namespace && src.namespace.path;
     let prefix = namespace ? `${ pathName( namespace ) }.` : '';
-    if (prefix.startsWith( 'cds.') && !prefix.match(/^cds\.foundation(\.|$)/)) {
+    if (isInReservedNamespace(prefix)) {
       error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -279,8 +284,7 @@ function getDefinerFunctions( model ) {
   function addDefinition( art, block ) {
     const { absolute } = art.name;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
-    if (absolute === 'cds' ||
-        absolute.startsWith( 'cds.') && !absolute.match(/^cds\.foundation(\.|$)/)) {
+    if (absolute === 'cds' || isInReservedNamespace(absolute)) {
       error( 'reserved-namespace-cds', [ art.name.location, art ], {},
              // TODO: use $(NAME)
              'The namespace "cds" is reserved for CDS builtins' );
@@ -304,7 +308,7 @@ function getDefinerFunctions( model ) {
     }
     else {
       setLink( art, '_block', block );
-      // dictAdd might set $duplicates to true if def in other source
+      // dictAdd might set $duplicates to true
       dictAdd( model.definitions, absolute, art );
       return true;
     }
@@ -443,6 +447,23 @@ function getDefinerFunctions( model ) {
 
   // Phase 2 ("init") --------------------------------------------------------
 
+  function checkRedefinition( art ) {
+    if (!art.$duplicates)
+      return;
+    if (art._main) {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.id,
+        '#': kindProperties[art.kind].normalized || art.kind,
+      } );
+    }
+    else {
+      error( 'duplicate-definition', [ art.name.location, art ], {
+        name: art.name.absolute,
+        '#': (art.kind === 'annotation' ? 'annotation' : 'absolute' ),
+      } );
+    }
+  }
+
   function initNamespaceAndUsing( src ) {
     if (src.namespace) {
       const decl = src.namespace;
@@ -487,12 +508,13 @@ function getDefinerFunctions( model ) {
     if (!reInit)
       initParentLink( art, model.definitions );
     const block = art._block;
+    checkRedefinition( art );
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
     initDollarSelf( art );      // $self
     if (art.params)
       initParams( art );        // $parameters
-    if (art.includes && !(art.name.absolute in extensionsDict))
+    if (art.includes && !(art.name.absolute in extensionsDict)) // TODO: in next phase?
       extensionsDict[art.name.absolute] = []; // structure with includes must be "extended"
 
     if (!art.query)
@@ -512,6 +534,7 @@ function getDefinerFunctions( model ) {
 
   function initVocabulary( art ) {
     initParentLink( art, model.vocabularies );
+    checkRedefinition( art );
     const block = art._block;
     defineAnnotations( art, art, block );
     initMembers( art, art, block );
@@ -553,20 +576,6 @@ function getDefinerFunctions( model ) {
 
   // From here til EOF, reexamine code ---------------------------------------
 
-  // currently called from preProcessArtifact(), do be called in "init"
-  function checkRedefinitions( obj, name, prop ) {
-    forEachMember( obj, checkRedefinitions, obj.targetAspect );
-    if (!obj.$duplicates)
-      return;
-    if (obj.name.location.file === '<built-in>') {
-      // builtin types like namespace 'cds' or namespace 'localized' shouldn't be printed.
-      // The error shall only be printed for the user-defined conflicting artifact.
-      return;
-    }
-    error( 'duplicate-definition', [ obj.name.location, obj ],
-           { name, '#': (obj.kind === 'namespace') ? 'namespace' : dictKinds[prop] } );
-  }
-
   function initDollarSelf( art ) {
     const selfname = '$self';
     // TODO: use setMemberParent() ?
@@ -607,14 +616,7 @@ function getDefinerFunctions( model ) {
     if (query.on)
       initExprForQuery( query.on, query );
     // TODO: MIXIN with name = ...subquery (not yet supported anyway)
-    for (const elem of query.columns || []) {
-      if (elem && (elem.value || elem.expand)) {
-        setProp( elem, '_block', query._block );
-        defineAnnotations( elem, elem, query._block );
-        initExprForQuery( elem.value, query );
-        initExpandInline( elem );
-      }
-    }
+    initSelectItems( query, query.columns );
     if (query.where)
       initExprForQuery( query.where, query );
     if (query.having)
@@ -622,22 +624,41 @@ function getDefinerFunctions( model ) {
     initMembers( query, query, query._block );
   }
 
-  function initExpandInline( elem ) {
-    // TODO: forbid with :param, global:true, in ref-where, outside queries (CSN), ...
-    for (const sub of elem.expand || elem.inline || []) {
-      if (!sub)                 // parse error
+  function initSelectItems( parent, columns ) {
+    // TODO: forbid expand/inline with :param, global:true, in ref-where, outside queries (CSN), ...
+    let wildcard = null;
+    for (const col of columns || parent.expand || parent.inline || []) {
+      if (!col)                 // parse error
         continue;
-      if (elem.value)
-        setProp( sub, '_pathHead', elem ); // also set for '*' in expand/inline
-      else if (elem._pathHead)
-        setProp( sub, '_pathHead', elem._pathHead );
-      if (sub.value || sub.expand) {
-        setProp( sub, '_block', elem._block );
-        defineAnnotations( sub, sub, elem._block ); // TODO: complain with inline
-        initExpandInline( sub );
+      if (!columns) {
+        if (parent.value)
+          setProp( col, '_pathHead', parent ); // also set for '*' in expand/inline
+        else if (parent._pathHead)
+          setProp( col, '_pathHead', parent._pathHead );
+      }
+      if (col.val === '*') {
+        if (!wildcard) {
+          wildcard = col;
+        }
+        else {
+          // a late syntax error (this code also runs with parse-cdl), i.e.
+          // no semantic loc (wouldn't be available for expand/inline anyway)
+          error( 'syntax-duplicate-clause', [ col.location, null ],
+                 { prop: '*', line: wildcard.location.line, col: wildcard.location.col },
+                 'You have provided a $(PROP) already at line $(LINE), column $(COL)' );
+          // TODO: extra text variants for expand/inline? - probably not
+          col.val = null;       // do not consider it for expandWildcard()
+        }
+      }
+      else if (col.value || col.expand) {
+        setProp( col, '_block', parent._block );
+        defineAnnotations( col, col, parent._block ); // TODO: complain with inline
+        // TODO: allow sub queries? at least in top-level expand without parallel ref
+        if (columns)
+          initExprForQuery( col.value, parent );
+        initSelectItems( col );
       }
     }
-    // TODO: allow sub queries in top-level expand without parallel ref
   }
 
   function initExprForQuery( expr, query ) {
@@ -656,9 +677,38 @@ function getDefinerFunctions( model ) {
     }
     else if (expr.path && expr.$expected === 'exists') {
       expr.$expected = 'approved-exists';
+      approveExistsInChildren(expr);
     }
   }
 
+  /**
+   * If we have a valid top-level exists, exists in filters of sub-expressions can be translated,
+   * since we will have a top-level subquery after exists-processing in the forHanaNew.
+   *
+   * Recursively drill down into:
+   * - the .path
+   * - the .args
+   * - the .where.args
+   *
+   * Any $expected === 'exists' encountered along the way are turned into 'approved-exists'
+   *
+   * working:     exists toE[exists toE] -> select from E where exists toE
+   * not working: toE[exists toE] -> we don't support subqueries in filters
+   *
+   * @param {object} exprOrPathElement starts w/ an expr but then subelem from .path or .where.args
+   */
+  function approveExistsInChildren(exprOrPathElement) {
+    if (exprOrPathElement.$expected === 'exists')
+      exprOrPathElement.$expected = 'approved-exists';
+    // Drill down
+    if (exprOrPathElement.args)
+      exprOrPathElement.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.where && exprOrPathElement.where.args)
+      exprOrPathElement.where.args.forEach(elem => approveExistsInChildren(elem));
+    else if (exprOrPathElement.path)
+      exprOrPathElement.path.forEach(elem => approveExistsInChildren(elem));
+  }
+
   // table is table expression in FROM, becomes an alias
   function initTableExpression( table, query, joinParents ) {
     if (!table)                 // parse error
@@ -706,6 +756,8 @@ function getDefinerFunctions( model ) {
           //        ? ta._joinParent.args[ta.$joinArgsIndex] // in JOIN
           //        : ta._parent.from )                      // directly in FROM
           // Note for --raw-output: _joinParent pointing to CROSS JOIN node has not name
+          if (!tab)             // parse error; time for #6241
+            return;             // (parser method to only add non-null to array)
           setProp( tab, '_joinParent', table );
           tab.$joinArgsIndex = index;
           initTableExpression( tab, query, joinParents );
@@ -730,12 +782,13 @@ function getDefinerFunctions( model ) {
       setMemberParent( table, table.name.id, query );
       setProp( table, '_block', query._block );
       dictAdd( query.$tableAliases, table.name.id, table, ( name, loc ) => {
-        error( 'duplicate-definition', [ loc, table ], { name, '#': '$tableAlias' } );
+        error( 'duplicate-definition', [ loc, table ], { name, '#': 'alias' } );
       } );
       // also add to JOIN nodes for name restrictions:
       for (const p of joinParents) {
-        // console.log('ADD:', query.name.id, parents.length, p)
-        dictAdd( p.$tableAliases, table.name.id, table );
+        // for JOIN alias restriction, we cannot use $duplicates, as it is
+        // already used for duplicate aliases of queries:
+        dictAddArray( p.$tableAliases, table.name.id, table );
       }
       if (table.name.id[0] === '$') {
         warning( 'syntax-dollar-ident', [ table.name.location, table ], {
@@ -822,7 +875,7 @@ function getDefinerFunctions( model ) {
           // assignments on the mixin... (also for future mixin definitions
           // with generated values)
           dictAdd( query.$tableAliases, name, query.mixin[name], ( dupName, loc ) => {
-            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': '$tableAlias' } );
+            error( 'duplicate-definition', [ loc, query ], { name: dupName, '#': 'alias' } );
           } );
           if (mixin.name.id[0] === '$') {
             warning( 'syntax-dollar-ident', [ mixin.name.location, mixin ],
@@ -859,6 +912,7 @@ function getDefinerFunctions( model ) {
    * (which is basically the component name of the `parent` element plus a dot).
    */
   function initMembers( construct, parent, block, initExtensions = false ) {
+    // TODO: split extend from init
     const isQueryExtension = kindProperties[construct.kind].isExtension &&
           (parent._main || parent).query;
     let obj = construct;
@@ -914,7 +968,7 @@ function getDefinerFunctions( model ) {
       forEachInOrder( construct, 'params', init );
     const { returns } = construct;
     if (returns) {
-      returns.kind = 'param';
+      returns.kind = (kindProperties[construct.kind].isExtension) ? construct.kind : 'param';
       init( returns, '' );      // '' is special name for returns parameter
     }
     return;
@@ -948,6 +1002,7 @@ function getDefinerFunctions( model ) {
       setProp( elem, '_block', bl );
       setMemberParent( elem, name, parent, construct !== parent && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
+      checkRedefinition( elem );
       defineAnnotations( elem, elem, bl );
       initMembers( elem, elem, bl, initExtensions );
 
@@ -983,6 +1038,7 @@ function getDefinerFunctions( model ) {
   }
 
   function checkDefinitions( construct, parent, prop, dict = construct[prop] ) {
+    // TODO: do differently, see also annotateMembers() in resolver
     // To have been checked by parsers:
     // - artifacts (CDL-only anyway) only inside [extend] context|service
     if (!dict)
@@ -1421,6 +1477,12 @@ function getDefinerFunctions( model ) {
 
         model.extensions.push(annotationArtifact);
         extendArtifact( exts, annotationArtifact ); // also sets _artifact link in extensions
+        // if one of the annotate statement mentions 'returns', assume it
+        // TODO: with warning/info?
+        for (const ext of exts) {
+          if (ext.$syntax === 'returns')
+            annotationArtifact.$syntax = 'returns';
+        }
       }
     }
   }
@@ -1704,6 +1766,7 @@ function getDefinerFunctions( model ) {
   }
 
   function extendMembers( extensions, art, noExtend ) {
+    // TODO: do the whole extension stuff lazily if the elements are requested
     const elemExtensions = [];
     extensions.sort( compareLayer );
     for (const ext of extensions) {
@@ -1749,7 +1812,12 @@ function getDefinerFunctions( model ) {
     [ 'elements', 'actions' ].forEach( (prop) => {
       const dict = art._extend && art._extend[prop];
       for (const name in dict) {
-        const validDict = art[prop] || prop === 'elements' && art.enum;
+        let obj = art;
+        if (obj.targetAspect)
+          obj = obj.targetAspect;
+        while (obj.items)
+          obj = obj.items;
+        const validDict = obj[prop] || prop === 'elements' && obj.enum;
         const member = validDict[name];
         if (!member)
           extendNothing( dict[name], prop, name, art, validDict );
@@ -1900,24 +1968,6 @@ function getDefinerFunctions( model ) {
     }
   }
 
-  // TODO: move to "init" phase
-  /**
-   * Check whether redefinitions of the given artifact name exist and
-   * adapt to `targetAspect`.
-   *
-   * @param {string} name
-   */
-  function preProcessArtifact( name ) {
-    const art = model.definitions[name];
-    if (Array.isArray(art.$duplicates)) {
-      // A definition name containing a `.` is not invalid (TODO: starting or
-      // ending with a dot is invalid and could be checked here)
-      for (const a of art.$duplicates)
-        checkRedefinitions( a, name, 'definitions' );
-    }
-    checkRedefinitions( art, name, 'definitions' );
-  }
-
   /**
    * Process "composition of" artifacts.
    *
@@ -1988,8 +2038,8 @@ function getDefinerFunctions( model ) {
 
       if (isKey && isLocalized) { // key with localized is wrong - ignore localized
         const errpos = elem.localized || elem.type || elem.name;
-        warning( 'localized-key', [ errpos.location, elem ], {},
-                 'Keyword "localized" is ignored for primary keys' );
+        warning( 'localized-key', [ errpos.location, elem ], { keyword: 'localized' },
+                 'Keyword $(KEYWORD) is ignored for primary keys' );
       }
     }
     if (textElems.length <= keys)
@@ -2131,9 +2181,9 @@ function getDefinerFunctions( model ) {
           });
         }
       }
-      else {                    // use location of LOCALIZED keyword
+      if (hasTruthyProp( orig, 'localized' )) { // use location of LOCALIZED keyword
         const localized = orig.localized || orig.type || orig.name;
-        elem.localized = { val: false, $inferred: 'localized', location: localized.location };
+        elem.localized = { val: null, $inferred: 'localized', location: localized.location };
       }
     }
     if (fioriEnabled)
@@ -2268,26 +2318,6 @@ function pathName(path) {
   return path.map( id => id.id ).join('.');
 }
 
-/**
- * Generates an XSN path out of the given name. Path segments are delimited by a dot.
- * Each segment will have the given location assigned.
- *
- * @param {CSN.Location} location
- * @param {string} name
- * @returns {XSN.Path}
- */
-function splitIntoPath( location, name ) {
-  return name.split('.').map( id => ({ id, location }) );
-}
-
-/**
- * @param {CSN.Location} location
- * @param  {...any} args
- */
-function augmentPath( location, ...args ) {
-  return { path: args.map( id => ({ id, location }) ), location };
-}
-
 function augmentEqual( location, assocname, relations, prefix = '' ) {
   const args = relations.map( eq );
   return (args.length === 1)
@@ -2316,9 +2346,4 @@ function augmentEqual( location, assocname, relations, prefix = '' ) {
 // these function could be used to a future lib/compiler/utils.js, but DO NOT
 // SHARE with utility functions for CSN processors
 
-module.exports = {
-  define: model => getDefinerFunctions( model ).define(),
-  getDefinerFunctions,
-  augmentPath,
-  splitIntoPath,
-};
+module.exports = { define };

package/lib/compiler/index.js

@@ -1,5 +1,17 @@
 // Main XSN-based compiler functions
 
+// ...
+
+// How functions are shared across the Core Compiler sub modules:
+
+// - Shared XSN-related functions which do not use a context are in utils.js,
+//   they are `require`d as usual at the beginning of sub modules.
+// - The XSN is the only context which context-dependent functions can depend on.
+// - Sharing such a function is by adding it to `‹xsn›.$functions`,
+//   e.g. `resolvePath` and similar will be attached to the XSN.
+// - Functions which might be overwritten in a next sub module
+//   are added to `‹xsn›.$volatileFunctions`, currently just `environment`.
+
 'use strict';
 
 const { resolveModule, resolveModuleSync } = require('../utils/moduleResolve');
@@ -8,6 +20,7 @@ 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 propagator = require('./propagator');
@@ -110,7 +123,6 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
   //   fileCache = Object.assign( Object.create(null), fileCache );
   dir = path.resolve(dir);
   const a = processFilenames( filenames, dir );
-  a.fileContentDict = Object.create(null);
 
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
@@ -149,7 +161,6 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
         }
         else {
           try {
-            a.fileContentDict[filename] = source;
             const ast = parseX( source, rel, options, model.$messageFunctions );
             a.sources[filename] = ast;
             ast.location = { file: rel };
@@ -220,7 +231,6 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
   // absolute file names - they start with `/` or `\` or similar
   dir = path.resolve(dir);
   const a = processFilenames( filenames, dir );
-  a.fileContentDict = Object.create(null);
 
   const model = { sources: a.sources, options };
   model.$messageFunctions = createMessageFunctions( options, 'compile', model );
@@ -281,7 +291,6 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
       }
       else {
         try {
-          a.fileContentDict[filename] = source;
           const ast = parseX( source, rel, options, model.$messageFunctions );
           a.sources[filename] = ast;
           ast.location = { file: rel };
@@ -416,6 +425,9 @@ function compileDoX( model ) {
     throwWithError();
     return model;
   }
+  model.$functions = {};
+  model.$volatileFunctions = {};
+  fns( model );                 // attach (mostly) paths functions
   define( 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…

package/lib/compiler/propagator.js

@@ -8,7 +8,7 @@ const {
   setProp,
   isDeprecatedEnabled,
 } = require( '../base/model');
-const { linkToOrigin, withAssociation } = require('./shared');
+const { linkToOrigin, withAssociation } = require('./utils');
 // const { refString } = require( '../base/messages')
 
 function propagate( model ) {
@@ -179,6 +179,8 @@ function propagate( model ) {
   // accessed at their type being a main artifact
   function expensive( prop, target, source ) {
     // console.log(prop,source.name,'->',target.kind,target.name);
+    if (source.kind === 'builtin')
+      return;
     if (prop !== 'foreignKeys' && availableAtType( prop, target, source ))
       // foreignKeys must always be copied with target to avoid any confusion
       // whether we have to generated implicit keys
@@ -211,7 +213,8 @@ function propagate( model ) {
   }
 
   function onlyViaParent( prop, target, source ) {
-    if (target.$inferred === 'proxy') // assocs and enums do not have 'include'
+    if (target.$inferred === 'proxy' || target.$inferred === 'expand-element')
+      // assocs and enums do not have 'include'
       always( prop, target, source );
   }