@sap/cds-compiler 4.7.6 → 4.9.0

package/lib/compiler/assert-consistency.js

@@ -66,10 +66,9 @@
 
 'use strict';
 
+const { Location } = require('../base/location');
 const { locationString, hasErrors } = require('../base/messages');
-const {
-  XsnSource, XsnName, XsnArtifact, CsnLocation,
-} = require('./classes');
+const { XsnSource, XsnName, XsnArtifact } = require('./xsn-model');
 
 
 // Properties that can appear where a type can have type arguments.
@@ -130,14 +129,18 @@ 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):
       isRequired: parent => noSyntaxErrors() || parent && parent.kind,
       kind: true,
-      instanceOf: CsnLocation,
+      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 },
@@ -233,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(),
@@ -317,7 +320,6 @@ function assertConsistency( model, stage ) {
           'kind', 'name', '_block', '_parent', '_main', 'elements',
           '_effectiveType', '$effectiveSeqNo', '_origin', '_joinParent', '$joinArgsIndex',
           '$duplicates', // duplicate query in FROM clause
-          '$inferred', // table alias with $inferred: '$internal'
         ],
       },
       none: { optional: () => true }, // parse error
@@ -517,11 +519,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/builtins.js

@@ -64,18 +64,6 @@ const typeParameters = {
 // a.k.a "typeProperties"
 typeParameters.list = Object.keys( typeParameters.expectedLiteralsFor );
 
-/**
- * Properties that are required next to `=` to make an annotation value an actual expression
- * and not some foreign structure.
- *
- * @type {string[]}
- */
-const xprInAnnoProperties = [
-  'ref', 'xpr', 'list', 'literal', 'val',
-  '#', 'func', 'args', 'SELECT', 'SET',
-  'cast',
-];
-
 
 // const hana = {
 //   BinaryFloat: {},
@@ -87,15 +75,6 @@ const xprInAnnoProperties = [
 //   hana: { kind: 'context' },
 // };
 
-/**
- * Functions without parentheses in CDL (common standard SQL-92 functions)
- * (do not add more - make it part of the SQL renderer to remove parentheses for
- * other funny SQL functions like CURRENT_UTCTIMESTAMP).
- */
-const functionsWithoutParens = [
-  'CURRENT_DATE', 'CURRENT_TIME', 'CURRENT_TIMESTAMP',
-  'CURRENT_USER', 'SESSION_USER', 'SYSTEM_USER',
-];
 
 const specialFunctions = compileFunctions( {
   '': [                         // the default
@@ -317,13 +296,6 @@ function checkDate( year, month, day ) {
   return !Number.isNaN( year ) && month > 0 && month < 13 && day > 0 && day < 32;
 }
 
-/**
- * Return whether JSON object `val` is a representation for an annotation expression
- */
-function isAnnotationExpression( val ) {
-  return val?.['='] !== undefined && xprInAnnoProperties.some( prop => val[prop] !== undefined );
-}
-
 /**
  * Check that the given time is within boundaries.
  * Checks according to ISO 8601.
@@ -371,44 +343,6 @@ function isGeoTypeName( typeName ) {
   return typeCategories.geo.includes( typeName );
 }
 
-/**
- * Checks whether the given absolute path is inside a reserved namespace.
- *
- * @param {string} absolute
- * @returns {boolean}
- */
-function isInReservedNamespace( absolute ) {
-  return absolute === 'cds' || absolute.startsWith( 'cds.' ) &&
-    !absolute.match( /^cds\.foundation(\.|$)/ ) &&
-    !absolute.match( /^cds\.outbox(\.|$)/ ) && // Requested by Node runtime
-    !absolute.match( /^cds\.xt(\.|$)/ ); // Requested by Mtx
-}
-
-/**
- * Tell if a type is (directly) a builtin type
- * Note that in CSN builtins are not in the definition of the model, so we can only
- * check against their absolute names.  Builtin types are "cds.<something>", i.e. they
- * are directly in 'cds', but not for example in 'cds.foundation'.
- *
- * TODO: Handle `{ ref: [ "cds.Integer" ] }`
- *
- * @param {string} type
- * @returns {boolean}
- */
-function isBuiltinType( type ) {
-  return typeof type === 'string' && isInReservedNamespace( type );
-}
-
-/**
- * Tell if a name is a magic variable
- *
- * @param {string} name
- * @returns {boolean}
- */
-function isMagicVariable( name ) {
-  return typeof name === 'string' && Object.prototype.hasOwnProperty.call(magicVariables, name);
-}
-
 /**
  * Add CDS builtins like the `cds` namespace with types like `cds.Integer` to
  * `definitions` of the XSN model as well as to `$builtins`.
@@ -424,8 +358,6 @@ function initBuiltins( model ) {
 
   // Also add the core artifacts to model.definitions`
   const c = { ...core };
-  if (!isBetaEnabled( model.options, 'vectorType' ))
-    delete c.Vector;
   model.$builtins = env( c, 'cds.', cds );
   model.$builtins.cds = cds;
 
@@ -541,14 +473,8 @@ function initBuiltins( model ) {
 
 module.exports = {
   typeParameters,
-  xprInAnnoProperties,
-  functionsWithoutParens,
   specialFunctions,
   quotedLiteralPatterns,
   initBuiltins,
-  isAnnotationExpression,
-  isInReservedNamespace,
-  isBuiltinType,
-  isMagicVariable,
   isGeoTypeName,
 };

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' );
 
@@ -29,7 +30,7 @@ const $location = Symbol.for( 'cds.$location' );
  */
 function check( model ) {
   const {
-    error, warning, info,
+    error, warning, info, message,
   } = model.$messageFunctions;
 
   checkSapCommonLocale( model );
@@ -41,6 +42,7 @@ function check( model ) {
   return;
 
   function checkDefinition( def ) {
+    checkEvent( def );
     checkGenericConstruct( def );
     if (def.includes && def.elements)
       checkElementIncludeOverride( def );
@@ -49,6 +51,16 @@ function check( model ) {
       def.$queries.forEach( checkQuery );
   }
 
+  function checkEvent( def ) {
+    // Ensure that events are structured. Up to compiler v4, we allowed non-structured events,
+    // because when we introduced them, it was not fully specified what they are.
+    // TODO(v5):
+    //  - Make this a (configurable) error; move to acceptTypeOrElement
+    //  - require type/elements to be set in parser
+    if (def.kind === 'event' && !def._effectiveType?.elements && !def._effectiveType?.projection)
+      message( 'def-expected-structured', [ (def.type || def.name).location, def ] );
+  }
+
   function checkAnnotationDefinition( art ) {
     // TODO: Should we check elements similar to definition-elements as well?
     checkEnumType( art );
@@ -58,14 +70,23 @@ function check( model ) {
     } );
   }
 
+  function* iterateAnnotations( art ) {
+    for (const prop in art) {
+      if (prop.charAt(0) === '@')
+        yield prop;
+    }
+  }
+
   function checkGenericConstruct( art ) {
     checkName( art );
     checkTypeArguments( art );
-    if (model.vocabularies) {
-      Object.keys( art )
-        .filter( a => a.startsWith( '@' ) )
-        .forEach( a => checkAnnotationAssignment1( art, art[a] ) );
-    }
+
+    if (art.value && !art.$calcDepElement && art.type)
+      checkTypeCast( art.value, art );
+
+    for (const anno of iterateAnnotations( art ))
+      checkAnnotationAssignment1( art, art[anno] );
+
     checkTypeStructure( art );
     checkAssociation( art ); // type def could be assoc
     if (art.kind === 'enum')
@@ -202,13 +223,40 @@ function check( model ) {
     }
   }
 
-  function requireExplicitTypeInSqlCast( art, user ) {
-    if (!art.type) {
-      error( 'expr-missing-type', [ art.location, user ], { },
+  /**
+   * Check the type in an SQL cast expression.
+   *
+   * @param xpr
+   * @param {XSN.Artifact} user
+   */
+  function requireExplicitTypeInSqlCast( xpr, user ) {
+    if (!xpr.type) {
+      error( 'expr-missing-type', [ xpr.location, user ], { },
              'Missing type in SQL cast function' );
     }
   }
 
+  function checkTypeCast( xpr, user ) {
+    const isCast = (xpr.op?.val === 'cast');
+    const elem = isCast
+      ? 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' } );
+      else if (elem.elements) // TODO: calc elements
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'from-structure' } );
+      else if (elem.target && !type._artifact?.target)
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'from-assoc' } );
+      else if (!elem.target && type._artifact?.target && !user.type?.$inferred)
+        // $inferred already reported in resolve.js
+        error( 'type-invalid-cast', [ type.location, user ], { '#': 'assoc' } );
+    }
+  }
+
   function checkLocalizedElement( elem ) {
     if (elem.localized?.val) {
       const type = elem._effectiveType;
@@ -224,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' );
       }
@@ -340,11 +390,8 @@ function check( model ) {
         .find( name => !enumNode.enum[name].value );
       if (emptyValue) {
         const failedEnum = enumNode.enum[emptyValue];
-        warning( 'type-missing-value', [ failedEnum.location, failedEnum ], {
+        message( 'type-missing-enum-value', [ failedEnum.location, failedEnum ], {
           '#': isNumeric ? 'numeric' : 'std', name: emptyValue,
-        }, {
-          std: 'Missing value for non-string enum element $(NAME)',
-          numeric: 'Missing value for numeric enum element $(NAME)',
         } );
       }
     }
@@ -551,15 +598,26 @@ function check( model ) {
       if (xorElements) {
         // one of the two elements is not structured
         const prop = !elem.elements ? 'new-not-structured' : 'old-not-structured';
-        const name = elem.name.id;
         // Position at type/struct, not name
         const loc = elem.type?.location || elem.elements?.[$location] || elem.location;
         error( 'ref-invalid-override', [ loc, elem ],
-               { '#': prop, art: original._main, name } );
+               { '#': prop, art: original._main, name: elem.name.id } );
         return false;
       }
       else if (original.elements &&
-               !checkSubStructureOverride( elem, elem.elements, original.elements )) {
+        !checkSubStructureOverride( elem, elem.elements, original.elements )) {
+        return false;
+      }
+
+      const xorTarget = !(elem.target || elem.targetAspect) !==
+        !(original.target || original.targetAspect);
+      if (xorTarget) {
+        // one of the two elements is not an association
+        const prop = !elem.target ? 'new-not-target' : 'old-not-target';
+        // Position at type/assoc, not name
+        const loc = elem.target?.location || elem.type?.location || elem.location;
+        error( 'ref-invalid-override', [ loc, elem ],
+               { '#': prop, art: original._main, name: elem.name.id } );
         return false;
       }
       return true;
@@ -599,6 +657,7 @@ function check( model ) {
     checkExpressionAssociationUsage( xpr, user, false );
     if (xpr.op?.val === 'cast') {
       requireExplicitTypeInSqlCast( xpr, user );
+      checkTypeCast( xpr, user );
       checkTypeArguments( xpr, user );
     }
   }
@@ -631,6 +690,7 @@ function check( model ) {
     // the cast, as otherwise we will check it twice (once here, once via element).
     if (elem.value?.op?.val === 'cast' && elem.type?.$inferred !== 'cast') {
       requireExplicitTypeInSqlCast( elem.value, elem );
+      checkTypeCast( elem.value, elem );
       checkTypeArguments( elem.value, elem );
     }
     visitSubExpression( elem.value, elem, (xpr) => {
@@ -810,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

@@ -140,7 +140,8 @@ const {
   targetCantBeAspect,
 } = require('./utils');
 const { compareLayer } = require('./moduleLayers');
-const { initBuiltins, isInReservedNamespace } = require('./builtins');
+const { initBuiltins } = require('./builtins');
+const { isInReservedNamespace } = require('../base/builtins');
 
 const $location = Symbol.for( 'cds.$location' );
 const $inferred = Symbol.for( 'cds.$inferred' );
@@ -212,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: ----------------------------------------------------------------
@@ -227,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;
     }
@@ -522,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]) {
@@ -561,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
 
@@ -635,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 );
@@ -678,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
     }
@@ -747,7 +762,6 @@ function define( model ) {
         // We don't worry about duplicate names here.
         const id = `$_select_${ query._main.$queries.length + 1 }__`;
         table.name = { id, location: table.location, $inferred: '$internal' };
-        table.$inferred = '$internal';
       }
       addAsAlias();
       // Store _origin to leading query of table.query for name resolution
@@ -796,7 +810,7 @@ function define( model ) {
       setMemberParent( table, table.name.id, query );
       setLink( table, '_block', query._block );
       dictAdd( query.$tableAliases, table.name.id, table, ( name, loc, tableAlias ) => {
-        if (tableAlias.$inferred === '$internal') {
+        if (tableAlias.name.$inferred === '$internal') {
           const semanticLoc = tableAlias.query?.name ? tableAlias.query : tableAlias;
           // TODO: the semanticLoc query is not initialized yet, and thus cannot
           // be used here
@@ -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› }' } );
           }
         }
@@ -1151,7 +1166,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
 
@@ -1177,27 +1192,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 );
     }
   }