@sap/cds-compiler 3.6.2 → 3.8.0

package/lib/json/to-csn.js

@@ -55,7 +55,7 @@ const transformers = {
   kind,
   id: n => n,                   // in path item
   doc: value,
-  '@': value,
+  '@': anno,
   virtual: value,
   key: value,
   unique: value,
@@ -73,6 +73,17 @@ const transformers = {
   // type properties (without 'elements') ------------------------------------
   localized: value,
   type,
+  $typeArgs: (node, csn, xsn) => {
+    const typeArgs = xsn.$typeArgs;
+    // One or two arguments are interpreted as either length or precision/scale.
+    if (typeArgs?.length === 1) {
+      csn.length = value(typeArgs[0]);
+    }
+    else if (typeArgs?.length === 2) {
+      csn.precision = value(typeArgs[0]);
+      csn.scale = value(typeArgs[1]);
+    }
+  },
   length: value,
   precision: value,
   scale: value,
@@ -190,6 +201,7 @@ const typeProperties = [
   'cardinality', // for association publishing in views
   'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
+  '$typeArgs', // for unresolved type arguments, e.g. through parseCql
 ];
 
 const csnDictionaries = [
@@ -243,6 +255,12 @@ function sortCsn( csn, cloneOptions = false ) {
       setHidden( r, 'elements', csnDictionary( csn.elements, false, cloneOptions ) );
     if (hasNonEnumerable( csn, '$tableConstraints' ) && !r.$tableConstraints)
       setHidden( r, '$tableConstraints', csn.$tableConstraints );
+    if (cloneOptions.hiddenPropertiesToClone) {
+      cloneOptions.hiddenPropertiesToClone.forEach((property) => {
+        if ({}.hasOwnProperty.call( csn, property )) // used in generic reference flattener
+          setHidden( r, property, csn[property] );
+      });
+    }
   }
   return r;
 }
@@ -382,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;
-    }
-  }
 }
 
 /**
@@ -522,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 ) : {};
@@ -531,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)
@@ -631,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 ) {
@@ -748,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
@@ -773,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;
@@ -812,12 +747,12 @@ function foreignKeys( dict, csn, node ) {
     csn.keys.push( definition( dict[n] ) );
 }
 
-function returns( art, csn, _node, prop ) {
+function returns( art, csn, node, prop ) {
   // TODO: currently, the `returns` structure might just have been created by the propagator
   // if that is the case, there should be no reason to store it in universal CSN
-  if (universalCsn && art.$inferred === 'proxy')
+  if (universalCsn && (art.$inferred === 'proxy' || node.$expand === 'origin'))
     return undefined;
-  return definition( art, csn, _node, prop );
+  return definition( art, csn, node, prop );
 }
 
 function definition( art, _csn, _node, prop ) {
@@ -872,16 +807,35 @@ function includesOrigin( includes, art ) {
     for (const prop in aspect) {
       if ((prop.charAt(0) === '@' || prop === 'doc') &&
           (!art[prop] || art[prop].$inferred)) {
-        const anno = aspect[prop];
-        if (anno.val !== null)
-          // matererialize non-null annos (whether direct or inherited)
-          result[prop] = value( Object.create( anno, { $inferred: { value: null } } ) );
+        const annoVal = aspect[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) ? $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;
@@ -926,18 +880,32 @@ function addOrigin( csn, xsn, node ) {
     return;
   }
   // from here on: member:
+  // TODO: write a xsnNode._csnOrigin, which is useful to decide whether to write
+  //       $origins for its members
   const parent = getParent( xsn );
   const parentOrigin = getOrigin( parent );
+  // console.log( 'X:',xsn, origin, parent, parentOrigin, getParent( origin ) );
   if (!origin) {
-    if (parentOrigin && !(parent.enum && !parent.$origin && parent.type))
+    if (parent && parentOrigin &&
+        (parent.kind !== 'select' || parent === parent._main._leadingQuery) &&
+        !(parent.enum && !parent.$origin && parent.type))
       csn.$origin = null;
     return;
   }
-  if (parentOrigin === getParent( origin )) {
+  if (parent?.kind !== 'select' && parentOrigin?.kind !== 'select' &&
+      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') {
@@ -1034,13 +1002,13 @@ function getOrigin( art ) {
   if (art.$noOrigin)
     return undefined;
   const { _origin } = art;
-  if (_origin)
-    return (_origin.kind === 'builtin') ? undefined : _origin; // not $dollarVariable
+  if (_origin)                  // also for query entities
+    return (_origin.kind === 'builtin') ? undefined : _origin;
+
   if (hasExplicitProp( art.type, 'cast' ))
     return art.type._artifact;
-  if (art._from)
-    return art._from[0]._origin;
-  // must come after _from, since queries can have includes as well.
+  // must come after checking _origin, since entities can have both queries and
+  // includes as well -> the query wins
   if (art.includes)
     return art.includes[0]._artifact;
   return undefined;
@@ -1052,7 +1020,7 @@ function hasExplicitProp( ref, alsoLikeExplicit ) {
 
 /**
  * @param art
- * @param user
+ * @param [user]
  * @return {boolean|string[]}
  */
 function originRef( art, user ) {
@@ -1230,6 +1198,12 @@ function args( node ) {
   return dict;
 }
 
+function anno( node ) {
+  if (node.$tokenTexts) // expressions in annotation values
+    return Object.assign({ '=': node.$tokenTexts }, expression( node ));
+  return value(node);
+}
+
 function value( node ) {
 // "Short" value form, e.g. for annotation assignments
   if (!node)
@@ -1243,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 );
@@ -1300,7 +1276,7 @@ function expression( node ) {
 function exprInternal( node, xprParens ) {
   if (typeof node === 'string')
     return node;
-  if (!node)                    // make to-csn robst
+  if (!node)                    // make to-csn robust
     return {};
   if (node.scope === 'param') {
     if (node.path)
@@ -1343,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':
@@ -1379,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' &&
@@ -1548,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

@@ -101,6 +101,7 @@ Object.assign( KeywordErrorStrategy.prototype, {
 
 // Attempt to recover from problems in subrules, except if rule has defined a
 // local variable `_sync` with value 'nop'
+// TODO: consider performance - see #8800
 function sync( recognizer ) {
   // If already recovering, don't try to sync
   if (this.inErrorRecoveryMode(recognizer))
@@ -406,6 +407,7 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
   return names;
 }
 
+// Used for sorting in messages
 const token1sort = {
   // 0: Identifier, Number, ...
   // 1: separators: