@sap/cds-compiler 5.1.2 → 5.2.0

package/CHANGELOG.md

@@ -7,12 +7,31 @@
 Note: `beta` fixes, changes and features are usually not listed in this ChangeLog but [here](doc/CHANGELOG_BETA.md).
 The compiler behavior concerning `beta` features can change at any time without notice.
 
+## Version 5.2.0 - 2024-08-27
+
+### Added
+
+- to.edm(x): Add `@Core.Links { rel: 'author', href: 'https://cap.cloud.sap' };` as watermark to lead schema.
+- to.sql.migration: Introduce option `script` to aid in generation of manual migration scripts by not aborting when encountering lossy changes.
+
+### Changed
+
+- for.odata: No longer reject default values on action/function parameters.
+- to.edm(x): Raise warning for default values on action/function parameters that they are ignored.
+
+### Fixed
+
+- compiler: Fix extensions with bound actions using an explicit binding parameter in `parseCdl` CSN.
+- for.odata, to.edm(x): Fix some issues with resolving annotation expressions in nested objects and
+  reliably replace value of `=` attribute with `true` after processing.
+
 ## Version 5.1.2 - 2024-08-05
 
 ### Fixed
 
 - compiler: In parseCdl mode, bound actions specifying the binding parameter with `$self` did not work.
 
+
 ## Version 5.1.0 - 2024-07-25
 
 ### Added
@@ -105,6 +124,13 @@ This is a preview version for the major release and contains breaking changes. I
   Use `to.edm(x)` instead.
 
 
+## Version 4.9.8 - 2024-07-29
+
+### Fixed
+
+- compiler: Fix extensions with bound actions using an explicit binding parameter in `parseCdl` CSN.
+- to.edm(x): No `Nullable` attribute for `$ReturnType` of `Collection(<entity type>)` [OData V4 CSDL, section 12.8 Return Type](https://docs.oasis-open.org/odata/odata-csdl-xml/v4.01/odata-csdl-xml-v4.01.html#sec_ReturnType)
+
 ## Version 4.9.6 - 2024-07-15
 
 ### Fixed

package/bin/cdsc.js

@@ -306,7 +306,7 @@ async function executeCommandLine( command, options, args ) {
     manageConstraints,
     toSql,
     inspect,
-    toEffectiveCsn,
+    forEffective,
     forSeal,
   };
   const commandsWithoutCompilation = {
@@ -352,7 +352,7 @@ async function executeCommandLine( command, options, args ) {
     return model;
   }
 
-  function toEffectiveCsn( model ) {
+  function forEffective( model ) {
     const features = [ 'resolveSimpleTypes', 'resolveProjections', 'remapOdataAnnotations', 'keepLocalized' ];
     for (const feature of features) {
       if (options[feature]) // map to boolean equivalent

package/bin/cdshi.js

@@ -34,40 +34,47 @@ const categoryChars = {         // default: first char of category name
   // ExtElement: 'E',       // using the first letter is the default
   ExtBoundAction: 'B',      // highlight like bound action definition
   ExtParam: 'P',            // highlight like entity/action parameter definition
+  FromImplicit: 'W',
   Event: 'Y',
   KeyImplicit: 'r',         // handle as normal ref
   // Remark: do not use `x`/`X` (hex literal `x'1e3d'`)
 };
 
+const options = { newParser: true, attachTokens: true, messages: [] };
+
 function highlight( err, buf ) {
   if (err) {
     console.error( 'ERROR:', err.toString() );
     return;
   }
-  const ts = compiler.parseX( buf, 'hi.cds', { attachTokens: true, messages: [] } ).tokenStream;
-  if (!buf.length || !ts.tokens || !ts.tokens.length)
+  const parser = compiler.parseX( buf, 'hi.cds', options ).tokenStream;
+  // ts is parser with new parser
+  const { tokens, lexer } = parser;
+  if (!buf.length || !tokens || !tokens.length)
     return;
   const chars = [ ...buf ];
-  for (const tok of ts.tokens) {
-    if (tok.start < 0)
+  for (const tok of tokens) {
+    const { location } = tok;
+    const start = lexer.characterPos( location.line, location.col );
+    if (start < 0)
       continue;
-    if (tok.$isSkipped) {
-      if (tok.stop > tok.start) {
-        chars[tok.start] = (tok.$isSkipped === true ? '\x0f' : '\x16'); // ^O / ^V
-        chars[tok.stop] = '\x17';                                       // ^W
+    const stop = lexer.characterPos( location.endLine, location.endCol ) - 1;
+    const cat = tok.parsed;
+    // console.log(tok.location.toString(),tok.text,tok.parsed,stop > start)
+    if (!cat) {
+      if (stop > start) {
+        chars[start] = (cat !== 0 ? '\x0f' : '\x16'); // ^O / ^V (ERROR)
+        chars[stop] = '\x17';                         // ^W
       }
       else {
-        chars[tok.start] = (tok.$isSkipped === true ? '\x0e' : '\x15'); // ^N / ^U
+        chars[start] = (cat !== 0 ? '\x0e' : '\x15'); // ^N / ^U (ERROR)
       }
     }
-    else {
-      const cat = tok.isIdentifier;
-      if (cat) {
-        if (cat !== 'ref' || chars[tok.start] !== '$')
-          chars[tok.start] = categoryChars[cat] || cat.charAt(0);
-        if (tok.stop > tok.start) // stop in ANTLR at last char, not behind
-          chars[tok.start + 1] = '_';
-      }
+    else if (cat !== 'keyword' && cat !== 'token') {
+      if (cat !== 'ref' || chars[start] !== '$')
+        chars[start] = categoryChars[cat] || cat.charAt(0);
+      if (stop > start) // stop in ANTLR at last char, not behind
+        chars[start + 1] = '_';
     }
   }
   for (const c of chars)

package/bin/cdsse.js

@@ -7,8 +7,8 @@
 // corrupted, incomplete or erroneous CDL sources.
 //
 // The output could be used directly by some editors, e.g. Emacs.  The
-// capabilities supported at the moments is: complete - work in progress.
-// Planned are: gotoDefinition, highlight (for syntax highlighting).
+// capabilities supported at the moments is: complete, find, lint.
+// Syntax highlighting is supported by ./cdshi.js.
 
 /* eslint no-console:off */
 // @ts-nocheck
@@ -52,6 +52,7 @@ function usage( err ) {
 }
 
 function complete( err, buf ) {
+  const messages = [];
   if (err)
     return usage( err );
   const off = offset( buf );
@@ -74,16 +75,13 @@ function complete( err, buf ) {
     const src = `${buf.substring( 0, off.prefix )}__NO_SUCH_ID__${buf.substring( off.cursor )}`;
     const fname = path.resolve( '', file );
     compiler.compileX( [ file ], '', {
-      attachValidNames: true, lintMode: true, beta, messages: [],
-    }, { [fname]: src } )
+      newParser: true, attachValidNames: true, lintMode: true, beta, messages }, { [fname]: src } )
       .then( ident, ident );
   }
   return true;
 
-  function ident( xsnOrErr ) {
-    if (!(xsnOrErr.messages || xsnOrErr.options && xsnOrErr.options.messages))
-      return usage( xsnOrErr );
-    const vn = messageAt( xsnOrErr, 'validNames', off.col ) || Object.create(null);
+  function ident() {
+    const vn = messageAt( messages, 'validNames', off.col ) || Object.create(null);
     // TODO: if there is no such message, use console.log( 'arbitrary identifier' )
     // if we want to avoid that the editor switches to fuzzy completion match
     // against the prefix (not yet done anyway)
@@ -107,18 +105,17 @@ function find( err, buf ) {
     return usage();
   if (off.prefix === off.cursor) // not at name
     return true;
+  const messages = [];
   const src = `${buf.substring( 0, off.prefix )}__NO_SUCH_ID__${buf.substring( off.cursor )}`;
   const fname = path.resolve( '', file );
   compiler.compileX( [ file ], '', {
-    attachValidNames: true, lintMode: true, beta, messages: [],
+    newParser: true, attachValidNames: true, lintMode: true, beta, messages,
   }, { [fname]: src } )
     .then( show, show );
   return true;
 
-  function show( xsnOrErr ) {
-    if (!(xsnOrErr.messages || xsnOrErr.options && xsnOrErr.options.messages))
-      return usage( xsnOrErr );
-    const vn = messageAt( xsnOrErr, 'validNames', off.col ) || Object.create(null);
+  function show() {
+    const vn = messageAt( messages, 'validNames', off.col ) || Object.create(null);
     const art = vn[buf.substring( off.prefix, off.cursor )];
     if (art)
       console.log( `${locationString( art.name.location || art.location )}: Definition` );
@@ -129,13 +126,13 @@ function find( err, buf ) {
 function lint( err, buf ) {
   if (err)
     return usage( err );
+  const messages = [];
   const fname = path.resolve( '', file );
-  compiler.compileX( [ file ], '', { lintMode: true, beta, messages: [] }, { [fname]: buf } )
+  compiler.compileX( [ file ], '', { newParser: true, lintMode: true, beta, messages }, { [fname]: buf } )
     .then( display, display );
   return true;
 
   function display( xsnOrErr ) {
-    const messages = xsnOrErr.messages || xsnOrErr.options && xsnOrErr.options.messages;
     if (!messages)
       return usage( xsnOrErr );
     for (const msg of messages)
@@ -145,8 +142,10 @@ function lint( err, buf ) {
 }
 
 function tokensAt( buf, _offset, col, symbol ) {
+  const messages = [];
   const src = `${buf.substring( 0, _offset )}≠${buf.substring( _offset )}`;
-  const et = messageAt( compiler.parseX( src, frel, { messages: [] } ), 'expectedTokens', col ) || [];
+  compiler.parseX( src, frel, { newParser: true, messages } );
+  const et = messageAt( messages, 'expectedTokens', col ) || [];
   for (const n of et) {
     if (typeof symbol === 'string') {
       if (n.length > 3 && n.charAt(0) === "'" && n.charAt(1) === symbol)
@@ -166,8 +165,8 @@ function tokensAt( buf, _offset, col, symbol ) {
   return et.includes( 'Identifier' );
 }
 
-function messageAt( model, prop, col ) {
-  const msg = (model.messages || model.options && model.options.messages).find(
+function messageAt( messages, prop, col ) {
+  const msg = messages.find(
     m => m[prop] && m.$location.line === line && m.$location.col === col && m.$location.file === frel
   );
   return msg && msg[prop];

package/lib/api/main.js

@@ -468,8 +468,19 @@ function remapName( key, csn, filter = () => true ) {
  */
 function sqlMigration( csn, options, messageFunctions, beforeImage ) {
   const internalOptions = prepareOptions.to.sql(options);
+
   messageFunctions.setOptions( internalOptions );
   handleTenantDiscriminator(options, internalOptions, messageFunctions);
+  if (!options.dry && internalOptions.script) {
+    messageFunctions.error('api-invalid-combination', null, { '#': 'dry-and-script', value: options.dry || 'undefined' });
+    messageFunctions.throwWithError();
+  }
+
+  if (internalOptions.script && !internalOptions.severities?.['type-unsupported-key-change']) {
+    internalOptions.severities ??= {};
+    internalOptions.severities['type-unsupported-key-change'] = 'warning';
+  }
+
   const { error, throwWithError } = messageFunctions;
 
   // Prepare after-image.
@@ -479,7 +490,7 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
   // Compare both images.
   const diff = modelCompare.compareModels(beforeImage || afterImage, afterImage, internalOptions);
   messageFunctions.setModel(diff);
-  const diffFilterObj = diffFilter[internalOptions.sqlDialect];
+  const diffFilterObj = diffFilter.getFilter(internalOptions);
 
   if (diffFilterObj) {
     diff.extensions = diff.extensions.filter(ex => diffFilterObj.extension(ex, messageFunctions));
@@ -487,6 +498,9 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
     Object.entries(diff.deletions).forEach(entry => diffFilterObj.deletion(entry, error));
     diff.changedPrimaryKeys = diff.changedPrimaryKeys
       .filter(an => diffFilterObj.changedPrimaryKeys(an));
+
+    if (internalOptions.script && diffFilterObj.hasLossyChanges())
+      messageFunctions.warning('def-unsupported-changes', null, null, 'Found potentially lossy changes - check generated SQL statements');
   }
 
   const identifierUtils = sqlUtils.getIdentifierUtils(csn, internalOptions);
@@ -494,7 +508,10 @@ function sqlMigration( csn, options, messageFunctions, beforeImage ) {
   const drops = {
     creates: {},
     final: Object.entries(diff.deletions).reduce((previous, [ name, artifact ]) => {
-      previous[name] = `DROP ${ (artifact.query || artifact.projection) ? 'VIEW' : 'TABLE' } ${ identifierUtils.renderArtifactName(name) };`;
+      if (artifact.query || artifact.projection)
+        previous[name] = `DROP VIEW ${ identifierUtils.renderArtifactName(name) };`;
+      else
+        previous[name] = `-- [WARNING] this statement is lossy\nDROP TABLE ${ identifierUtils.renderArtifactName(name) };`;
       return previous;
     }, {}),
   };

package/lib/api/options.js

@@ -44,6 +44,7 @@ const publicOptionsNewAPI = [
   'odataXServiceRefs',
   'odataV2PartialConstr',
   'odataVocabularies',
+  'odataNoCreator',
   'service',
   'serviceNames',
   //
@@ -53,6 +54,8 @@ const publicOptionsNewAPI = [
   'resolveProjections',
   'remapOdataAnnotations',
   'keepLocalized',
+  // to.sql.migration
+  'script',
 ];
 
 // Internal options used for testing/debugging etc.
@@ -195,7 +198,7 @@ module.exports = {
       return translateOptions(options, defaultOptions, hardOptions, undefined, [ 'valid-structured' ], 'to.odata');
     },
   },
-  for: {   // TODO: Rename version to oDataVersion
+  for: {
     odata: (options) => {
       const hardOptions = { toOdata: true };
       const defaultOptions = { odataVersion: 'v4', odataFormat: 'flat' };

package/lib/base/builtins.js

@@ -17,6 +17,7 @@ const propagationRules = {
   '@cds.autoexpose': 'onlyViaArtifact',
   '@cds.autoexposed': 'never',
   '@cds.external': 'never',
+  '@cds.java.this.name': 'onlyViaParent',
   '@cds.persistence.calcview': 'never',
   '@cds.persistence.exists': 'never',
   '@cds.persistence.skip': 'notWithPersistenceTable',

package/lib/base/message-registry.js

@@ -157,6 +157,8 @@ const centralMessages = {
   'syntax-duplicate-equal-clause': { severity: 'Warning' },
   'syntax-invalid-name': { severity: 'Error', configurableFor: 'deprecated' },
   'syntax-missing-as': { severity: 'Error', configurableFor: true },
+  'syntax-missing-proj-semicolon': { severity: 'Warning', errorFor: [ 'v6' ] },
+  'syntax-unexpected-many-one': { severity: 'Error', configurableFor: true }, // TODO: remove `configurableFor` soon, latest v6
   'syntax-unexpected-null': { severity: 'Error', configurableFor: true },
   'syntax-unexpected-reserved-word': { severity: 'Error', configurableFor: true },
   'syntax-unknown-escape': { severity: 'Error', configurableFor: true },
@@ -260,7 +262,8 @@ const centralMessageTexts = {
     std: 'Invalid option combination found: $(OPTION) and $(PROP)', // unused
     'valid-structured': 'Structured OData is only supported with OData version v4',
     'sql-dialect-and-naming': 'sqlDialect $(NAME) can\'t be combined with sqlMapping $(PROP)',
-    'tenant-and-naming': 'Option $(OPTION) can\'t be combined with sqlMapping $(PROP) - expected sqlMapping $(VALUE)'
+    'tenant-and-naming': 'Option $(OPTION) can\'t be combined with sqlMapping $(PROP) - expected sqlMapping $(VALUE)',
+    'dry-and-script': 'script:true must be combined with dry:true, found $(VALUE)',
   },
   'api-unexpected-combination': {
     std: 'Unexpected option combination: $(OPTION) and $(PROP)', // unused
@@ -356,6 +359,7 @@ const centralMessageTexts = {
     std: 'Annotations can\'t be used in a column with $(CODE)',
     doc: 'Doc comments can\'t be used in a column with $(CODE)',
   },
+  'syntax-unexpected-many-one': 'Replace $(CODE) with $(DELIMITED) to avoid an ambiguity with managed compositions of anonymous aspects',
   '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
@@ -694,8 +698,12 @@ const centralMessageTexts = {
     'annotation': 'Variable $(NAME) can only be used in annotation values',
   },
 
-  // TODO: Better text ?
-  'rewrite-not-supported': 'The ON-condition is not rewritten here - provide an explicit ON-condition',
+  'rewrite-not-supported': {
+    // TODO: Better text ?
+    std: 'The ON-condition is not rewritten here - provide an explicit ON-condition',
+    'inline-expand': 'The ON-condition is not rewritten in nested projections - provide an explicit ON-condition',
+    'secondary': 'The ON-condition is not rewritten due to multiple associations in this path - provide an explicit ON-condition',
+  },
   'type-unsupported-rewrite': {
     std:  'Rewriting the ON-condition not supported here', // unused: merge with 'rewrite-not-supported'
     'sub-element': 'Rewriting the ON-condition of unmanaged association in sub element is not supported'
@@ -1109,6 +1117,11 @@ const centralMessageTexts = {
   'odata-parameter-order': 'Unexpected mandatory after optional parameter',
   'odata-key-recursive': 'Unexpected recursive key $(NAME)',
   'odata-key-uuid-default-anno': 'Expected element of type $(TYPE) to be annotated with $(ANNO) when used as primary key in $(ID)',
+  'odata-ignoring-param-default': {
+    'std': 'Ignoring default value on parameter',
+    'xpr': 'Ignoring unexpected expression as default value',
+    'colitem': 'Ignoring unexpected default value for a structured or collection like parameter',
+  },
   // -----------------------------------------------------------------------------------
   // All odata-anno MUST have a '$(ANNO)' parameter to indicate error location
   // -----------------------------------------------------------------------------------

package/lib/base/model.js

@@ -7,15 +7,6 @@
 
 const { forEach } = require('../utils/objectUtils');
 
-const queryOps = {
-  query: 'select',                // TODO: rename to SELECT
-  union: 'union',
-  intersect: 'union',
-  except: 'union',
-  minus: 'union',
-  subquery: 'union',            // for (subquery) with ORDER BY or LIMIT/OFFSET
-};
-
 /**
  * Object of all available beta flags that will be enabled/disabled by `--beta-mode`
  * through cdsc.  Only intended for INTERNAL USE.
@@ -224,7 +215,6 @@ module.exports = {
   availableBetaFlags,
   isDeprecatedEnabled,
   checkRemovedDeprecatedFlags,
-  queryOps,
   forEachDefinition,
   forEachMember,
   forEachMemberRecursively,

package/lib/checks/actionsFunctions.js

@@ -1,7 +1,6 @@
 'use strict';
 
 const { isBuiltinType } = require('../base/builtins');
-const { isBetaEnabled } = require('../base/model');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -21,8 +20,6 @@ function checkActionOrFunction( art, artName, prop, path ) {
   //   (this.options.odataProxies || this.options.odataXServiceRefs);
 
   const serviceName = this.csnUtils.getServiceName(artName);
-  if (!serviceName && art.kind !== 'aspect')
-    this.warning(null, path, {}, 'Functions and actions must be declared in a service');
 
   if (art.kind === 'entity') {
     for (const [ actName, act ] of Object.entries(art.actions)) {
@@ -71,15 +68,6 @@ function checkActionOrFunction( art, artName, prop, path ) {
     if (!paramType)
       return; // no type could be resolved
 
-    // "default" is always propagated to params
-    if (param.default && !isBetaEnabled(this.options, 'optionalActionFunctionParameters')) {
-      this.message('param-default', currPath, { '#': actKind }, {
-        std: 'Artifact parameters can\'t have a default value', // Not used
-        action: 'Action parameters can\'t have a default value',
-        function: 'Function parameters can\'t have a default value',
-      });
-    }
-
     if (param.type && this.csnUtils.isAssocOrComposition(param)) {
       this.error(null, currPath, { '#': actKind }, {
         std: 'An association is not allowed as this artifact\'s parameter type', // Not used

package/lib/checks/structuredAnnoExpressions.js

@@ -1,27 +1,23 @@
 'use strict';
 
 const { isBuiltinType } = require('../base/builtins');
-const { transformExpression, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
+const { transformAnnotationExpression } = require('../model/csnUtils');
 /**
  *
  * @param {object} member
  */
 function checkAnnotationExpression( member, _memberName, _prop, path ) {
   Object.keys(member).filter(pn => pn[0] === '@').forEach((anno) => {
-    applyTransformationsOnNonDictionary(member, anno, {
-      xpr: (parent, prop, _xpr, xprPath) => {
-        transformExpression(parent, prop, {
-          ref: (elemref, __prop, ref, refPath) => {
-            const { art, scope } = this.csnUtils.inspectRef(refPath);
-            if (scope !== '$magic' && art) {
-              const ft = this.csnUtils.getFinalTypeInfo(art.type);
-              if (!isBuiltinType(ft?.type))
-                this.error('odata-anno-xpr-ref', refPath, { anno, elemref, '#': 'flatten_builtin_type' });
-            }
-          },
-        }, xprPath);
+    transformAnnotationExpression(member, anno, {
+      ref: (elemref, __prop, _ref, refPath) => {
+        const { art, scope } = this.csnUtils.inspectRef(refPath);
+        if (scope !== '$magic' && art) {
+          const ft = this.csnUtils.getFinalTypeInfo(art.type);
+          if (!isBuiltinType(ft?.type))
+            this.error('odata-anno-xpr-ref', refPath, { anno, elemref, '#': 'flatten_builtin_type' });
+        }
       },
-    }, {}, path);
+    }, path);
   });
 }
 

package/lib/compiler/assert-consistency.js

@@ -289,7 +289,8 @@ function assertConsistency( model, stage ) {
           '$calcDepElement',
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit', '$limit',
           '_origin', '_block', '$contains',
-          '_projections', '_parent', '_main', '_effectiveType', '$effectiveSeqNo', '$expand',
+          '_projections', '_complexProjections',
+          '_parent', '_main', '_effectiveType', '$effectiveSeqNo', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
         ],
       },
@@ -313,7 +314,7 @@ function assertConsistency( model, stage ) {
           'kind', 'name', '$syntax', '_block', '_parent', '_main',
           'elements', '_origin', '_joinParent', '$joinArgsIndex', '$syntax',
           '$parens', '_status', // TODO: only in from
-          'scope', '_artifact', '$inferred', 'kind',
+          'scope', '_artifact', '_originalArtifact', '$inferred', 'kind',
           '_effectiveType', '$effectiveSeqNo',         // TODO:check this
           '$duplicates', // In JOIN if both sides are the same.
         ],
@@ -370,7 +371,8 @@ function assertConsistency( model, stage ) {
       requires: [ 'location' ],
       optional: [
         'path', 'elements', '_outer', '_parent', '_main', '_block', 'kind',
-        'scope', '_artifact', '$inferred', '$expand', '$inCycle', '$tableAliases', '_$next',
+        'scope', '_artifact', '$inferred', '$expand', '$inCycle',
+        '$tableAliases', '_$next',
         '_origin', '_effectiveType', '$effectiveSeqNo', '_extensions', '$contains',
       ],
     },
@@ -390,7 +392,8 @@ function assertConsistency( model, stage ) {
         'args', '$syntax',
         'where', 'groupBy', 'limit', 'orderBy', 'having',
         'cardinality',
-        '_artifact', '_navigation', '_user',
+        '_artifact', '_originalArtifact',
+        '_navigation', '_user',
         '$inferred',
       ],
     },
@@ -443,7 +446,10 @@ function assertConsistency( model, stage ) {
       test: expression,         // properties below are "sub specifications"
       ref: {
         requires: [ 'location', 'path' ],
-        optional: [ 'scope', 'variant', '_artifact', '$inferred', '$parens', 'sort', 'nulls' ],
+        optional: [
+          'scope', 'variant', '_artifact', '_originalArtifact',
+          '$inferred', '$parens', 'sort', 'nulls',
+        ],
       },
       none: { optional: () => true }, // parse error
       // TODO: why optional / enough in name?
@@ -488,7 +494,7 @@ function assertConsistency( model, stage ) {
         'literal', 'val', 'sym', 'struct', 'variant', 'path', 'name', '$duplicates', 'upTo',
         // expressions as annotation values
         '$tokenTexts', 'op', 'args', 'func', '_artifact', 'type', '$typeArgs',
-        'scale', 'srid', 'length', 'precision', 'scope',
+        'scale', 'srid', 'length', 'precision', 'scope', '$parens',
       ],
       // TODO: restrict path to #simplePath
     },
@@ -524,7 +530,7 @@ function assertConsistency( model, stage ) {
         '_effectiveType', '$effectiveSeqNo', '_origin', '_deps',
         // CSN parser may let these properties slip through to XSN, even if input is invalid.
         'args', 'op', 'func', 'suffix',
-        '$invalidPaths',
+        '$invalidPaths', '$parens',
       ],
       // TODO: name requires if not in parser?
     },
@@ -538,7 +544,7 @@ function assertConsistency( model, stage ) {
       schema: {
         id: { test: isStringOrNumber },
         select: { test: TODO }, // TODO: remove
-      }, // TODO: rename query prop in name
+      },
       requires: [ 'location' ],
       optional: [
         'path', 'id', '$delimited', 'variant', // TODO: req path, opt id for main, req id for member
@@ -607,6 +613,7 @@ function assertConsistency( model, stage ) {
     // - on a path item with a filter condition to the user of the ref (not nested)
     // - on a JOIN node to the query (TODO: _outer?)
     _artifact: { test: TODO },
+    _originalArtifact: { test: TODO },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
     $effectiveSeqNo: { kind: true, test: isNumber },
@@ -641,7 +648,7 @@ function assertConsistency( model, stage ) {
     $replacement: { kind: true, test: TODO }, // for smart * in queries
     _origin: { kind: true, test: TODO },
     _calcOrigin: { kind: true, test: TODO },
-    _pathHead: { kind: [ 'element', undefined ], test: TODO }, // column or * (wildcard)
+    _columnParent: { kind: [ 'element', undefined ], test: TODO }, // column or * (wildcard)
     _from: { kind: true, test: TODO }, // TODO: not necessary anymore ?
     // array of $tableAlias (or includes) for explicit and implicit redirection:
     _redirected: { kind: true, test: TODO },
@@ -658,7 +665,8 @@ function assertConsistency( model, stage ) {
     _scc: { kind: true, test: TODO },       // for cyclic calculation
     _sccCaller: { kind: true, test: TODO }, // for cyclic calculation
     _status: { kind: true, test: TODO },    // TODO: $status
-    _projections: { kind: true, test: TODO }, // for mixin definitions
+    _projections: { kind: true, test: TODO },
+    _complexProjections: { kind: true, test: TODO }, // for projected paths with filters
     $entity: { kind: true, test: TODO },
     _entities: { test: TODO },
     $compositionTargets: { test: isDictionary( isBoolean ) },
@@ -972,7 +980,7 @@ function assertConsistency( model, stage ) {
     return function valWithLocation( node, parent, prop, spec, name ) {
       const valSchema = { val: Object.assign( {}, spec, { test: func } ) };
       const requires = [ 'val', 'location' ];
-      const optional = [ 'literal', '$inferred', '$priority', '_pathHead' ];
+      const optional = [ 'literal', '$inferred', '$priority', '_columnParent' ];
       standard( node, parent, prop, {
         schema: valSchema, requires, optional, instanceOf: spec.instanceOf,
       }, name );

package/lib/compiler/builtins.js

@@ -77,6 +77,7 @@ typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
 
 
 const specialFunctions = compileFunctions( {
+  // TODO: use lower-case
   '': [                         // the default
     {
       intro: [ 'ALL', 'DISTINCT' ],
@@ -231,7 +232,6 @@ const numberRegEx = /^[ \t]*[-+]?(\d+(\.\d*)?|\.\d+)(e[-+]?\d+)?[ \t]*$/i;
  *  - `unexpected_msg`: error message which is issued if `unexpected_char` matches
  *  - `unexpected_char`: regular expression matching an illegal character in `value`,
  *    the error location is only correct for a literal <prefix>'<value>'
- *  - `literal`: the value which is used instead of `prefix` in the AST
  * TODO: we might do a range check (consider leap seconds, i.e. max value 60),
  *       but always allow Feb 29 (no leap year computation)
  * Notes:

package/lib/compiler/define.js

@@ -903,9 +903,9 @@ function define( model ) {
       hasItems = true;
       if (!columns) {           // expand or inline
         if (parent.value)
-          setLink( col, '_pathHead', parent ); // also set for '*' in expand/inline
-        else if (parent._pathHead)
-          setLink( col, '_pathHead', parent._pathHead );
+          setLink( col, '_columnParent', parent ); // also set for '*' in expand/inline
+        else if (parent._columnParent)
+          setLink( col, '_columnParent', parent._columnParent );
       }
       if (col.val === '*') {
         if (!wildcard) {

package/lib/compiler/extend.js

@@ -441,8 +441,8 @@ function extend( model ) {
   function applySingleExtension( art, ext, prop ) {
     if (prop === 'includes') {
       if (ext.kind === 'extend' && art.$inferred) {
-        error( 'extend-for-generated', [ ext.name.location, ext ], { art },
-               'You can\'t use EXTEND on the generated $(ART)' );
+        error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
+               'You can\'t use $(KEYWORD) on the generated $(ART)' );
       }
       else if (art.kind !== 'annotate' && !art._outer) { // not with elem extension in targetAspect
         const { id } = art.name;
@@ -797,7 +797,7 @@ function extend( model ) {
     const dict = parent[prop];
     if (!dict) {
       // TODO: check - for each name? - better locations
-      const location = ext._parent[prop]?.[$location] || ext.name.location;
+      const location = ext._parent?.[prop]?.[$location] || ext.name.location;
       // Remark: no `elements` dict location with `annotate Main:elem`
       switch (prop) {
         // TODO: change texts, somehow similar to checkDefinitions() ?
@@ -1052,8 +1052,8 @@ function extend( model ) {
       if (ext.name._artifact === undefined) { // not already applied
         setArtifactLink( ext.name, art );
         if (noExtend && ext.kind === 'extend') {
-          error( 'extend-for-generated', [ ext.name.location, ext ], { art },
-                 'You can\'t use EXTEND on the generated $(ART)' );
+          error( 'extend-for-generated', [ ext.name.location, ext ], { art, keyword: 'extend' },
+                 'You can\'t use $(KEYWORD) on the generated $(ART)' );
           continue;
         }
         if (ext.includes) {