@sap/cds-compiler 3.1.2 → 3.4.0

package/lib/json/to-csn.js

@@ -186,7 +186,7 @@ const propertyOrder = (function orderPositions() {
 const typeProperties = [
   'target', 'elements', 'enum', 'items',
   'cardinality', // for association publishing in views
-  'type', 'length', 'precision', 'scale', 'srid', 'localized', // TODO: notNull?
+  'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
 ];
 
@@ -252,9 +252,10 @@ function sortCsn( csn, cloneOptions = false ) {
     const sortDict = n === 'definitions' &&
                      (!cloneOptions || cloneOptions.testMode || cloneOptions.testSortCsn);
     const val = csn[n];
-    if (!val || typeof val !== 'object' || n.charAt(0) === '@' || csnDirectValues.includes(n))
+    if (!val || typeof val !== 'object' || csnDirectValues.includes(n))
       r[n] = val;
-
+    else if (n.charAt(0) === '@')
+      r[n] = cloneAnnotationValue( val );
     else if (csnDictionaries.includes(n) && !Array.isArray(val))
       // Array check for property `args` which may either be a dictionary or an array.
       r[n] = csnDictionary( val, sortDict, cloneOptions );
@@ -279,6 +280,12 @@ function sortCsn( csn, cloneOptions = false ) {
   return r;
 }
 
+function cloneAnnotationValue(val) {
+  if (typeof val !== 'object') // scalar
+    return val;
+  return JSON.parse( JSON.stringify( val ) );
+}
+
 /**
  * Check whether the given object has non enumerable property.
  * Ensure that we don't take it from the prototype, only "directly" - we accidentally
@@ -663,7 +670,9 @@ 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;
-  return insertOrderDict( dict );
+  if (dict !== 0)
+    return insertOrderDict( dict );
+  return undefined;
 }
 
 function enumDict( dict, csn, node ) {
@@ -873,7 +882,24 @@ function definition( art, _csn, _node, prop ) {
   return c;
 }
 
-// create $origin specification for `includes` of `art`
+/**
+ * Create $origin specification for query/projection.
+ */
+function queryOrigin( xsn ) {
+  const source = xsn._from[0]._origin;
+  let $origin;
+  if (xsn.includes)
+    // includesOrigin() does originRef() on the first include.
+    // Use it to behave the same as entity includes.
+    $origin = includesOrigin( [ { _artifact: source }, ...xsn.includes ], xsn );
+  else
+    $origin = originRef( source );
+  return $origin;
+}
+
+/**
+ * Create $origin specification for `includes` of `art`.
+ */
 function includesOrigin( includes, art ) {
   const $origin = originRef( includes[0]._artifact );
   if (includes.length === 1)
@@ -913,7 +939,7 @@ function addOrigin( csn, xsn, node ) {
   }
   if (xsn._from) {
     const source = xsn._from[0]._origin;
-    csn.$origin = originRef( source );
+    csn.$origin = queryOrigin( xsn );
     if (source.params && !xsn.params)
       csn.params = null;        // discontinue `params` inheritance
     if (source.actions && !xsn.actions)
@@ -927,6 +953,11 @@ function addOrigin( csn, xsn, node ) {
   let origin = getOrigin( node );
   if (xsn.$inferred === 'composition-entity') {
     csn.$origin = originRef( origin, xsn );
+    inferredPropertiesForOrigin( csn, node );
+    return;
+  }
+  else if (xsn.$inferred === 'localized-entity') {
+    inferredPropertiesForOrigin( csn, node );
     return;
   }
   else if (!isMember( xsn ) || xsn.kind === 'select') {
@@ -993,6 +1024,30 @@ function addOrigin( csn, xsn, node ) {
   }
 }
 
+/**
+ * Copy properties with $inferred === 'parent-origin' to $origin.
+ * This indicates that the property is neither direct nor can be inferred through $origin.
+ *
+ * @param csn
+ * @param node
+ */
+function inferredPropertiesForOrigin( csn, node ) {
+  let hasProp = false;
+  const props = {};
+  for (const prop of Object.keys(node)) {
+    if (node[prop]?.$inferred === 'parent-origin') {
+      hasProp = true;
+      props[prop] = value({ ...node[prop], $inferred: false });
+    }
+  }
+  const origin = csn.$origin;
+  if (hasProp) {
+    csn.$origin = props;
+    if (origin)
+      csn.$origin.$origin = origin;
+  }
+}
+
 function getParent( art ) {
   const parent = art._parent;
   const main = parent._main;
@@ -1021,10 +1076,11 @@ function getOrigin( art ) {
     return (_origin.kind === 'builtin') ? undefined : _origin; // not $dollarVariable
   if (hasExplicitProp( art.type, 'cast' ))
     return art.type._artifact;
-  if (art.includes)
-    return art.includes[0]._artifact;
   if (art._from)
     return art._from[0]._origin;
+  // must come after _from, since queries can have includes as well.
+  if (art.includes)
+    return art.includes[0]._artifact;
   return undefined;
 }
 
@@ -1092,7 +1148,9 @@ function type( node, csn, xsn ) {
     return undefined;
   if (xsn._origin) {
     if (xsn._origin.$inferred === 'REDIRECTED') { // auto-redirected user-provided target
-      csn.$origin = definition( xsn._origin );
+      const $origin = definition( xsn._origin );
+      if ($origin)              // if not rendered as column
+        csn.$origin = $origin;
     }
   }
   return artifactRef( node, !node.$extra );
@@ -1210,7 +1268,8 @@ function value( node ) {
   if (!node)
     return true;                // `@aBool` short for `@aBool: true`
   if (universalCsn && node.$inferred) {
-    if (node.$inferred === 'prop' || node.$inferred === '$generated') // via propagator.js
+    if (node.$inferred === 'prop' || node.$inferred === '$generated' || // via propagator.js
+      node.$inferred === 'parent-origin')
       return undefined;
     else if (node.$inferred === 'NULL')
       return null;
@@ -1610,6 +1669,7 @@ function initModuleVars( options = { csnFlavor: 'gensrc' } ) {
 
 module.exports = {
   cloneCsnDictionary: (csn, options) => csnDictionary(csn, false, options),
+  cloneAnnotationValue,
   compactModel,
   compactQuery,
   compactExpr,

package/lib/language/.eslintrc.json

@@ -0,0 +1,4 @@
+{
+  "root": true,
+  "extends": "../../.eslintrc-ydkjsi.json"
+}

package/lib/language/antlrParser.js

@@ -18,22 +18,17 @@ const Lexer = require('../gen/languageLexer').default;
 
 // Error listener used for ANTLR4-generated parser
 class ErrorListener extends antlr4.error.ErrorListener {
-  constructor(...args) {
-    super(...args);
-  }
-
   // method which is called by generated parser with --trace-parser[-amg]:
+  // eslint-disable-next-line class-methods-use-this
   syntaxError( recognizer, offendingSymbol, line, column, msg, e ) {
     if (!(e instanceof CompileMessage)) // not already reported
-      recognizer.error( null, offendingSymbol, msg );
+      // Ignore warning, because only relevant for --trace-parser
+      // eslint-disable-next-line cds-compiler/message-call-format
+      recognizer.error( null, offendingSymbol, {}, msg );
   }
 }
 
 class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
-  constructor(...args) {
-    super(...args);
-  }
-
   LT( k ) {
     const t = super.LT(k);
     if (!t || !t.type)
@@ -112,7 +107,9 @@ const rules = {
   expr: { func: 'conditionEOF', returns: 'cond' }, // yes, condition
 };
 
-function parse( source, filename = '<undefined>.cds', options = {}, messageFunctions = null, rule = 'cdl' ) {
+function parse( source, filename = '<undefined>.cds',
+                options = {}, messageFunctions = null,
+                rule = 'cdl' ) {
   const lexer = new Lexer( new antlr4.InputStream(source) );
   const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
@@ -168,7 +165,7 @@ function parse( source, filename = '<undefined>.cds', options = {}, messageFunct
     for (const token of tokenStream.tokens) {
       if (token.type === parser.constructor.DocComment && !token.isUsed) {
         messageFunctions.info('syntax-ignoring-doc-comment', parser.tokenLocation(token), {},
-          "Ignoring doc-comment as it does not belong to any artifact");
+                              'Ignoring doc comment as it does not belong to any artifact');
       }
     }
   }

package/lib/language/docCommentParser.js

@@ -93,9 +93,8 @@ function stripCommentIndentation(lines, ignoreFirstLine) {
 
     let count = 0;
     const length = Math.min(min, line.length);
-    while (count < length && isWhitespaceCharacterNoNewline(line[count])) {
+    while (count < length && isWhitespaceCharacterNoNewline(line[count]))
       count++;
-    }
     return Math.min(min, count);
   }, Number.MAX_SAFE_INTEGER);
 

package/lib/language/errorStrategy.js

@@ -29,10 +29,13 @@
 'use strict';
 
 const antlr4 = require('antlr4');
-const antlr4_LL1Analyzer = require('antlr4/src/antlr4/LL1Analyzer');
+// eslint-disable-next-line camelcase
+const Antlr4LL1Analyzer = require('antlr4/src/antlr4/LL1Analyzer');
 const { DefaultErrorStrategy } = require('antlr4/src/antlr4/error/ErrorStrategy');
 const { InputMismatchException } = require('antlr4/src/antlr4/error/Errors');
-const { predictionContextFromRuleContext: predictionContext } = require('antlr4/src/antlr4/PredictionContext');
+const {
+  predictionContextFromRuleContext: predictionContext,
+} = require('antlr4/src/antlr4/PredictionContext');
 const { ATNState } = require('antlr4/src/antlr4/atn/ATNState');
 const { IntervalSet, Interval } = require('antlr4/src/antlr4/IntervalSet');
 
@@ -53,8 +56,7 @@ function match( ttype ) {
   if (token.type === identType || !keywordRegexp.test( token.text ))
     return antlr4.Parser.prototype.match.call( this, ttype );
 
-  this.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text },
-                '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it' );
+  this.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text } );
   this._errHandler.reportMatch(this);
   this.consume();
   return token;
@@ -107,7 +109,8 @@ function sync( recognizer ) {
   const s = recognizer._interp.atn.states[recognizer.state];
   // try cheaper subset first; might get lucky. seems to shave a wee bit off
   const nextTokens = recognizer.atn.nextTokens(s);
-  // console.log('SYNC:', recognizer._ctx._sync, s.stateType, token.text, intervalSetToArray( recognizer, nextTokens ))
+  // console.log('SYNC:', recognizer._ctx._sync, s.stateType, token.text,
+  // intervalSetToArray( recognizer, nextTokens ))
 
   if (nextTokens.contains(token.type)) { // we are sure the token matches
     if (token.text === '}' && recognizer.$nextTokensToken !== token &&
@@ -124,7 +127,8 @@ function sync( recognizer ) {
     // when exiting a (innermost) rule, remember the state to make
     // getExpectedTokensForMessage() calculate the full "expected set"
     if (recognizer.$nextTokensToken !== token) {
-      // console.log('SET:',token.type,recognizer.state,recognizer.$nextTokensToken && recognizer.$nextTokensToken.type)
+      // console.log('SET:',token.type,recognizer.state,recognizer.$nextTokensToken &&
+      // recognizer.$nextTokensToken.type)
       recognizer.$nextTokensToken = token;
       recognizer.$nextTokensState = recognizer.state;
       recognizer.$nextTokensContext = recognizer._ctx;
@@ -142,8 +146,7 @@ function sync( recognizer ) {
   // interpreter to see behind EPSILON.
   const identType = recognizer.constructor.Identifier;
   if (keywordRegexp.test( token.text ) && nextTokens.contains( identType )) {
-    recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text },
-                        '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it' );
+    recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text } );
     token.type = identType;     // make next ANTLR decision assume identifier
     return;
   }
@@ -187,7 +190,8 @@ function sync( recognizer ) {
 
 // Report `NoViableAltException e` signalled by parser `recognizer`
 function reportNoViableAlternative( recognizer, e ) {
-  // console.log('NOV:',this.getTokenErrorDisplay(e.startToken), this.getTokenErrorDisplay(e.offendingToken))
+  // console.log('NOV:',this.getTokenErrorDisplay(e.startToken),
+  // this.getTokenErrorDisplay(e.offendingToken))
   if (e.startToken === e.offendingToken) { // mismatch at LA(1)
     this.reportInputMismatch( recognizer, e );
   }
@@ -262,6 +266,7 @@ function reportIgnoredWith( recognizer, t ) {
   const expecting = this.getExpectedTokensForMessage( recognizer, t );
   const m = recognizer.warning( 'syntax-ignored-with', t,
                                 { offending: "';'", expecting },
+    // eslint-disable-next-line max-len
                                 'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous WITH' );
   m.expectedTokens = expecting;
 }
@@ -279,7 +284,8 @@ function consumeUntil( recognizer, set ) {
   }
   else if (set.contains(SEMI)) { // do not check for RBRACE here!
     this._super.consumeUntil.call( this, recognizer, set );
-    // console.log('CONSUMED-ORIG:',s,this.getTokenDisplay( recognizer.getCurrentToken(), recognizer ),recognizer.getCurrentToken().line,intervalSetToArray( recognizer, set ));
+    // console.log('CONSUMED-ORIG:',s,this.getTokenDisplay( recognizer.getCurrentToken(),
+    // recognizer ),recognizer.getCurrentToken().line,intervalSetToArray( recognizer, set ));
   }
   else {
     // DO NOT modify input param `set`, as the set might be cached in the ATN
@@ -300,7 +306,8 @@ function consumeUntil( recognizer, set ) {
       recognizer.consume();
       this.reportMatch(recognizer); // we know current token is correct
     }
-    // console.log('CONSUMED:',s,this.getTokenDisplay( recognizer.getCurrentToken(), recognizer ),recognizer.getCurrentToken().line);
+    // console.log('CONSUMED:',s,this.getTokenDisplay( recognizer.getCurrentToken(),
+    // recognizer ),recognizer.getCurrentToken().line);
     // throw new Error('Sync')
   }
 }
@@ -321,8 +328,7 @@ function recoverInline( recognizer ) {
   if (!keywordRegexp.test( token.text ))
     return this._super.recoverInline.call( this, recognizer );
 
-  recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text },
-                      '$(ID) is a reserved name here - write $(DELIMITED) instead if you want to use it' );
+  recognizer.message( 'syntax-fragile-ident', token, { id: token.text, delimited: token.text } );
   this.reportMatch(recognizer); // we know current token is correct
   recognizer.consume();
   return token;
@@ -362,7 +368,8 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
     }
   }
   // The parser method excludeExpected() additionally removes some tokens from the message:
-  if (recognizer.$adaptExpectedToken && recognizer.$nextTokensToken === recognizer.$adaptExpectedToken) {
+  if (recognizer.$adaptExpectedToken &&
+      recognizer.$nextTokensToken === recognizer.$adaptExpectedToken) {
     const excludes = (excludesForNextToken && Array.isArray(recognizer.$adaptExpectedExcludes[0]))
       ? recognizer.$adaptExpectedExcludes[0]
       : recognizer.$adaptExpectedExcludes;
@@ -381,13 +388,32 @@ function intervalSetToArray( recognizer, expected, excludesForNextToken ) {
 const token1sort = {
   // 0: Identifier, Number, ...
   // 1: separators:
-  ',': 1, '.': 1, ':': 1, ';': 1,
+  ',': 1,
+  '.': 1,
+  ':': 1,
+  ';': 1,
   // 2: parentheses:
-  '(': 2, ')': 2, '[': 2, ']':2, '{': 2, '}': 2,
+  '(': 2,
+  ')': 2,
+  '[': 2,
+  ']': 2,
+  '{': 2,
+  '}': 2,
   // 3: special:
-  '!': 3, '#': 3, '$': 3, '?': 3, '@': 3,
+  '!': 3,
+  '#': 3,
+  $: 3,
+  '?': 3,
+  '@': 3,
   // 4: operators:
-  '*': 4, '+': 4, '-': 4, '/': 4, '<': 4, '=': 4, '>': 4, '|': 4,
+  '*': 4,
+  '+': 4,
+  '-': 4,
+  '/': 4,
+  '<': 4,
+  '=': 4,
+  '>': 4,
+  '|': 4,
   // 8: KEYWORD
   // 9: <EOF>
 };
@@ -425,7 +451,7 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   if (recognizer.state < 0)
     return [];
   if (recognizer.state >= atn.states.length) {
-    throw ( `Invalid state number ${ recognizer.state } for ${
+    throw new Error( `Invalid state number ${ recognizer.state } for ${
       this.getTokenErrorDisplay( offendingToken ) }`);
   }
 
@@ -435,10 +461,10 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   if (!identType || !beforeUnreserved || beforeUnreserved + 2 > identType)
     return intervalSetToArray( recognizer, this._super.getExpectedTokens.call( this, recognizer ) );
 
-  const ll1 = new antlr4_LL1Analyzer(atn);
+  const ll1 = new Antlr4LL1Analyzer(atn);
   const expected = new IntervalSet();
-  const orig_addInterval = expected.addInterval;
-  const orig_addSet = expected.addSet;
+  const origAddInterval = expected.addInterval;
+  const origAddSet = expected.addSet;
   expected.addInterval = addInterval;
   expected.addSet = addSet;
   const lookBusy = new antlr4.Utils.Set();
@@ -466,23 +492,24 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
                predictionContext( atn, recognizer._ctx ),
                expected, lookBusy, calledRules, true, true );
   }
-  // console.log(state, recognizer.$nextTokensState, expected.toString(recognizer.literalNames, recognizer.symbolicNames));
+  // console.log(state, recognizer.$nextTokensState,
+  // expected.toString(recognizer.literalNames, recognizer.symbolicNames));
   return intervalSetToArray( recognizer, expected );
 
   function addSet(other) {
     if (!other.contains( hideAltsType ))
-      orig_addSet.call( this, other );
+      origAddSet.call( this, other );
   }
 
   // Add an interval `v` to the IntervalSet `this`.  If `v` contains the token
   // type `Identifier`, do not add non-reserved keywords in `v`.
   function addInterval(v) {
     if (v.stop <= identType) {
-      orig_addInterval.call(this, v);
+      origAddInterval.call(this, v);
     }
     else if (v.start >= identType) {
       if (v.stop === identType + 1 || !recognizer.tokenRewrite) {
-        orig_addInterval.call(this, v);
+        origAddInterval.call(this, v);
       }
       else {
         for (let j = v.start; j < v.stop; j++)
@@ -497,7 +524,7 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   }
 
   function addRange( interval, start, stop ) {
-    orig_addInterval.call( interval, new Interval( start, stop || start + 1 ) );
+    origAddInterval.call( interval, new Interval( start, stop || start + 1 ) );
   }
 }