@sap/cds-compiler 4.0.2 → 4.2.2

package/lib/json/from-csn.js

@@ -72,8 +72,9 @@
  *     What "kind" values are possible in a definition. The root "definitions" properties allows
  *     more kinds than e.g. definitions inside "elements".
  *
- * @property {string|string[]}  [onlyWith]
- *     Defines that the property *must* be used with these properties.
+ * @property {string|string[]|Object}  [onlyWith]
+ *     Defines that the property *must* be used with one of these properties.
+ *     If an object, it maps the kind value to a string or array of strings.
  *
  * @property {number}           [minLength]
  *     Minimum number of elements that an array must have.
@@ -84,6 +85,7 @@
  * @property {string[]}         [xorGroups]
  *     Corresponding xor groups. It references a value of xorGroups. If set then only one property
  *     of the xorGroup may be set, e.g. if target is set, elements may not.
+ *     If you are looking for a `notWith` (which should be symmetric), this is your property.
  *
  * @property {string}               [xsnOp]
  *     Defines the operator to be used for XSN. Used for SET and SELECT. See queryTerm().
@@ -117,6 +119,7 @@
 const { dictAdd } = require('../base/dictionaries');
 const { quotedLiteralPatterns } = require('../compiler/builtins');
 const { CompilerAssertion } = require('../base/error');
+const { XsnSource, CsnLocation } = require('../compiler/classes');
 
 const $location = Symbol.for('cds.$location');
 
@@ -144,20 +147,22 @@ const exprProperties = [
 // Groups of properties which cannot be used together:
 const xorGroups = {
   // include CSN v0.1.0 properties here:
-  ':type': [ 'target', 'elements', 'enum', 'items' ],
+  ':type': [
+    'target', 'targetAspect', 'elements', 'items', // xorException: target+targetAspect
+    'length', 'precision', 'scale', 'srid', // xorException: precision+scale
+  ],
+  ':enum': [ 'target', 'targetAspect', 'elements', 'enum', 'items' ],
   ':expr': [                    // see also xorException property in schema
     'ref', 'xpr', 'list', 'val', '#', 'func', 'SELECT', 'SET', 'expand',
     '=', 'path', 'value', 'op', // '='/'path' is CSN v0.1.0 here
   ],
   ':col': [ 'expand', 'inline' ],
   ':ext': [ 'annotate', 'extend' ], // TODO: better msg for test/negative/UnexpectedProperties.csn
-  ':assoc': [ 'on', 'keys', 'foreignKeys', 'onCond' ], // 'foreignKeys'/'onCond' is CSN v0.1.0
-
-  // TODO: Maybe use a field "notWith", similar to "onlyWith" on `elements`/`items`?
-  ':length': [ 'elements', 'items', 'length' ],
-  ':srid': [ 'elements', 'items', 'srid' ],
-  ':precision': [ 'elements', 'items', 'precision' ],
-  ':scale': [ 'elements', 'items', 'scale' ],
+  ':assoc': [
+    'on', 'keys',
+    'foreignKeys', 'onCond', // 'foreignKeys'/'onCond' is CSN v0.1.0
+  ],
+  ':on': [ 'on', 'default' ],
 
   // TODO - improve consequential errors: assume no name given with `join` or `inline`?
   as: [ 'as', 'join', 'inline' ],
@@ -251,12 +256,14 @@ const schema = compileSchema( {
     requires: [ 'extend', 'annotate' ],
   },
   enum: {
+    type: enumDict,
     dictionaryOf: definition,
     defaultKind: 'enum',
     validKinds: [ 'enum' ],
     inKind: [ 'element', 'type', 'param', 'annotation', 'annotate', 'extend' ],
   },
   elements: {
+    type: elementsDict,
     dictionaryOf: definition,
     defaultKind: 'element',
     validKinds: [ 'element' ],
@@ -272,17 +279,11 @@ const schema = compileSchema( {
       'extend',
     ],
   },
-  payload: {                    // keep it for a while, TODO: remove with v2 - at least warning
-    dictionaryOf: definition,   // duplicate of line below only for better error message
-    type: renameTo( 'elements', dictionaryOf( definition ) ),
-    defaultKind: 'element',
-    validKinds: [],
-    inKind: [ 'event' ],
-  },
   actions: {
     dictionaryOf: actions,
     defaultKind: 'action',
     validKinds: [ 'action', 'function' ],
+    onlyWith: { aspect: 'elements' },
     inKind: [ 'entity', 'aspect', 'annotate', 'extend' ],
   },
   params: {
@@ -364,6 +365,7 @@ const schema = compileSchema( {
   },
   targetAspect: {
     type: artifactRef,
+    xorException: 'target',     // see xorGroup :type
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
     requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc aspect compositions
@@ -371,6 +373,7 @@ const schema = compileSchema( {
   },
   target: {
     type: artifactRef,
+    xorException: 'targetAspect', // see xorGroup :type
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
     requires: 'elements',
     optional: [ 'elements' ], // 'elements' for ad-hoc COMPOSITION OF (gensrc style CSN)
@@ -398,10 +401,12 @@ const schema = compileSchema( {
   },
   precision: {
     type: natnum,
+    xorException: 'scale',      // see xorGroup :type
     inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
   },
   scale: {
     type: scalenum,
+    xorException: 'precision',  // see xorGroup :type
     inKind: [ 'element', 'type', 'param', 'annotation', 'extend' ],
   },
   srid: {
@@ -655,7 +660,7 @@ const schema = compileSchema( {
       '-expr': { // '-expr' and '-' must not exist top-level
         prop: '@‹anno›',
         type: object,
-        optional: [ '=', '#', 'xpr', 'ref', 'val', 'list', 'literal', 'func', 'args' ],
+        optional: [ '=', '#', 'xpr', 'ref', 'val', 'list', 'literal', 'func', 'args', 'param' ],
         schema: {
           '=': {
             type: renameTo( '$tokenTexts', string ),
@@ -990,15 +995,12 @@ function definition( def, spec, xsn, csn, name ) {
   const kind0 = (spec.validKinds.length || spec.prop === 'extensions') && kind;
   const csnProps = Object.keys( def );
 
-  // If we have `extend … with { name = 3 }`, it could mean adding an element or an enum.
-  // We use `elements: { name: { val: 3 } }` to represent this ambiguity.
-  if (savedInExtensions === '' && prop === 'elements' &&
-      (def.val !== undefined || def['#'] !== undefined ||
-       def.value?.val !== undefined || def.value?.['#'] !== undefined) &&
-      def.virtual === undefined && def.key === undefined && def.masked === undefined &&
-      def.type === undefined && def.elements === undefined) {
-    r.$syntax = 'enum';
-    kind = 'enum';              // for function expected()
+  // For compatibility, extension property `elements` could actually be an `enum`:
+  if (savedInExtensions === '' && prop === 'elements' && // in extend property `elements`
+      !Object.keys( def ).some( couldNotBeEnumProperty )) {
+    r.$syntax = 'enum';         // could be an enum
+    if (def.val !== undefined || def['#'] !== undefined)
+      kind = 'enum';            // for function expected(), i.e. allow property `val`/`#`
   }
 
   if (csnProps.length) {
@@ -1018,15 +1020,6 @@ function definition( def, spec, xsn, csn, name ) {
     r.name = { id: name, location: r.location };
     if (prop === 'columns' || prop === 'keys' || prop === 'foreignKeys')
       r.name.$inferred = 'as';
-    // TODO the following 'if' (if necessary) should be part of the core compiler
-    if (prop === 'definitions' || prop === 'vocabularies') { // as spec property
-      r.name = {
-        absolute: name,
-        id: name.substring( name.lastIndexOf('.') + 1 ),
-        path: [ { id: name, location: r.location } ],
-        location: r.location,
-      };
-    }
   }
   if (spec.requires)
     onlyWith( spec, spec.requires, def, null, xor, () => true );
@@ -1049,11 +1042,18 @@ function definition( def, spec, xsn, csn, name ) {
       // for an 'annotate', both 'annotate' and the "host" kind must be expected
       (!inExtensions || s.inKind.includes( inExtensions ) ||
        // extending elements in returns can be without 'returns' in CSN
-       // TODO: with warning/info?
+       // see function elementsDict() for detail, TODO: remove finally
        inExtensions === 'action' && p === 'elements');
   }
 }
 
+function couldNotBeEnumProperty( prop ) {
+  // returns true for `value` (which we allow with warning when extending an enum with `elements`)
+  const inKind = schema[prop]?.inKind; // undefined for annotations, $location, …
+  // inKind for annotation assignments is function -> can be for enum
+  return Array.isArray( inKind ) && inKind.includes( 'element' );
+}
+
 function actions( def, spec, xsn, csn, name ) {
   if (def.kind === 'extend' && (def.elements || def.enum)) {
     // TODO: Handle this case in extend.js; already done for `returns`
@@ -1125,6 +1125,27 @@ function returnsDefinition( def, spec, xsn, csn ) {
   return definition( def, spec, xsn, csn, '' );
 }
 
+// Temporary function as long as the message below is not a hard error
+function elementsDict( def, spec, xsn ) {
+  const elements = dictionaryOf( definition )( def, spec );
+  if (inExtensions !== 'action')
+    return elements;
+  warning( 'syntax-expecting-returns', elements[$location],
+           { prop: 'elements', parentprop: 'returns' },
+           // eslint-disable-next-line max-len
+           'Expecting property $(PROP) to be put into an object for property $(PARENTPROP) when annotating action return structures' );
+  xsn.returns = { kind: 'annotate', elements, location: elements[$location] };
+  return undefined;
+}
+
+function enumDict( def, spec, xsn ) {
+  const dict = dictionaryOf( definition )( def, spec );
+  if (!inExtensions)
+    return dict;
+  xsn.elements = dict;          // normalize to `elements` for `annotate`
+  return undefined;
+}
+
 // For v1 CSNs with annotation definitions
 function attachVocabInDefinitions( csn ) {
   if (!csn.vocabularies) {
@@ -1472,7 +1493,7 @@ function annoValue( val, spec ) {
 function annotation( val, spec, xsn, csn, name ) {
   const absolute = (xsn ? name.substring(1) : name);
   // TODO: really care about variant (qualifier parts)?
-  const variantIndex = absolute.indexOf('#') + 1 || absolute.length;
+  const variantIndex = absolute.indexOf('#') + 1 || absolute.length; // including '#'
   const n = refSplit( absolute.substring( 0, variantIndex ), !xsn && '{}' );
   if (!n)
     return undefined;
@@ -1831,6 +1852,11 @@ function calculateKind( def, spec ) {
 function onlyWith( spec, need, csn, prop, xor, expected ) {
   if (!need)
     return spec;
+  if (typeof need === 'object' && !Array.isArray( need )) {
+    need = need[csn.kind];
+    if (!need)
+      return spec;
+  }
   if (typeof need === 'string') {
     if (need in csn)            // TODO: enumerable ?
       return spec;
@@ -1941,7 +1967,8 @@ function replaceZeroValue( spec, msgVariant, newValue ) {
  */
 function location( enforceJsonPos ) {
   return !enforceJsonPos && dollarLocations.length &&
-         dollarLocations[dollarLocations.length - 1] || {
+    dollarLocations[dollarLocations.length - 1] || {
+    __proto__: CsnLocation.prototype,
     file: csnFilename,
     line: virtualLine,
     col: 0,
@@ -1954,7 +1981,7 @@ function pushLocation( obj ) {
   if (loc === undefined)
     return;
   if (loc && typeof loc === 'object' && !Array.isArray( loc )) {
-    dollarLocations.push( loc.line ? loc : null );
+    dollarLocations.push( loc.line ? { __proto__: CsnLocation.prototype, ...loc } : null );
     return;
   }
   else if (!loc || typeof loc !== 'string') {
@@ -1970,10 +1997,9 @@ function pushLocation( obj ) {
   else {
     const line = Number( m[1] );
     const column = m[2] && Number( m[2] ) || 0;
-    dollarLocations.push( {
-      file: loc.substring( 0, m.index ),
-      line,
-      col: column,
+    const file = loc.substring( 0, m.index );
+    dollarLocations.push({
+      __proto__: CsnLocation.prototype, file, line, col: column,
     } );
   }
 }
@@ -2011,7 +2037,8 @@ function toXsn( csn, filename, options, messageFunctions ) {
   inExtensions = null;
   vocabInDefinitions = null;
 
-  const xsn = { $frontend: 'json' };
+  const xsn = new XsnSource();
+  xsn.$frontend = 'json';
 
   // eslint-disable-next-line object-curly-newline
   ({ message, error, warning, info } = messageFunctions);
@@ -2050,7 +2077,7 @@ function parse( source, filename = 'csn.json', options = {}, messageFunctions =
     resetHeapModuleVars();
     if (!(e instanceof SyntaxError))
       throw e;
-    const xsn = {};
+    const xsn = new XsnSource();
     const msg = e.message;
     const p = /in JSON at position ([0-9]+)/.exec( msg );
     let line = 1;
@@ -2067,12 +2094,11 @@ function parse( source, filename = 'csn.json', options = {}, messageFunctions =
       }
       column = end - eol + 1;
     }
-    /** @type {CSN.Location} */
-    const loc = {
-      file: filename,
+    const loc = new CsnLocation(
+      filename,
       line,
-      col: column,
-    };
+      column
+    );
     messageFunctions.error( 'syntax-invalid-json', loc, { msg },
                             'Invalid JSON: $(MSG)' );
     return xsn;

package/lib/json/to-csn.js

@@ -115,7 +115,6 @@ const transformers = {
   offset: expression,
   on: onCondition,
   // definitions, extensions, members ----------------------------------------
-  returns,                      // storing the return type of actions
   notNull: value,
   default: expression,
   // targetElement: ignore,     // special display of foreign key, renameTo: select
@@ -123,6 +122,7 @@ const transformers = {
   query,
   elements,
   actions,                      // TODO: just normal dictionary
+  returns,                      // storing the return type of actions
   // special: top-level, cardinality -----------------------------------------
   sources,
   definitions: sortedDict,
@@ -335,7 +335,8 @@ function compactModel( model, options = model.options || {} ) {
     break;
   }
   set( 'definitions', csn, model );
-  set( 'vocabularies', csn, model );
+  if (Object.keys(model.vocabularies || {}).length > 0)
+    set( 'vocabularies', csn, model );
   const exts = extensions( model.extensions || [], csn, model );
   if (exts && exts.length)
     csn.extensions = exts;
@@ -464,13 +465,13 @@ function attachAnnotations( annotate, prop, dict, inferred, insideReturns = fals
         attachAnnotations( sub, 'actions', entry.actions, inf );
       else if (entry.params)
         attachAnnotations( sub, 'params', entry.params, inf );
-      const obj = entry.returns || entry; // TODO: create returns !
+      const obj = entry.returns || entry;
       const many = obj.items || obj;
       const elems = (many.targetAspect || many).elements;
       if (elems)
         attachAnnotations( sub, 'elements', elems, inf, entry.returns );
-      if (many.enum)
-        attachAnnotations( sub, 'enum', many.enum, inf );
+      else if (many.enum)       // make 'enum' annotations appear in 'elements' annotate
+        attachAnnotations( sub, 'elements', many.enum, inf, entry.returns );
     }
     if (Object.keys( sub ).length)
       annoDict[name] = sub;
@@ -493,10 +494,12 @@ function standard( node ) {
   // XSN input node, not the CSN result node.  Not really an issue...
   const keys = Object.keys( node ).sort( compareProperties );
   for (const prop of keys) {
-    const transformer = transformers[prop] || transformers[prop.charAt(0)] || unexpected;
-    const sub = transformer( node[prop], csn, node, prop );
-    if (sub !== undefined)
-      csn[prop] = sub;
+    if (node[prop] !== undefined) {
+      const transformer = transformers[prop] || transformers[prop.charAt(0)] || unexpected;
+      const sub = transformer( node[prop], csn, node, prop );
+      if (sub !== undefined)
+        csn[prop] = sub;
+    }
   }
   return csn;
 }
@@ -715,14 +718,12 @@ function actions( dict, _csn, node ) {
   const keys = Object.keys( dict );
   if (strictMode && node.kind === 'annotate')
     keys.sort();                // TODO: always sort with --test-mode ?
-  return (keys.length)
-    ? dictionary( dict, keys, 'actions' )
-    : undefined;
+  return dictionary( dict, keys, 'actions' );
 }
 
 function params( dict ) {
   const keys = Object.keys( dict );
-  return (keys.length)
+  return (keys.length)          // TODO: still?
     ? insertOrderDict( dict )
     : undefined;
 }
@@ -1212,8 +1213,7 @@ function value( node ) {
 function enumValueOrCalc( v, csn, node ) {
   if (v.$inferred && (universalCsn || gensrcFlavor))
     return undefined;
-  // Enums can have values but if enums are extended, their kind is 'element'.
-  // In v4, we don't check `node.$syntax === 'enum'` anymore.
+  // Enums values in CSN are without outer `value: { … }`:
   if (node.kind === 'enum') {
     Object.assign( csn, expression( v ) );
   }

package/lib/language/antlrParser.js

@@ -12,6 +12,7 @@ const antlr4 = require('antlr4');
 
 const { CompileMessage } = require('../base/messages');
 const errorStrategy = require('./errorStrategy');
+const { XsnSource } = require('../compiler/classes');
 
 const Parser = require('../gen/languageParser').default;
 const Lexer = require('../gen/languageLexer').default;
@@ -167,7 +168,7 @@ function parse( source, filename = '<undefined>.cds',
       throw e;
     }
   }
-  const ast = tree && tree[rulespec.returns] || {};
+  const ast = tree && tree[rulespec.returns] || new XsnSource();
   ast.options = options;
   if (rulespec.$frontend)
     ast.$frontend = rulespec.$frontend;

package/lib/language/genericAntlrParser.js

@@ -18,6 +18,9 @@ const {
   quotedLiteralPatterns,
 } = require('../compiler/builtins');
 const { pathName } = require('../compiler/utils');
+const {
+  XsnArtifact, XsnName, CsnLocation, XsnSource,
+} = require('../compiler/classes');
 const { isBetaEnabled } = require('../base/model');
 const { weakLocation } = require('../base/messages');
 const { normalizeNewLine } = require('./textUtils');
@@ -110,7 +113,6 @@ Object.assign(GenericAntlrParser.prototype, {
   addDef,
   addItem,
   addExtension,
-  aspectWithoutElements,
   createSource,
   createDict,
   createArray,
@@ -139,6 +141,8 @@ Object.assign(GenericAntlrParser.prototype, {
   prepareGenericKeywords,
   reportErrorForGenericKeyword,
   parseMultiLineStringLiteral,
+  XsnArtifact,
+  XsnName,
 });
 
 // Use the following function for language constructs which we (currently)
@@ -160,7 +164,13 @@ function csnParseOnly( msgId, tokens, textArgs ) {
   this.error( msgId, loc, textArgs );
 }
 
-/** @this {object} */
+/**
+ * Do not propose a `;` or closing brace `}` at this position.
+ *
+ * Attention: May conflict with excludeExpected()!
+ *
+ * @this {object}
+ * */
 function noSemicolonHere() {
   const handler = this._errHandler;
   const t = this.getCurrentToken();
@@ -173,10 +183,21 @@ function noSemicolonHere() {
     handler.reportIgnoredWith( this, t );
 }
 
-// Using this function "during ATN decision making" has no effect
-// In front of an ATN decision, you might specify dedicated excludes
-// for non-LA1 tokens via a sub-array in excludes[0].
-// TODO: consider $nextTokens…, see commented use in rule `elementProperties`
+/**
+ * Using this function "during ATN decision making" has no effect
+ * In front of an ATN decision, you might specify dedicated excludes
+ * for non-LA1 tokens via a sub-array in excludes[0].
+ * TODO: consider $nextTokens…, see commented use in rule `elementProperties`
+ *
+ * Usage Note:
+ *   Must be used at all positions where sync() is called in the generated coding.
+ *   ```antlr4
+ *   { this.excludeExpected(['ACTIONS']); }
+ *   ( WITH { this.excludeExpected(['ACTIONS']); } )?
+ *   annotationAssignment_ll1[ $art ]* { this.excludeExpected(['ACTIONS']); }
+ *   ACTIONS
+ *   ```
+ */
 function excludeExpected( excludes ) {
   if (excludes) {
     // @ts-ignore
@@ -414,6 +435,12 @@ function checkExtensionDict( dict ) {
           def[prop] = dup[prop]; // continuation semantics: last wins
         }
       }
+      if (dup.$annotations) {   // update deprecated $annotations for cds-lsp / annotation modeler
+        if (def.$annotations)
+          def.$annotations.push( ...dup.$annotations );
+        else
+          def.$annotations = dup.$annotations;
+      }
     }
     def.$duplicates = null;
   }
@@ -445,14 +472,14 @@ function handleDuplicateExtension( ext, name, numDefines ) {
  * Return start location of `token`, or the first token matched by the current
  * rule if `token` is undefined
  *
- * @returns {CSN.Location}
+ * @returns {CsnLocation}
  */
 function startLocation( token = this._ctx.start ) {
-  return {
-    file: this.filename,
-    line: token.line,
-    col: token.column + 1,
-  };
+  return new CsnLocation(
+    this.filename,
+    token.line,
+    token.column + 1
+  );
 }
 
 /**
@@ -461,7 +488,7 @@ function startLocation( token = this._ctx.start ) {
  *
  * @param {object} token
  * @param {object} endToken
- * @return {CSN.Location}
+ * @return {CsnLocation}
  */
 function tokenLocation( token, endToken = null ) {
   if (!token)
@@ -469,16 +496,11 @@ function tokenLocation( token, endToken = null ) {
   if (!endToken)                // including null
     endToken = token;
 
-  /** @type {CSN.Location} */
-  const loc = {
-    file: this.filename,
-    line: token.line,
-    col: token.column + 1,
-    // Default for single line tokens
-    endLine: endToken.line,
-    // after the last char (special for EOF?)
-    endCol: endToken.stop - endToken.start + endToken.column + 2,
-  };
+  // Default for single line tokens
+  const endLine = endToken.line;
+  // after the last char (special for EOF?)
+  const endCol = endToken.stop - endToken.start + endToken.column + 2;
+  const loc = new CsnLocation( this.filename, token.line, token.column + 1, endLine, endCol );
 
   // This check is done for performance reason. No need to access a token's
   // data if we know that it spans only one single line.
@@ -579,7 +601,7 @@ function secureParens( expr ) {
   return {
     op: { val: 'xpr', location: this.startLocation() },
     args: [ expr ],
-    location: { ...expr.location },
+    location: { __proto__: CsnLocation.prototype, ...expr.location },
     $parens,
   };
 }
@@ -733,7 +755,11 @@ function argsExpression( args, nary, location ) {
     val, // there is no n-ary in rule conditionTerm
     location: this.startLocation(),
   };
-  return this.attachLocation( { op, args, location: location && { ...location } } );
+  return this.attachLocation( {
+    op,
+    args,
+    location: location && { __proto__: CsnLocation.prototype, ...location },
+  } );
 }
 
 function pushXprToken( args ) {
@@ -1097,16 +1123,6 @@ function addExtension( ext, parent, kind, artName, elemPath ) {
   }
 }
 
-function aspectWithoutElements( art ) {
-  // Empty dictionary to allow element extensions. NO, please NO empty dict.
-  // TODO: Checking it here does not prevent aspect in CSN input having no elements!
-  art.elements = this.createDict();
-  if (!isBetaEnabled( this.options, 'aspectWithoutElements' )) {
-    this.error( null, [ art.name.location, null ], {},
-                'Aspects without elements are not supported, yet' );
-  }
-}
-
 // must be in action directly after having parsed '{', '(`, or a keyword before
 function createDict() {
   const dict = Object.create(null);
@@ -1132,14 +1148,7 @@ function finalizeDictOrArray( dict ) {
 }
 
 function createSource() {
-  return {
-    kind: 'source',
-    usings: [],
-    dependencies: [],
-    artifacts: Object.create(null),
-    // vocabularies: Object.create(null),
-    extensions: [],
-  };
+  return new XsnSource();
 }
 
 // Create AST node for prefix operator `op` and arguments `args`