@sap/cds-compiler 3.7.2 → 3.8.0

package/lib/inspect/inspectPropagation.js

@@ -4,7 +4,13 @@ const { createMessageFunctions } = require('../base/messages');
 const { locationString } = require('../base/location');
 const { findArtifact, stringRefToPath } = require('./inspectUtils');
 const { term } = require('../utils/term');
-const { CompilerAssertion } = require('../base/error');
+
+const inferredNiceOutput = {
+  '*': 'wildcard',
+  'aspect-composition': 'composition',
+  prop: 'propagation',
+  $generated: 'generated',
+};
 
 /**
  * @param {XSN.Model} xsn
@@ -77,29 +83,16 @@ function _inspectAnnotations( artifactXsn ) {
   for (const anno of annos) {
     const annoXsn = artifactXsn[anno];
     const loc = locationString(annoXsn.name.location);
+
     let origin;
-    switch (annoXsn.$priority) {
-      case false:
-        if (annoXsn.$inferred)
-          origin = 'propagation';
-        else
-          origin = 'direct';
-        break;
-
-      case 'extend':
-      case 'annotate':
-        origin = annoXsn.$priority;
-        break;
-
-      case undefined:
-        if (annoXsn.$inferred === '$generated') {
-          origin = 'generated';
-          break;
-        }
-        // fallthrough
-      default:
-        throw new CompilerAssertion(`inspect anno: Unhandled Case: ${ annoXsn.$priority }`);
-    }
+    if (annoXsn.$inferred === '$generated')
+      origin = 'generated';
+    else if (annoXsn.$inferred)
+      origin = inferredNiceOutput[annoXsn.$inferred] || annoXsn.$inferred;
+    else if (isContainedInParentLocation(annoXsn.name, artifactXsn))
+      origin = 'direct';
+    else
+      origin = 'annotate';      // ...or `extend`
 
     maxAnnoLength = Math.max(maxAnnoLength, anno.length);
 
@@ -122,11 +115,6 @@ function _inspectElements( artifactXsn ) {
   const result = [];
   const elements = Object.keys(artifactXsn.elements);
 
-  const inferredNiceOutput = {
-    '*': 'wildcard',
-    'aspect-composition': 'composition',
-  };
-
   let maxElemLength = 12;
   let maxOriginLength = 6;
 
@@ -153,7 +141,7 @@ function _inspectElements( artifactXsn ) {
         origin = elementXsn.$inferred;
     }
     else if (!isContainedInParentLocation(elementXsn, artifactXsn)) {
-      // just a heuristic
+      // just a heuristic - a good enough one
       origin = 'extend';
     }
     else {
@@ -192,13 +180,9 @@ function isContainedInParentLocation( art, parent ) {
   const parentLoc = parent.location;
   if (artLoc.file !== parentLoc.file)
     return false;
-  // Warning is correct, but we have a "TODO" below.
-  // eslint-disable-next-line sonarjs/prefer-single-boolean-return
-  if (artLoc.line < parentLoc.line || artLoc.line > parentLoc.endLine)
-    return false;
-  // Good enough for now
-  // TODO: Check columns
-  return true;
+  const startDiff = artLoc.line - parentLoc.line || artLoc.col - parentLoc.col;
+  const endDiff = artLoc.endLine - parentLoc.endLine || artLoc.endCol - parentLoc.endCol;
+  return startDiff >= 0 && endDiff <= 0;
 }
 
 module.exports = {

package/lib/json/from-csn.js

@@ -75,6 +75,8 @@
  *                                          it.
  * @property {string}        [xorException] A property name that is allowed besides another property
  *                                          of an xorGroup (as an exception to the rule).
+ * @property {boolean}        [ignoreExtra] Whether extra properties are ignored and not put
+ *                                          into $extra.
  */
 
 /**
@@ -303,10 +305,20 @@ const schema = compileSchema( {
   },
   // type properties (except: elements, enum, keys, on): ---------------------
   type: {
-    type: artifactRef,
+    type: typeArtifactRef,
     msgVariant: 'or-object',    // for 'syntax-expecting-string',
     optional: [ 'ref', 'global' ],
     inKind: [ 'element', 'type', 'param', 'mixin', 'event', 'annotation', 'extend' ],
+    schema: {
+      ref: {
+        arrayOf: typeRefItem,
+        type: renameTo( 'path', typeRef ),
+        minLength: 1,
+        requires: 'id',
+        optional: [ 'id' ],
+        ignoreExtra: true, // custom properties inside `ref` ignored.
+      },
+    },
   },
   targetAspect: {
     type: artifactRef,
@@ -429,6 +441,7 @@ const schema = compileSchema( {
   list: {
     class: 'condition',
     type: list,
+    inKind: [ '$column' ],
   },
   val: {
     type: value,
@@ -604,7 +617,7 @@ const schema = compileSchema( {
         optional: [ '=', '#', 'xpr', 'ref', 'val', 'list', 'literal', 'func', 'args' ],
         schema: {
           '=': {
-            type: ignore,
+            type: renameTo( '$tokenTexts', string ),
             xorGroups: null, // reset xorGroup; allow '=' for all :expr
           },
         },
@@ -625,7 +638,7 @@ const schema = compileSchema( {
   },
   notNull: {
     type: boolOrNull,
-    inKind: [ 'element', 'param' ], // TODO: $column  - or if so: in 'cast'?
+    inKind: [ 'element', 'param', 'type' ], // TODO: $column  - or if so: in 'cast'?
   },
   virtual: {
     type: boolOrNull,
@@ -1133,6 +1146,14 @@ function validKind( val, spec, xsn ) {
   return ignore( val );
 }
 
+function typeArtifactRef( ref, spec ) {
+  if (ref && typeof ref === 'object' && !Array.isArray( ref )) {
+    if (ref.ref?.length === 1)
+      return artifactRef( ref, { ...spec, ignoreExtra: true } );
+  }
+  return artifactRef( ref, spec );
+}
+
 // Use with spec.msgVariant: 'or-object'
 function artifactRef( ref, spec ) {
   if (!ref || typeof ref !== 'string') {
@@ -1253,6 +1274,32 @@ function symbol( id, spec, xsn ) { // for CSN property '#'
   xsn.sym = { id, location: location() };
 }
 
+/**
+ * Wrapper around the default `ref` spec: Don't allow references of length 1 for types.
+ */
+function typeRef( val, spec, xsn, csn ) {
+  // e.g. { ref: [ 'T' ] }
+  if (Array.isArray(val) && val.length <= 1)
+    warning( 'syntax-deprecated-type-ref', location(true), { '#': 'std', prop: 'type' });
+
+  return arrayOf(spec.arrayOf)(val, spec, xsn, csn);
+}
+
+/**
+ * Similar to refItem(), but warns that the item should be a string if `id` is the only CSN
+ * property inside the ref-item.
+ */
+function typeRefItem( val, spec, xsn, csn ) {
+  // e.g. [ 'T', { id: 'elem', other_prop: true } ]
+  // avoid duplicate messages for single-item reference, see typeRef()
+  if (val && csn.ref?.length > 1 && typeof val === 'object' && val.id) {
+    const ownKeysCount = Object.keys(val).filter(key => ourpropsRegex.test(key)).length;
+    if (ownKeysCount === 1)
+      warning('syntax-deprecated-type-ref', location(true), { '#': 'ref-item', prop: 'ref[]' });
+  }
+  return refItem(val, spec);
+}
+
 /**
  * returns:
  *  - false = no "...",
@@ -1311,7 +1358,7 @@ function annoValue( val, spec ) {
     if (valKeys.length > 1 && isBetaEnabled(userOptions, 'annotationExpressions')) {
       const s = schema['@'].schema['-expr'];
       const r = { location: location() };
-      r.value = object(val, s);
+      Object.assign(r, object(val, s));
       return r;
     }
     else if (valKeys.length === 1) {
@@ -1643,8 +1690,11 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
   const p0 = schema[prop] ? prop : prop.charAt(0);
   const s = (parentSpec.schema || schema)[p0];
   if (!s || s.noPrefix === (prop !== p0) ) {
-    if (prop && !ourpropsRegex.test( prop ))
+    if (prop && !ourpropsRegex.test( prop )) {
+      if (parentSpec.ignoreExtra)
+        return { prop, type: ignore };
       return { prop, type: extra };
+    }
     // TODO v4: No warning with --sloppy
     warning( 'syntax-unknown-property', location(true), { prop },
              'Unknown CSN property $(PROP)' );

package/lib/json/to-csn.js

@@ -400,109 +400,19 @@ function extensions( node, csn, model ) {
   if (model.kind && model.kind !== 'source')
     return undefined;
   const exts = node.map( definition );
-
-  // builtins are non-enumerable for smaller display
-  for (const name of Object.getOwnPropertyNames( model.definitions || {} ).sort()) {
-    const art = model.definitions[name];
-
-    // For namespaces and builtins: Extract annotations since they cannot be represented
-    // in CSN.  For all other artifacts, check whether they may be auto-exposed,
-    // $inferred, etc. and extract their annotations.
-    // In parseCdl mode extensions were already put into "extensions".
-    if (!model.options.parseCdl && (art.kind === 'namespace' || art.builtin)) {
-      extractAnnotationsToExtension( art );
-    }
-    else if (gensrcFlavor) {
+  if (gensrcFlavor) {
+    for (const name of Object.getOwnPropertyNames( model.definitions || {} ).sort()) {
+      const art = model.definitions[name];
       // From definitions (without redefinitions) with potential inferred elements:
       const result = { annotate: Object.create(null) };
-      attachAnnotations(result, 'annotate', { [name]: art }, art.$inferred );
+      attachAnnotations( result, 'annotate', { [name]: art }, art.$inferred );
       if (result.annotate[name])
-        exts.push({ annotate: name, ...result.annotate[name] } );
+        exts.push( { annotate: name, ...result.annotate[name] } );
     }
   }
-
-  return exts.sort(
+  return exts.sort(             // TODO: really sort with parse.cdl?
     (a, b) => (a.annotate || a.extend).localeCompare( b.annotate || b.extend )
   );
-
-  /*
-  function attachElementAnnos( annotate, art ) {
-    while (art.items)
-      art = art.items;
-    if (art.elements) {
-      const elems = inferred( art.elements, art.$inferred );
-      if (Object.keys( elems ).length)
-        annotate.elements = elems;
-    }
-  }
-
-  function attachParamAnnos( annotate, art ) {
-    const inferredParent = art.$inferred;
-    if (art.params) {
-      const ext = Object.create( dictionaryPrototype );
-      for (const name in art.params) {
-        const par = art.params[name];
-        if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
-          continue;
-        const render = annotationsAndDocComment( par );
-        const subElems = par.$expand !== 'origin' && (par.items || par).elements;
-        if (subElems) {
-          const sub = inferred( subElems, par.$inferred );
-          if (Object.keys( sub ).length)
-            render.elements = sub;
-        }
-        if (Object.keys(render).length)
-          ext[name] = render;
-      }
-      if (obj.keys( ext ))
-        annotate.params = ext;
-    }
-    if (art.returns) {
-      const par = art.returns;
-      if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
-        return;
-      const render = annotationsAndDocComment( par );
-      const subElems = par.$expand !== 'origin' && (par.items || par).elements;
-      if (subElems) {
-        const sub = inferred( subElems, par.$inferred );
-        if (Object.keys( sub ).length)
-          render.elements = sub;
-      }
-      if (Object.keys(render).length)
-        const sub = inferred( subElems, par.$inferred );
-      if (Object.keys( sub ).length)
-        render.elements = sub;
-    }
-  }
-  return ext;
-  */
-
-  // extract namespace/builtin annotations
-  function extractAnnotationsToExtension( art ) {
-    const name = art.name.absolute;
-    // 'true' because annotations on namespaces and builtins can only
-    // happen through extensions.
-    const annos = annotationsAndDocComment( art );
-    const annotate = Object.assign( { annotate: name }, annos );
-    if (Object.keys( annotate ).length > 1) {
-      const loc = locationForAnnotationExtension();
-      if (loc)
-        location( loc, annotate, art );
-      exts.push( annotate );
-    }
-
-    // Either the artifact's name's location or (for builtin types) the location
-    // of its first annotation.
-    function locationForAnnotationExtension() {
-      if (art.location)
-        return art.location;
-      for (const key in art) {
-        if (key.charAt(0) === '@' && art[key].name)
-          return art[key].name.location;
-      }
-      return null;
-    }
-  }
 }
 
 /**
@@ -540,7 +450,10 @@ function sources( srcDict, csn ) {
 
 function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
   const annoDict = Object.create( dictionaryPrototype );
-  for (const name in dict) {
+  const names = Object.keys( dict );
+  if (strictMode)
+    names.sort();
+  for (const name of names) {
     const entry = dict[name];
     const inf = inferred || entry.$inferred; // is probably always inferred if parent was
     const sub = (inf) ? annotationsAndDocComment( entry ) : {};
@@ -549,7 +462,7 @@ 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;
+      const obj = entry.returns || entry; // TODO: create returns !
       const many = obj.items || obj;
       const elems = (many.targetAspect || many).elements;
       if (elems)
@@ -649,9 +562,11 @@ function elements( dict, csn, node ) {
     // no 'elements' with SELECT or inferred elements with gensrc;
     // hidden or visible 'elements' will be set in query()
     return undefined;
-  if (dict !== 0)
-    return insertOrderDict( dict );
-  return undefined;
+  // TODO(!): inside `annotate`, use sorted with --test-mode
+  if (dict === 0)
+    return undefined;
+  // In "super annotate" statements, use sorted dictionary
+  return (node.$inferred === '') ? sortedDict( dict ) : insertOrderDict( dict );
 }
 
 function enumDict( dict, csn, node ) {
@@ -766,7 +681,7 @@ function location( loc, csn, xsn ) {
  * @param {object} csn
  */
 function addLocation( loc, csn ) {
-  if (loc) {
+  if (loc?.file) {
     // Remove endLine/endCol:
     // Reasoning: $location is mostly attached to definitions/members but the name
     // is often not the reason for an error or warning.  So we gain little benefit for
@@ -791,8 +706,10 @@ function sortedDict( dict ) {
   return dictionary( dict, keys );
 }
 
-function actions( dict ) {
+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;
@@ -900,6 +817,25 @@ function includesOrigin( includes, art ) {
   return (Object.keys( result ).length === 1) ? $origin : result;
 }
 
+/**
+ * Calculated elements via `includes` can inherit annotations from sibling elements.
+ * These annotations need to be put into `$origin`, because `$origin` points to
+ * the calculated element, not the simple ref's artifact.
+ */
+function calculatedElementOrigin( csn, xsn, origin ) {
+  const $origin = originRef( origin );
+  const result = { $origin };
+  for (const prop in xsn) {
+    if ((prop.charAt(0) === '@' || prop === 'doc') && !origin[prop] && xsn[prop].$inferred) {
+      const annoVal = xsn[prop];
+      if (annoVal.val !== null)
+        // materialize non-null annos (whether direct or inherited)
+        result[prop] = value( Object.create( annoVal, { $inferred: { value: null } } ) );
+    }
+  }
+  return (Object.keys( result ).length === 1) ? undefined : result;
+}
+
 function addOrigin( csn, xsn, node ) {
   if (!universalCsn)
     return;
@@ -945,7 +881,7 @@ function addOrigin( csn, xsn, node ) {
   }
   // from here on: member:
   // TODO: write a xsnNode._csnOrigin, which is useful to decide whether to write
-  // $origins for its members
+  //       $origins for its members
   const parent = getParent( xsn );
   const parentOrigin = getOrigin( parent );
   // console.log( 'X:',xsn, origin, parent, parentOrigin, getParent( origin ) );
@@ -960,8 +896,16 @@ function addOrigin( csn, xsn, node ) {
       parentOrigin === getParent( origin )) {
     // implicit prototype or shortened reference
     const { id } = origin.name || {};
-    if (id && xsn.name && id !== xsn.name.id)
+
+    if (id && xsn.name && id !== xsn.name.id) {
       csn.$origin = id;
+    }
+    else if (xsn._calcOrigin) {
+      const calcOrigin = calculatedElementOrigin( csn, xsn, origin );
+      if (calcOrigin)
+        csn.$origin = calcOrigin;
+    }
+
     return;
   }
   if (origin.kind === 'mixin') {
@@ -1076,7 +1020,7 @@ function hasExplicitProp( ref, alsoLikeExplicit ) {
 
 /**
  * @param art
- * @param user
+ * @param [user]
  * @return {boolean|string[]}
  */
 function originRef( art, user ) {
@@ -1255,9 +1199,8 @@ function args( node ) {
 }
 
 function anno( node ) {
-  if (node.value) // expressions in annotation values
-    // TODO: actual string representation and not placeholder "42"
-    return Object.assign({ '=': '42' }, expression( node.value ));
+  if (node.$tokenTexts) // expressions in annotation values
+    return Object.assign({ '=': node.$tokenTexts }, expression( node ));
   return value(node);
 }
 
@@ -1274,6 +1217,8 @@ function value( node ) {
   }
   if (node.$inferred && gensrcFlavor)
     return undefined;
+  if (node.$tokenTexts)
+    return Object.assign({ '=': node.$tokenTexts }, expression( node ));
   if (node.path) {
     const ref = pathName( node.path );
     return extra( { '=': node.variant ? `${ ref }#${ pathName(node.variant.path) }` : ref }, node );
@@ -1374,6 +1319,8 @@ function exprInternal( node, xprParens ) {
     case 'ixpr':
     case 'xpr':
       break;
+    case '?:':
+      return ternaryOperator( node );
     case 'cast':
       return cast( expression( node.args[0] ), node );
     case 'list':
@@ -1410,6 +1357,20 @@ function flattenInternalXpr( array, op ) {
   return left;
 }
 
+function ternaryOperator( node ) {
+  const rargs = [
+    'case',
+    'when', exprInternal(node.args[0]),
+    'then', exprInternal(node.args[2]),
+    'else', exprInternal(node.args[4]),
+    'end',
+  ];
+
+  if (node.$parens?.length)
+    return { xpr: flattenInternalXpr( rargs, 'xpr' ) };
+  return flattenInternalXpr( rargs, 'xpr' );
+}
+
 function query( node, csn, xsn, _prop, expectedParens = 0 ) {
   if (node.op.val === 'SELECT') {
     if (xsn && xsn.query === node && xsn.$syntax === 'projection' &&
@@ -1579,7 +1540,7 @@ function setHidden( obj, prop, val ) {
 }
 
 function addExplicitAs( node, name, implicit ) {
-  if (name && name.id &&
+  if (name?.id && name.$inferred !== '$internal' &&
       (!name.$inferred || !node.ref && !node.func || implicit && implicit(name.id) ))
     node.as = name.id;
   return node;

package/lib/language/errorStrategy.js

@@ -407,6 +407,7 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
   return names;
 }
 
+// Used for sorting in messages
 const token1sort = {
   // 0: Identifier, Number, ...
   // 1: separators:

package/lib/language/genericAntlrParser.js

@@ -20,6 +20,7 @@ const {
 const { pathName } = require('../compiler/utils');
 const { isBetaEnabled } = require('../base/model');
 const { weakLocation } = require('../base/messages');
+const { normalizeNewLine } = require('./textUtils');
 
 const $location = Symbol.for('cds.$location');
 
@@ -78,6 +79,7 @@ Object.assign(GenericAntlrParser.prototype, {
   attachLocation,
   assignAnnotation,
   addAnnotation,
+  expressionAsAnnotationValue,
   checkExtensionDict,
   handleDuplicateExtension,
   startLocation,
@@ -88,6 +90,7 @@ Object.assign(GenericAntlrParser.prototype, {
   previousTokenAtLocation,
   combinedLocation,
   surroundByParens,
+  tokensToStringRepresentation,
   secureParens,
   unaryOpForParens,
   leftAssocBinaryOp,
@@ -526,18 +529,24 @@ function fixMultiLineTokenEndLocation( token, location ) {
 }
 
 /**
- * Return `val` with the location of `token`.  If `endToken` is provided, use its end
- * location as end location in the result.
+ * Return `val` with a location; if `val` and `endToken` are not provided, use the
+ * lower-cased token string of `startToken` as `val`.  As location, use the
+ * location covered by `startToken` and `endToken`, or only `startToken` if no
+ * `endToken` is provided.  The `startToken` defaults to the previous token.
  *
  * @param {object} startToken
  * @param {object} endToken
  * @param {any} val
  */
-function valueWithTokenLocation( val, startToken, endToken = null ) {
-  if (!startToken)
-    return undefined;
+function valueWithTokenLocation( val = undefined, startToken = this._input.LT(-1),
+                                 endToken = undefined ) {
+  // if (!startToken)
+  //   startToken = this._input.LT(-1);
   const loc = this.tokenLocation( startToken, endToken );
-  return { location: loc, val };
+  return {
+    location: loc,
+    val: (endToken || val !== undefined) ? val : startToken.text.toLowerCase(),
+  };
 }
 
 function previousTokenAtLocation( location ) {
@@ -585,6 +594,23 @@ function surroundByParens( expr, open, close, asQuery = false ) {
   return (asQuery) ? { query: expr, location } : expr;
 }
 
+
+function tokensToStringRepresentation( matchedRule ) {
+  const tokens = this._input.getTokens(
+    matchedRule.start.tokenIndex,
+    matchedRule.stop.tokenIndex + 1, null
+  ).filter(tok => tok.channel === antlr4.Token.DEFAULT_CHANNEL);
+  if (tokens.length === 0)
+    return '';
+
+  let result = tokens[0].text;
+  for (let i = 1; i < tokens.length; ++i) {
+    const str = normalizeNewLine(tokens[i].text);
+    result += (tokens[i].start > tokens[i - 1].stop + 1) ? ` ${ str }` : str;
+  }
+  return result;
+}
+
 function unaryOpForParens( query, val ) {
   const parens = query?.$parens;
   if (!parens)
@@ -697,8 +723,11 @@ function argsExpression( args, nary, location ) {
       location: undefined,
     } );
   }
+  // eslint-disable-next-line no-nested-ternary
+  const val = nary === '?:' ? nary
+    : (nary && nary !== '=' ? 'nary' : 'ixpr');
   const op = {
-    val: (nary && nary !== '=' ? 'nary' : 'ixpr'), // there is no n-ary in rule conditionTerm
+    val, // there is no n-ary in rule conditionTerm
     location: this.startLocation(),
   };
   return this.attachLocation( { op, args, location: location && { ...location } } );
@@ -814,6 +843,16 @@ function fixNewKeywordPlacement( args ) {
   args.push(ixpr);
 }
 
+function expressionAsAnnotationValue( assignment, cond ) {
+  if (!cond.cond) // parse error
+    return;
+  Object.assign(assignment, cond.cond);
+  assignment.$tokenTexts = this.tokensToStringRepresentation(cond);
+  if (!this.isBetaEnabled(this.options, 'annotationExpressions')) {
+    this.error( 'syntax-unsupported-expression', [ cond.cond.location ], {},
+                'Expressions in annotation values are not supported' );
+  }
+}
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
 // otherwise (including for '+'), represent it as extra unary prefix operator.
@@ -1063,7 +1102,7 @@ function aspectWithoutElements( art ) {
   }
 }
 
-// must be in action directly after having parsed '{' or '(`
+// must be in action directly after having parsed '{', '(`, or a keyword before
 function createDict() {
   const dict = Object.create(null);
   dict[$location] = this.startLocation( this._input.LT(-1) );