@sap/cds-compiler 3.0.2 → 3.1.0

package/lib/checks/types.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { getUtils, isBuiltinType, hasAnnotationValue } = require('../model/csnUtils');
+const { getUtils, hasAnnotationValue } = require('../model/csnUtils');
 
 // Only to be used with validator.js - a correct this value needs to be provided!
 
@@ -55,7 +55,7 @@ function checkElementTypeDefinitionHasType(member, memberName, prop, path) {
 
   // should only happen with csn input, not in cdl
   if (!hasArtifactTypeInformation(member)) {
-    warnAboutMissingType(this.error, path, memberName, true);
+    errorAboutMissingType(this.error, path, memberName, true);
     return;
   }
 
@@ -96,7 +96,7 @@ function checkTypeDefinitionHasType(artifact, artifactName, prop, path) {
 
   // should only happen with csn input, not in cdl
   if (!hasArtifactTypeInformation(artifact)) {
-    warnAboutMissingType(this.error, path, artifactName);
+    errorAboutMissingType(this.error, path, artifactName);
     return;
   }
 
@@ -157,9 +157,8 @@ function checkTypeOfHasProperType(artOrElement, name, model, error, path, derive
  * @param {CSN.Path} path the path to the element or the artifact
  * @param {string} name of the element or the artifact which is dubious
  * @param {boolean} isElement indicates whether we are dealing with an element or an artifact
- * @todo Rename, is an error not a warning
  */
-function warnAboutMissingType(error, path, name, isElement = false) {
+function errorAboutMissingType(error, path, name, isElement = false) {
   error('check-proper-type', path, { art: name, '#': isElement ? 'elm' : 'std' }, {
     std: 'Dubious type $(ART) without type information',
     elm: 'Dubious element $(ART) without type information',
@@ -174,12 +173,10 @@ function warnAboutMissingType(error, path, name, isElement = false) {
  *
  * @param {CSN.Artifact} artifact the artifact to check
  * @returns {boolean} indicates whether the artifact has type information
- * @todo What is the point of isBuiltinType here if we check for artifact.type at the end?
  */
 function hasArtifactTypeInformation(artifact) {
   // When is what property set?
-  return isBuiltinType(artifact.type) || // => `Integer`
-    artifact.elements ||  // => `type A {}`
+  return artifact.elements ||  // => `type A {}`
     artifact.items ||     // => `type A : array of Integer`
     artifact.enum ||      // => `type A : Integer enum {}`, `type` also set
     artifact.target ||    // => `type A : Association to B;`

package/lib/checks/validator.js

@@ -32,7 +32,6 @@ const { validateAssociationsInItems } = require('./arrayOfs');
 const checkQueryForNoDBArtifacts = require('./queryNoDbArtifacts');
 const checkExplicitlyNullableKeys = require('./nullableKeys');
 const nonexpandableStructuredInExpression = require('./nonexpandableStructured');
-const unknownMagic = require('./unknownMagic');
 const managedWithoutKeys = require('./managedWithoutKeys');
 const {
   checkSqlAnnotationOnArtifact,
@@ -62,7 +61,7 @@ const forHanaArtifactValidators
   checkSqlAnnotationOnArtifact,
 ];
 
-const forHanaCsnValidators = [ nonexpandableStructuredInExpression, unknownMagic ];
+const forHanaCsnValidators = [ nonexpandableStructuredInExpression ];
 /**
  * @type {Array<(query: CSN.Query, path: CSN.Path) => void>}
  */

package/lib/compiler/assert-consistency.js

@@ -97,7 +97,6 @@ function assertConsistency( model, stage ) {
         '$lateExtensions',
         '_entities', '$entity',
         '$blocks',
-        '$newfeatures',
         '$messageFunctions',
         '$functions',
         '$volatileFunctions',
@@ -143,7 +142,6 @@ function assertConsistency( model, stage ) {
     },
     fileDep: { test: TODO },    // in usings
     $frontend: { parser: true, test: isString, enum: [ 'cdl', 'json', 'xml' ] },
-    $newfeatures: { test: TODO }, // if new features have been used which break the old backends
     messages: {
       enumerable: () => true,  // does not matter (non-enum std), enum in CSN/XML parser
       test: isArray( TODO ),
@@ -175,7 +173,6 @@ function assertConsistency( model, stage ) {
         return innerDict( val, parent, lang, spec );
       } ),
     },
-    _assocSources: { kind: true, test: TODO }, // just null: isArray( inDefinitions ) during resolve
     $magicVariables: {
       // $magicVariables contains "builtin" artifacts that differ from
       // "normal artifacts" and therefore have a custom schema
@@ -256,6 +253,7 @@ function assertConsistency( model, stage ) {
           'where', 'groupBy', 'having', 'orderBy', '$orderBy', 'limit',
           '_projections', '_block', '_parent', '_main', '_effectiveType', '$expand',
           '$tableAliases', 'kind', '_$next', '_combined', '$inlines', '_status',
+          '_extension', // for unapplied extensions
         ],
       },
       none: { optional: () => true }, // parse error
@@ -375,13 +373,21 @@ function assertConsistency( model, stage ) {
     },
     // locations of parentheses pairs around expression:
     $parens: { parser: true, test: TODO },
+    $prefix: { test: isString }, // compiler-corrected path prefix
     $syntax: {
       parser: true,
       kind: [ 'entity', 'view', 'type', 'aspect' ],
       test: isString,            // CSN parser should check for 'entity', 'view', 'projection'
     },
     value: {
-      optional: [ 'location', '$inferred', 'sort', 'nulls' ],
+      optional: [
+        'location', '$inferred', 'sort', 'nulls',
+        'param', 'scope', // for dynamic parameter '?'
+        // through cast() with enum through CSN->XSN
+        // TODO: re-check #9225, this should be directly in the query element,
+        // not inside value, no `enum` inside `cast`!
+        'elements', 'items', 'enum', '$expand', 'target',
+      ],
 
       kind: true,
       test: expression,         // properties below are "sub specifications"
@@ -439,7 +445,10 @@ function assertConsistency( model, stage ) {
     struct: { inherits: 'val', test: isDictionary( definition ) }, // def because double @
     args: {
       inherits: 'value',
-      optional: [ 'name', '$duplicate', '$expected', 'args', 'suffix' ],
+      optional: [
+        'name', '$duplicate', '$expected', 'args', 'suffix',
+        'param', 'scope', // for dynamic parameter '?'
+      ],
       test: args,
     },
     on: { kind: true, inherits: 'value', test: expression },
@@ -456,7 +465,7 @@ function assertConsistency( model, stage ) {
       optional: [ 'name', '_block', '$priority', '$inferred', '$duplicates', '$errorReported' ],
       // TODO: name requires if not in parser?
     },
-    $priority: { test: TODO },
+    $priority: { test: isOneOf([ undefined, false, 'extend', 'annotate' ]) },
     $annotations: { parser: true, kind: true, test: TODO }, // deprecated, still there for cds-lsp
     name: {
       isRequired: stageParser && (() => false), // not required in parser
@@ -475,7 +484,7 @@ function assertConsistency( model, stage ) {
     variant: { test: TODO }, // TODO: not set in CDL parser
     element: { test: TODO }, // TODO: { test: isString },
     action: { test: isString },
-    param: { test: isString },
+    param: { test: TODO },
     alias: { test: isString },
     expectedKind: { kind: [ 'extend' ], inherits: 'kind' },
     virtual: { kind: true, test: locationVal() },
@@ -528,7 +537,6 @@ function assertConsistency( model, stage ) {
     _service: { kind: true, test: TODO },
     _main: { kind: true, test: TODO },
     _artifact: { test: TODO },
-    _base: { test: TODO, kind: true },
     _navigation: { test: TODO },
     _effectiveType: { kind: true, test: TODO },
     _joinParent: { test: TODO },
@@ -552,6 +560,7 @@ function assertConsistency( model, stage ) {
         'where', 'columns', 'mixin', 'quantifier', 'offset',
         'orderBy', '$orderBy', 'groupBy', 'excludingDict', 'having',
         'limit', '_status',
+        '_extension', // for unapplied extensions
       ],
     },
     _leadingQuery: { kind: true, test: TODO },
@@ -588,18 +597,54 @@ function assertConsistency( model, stage ) {
     $errorReported: { parser: true, kind: true, test: isString },     // to avoid duplicate messages
     $duplicates: { parser: true, kind: true, test: TODO }, // array of arts or true
     $extension: { kind: true, test: TODO }, // TODO: introduce $applied instead or $status
-    $inferred: { parser: true, kind: true, test: isString },
+    $inferred: {
+      parser: true,
+      kind: true,
+      test: isOneOf([
+        // Uppercase values are used in logic, lowercase value are "just for us", i.e.
+        // debugging or to add non-enumerable properties such as $generated in Universal CSN.
+        // However, that is no longer true. For example, `autoexposed` is used in populate.js
+        // as well.
+        'IMPLICIT',
+        'REDIRECTED',
+
+        '$autoElement', // for magicVars: $user is automatically changed to $user.id
+        '$generated', // compiler generated annotations, e.g. @Core.Computed
+        '*', // inferred from query wildcard
+        'as', // query alias name
+        'aspect-composition',
+        'autoexposed', // for auto-exposed entities (they can't be referred to)
+        'cast', // type from cast() function
+        'composition-entity',
+        'copy', // only used in rewriteCondition(): On-condition is copied
+        'duplicate-autoexposed', // just like `autoexposed`, but with `duplicate` error.
+        'expand-element', // expanded elements
+        'expand-param',  // expanded params (difference to expand-element only for debugging)
+        'include', // through includes, e.g. `entity E : F {}`
+        'keys',
+        'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
+        'localized-entity', // `.texts` entity
+        'nav', // only used for MASKED, TODO(v4): Remove
+        'none', // only used in ensureColumnName(): Used in object representing empty alias
+        'query', // inferred query properties, e.g. `key`
+        'rewrite', // on-conditions or FKeys are rewritten
+      ]),
+    },
 
     // Helper property for the XSN-to-CSN transformation, see function setExpandStatus():
     // client, universal: render expanded elements?  gensrc: produce annotate statements?
-    $expand: { kind: true, test: isString }, // TODO: rename it to $elementsExpand ?
+    // TODO: rename it to $elementsExpand ?
+    $expand: {
+      kind: true,
+      // See description of `setExpandStatus()` of in `lib/compiler/utils.js`.
+      test: isOneOf([ 'origin', 'annotate', 'target' ]),
+    },
 
     $autoexpose: { kind: [ 'entity' ], test: isBoolean, also: [ null, 'Composition' ] },
-    $a2j: { kind: true, enumerable: true, test: TODO },
     $extra: { parser: true, test: TODO },   // for unexpected properties in CSN
     $withLocalized: { test: isBoolean },
     $sources: { parser: true, test: isArray( isString ) },
-    $expected: { parser: true, test: isString },
+    $expected: { parser: true, test: isOneOf([ 'approved-exists', 'exists' ]) },
     $messageFunctions: { test: TODO },
     $functions: { test: TODO },
     $volatileFunctions: { test: TODO },
@@ -859,6 +904,13 @@ function assertConsistency( model, stage ) {
       isString(node, parent, prop, spec);
   }
 
+  function isOneOf(values) {
+    return function isOneOfInner( node, parent, prop ) {
+      if (!values.includes(node))
+        throw new Error( `Unexpected value '${ node }', expected ${ JSON.stringify(values) }${ at( [ node, parent ], prop ) }` );
+    };
+  }
+
   function isString( node, parent, prop, spec ) {
     if (typeof node !== 'string')
       throw new Error( `Expected string${ at( [ node, parent ], prop ) }` );

package/lib/compiler/base.js

@@ -16,16 +16,18 @@ const kindProperties = {
   namespace: { artifacts: true }, // on-the-fly context
   context: { artifacts: true, normalized: 'namespace' },
   service: { artifacts: true, normalized: 'namespace' },
-  entity: { elements: true, actions: true, params: () => false },
+  entity: {
+    elements: true, actions: true, params: () => false, include: true,
+  },
   select: { normalized: 'select', elements: true },
   $join: { normalized: 'select' },
   $tableAlias: { normalized: 'alias' }, // table alias in select
   $self: { normalized: 'alias' }, // table alias in select
   $navElement: { normalized: 'element' },
   $inline: { normalized: 'element' }, // column with inline property
-  event: { elements: true },
-  type: { elements: propExists, enum: propExists },
-  aspect: { elements: propExists },
+  event: { elements: true, include: true },
+  type: { elements: propExists, enum: propExists, include: true },
+  aspect: { elements: propExists, actions: true, include: true },
   annotation: { elements: propExists, enum: propExists },
   enum: { normalized: 'element' },
   element: { elements: propExists, enum: propExists, dict: 'elements' },

package/lib/compiler/builtins.js

@@ -154,12 +154,14 @@ function compileArg( src ) {
     expr: src.expr || [],
     separator: src.separator || [],
   };
-  for (const generic of [ 'intro', 'expr', 'separator' ]) { // intro before expr!
+  for (const generic of [ 'intro', 'expr', 'separator' ]) {
+    // intro before expr: if both intro and expr, tag as 'expr'
     for (const token of src[generic] || [])
       tgt[token] = generic;
   }
-  if (tgt.intro)             // same token could be in both 'expr' and 'intro':
-    tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
+  // As GenericIntro is always together with GenericExpr, only mention those
+  // which are not already proposed for GenericExpr:
+  tgt.introMsg = src.introMsg || tgt.intro.filter( token => tgt[token] === 'intro' );
   return tgt;
 }
 
@@ -196,15 +198,16 @@ const magicVariables = {
 /**
  * Patterns for literal token tests and creation.  The value is a map from the
  * `prefix` argument of function `quotedliteral` to the following properties:
- *  - `test_msg`: error message which is issued if `test_fn` or `test_re` fail.
+ *  - `test_msg`: error message which is issued if `test_fn` fails.
  *  - `test_fn`: function called with argument `value`, fails falsy return value
- *  - `test_re`: regular expression, fails if it does not match argument `value`
  *  - `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:
+ *  - Dates/Times as defined in ISO 8601, see <https://en.wikipedia.org/wiki/ISO_8601>
  */
 const quotedLiteralPatterns = {
   x: {
@@ -216,21 +219,68 @@ const quotedLiteralPatterns = {
   },
   time: {
     test_variant: 'time',
-    test_re: /^[0-9]{1,2}:[0-9]{1,2}(:[0-9]{1,2})?$/,
+    test_fn: (x) => {
+      // Leading `T` allowed in ISO 8601.
+      const match = x.match( /^T?(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?$/ );
+      return match !== null && checkTime( match[1], match[2], match[3] );
+    },
     json_type: 'string',
   },
   date: {
     test_variant: 'date',
-    test_re: /^[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}$/,
+    test_fn: (x) => {
+      const match = x.match( /^(-?\d{4})-(\d{1,2})-(\d{1,2})$/ );
+      return match !== null && checkDate( match[1], match[2], match[3] );
+    },
     json_type: 'string',
   },
   timestamp: {
     test_variant: 'timestamp',
-    test_re: /^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}(:[0-9]{2}(\.[0-9]{1,7})?)?$/,
+    test_fn: (x) => {
+      // eslint-disable-next-line max-len
+      const match = x.match( /^(-?\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2})(?::(\d{2})(\.\d{1,7})?)?$/ );
+      return match !== null && checkDate( match[1], match[2], match[3] ) &&
+        checkTime( match[4], match[5], match[6] );
+    },
     json_type: 'string',
   },
 };
 
+/**
+ * Check that the given date is within boundaries.
+ * We can't use Date.parse() since that also allows non-standard values (2022-02-31 for example).
+ * Checks according to ISO 8601.
+ *
+ * @returns {boolean} True if the date is valid.
+ */
+function checkDate(year, month, day) {
+  // Negative years are allowed
+  year = Math.abs(Number.parseInt(year, 10));
+  month = Number.parseInt(month, 10);
+  day = Number.parseInt(day, 10);
+  // If any is NaN, the condition will be false.
+  // Year 0 does not exist, but ISO 8601 allows it and defines it as 1 BC.
+  return !Number.isNaN(year) && month > 0 && month < 13 && day > 0 && day < 32;
+}
+
+/**
+ * Check that the given time is within boundaries.
+ * Checks according to ISO 8601.
+ *
+ * @returns {boolean} True if the date is valid.
+ */
+function checkTime(hour, minutes, seconds) {
+  hour = Number.parseInt(hour, 10);
+  minutes = Number.parseInt(minutes, 10);
+  seconds = seconds ? Number.parseInt(seconds, 10) : 0;
+  if (hour === 24) // allow 24:00:00 (ISO 8601 version earlier than 2019)
+    return minutes === 0 && seconds === 0;
+  // If any is NaN, the condition will be false.
+  return hour >= 0 && hour < 24 &&
+    minutes >= 0 && minutes < 60 &&
+    seconds >= 0 && seconds < 61; // we allow 60 for lead seconds
+}
+
 /** All types belong to one category. */
 const typeCategories = {
   string: [],

package/lib/compiler/checks.js

@@ -414,7 +414,7 @@ function check( model ) {       // = XSN
     }
   }
 
-  // TODO: make this part of the the name resolution in the compiler
+  // TODO: make this part of the name resolution in the compiler
   // Check that queries in 'art' do not contain unmanaged associations in GROUP BY or ORDER BY
   function checkNoUnmanagedAssocsInGroupByOrderBy( query ) {
     const art = query._main;    // TODO - remove, use query for semantic location

package/lib/compiler/define.js

@@ -109,7 +109,7 @@
 
 'use strict';
 
-const { isDeprecatedEnabled, forEachGeneric, forEachInOrder } = require('../base/model');
+const { forEachGeneric, forEachInOrder } = require('../base/model');
 const {
   dictAdd, dictAddArray, dictForEach, pushToDict,
 } = require('../base/dictionaries');
@@ -147,6 +147,7 @@ function define( model ) {
   } = model.$messageFunctions;
   const {
     resolveUncheckedPath,
+    checkAnnotate,
     defineAnnotations,
   } = model.$functions;
 
@@ -197,11 +198,12 @@ function define( model ) {
   }
 
   // Phase 1: ----------------------------------------------------------------
+  // Functions called from top-level: addSource()
 
   /**
    * Add definitions of the given source AST, both CDL and CSN
    *
-   * @param {XSN.AST} src
+   * @param {XSN.SourceAst} src
    */
   function addSource( src ) {
     // handle sub model from parser
@@ -266,7 +268,7 @@ function define( model ) {
       return;
     }
     setLink( art, '_block', block );
-    // dictAdd might set $duplicates to true
+    // dictAdd might set $duplicates
     dictAdd( model.definitions, absolute, art );
   }
 
@@ -306,7 +308,7 @@ function define( model ) {
    * declaration.
    *
    * @param {XSN.Using} decl Node to be expanded and added to `src`
-   * @param {XSN.AST} src
+   * @param {XSN.SourceAst} src
    */
   function addUsing( decl, src ) {
     if (decl.usings) {
@@ -395,9 +397,12 @@ function define( model ) {
   }
 
   // Phase 2 ("init") --------------------------------------------------------
+  // Functions called from top-level: initNamespaceAndUsing(), initArtifact(),
+  // initVocabulary()
 
   function checkRedefinition( art ) {
-    if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend')
+    if (!art.$duplicates || art.$errorReported === 'syntax-duplicate-extend' ||
+        art.$errorReported === 'syntax-duplicate-annotate')
       return;
     if (art._main) {
       error( 'duplicate-definition', [ art.name.location, art ], {
@@ -504,18 +509,6 @@ function define( model ) {
       definitions[prefix] = parent;
       initParentLink( parent, definitions );
     }
-    if (art.kind !== 'namespace' &&
-        isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' )) {
-      let p = parent;
-      while (p && kindProperties[p.kind].artifacts)
-        p = p._parent;
-      if (p) {
-        error( 'subartifacts-not-supported', [ art.name.location, art ],
-               { art: p, prop: 'deprecated._generatedEntityNameWithUnderscore' },
-               // eslint-disable-next-line max-len
-               'With the option $(PROP), no sub artifact can be defined for a non-context/service $(ART)' );
-      }
-    }
     setLink( art, '_parent', parent );
     if (!parent._subArtifacts)
       setLink( parent, '_subArtifacts', Object.create(null) );
@@ -611,7 +604,17 @@ function define( model ) {
       // Either expression (value), expand or new association (target && type)
       else if (col.value || col.expand || (col.target && col.type)) {
         setLink( col, '_block', parent._block );
-        defineAnnotations( col, col, parent._block ); // TODO: complain with inline
+        defineAnnotations( col, col, parent._block );
+        if (col.inline) { // `@anno elem.{ * }` does not work
+          if (col.doc)
+            warning( 'syntax-anno-ignored', [ col.doc.location, col ], { '#': 'doc' } );
+
+          // col.$annotations no available for CSN input, have to search.
+          // Warning about first annotation should be enough to avoid spam.
+          const firstAnno = Object.keys(col).find(key => key.startsWith('@'));
+          if (firstAnno)
+            warning( 'syntax-anno-ignored', [ col[firstAnno].name.location, col ] );
+        }
         // TODO: allow sub queries? at least in top-level expand without parallel ref
         if (columns)
           initExprForQuery( col.value, parent );
@@ -882,9 +885,7 @@ function define( model ) {
 
   /**
    * Set property `_parent` for all elements in `parent` to `parent` and do so
-   * recursively for all sub elements.  Also set the property
-   * `name.component` of the element with the help of argument `prefix`
-   * (which is basically the component name of the `parent` element plus a dot).
+   * recursively for all sub elements.
    */
   // If not for extensions: construct === parent
   function initMembers( construct, parent, block, initExtensions = false ) {
@@ -1016,6 +1017,8 @@ function define( model ) {
       setMemberParent( elem, name, parent, construct !== parent && prop );
       // console.log(message( null, elem.location, elem, {}, 'Info', 'INIT').toString())
       checkRedefinition( elem );
+      if (elem.kind === 'annotate')
+        checkAnnotate( elem, elem );
       defineAnnotations( elem, elem, bl );
       initMembers( elem, elem, bl, initExtensions );
 
@@ -1127,7 +1130,7 @@ function mergeI18nBlocks( model ) {
    * Add the source's translations to the model. Warns if the sources translations
    * do not match the ones from previous sources.
    *
-   * @param {XSN.AST} src
+   * @param {XSN.SourceAst} src
    */
   function initI18nFromSource( src ) {
     for (const langKey of Object.keys( src.i18n )) {

package/lib/compiler/extend.js

@@ -33,6 +33,7 @@ function extend( model ) {
   const {
     resolvePath,
     resolveUncheckedPath,
+    checkAnnotate,
     defineAnnotations,
     attachAndEmitValidNames,
     checkDefinitions,
@@ -179,6 +180,10 @@ function extend( model ) {
       checkDefinitions( ext, art, 'actions');
       checkDefinitions( ext, art, 'params');
       checkDefinitions( ext, art, 'columns');
+      if (ext.includes)
+        applyIncludes( ext, art ); // emits error if `includes` is set
+      if (ext.kind === 'annotate')
+        checkAnnotate( ext, art );
       defineAnnotations( ext, art, ext._block, ext.kind );
     }
     return true;
@@ -238,6 +243,8 @@ function extend( model ) {
             art.includes = [ ...ext.includes ];
           applyIncludes( ext, art );
         }
+        if (ext.kind === 'annotate')
+          checkAnnotate( ext, art );
         defineAnnotations( ext, art, ext._block, ext.kind );
         // TODO: do we allow to add elements with array of {...}?  If yes, adapt
         initMembers( ext, art, ext._block ); // might set _extend, _annotate
@@ -395,6 +402,7 @@ function extend( model ) {
             resolvePath( ext.name, ext.kind, ext )) { // should issue error/info
             // should issue error for cds extensions (annotate ok)
             if (art.kind === 'namespace') {
+              // TODO: Emit error if namespace is extended by non-definitions.
               info( 'anno-namespace', [ ext.name.location, ext ], {},
                     'Namespaces can\'t be annotated' );
             }
@@ -454,6 +462,12 @@ function extend( model ) {
    * @param {XSN.Artifact} art
    */
   function applyIncludes( ext, art ) {
+    if (kindProperties[art.kind].include !== true) {
+      error('extend-unexpected-include', [ ext.includes[0]?.location, ext ], { kind: art.kind },
+            'Can\'t extend $(KIND) with includes');
+      return;
+    }
+
     if (!art._ancestors)
       setLink( art, '_ancestors', [] ); // recursive array of includes
     for (const ref of ext.includes) {
@@ -515,9 +529,7 @@ function extend( model ) {
     const fioriAnno = art['@fiori.draft.enabled'];
     const fioriEnabled = fioriAnno && (fioriAnno.val === undefined || fioriAnno.val);
 
-    const textsName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-      ? `${ art.name.absolute }_texts`
-      : `${ art.name.absolute }.texts`;
+    const textsName = `${ art.name.absolute }.texts`;
     const textsEntity = model.definitions[textsName];
     const localized = localizedData( art, textsEntity, fioriEnabled );
     if (!localized)
@@ -660,8 +672,6 @@ function extend( model ) {
       };
       dictAdd( art.elements, 'ID_texts', textId );
     }
-    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-      setLink( art, '_base', base );
 
     dictAdd( art.elements, 'locale', locale );
     if (addTextsLanguageAssoc) {
@@ -834,9 +844,7 @@ function extend( model ) {
         target = resolvePath( origin.targetAspect, 'compositionTarget', origin );
       if (!target || !target.elements)
         return;
-      const entityName = (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-        ? `${ base.name.absolute }_${ elem.name.id }`
-        : `${ base.name.absolute }.${ elem.name.id }`;
+      const entityName = `${ base.name.absolute }.${ elem.name.id }`;
       const entity = allowAspectComposition( target, elem, keys, entityName ) &&
             createTargetEntity( target, elem, keys, entityName, base );
       elem.target = {
@@ -968,8 +976,6 @@ function extend( model ) {
       // even if target cardinality is 1..1
       up.notNull = { location, val: true };
     }
-    if (isDeprecatedEnabled( options, '_generatedEntityNameWithUnderscore' ))
-      setLink( art, '_base', base._base || base );
 
     dictAdd( art.elements, 'up_', up);
     addProxyElements( art, target.elements, 'aspect-composition', target.name && location );

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

@@ -82,8 +82,12 @@ function finalizeParseCdl( model ) {
     for (const include of artifact.includes || [])
       resolveUncheckedPath(include, 'include', main);
 
+    // define.js takes care that `target` is a ref and
+    // `targetAspect` is a structure.
     if (artifact.target)
       resolveUncheckedPath(artifact.target, 'target', main);
+    if (artifact.targetAspect)
+      resolveTypesForParseCdl(artifact.targetAspect, main);
 
     if (artifact.from) {
       const { from } = artifact;
@@ -93,12 +97,6 @@ function finalizeParseCdl( model ) {
       resolveTypesForParseCdl(from, main);
     }
 
-    if (artifact.targetAspect) {
-      if (artifact.targetAspect.path)
-        resolveUncheckedPath(artifact.targetAspect, 'target', main);
-      resolveTypesForParseCdl(artifact.targetAspect, main);
-    }
-
     // Recursively go through all XSN properties.  There are a few that need to be
     // handled specifically.  Refer to the code below this loop for details.
     for (const prop in artifact) {
@@ -158,8 +156,6 @@ function finalizeParseCdl( model ) {
    * @param {XSN.Artifact} user
    */
   function resolveTypeUnchecked(artWithType, user) {
-    if (!artWithType.type)
-      return;
     const root = artWithType.type.path && artWithType.type.path[0];
     if (!root) // parse error
       return;
@@ -187,7 +183,7 @@ function finalizeParseCdl( model ) {
       let struct = artWithType;
       while (struct.kind === 'element')
         struct = struct._parent;
-      if (struct.kind === 'select' || struct !== user._main) {
+      if (struct.kind === 'select' || struct.kind === 'annotation' || struct !== user._main) {
         message( 'type-unexpected-typeof', [ artWithType.type.location, user ],
                  { keyword: 'type of', '#': struct.kind } );
         return;

package/lib/compiler/index.js

@@ -84,6 +84,8 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
     return parseCsn.parse( source, filename, options, messageFunctions );
   if (options.fallbackParser)   // any other value: like 'cdl' (historic reasons)
     return parseLanguage( source, filename, options, messageFunctions );
+  if (source.startsWith('{')) // Source may be JSON.
+    return parseCsn.parse( source, filename, options, messageFunctions );
 
   const model = { location: { file: filename } };
   messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),