@sap/cds-compiler 4.8.0 → 4.9.2

package/lib/base/model.js

@@ -26,9 +26,6 @@ const queryOps = {
  */
 const availableBetaFlags = {
   // enabled by --beta-mode
-  annotationExpressions: true,
-  odataPathsInAnnotationExpressions: true,
-  odataAnnotationExpressions: true,
   hanaAssocRealCardinality: true,
   mapAssocToJoinCardinality: true, // only SAP HANA HEX engine supports it
   enableUniversalCsn: true,
@@ -39,8 +36,10 @@ const availableBetaFlags = {
   tenantVariable: true,
   calcAssoc: true,
   v5preview: true,
+  temporalRawProjection: true,
   // disabled by --beta-mode
   nestedServices: false,
+  rewriteAnnotationExpressionsViaType: false,
 };
 
 // Used by isDeprecatedEnabled() to check if any flag ist set.
@@ -81,7 +80,7 @@ const oldDeprecatedFlags_v2 = [
  *
  * A feature always needs to be provided - otherwise false will be returned.
  *
- * Please do not move this function to the "option processor" code.
+ * Do not move this function to the "option processor" code.
  *
  * @param {object} options Options
  * @param {string} feature Feature to check for
@@ -101,7 +100,7 @@ function isBetaEnabled( options, feature ) {
  * Useful for newer functionality which might not work with some
  * deprecated feature turned on.
  *
- * Please do not move this function to the "option processor" code.
+ * Do not move this function to the "option processor" code.
  *
  * @param {object} options Options
  * @param {string|null} [feature] Feature to check for

package/lib/checks/actionsFunctions.js

@@ -53,8 +53,8 @@ function checkActionOrFunction( art, artName, prop, path ) {
     Object.entries(params).forEach(([ pn, p ], i) => {
       const type = p.items?.type || p.type;
       if (type === '$self' && !this.csn.definitions.$self && i > 0) {
-        this.error(null, currPath.concat(pn),
-                   'Binding parameter is expected to appear on first position only');
+        this.error('def-invalid-param', currPath.concat(pn),
+                   'Binding parameter is expected to appear in first position only');
       }
     });
   }

package/lib/checks/annotationsOData.js

@@ -37,6 +37,7 @@ function checkCoreMediaTypeAllowance( member ) {
 function checkAnalytics( member ) {
   if (member['@Analytics.Measure'] && !member['@Aggregation.default']) {
     this.info(null, member.$path, {},
+              // eslint-disable-next-line cds-compiler/message-no-quotes
               'Annotation “@Analytics.Measure” expects “@Aggregation.default” to be assigned for the same element as well');
   }
 }
@@ -63,6 +64,7 @@ function checkReadOnlyAndInsertOnly( artifact, artifactName ) {
   if (!this.csnUtils.getServiceName(artifactName))
     return;
   if (artifact.kind === 'entity' && artifact['@readonly'] && artifact['@insertonly'])
+    // eslint-disable-next-line cds-compiler/message-no-quotes
     this.warning(null, artifact.$path, {}, 'Annotations “@readonly” and “@insertonly” can\'t be assigned in combination');
 }
 
@@ -93,6 +95,7 @@ function checkTemporalAnnotationsAssignment( artifact, artifactName ) {
 
   // if @cds.valid.key is defined, check whether @cds.valid.from and @cds.valid.to are also there
   if (valid.key.length && !(valid.from.length && valid.to.length))
+    // eslint-disable-next-line cds-compiler/message-no-quotes
     this.error(null, [ 'definitions', artifactName ], 'Annotation “@cds.valid.key” was used but “@cds.valid.from” and “@cds.valid.to” are missing');
 
   /**

package/lib/checks/defaultValues.js

@@ -23,6 +23,7 @@ function validateDefaultValues( member, memberName, prop, path ) {
       // TODO: This check only counts the number of leading signs, not inbetween (e.g. 1 - - 1).
       //       The message also needs to be improved.
       if (i > 1)
+        // eslint-disable-next-line cds-compiler/message-no-quotes
         this.error(null, path, {}, 'Illegal number of unary ‘+’/‘-’ operators');
     }
   }
@@ -37,8 +38,10 @@ function validateDefaultValues( member, memberName, prop, path ) {
  * @param {CSN.Path} path Path to the member
  */
 function rejectParamDefaultsInHanaCds( member, memberName, prop, path ) {
-  if (member.default && prop === 'params' && this.options.transformation === 'hdbcds')
-    this.error(null, path, {}, 'Parameter default values are not supported in SAP HANA CDS');
+  if (member.default && prop === 'params' && this.options.transformation === 'hdbcds') {
+    this.error('def-unsupported-param', path, {},
+               'Parameter default values are not supported in SAP HANA CDS');
+  }
 }
 
 /**

package/lib/checks/queryNoDbArtifacts.js

@@ -167,12 +167,13 @@ function _checkRef( ref, _links, $path, inColumns ) {
         const cdsPersistenceSkipped = hasAnnotationValue(targetArt, '@cds.persistence.skip');
         this.error( null, $path, {
           '#': cdsPersistenceSkipped ? 'std' : 'abstract',
+          anno: '@cds.persistence.skip',
           id: nonPersistedTarget.pathStep,
           elemref: { ref },
           name: nonPersistedTarget.name,
         }, {
-          std: 'Unexpected “@cds.persistence.skip” annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
-          abstract: 'Unexpected “abstract” association target $(NAME) of $(ID) in path $(ELEMREF)',
+          std: 'Unexpected $(ANNO) annotation on association target $(NAME) of $(ID) in path $(ELEMREF)',
+          abstract: 'Unexpected abstract association target $(NAME) of $(ID) in path $(ELEMREF)',
         } );
         break; // only one error per path
       }

package/lib/checks/validator.js

@@ -3,7 +3,7 @@
 const {
   forEachDefinition, forEachMemberRecursively, forAllQueries,
   forEachMember, getNormalizedQuery, hasAnnotationValue,
-  applyTransformations, functionList,
+  applyTransformations, functionList, mergeTransformers,
 } = require('../model/csnUtils');
 const enrichCsn = require('./enricher');
 
@@ -156,7 +156,7 @@ function _validate( csn, that,
   // 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' });
 
-  applyTransformations(csn, mergeCsnValidators(csnValidators, that), [], { drillRef: true });
+  applyTransformations(csn, mergeTransformers(csnValidators, that), [], { drillRef: true });
 
   forEachDefinition(csn, (artifact, artifactName, prop, path) => {
     artifactValidators.forEach((artifactValidator) => {
@@ -180,38 +180,6 @@ function _validate( csn, that,
   return cleanup;
 }
 
-/**
- * Ensure the CSN validators adhere to the applyTransformation format - also, supply correct this value for each subfunction
- *
- * @param {object[]} csnValidators Validators
- * @param {object} that Value for this
- * @returns {object} Remapped validators.
- */
-function mergeCsnValidators( csnValidators, that ) {
-  const remapped = {};
-  for (const validator of csnValidators) {
-    for (const [ n, fns ] of Object.entries(validator)) {
-      if (!remapped[n])
-        remapped[n] = [];
-
-      if (Array.isArray(fns)) {
-        remapped[n].push((parent, name, prop, path) => fns.forEach(
-          fn => fn.bind(that)(parent, name, prop, path)
-        ));
-      }
-      else {
-        remapped[n].push((parent, name, prop, path) => fns.bind(that)(parent, name, prop, path));
-      }
-    }
-  }
-
-  for (const [ n, fns ] of Object.entries(remapped))
-    remapped[n] = (parent, name, prop, path) => fns.forEach(fn => fn.bind(that)(parent, name, prop, path));
-
-
-  return remapped;
-}
-
 /**
  * Depending on the dialect we need to run different validations.
  *

package/lib/compiler/assert-consistency.js

@@ -129,6 +129,7 @@ function assertConsistency( model, stage ) {
       ],
       instanceOf: XsnSource,
     },
+    tokenIndex: { test: isNumber },
     location: {
       // every thing with a $location in CSN must have a XSN location even
       // with syntax errors (currently even internal artifacts like $using):
@@ -136,7 +137,10 @@ function assertConsistency( model, stage ) {
       kind: true,
       instanceOf: Location,
       requires: [ 'file' ],     // line is optional in top-level location
-      optional: [ 'line', 'col', 'endLine', 'endCol', '$notFound' ],
+      optional: [
+        'line', 'col', 'endLine', 'endCol', '$notFound',
+        'tokenIndex', // in parser for $lsp
+      ],
       schema: {
         line: { test: isNumber },
         col: { test: isNumber },
@@ -203,7 +207,7 @@ function assertConsistency( model, stage ) {
           optional: [
             'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
             '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
-            '$calcDepElement', '$filtered', '_parent',
+            '$calcDepElement', '$filtered', '$enclosed', '_parent',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -232,7 +236,7 @@ function assertConsistency( model, stage ) {
       test: (model.$frontend !== 'json') ? standard : TODO,
       // TODO: the JSON parser should augment 'namespace' correctly or better: hide it
       requires: [ 'location' ],
-      optional: [ 'path' ],
+      optional: [ 'kind', 'name' ],
     },
     usings: {
       test: isArray(),
@@ -257,6 +261,7 @@ function assertConsistency( model, stage ) {
     foreignKeys: { kind: true, inherits: 'definitions', instanceOf: 'ignore' },
     $keysNavigation: { kind: true, test: TODO },
     $filtered: { kind: true, inherits: 'value' }, // for assoc+filter
+    $enclosed: { kind: true, inherits: 'value' }, // for comp+filter
     params: { kind: true, inherits: 'definitions' },
     _extendType: { kind: true, test: TODO },
     mixin: { inherits: 'definitions' },
@@ -515,11 +520,13 @@ 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',
       ],
       // TODO: name requires if not in parser?
     },
     $priority: { test: isOneOf( [ undefined, false, 'extend', 'annotate' ] ) },
     $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
+    $invalidPaths: { test: isBoolean },
     name: {
       isRequired: stageParser && (() => false), // not required in parser
       kind: true,

package/lib/compiler/checks.js

@@ -19,6 +19,7 @@ const {
 } = require('../base/model');
 const { CompilerAssertion } = require('../base/error');
 const { typeParameters } = require('./builtins');
+const { propagationRules } = require('../base/builtins');
 
 const $location = Symbol.for( 'cds.$location' );
 
@@ -69,6 +70,13 @@ function check( model ) {
     } );
   }
 
+  function* iterateAnnotations( art ) {
+    for (const prop in art) {
+      if (prop.charAt(0) === '@')
+        yield prop;
+    }
+  }
+
   function checkGenericConstruct( art ) {
     checkName( art );
     checkTypeArguments( art );
@@ -76,11 +84,9 @@ function check( model ) {
     if (art.value && !art.$calcDepElement && art.type)
       checkTypeCast( art.value, art );
 
-    if (model.vocabularies) {
-      Object.keys( art )
-        .filter( a => a.startsWith( '@' ) )
-        .forEach( a => checkAnnotationAssignment1( art, art[a] ) );
-    }
+    for (const anno of iterateAnnotations( art ))
+      checkAnnotationAssignment1( art, art[anno] );
+
     checkTypeStructure( art );
     checkAssociation( art ); // type def could be assoc
     if (art.kind === 'enum')
@@ -236,6 +242,8 @@ function check( model ) {
       ? xpr.args[0]?._artifact
       : xpr._artifact;
     const type = isCast ? xpr.type : user.type;
+    if (!isCast && type.$inferred)
+      return; // e.g. $inferred:'generated'
     if (elem && type) { // has explicit type
       if (type._artifact?.elements)
         error( 'type-invalid-cast', [ type.location, user ], { '#': 'to-structure' } );
@@ -264,9 +272,11 @@ function check( model ) {
     // "key" keyword at localized element in SELECT list.
     // TODO: not in inferred elements, but also inside aspects
     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
       // already resulted in a warning by localized.js
-      if (elem._origin?.localized?.val && !elem._origin.key?.val) {
+      if ((!elem._origin && elem.localized?.val) ||
+        (elem._origin?.localized?.val && !elem._origin.key?.val)) {
         warning( 'def-ignoring-localized', [ elem.key.location, elem ], { keyword: 'localized' },
                  'Keyword $(KEYWORD) is ignored for primary keys' );
       }
@@ -860,21 +870,37 @@ function check( model ) {
     return false;
   }
 
+  /**
+   * Returns true if the given annotation accepts expressions as values.
+   *
+   * @param {object} anno
+   * @param {XSN.Artifact} art
+   * @returns {boolean}
+   */
+  function checkAnnotationAcceptsExpressions( anno, art ) {
+    const name = anno.name?.id;
+    if (!name)
+      return true;
+    if (!propagationRules[`@${ name }`])
+      return true;
+    error( 'anno-unexpected-expr', [ anno.location, art ], { anno: name },
+           'Unexpected expression as value for $(ANNO)' );
+    return false;
+  }
 
-  // Former checkAnnotationAssignments.js ------------------------------------
-
-  // Check the annotation assignments (if any) of 'annotatable', possibly using annotation
-  // definitions from 'model'. Report errors on 'options.messages.
-  //
-  // TODO: rework completely!
-  // TODO: if we have such a check, consider #variant, anno.@anno, anno@anno
-
-  // Has been slightly adapted for model.vocabularies but comments need to be
-  // adapted, etc.
   function checkAnnotationAssignment1( art, anno ) {
-    if (art.$contains?.$annotation)
-      checkAnnotationExpressions( anno, art );
+    if (art.$contains?.$annotation && anno.kind === '$annotation') {
+      if (checkAnnotationAcceptsExpressions( anno, art ))
+        checkAnnotationExpressions( anno, art );
+    }
+
+    if (!model.vocabularies)
+      return;
 
+    // Has been slightly adapted for model.vocabularies but comments need to be
+    // adapted, etc.
+    // TODO: rework completely!
+    // TODO: if we have such a check, consider #variant, anno.@anno, anno@anno
     // Sanity checks (ignore broken assignments)
     if (!anno.name?.id)
       return;

package/lib/compiler/define.js

@@ -213,6 +213,12 @@ function define( model ) {
     dictForEach( model.$collectedExtensions, e => e._extensions.forEach( initExtension ) );
 
     addI18nBlocks();
+
+    const { $self } = model.definitions;
+    if ($self) {
+      message( 'name-deprecated-$self', [ $self.location, $self ], { name: '$self' },
+               'Do not use $(NAME) as name for an artifact definition' );
+    }
   }
 
   // Phase 1: ----------------------------------------------------------------
@@ -228,14 +234,15 @@ function define( model ) {
     if (!src.kind)
       src.kind = 'source';
 
-    let { namespace } = src;
+    let namespace = src.namespace?.name;
     let prefix = '';
     if (namespace?.path && !namespace.path.broken) {
       namespace.id = pathName( namespace.path );
       prefix = `${ namespace.id }.`;
     }
     if (isInReservedNamespace( prefix )) {
-      error( 'reserved-namespace-cds', [ src.namespace.location, src.namespace ], { name: 'cds' },
+      error( 'reserved-namespace-cds', [ src.namespace.name.location, src.namespace.name ],
+             { name: 'cds' },
              'The namespace $(NAME) is reserved for CDS builtins' );
       namespace = null;
     }
@@ -523,7 +530,7 @@ function define( model ) {
     if (src.$frontend && src.$frontend !== 'cdl')
       return;
     if (src.namespace) {
-      const decl = src.namespace;
+      const decl = src.namespace.name;
       if (!decl.id)             // parsing may have failed
         return;
       if (!model.definitions[decl.id]) {
@@ -562,8 +569,8 @@ function define( model ) {
       initArtifactParentLink( art, model.definitions );
     const block = art._block;
     checkRedefinition( art );
-    initMembers( art, art, block );
     initDollarSelf( art );      // $self
+    initMembers( art, art, block );
     if (art.params)
       initDollarParameters( art ); // $parameters
 
@@ -636,6 +643,7 @@ function define( model ) {
       name: { id: '$parameters' },
       kind: '$parameters',
       location: art.location,
+      deprecated: true, // hide in code completion
     };
     setLink( parameters, '_parent', art );
     setLink( parameters, '_main', art );
@@ -679,8 +687,14 @@ function define( model ) {
         setLink( self, '_origin', query );
         setLink( self, '_parent', query );
         setLink( self, '_main', query._main );
+
+        const projection = { ...self, deprecated: true }; // hide in code completion
+        setLink( projection, '_origin', query );
+        setLink( projection, '_parent', query );
+        setLink( projection, '_main', query._main );
+
         query.$tableAliases.$self = self;
-        query.$tableAliases.$projection = self;
+        query.$tableAliases.$projection = projection;
       }
       initSubQuery( query );    // check for SELECT clauses after from / mixin
     }
@@ -858,12 +872,13 @@ function define( model ) {
   }
 
   function initMixins( query, art ) {
-    // TODO: re-check if mixins have already duplicates
-    for (const name in query.mixin) {
-      const mixin = query.mixin[name];
+    forEachInOrder( query, 'mixin', initMixin );
+
+    function initMixin( mixin, name ) {
+      setLink( mixin, '_block', art._block );
+      setMemberParent( mixin, name, query );
+      checkRedefinition( mixin );
       if (!(mixin.$duplicates)) {
-        setMemberParent( mixin, name, query );
-        setLink( mixin, '_block', art._block );
         // TODO: do some initMembers() ?  If people had annotation
         // assignments on the mixin... (also for future mixin definitions
         // with generated values)
@@ -924,14 +939,14 @@ function define( model ) {
           setLink( col, '_block', parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
-            warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
+            message( 'syntax-ignoring-anno', [ col.doc.location, col ],
                      { '#': 'doc', code: '.{ ‹inline› }' } );
           }
           // col.$annotations no available for CSN input, have to search.
-          // Warning about first annotation should be enough to avoid spam.
+          // Message about first annotation should be enough to avoid spam.
           const firstAnno = Object.keys( col ).find( key => key.startsWith( '@' ) );
           if (firstAnno) {
-            warning( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
+            message( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
                      { code: '.{ ‹inline› }' } );
           }
         }
@@ -1009,15 +1024,11 @@ function define( model ) {
     const { targetAspect } = obj;
     if (targetAspect) {
       if (obj.foreignKeys) {
-        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ],
-               {},
-               'A managed aspect composition can\'t have a foreign keys specification' );
+        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ] );
         delete obj.foreignKeys; // continuation semantics: not specified
       }
       if (obj.on && !obj.target) {
-        error( 'type-unexpected-on-condition', [ obj.on.location, construct ],
-               {},
-               'A managed aspect composition can\'t have a specified ON-condition' );
+        error( 'type-unexpected-on-condition', [ obj.on.location, construct ] );
         delete obj.on;          // continuation semantics: not specified
       }
       if (targetAspect.elements)
@@ -1151,7 +1162,7 @@ function define( model ) {
       checkRedefinition( elem );
       initMembers( elem, elem, bl, initExtensions );
       if (boundSelfParamType && (elem.kind === 'action' || elem.kind === 'function'))
-        initBoundSelfParam( elem.params );
+        initBoundSelfParam( elem.params, elem._main );
 
       // for a correct home path, setMemberParent needed to be called
 
@@ -1167,8 +1178,8 @@ function define( model ) {
       // TODO: it is not just "syntax" - maybe better test for `$calcDepElement`?
       createAndLinkCalcDepElement( elem );
 
-      // Special case (hack) for calculated elements that use associations+filter:
-      // See "Notes on `$filtered`" in `ExposingAssocWithFilter.md` for details.
+      // Special case (hack) for calculated elements that use composition+filter:
+      // See "Notes on `$enclosed`" in `ExposingAssocWithFilter.md` for details.
       if (elem.target && elem.value.path?.[elem.value.path.length - 1]?.where) {
         delete elem.type;
         delete elem.on;
@@ -1177,27 +1188,24 @@ function define( model ) {
     }
   }
 
-  function initBoundSelfParam( params ) {
+  function initBoundSelfParam( params, main ) {
     if (!params)
       return;
     if (boundSelfParamType === true) { // first try
       const def = model.definitions.$self;
       if (def) {
-        // TODO v5: bring this always, probably even as error
-        warning( 'name-deprecated-for-artifacts', [ def.location, def ], { name: '$self' },
-                 'Do not use $(NAME) as name for an artifact definition' );
         boundSelfParamType = false;
         return;
       }
-      const location = { file: '' };
-      boundSelfParamType = { name: { id: '$self', location }, location };
+      boundSelfParamType = '$self';
     }
     const first = params[Object.keys( params )[0] || ''];
     const type = first?.type || first?.items?.type; // this sequence = no derived type
     const path = type?.path;
     if (path?.length === 1 && path[0]?.id === '$self') { // TODO: no where: ?
-      setLink( type, '_artifact', boundSelfParamType );
-      setLink( path[0], '_artifact', boundSelfParamType );
+      const { $self } = main.$tableAliases;
+      setLink( type, '_artifact', $self );
+      setLink( path[0], '_artifact', $self );
     }
   }
 

package/lib/compiler/extend.js

@@ -9,6 +9,7 @@ const {
   forEachDefinition,
   forEachMember,
   isDeprecatedEnabled,
+  isBetaEnabled,
 } = require('../base/model');
 const { dictAdd, pushToDict } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
@@ -71,6 +72,7 @@ function extend( model ) {
   } );
 
   const includesNonShadowedFirst = isDeprecatedEnabled( model.options, 'includesNonShadowedFirst' );
+  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
 
   sortModelSources();
   const extensionsDict = Object.create( null ); // TODO TMP
@@ -222,6 +224,7 @@ function extend( model ) {
             code: 'extend … with definitions',
             keyword: 'extend service',
           };
+          // TODO(v5): Discuss: make this an error?
           warning( 'ext-invalid-kind', [ loc, ext ], msgArgs, {
             std: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) instead',
             annotate: 'There is no artifact $(ART), use $(CODE) instead',
@@ -818,7 +821,7 @@ function extend( model ) {
             annotate[prop] = art[prop];
         }
       }
-      if (extensions.length === 1) { // i.e. no proper location if from more than one extensions
+      if (extensions.length === 1) { // i.e. no proper location if from more than one extension
         annotate.location = extensions[0].location;
         annotate.name.location = extensions[0].name.location;
       }
@@ -829,18 +832,38 @@ function extend( model ) {
   }
 
   function checkRemainingMainExtensions( art, ext, localized ) {
-    if (localized)              // TODO v5: ignore only for annotate
+    if (localized) {
+      if (isV5preview && ext.kind === 'extend') {
+        // In v5, reject any `extend` on localized.
+        error( 'ref-undefined-art', [ ext.location || ext.name.location, ext ],
+               { '#': 'localized', keyword: 'annotate' } );
+      }
       return;
+    }
+
     if (!resolvePath( ext.name, ext.kind, ext )) // error for extend, info for annotate
       return;
-    if (art?.kind === 'namespace') {
-      // TODO: not at all different to having no definition
-      info( 'anno-namespace', [ ext.name.location, ext ], {}, // TODO: better location?
-            'Namespaces can\'t be annotated' );
-    }
-    else if (art?.builtin) {
-      info( 'anno-builtin', [ ext.name.location, ext ], {}, // TODO: better location?
-            'Builtin types should not be annotated. Use custom type instead' );
+
+    if (art?.builtin) {
+      info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
+    }
+    else if (art?.kind === 'namespace') {
+      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).
+      if ((hasAnnotations || !ext.artifacts) ) {
+        if (isV5preview) {
+          error( 'ref-undefined-art', [ (firstAnno?.name || ext.name).location, ext ], {
+            '#': 'namespace', art: ext,
+          } );
+        }
+        else {
+          info( 'anno-namespace', [ (firstAnno?.name || ext.name).location, ext ], {},
+                'Namespaces can\'t be annotated nor extended' );
+        }
+      }
     }
   }
 

package/lib/compiler/index.js

@@ -56,7 +56,6 @@ class InvocationError extends Error {
     super( ...args );
     this.code = 'ERR_CDS_COMPILER_INVOCATION';
     this.errors = errs;
-    this.hasBeenReported = false;
   }
 }
 

package/lib/compiler/lsp-api.js

@@ -0,0 +1,5 @@
+'use strict';
+
+// Placeholder for future LSP API.
+
+module.exports = {};

package/lib/compiler/populate.js

@@ -617,8 +617,6 @@ function populate( model ) {
 
     function resolveTabRef( alias ) {
       // effectiveType() must not be called on $self, is unnecessary for mixins:
-      // TODO: have a test for `select from E { a, $self.a as b, $self.{ b as c } }`
-      // TODO: have a negative test for `select from E { $self.*, assoc.* }`
       // (we might have those already)
       if (alias.kind === 'mixin' || alias.kind === '$self')
         return;