@sap/cds-compiler 3.4.0 → 3.4.4

package/lib/json/from-csn.js

@@ -961,7 +961,7 @@ function dictionaryOf( elementFct ) {
     ++virtualLine;
     for (const name of allNames) {
       if (!name) {
-        warning( 'syntax-invalid-name', location(true), // TODO: Error
+        message( 'syntax-invalid-name', location(true),
                  { '#': 'csn', parentprop: spec.prop } );
       }
       const val = elementFct( dict[name], spec, r, dict, name );
@@ -1148,8 +1148,11 @@ function natnum( val, spec ) {
   if (typeof val === 'number' && val >= 0)
     //  XSN TODO: do not require literal
     return { val, literal: 'number', location: location() };
-  error( spec.msgId || 'syntax-expecting-natnum', location(true),
-         { prop: spec.msgProp } );
+  const loc = location(true);
+  if (spec.msgId)
+    error( spec.msgId, loc, { prop: spec.msgProp } );
+  else
+    error( 'syntax-expecting-natnum', loc, { prop: spec.msgProp } );
   return ignore( val );
 }
 
@@ -1456,8 +1459,7 @@ function excluding( array, spec, xsn ) {
 }
 
 function duplicateExcluding( name, loc ) {
-  error( 'syntax-duplicate-excluding', loc, { name, keyword: 'excluding' }, // TODO: also CDL
-         'Duplicate $(NAME) in the $(KEYWORD) clause' );
+  error( 'syntax-duplicate-excluding', loc, { '#': 'csn', name, prop: 'excluding[]' } );
 }
 
 function masked( val, spec ) {
@@ -1541,14 +1543,14 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
     const variant = kind && s.inKind
       ? ([ 'extend', 'annotate' ].includes(kind) ? kind : 'kind')
       : (parentSpec.msgProp ? 'prop' : 'top');
-    message( 'syntax-unexpected-property', location(true),
-             {
-               '#': variant,
-               prop,
-               parentprop:
-               parentSpec.msgProp,
-               kind,
-             } );
+    error( 'syntax-unexpected-property', location(true),
+           {
+             '#': variant,
+             prop,
+             parentprop:
+             parentSpec.msgProp,
+             kind,
+           } );
   }
   else if (checkAndSetXorGroup( s.xorGroup, s.xorException, prop, xor )) {
     onlyWith( s, s.onlyWith, csn, prop, xor, expected );
@@ -1622,7 +1624,7 @@ function checkAndSetXorGroup( group, exception, prop, xor ) {
   }
   if (siblingprop === exception)
     return true;
-  message( 'syntax-unexpected-property', location(true), { '#': 'sibling', prop, siblingprop } );
+  error( 'syntax-unexpected-property', location(true), { '#': 'sibling', prop, siblingprop } );
   return false;
 }
 
@@ -1652,8 +1654,11 @@ function isArray( array, spec ) {
 function isObject( obj, spec ) {
   if (obj && typeof obj === 'object' && !Array.isArray( obj ))
     return obj;
-  error( spec.msgId || 'syntax-expecting-object', location(true),
-         { prop: spec.msgProp });
+  const loc = location(true);
+  if (spec.msgId)
+    error( spec.msgId, loc, { prop: spec.msgProp });
+  else
+    error( 'syntax-expecting-object', loc, { prop: spec.msgProp });
   return ignore( obj );
 }
 

package/lib/json/to-csn.js

@@ -23,6 +23,7 @@ const normalizedKind = {
   param: 'param',
   action: 'action',
   function: 'action',
+  enum: 'enum',
 };
 
 /** @type {boolean|string} */
@@ -429,21 +430,10 @@ function extensions( node, csn, model ) {
     }
     else if (gensrcFlavor) {
       // From definitions (without redefinitions) with potential inferred elements:
-      const annotate = { annotate: name };
-      if (art.$inferred)
-        Object.assign( annotate, annotationsAndDocComment( art, true ) );
-      if (art.$expand === 'annotate') {
-        if (art.actions)
-          attachAnnotations( annotate, 'actions', art.actions, art.$inferred );
-        else if (art.params)
-          attachAnnotations( annotate, 'params', art.params, art.$inferred );
-        const obj = art.returns || art;
-        const elems = (obj.items || obj).elements; // no targetAspect here
-        if (elems)
-          attachAnnotations( annotate, 'elements', elems, art.$inferred, art.returns );
-      }
-      if (Object.keys( annotate ).length > 1)
-        exts.push( annotate );
+      const result = { annotate: Object.create(null) };
+      attachAnnotations(result, 'annotate', { [name]: art }, art.$inferred );
+      if (result.annotate[name])
+        exts.push({ annotate: name, ...result.annotate[name] } );
     }
   }
 
@@ -470,7 +460,7 @@ function extensions( node, csn, model ) {
         const par = art.params[name];
         if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
           continue;
-        const render = annotationsAndDocComment( par, true );
+        const render = annotationsAndDocComment( par );
         const subElems = par.$expand !== 'origin' && (par.items || par).elements;
         if (subElems) {
           const sub = inferred( subElems, par.$inferred );
@@ -487,7 +477,7 @@ function extensions( node, csn, model ) {
       const par = art.returns;
       if (!inferredParent && !par.$inferred && par.$expand !== 'annotate')
         return;
-      const render = annotationsAndDocComment( par, true );
+      const render = annotationsAndDocComment( par );
       const subElems = par.$expand !== 'origin' && (par.items || par).elements;
       if (subElems) {
         const sub = inferred( subElems, par.$inferred );
@@ -508,7 +498,7 @@ function extensions( node, csn, model ) {
     const name = art.name.absolute;
     // 'true' because annotations on namespaces and builtins can only
     // happen through extensions.
-    const annos = annotationsAndDocComment( art, true );
+    const annos = annotationsAndDocComment( art );
     const annotate = Object.assign( { annotate: name }, annos );
     if (Object.keys( annotate ).length > 1) {
       const loc = locationForAnnotationExtension();
@@ -567,16 +557,21 @@ function sources( srcDict, csn ) {
 function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
   const annoDict = Object.create( dictionaryPrototype );
   for (const name in dict) {
-    const elem = dict[name];
-    const inf = inferred || elem.$inferred; // is probably always inferred if parent was
-    const sub = (inf) ? annotationsAndDocComment( elem, true ) : {};
-    if (elem.$expand === 'annotate') {
-      if (elem.params)
-        attachAnnotations( sub, 'params', elem.params, inf );
-      const obj = elem.returns || elem;
-      const elems = (obj.items || obj.targetAspect || obj).elements;
+    const entry = dict[name];
+    const inf = inferred || entry.$inferred; // is probably always inferred if parent was
+    const sub = (inf) ? annotationsAndDocComment( entry ) : {};
+    if (entry.$expand === 'annotate') {
+      if (entry.actions)
+        attachAnnotations( sub, 'actions', entry.actions, inf );
+      else if (entry.params)
+        attachAnnotations( sub, 'params', entry.params, inf );
+      const obj = entry.returns || entry;
+      const many = obj.items || obj;
+      const elems = (many.targetAspect || many).elements;
       if (elems)
-        attachAnnotations( sub, 'elements', elems, inf, elem.returns );
+        attachAnnotations( sub, 'elements', elems, inf, entry.returns );
+      if (many.enum)
+        attachAnnotations( sub, 'enum', many.enum, inf );
     }
     if (Object.keys( sub ).length)
       annoDict[name] = sub;
@@ -723,10 +718,14 @@ function keepElements( node, line ) {
   return false;                 // no need to render elements
 }
 
-// for gensrcFlavor and namespace/builtin annotation extraction:
-// return annotations from definition (annotated==false)
-// or annotations (annotated==true)
-function annotationsAndDocComment( node, annotated ) {
+/**
+ * For gensrcFlavor and namespace/builtin annotation extraction:
+ * return annotations from definition and annotations.
+ * The call side should check that node.$inferred is truthy.
+ *
+ * @param {object} node
+ */
+function annotationsAndDocComment( node ) {
   const csn = {};
   const transformer = transformers['@'];
   const keys = Object.keys( node ).filter( a => a.charAt(0) === '@' ).sort();
@@ -734,15 +733,12 @@ function annotationsAndDocComment( node, annotated ) {
     const val = node[prop];
     // val.$priority isn't set for computed annotations like @Core.Computed
     // and @odata.containment.ignore
-    // TODO: use $inferred instead special $priority value
-    if (val.$priority !== undefined && (!!val.$priority) === annotated) {
-      // transformer (= value) takes care to exclude $inferred annotation assignments
-      const sub = transformer( val );
-      // As value() just has one value, so we do not provide ( val, csn, node, prop )
-      // which would be more robust, but makes some JS checks unhappy
-      if (sub !== undefined)
-        csn[prop] = sub;
-    }
+    // transformer (= value) takes care to exclude $inferred annotation assignments
+    const sub = transformer( val );
+    // As value() just has one value, so we do not provide ( val, csn, node, prop )
+    // which would be more robust, but makes some JS checks unhappy
+    if (sub !== undefined)
+      csn[prop] = sub;
   }
   if (node.doc)
     csn.doc = transformers.doc(node.doc);
@@ -1534,7 +1530,7 @@ function addElementAsColumn( elem, cols ) {
   if (elem.$inferred === '*')
     return;
   // only list annotations here which are provided directly with definition
-  const col = (gensrcFlavor) ? annotationsAndDocComment( elem, false ) : {};
+  const col = (gensrcFlavor) ? annotationsAndDocComment( elem ) : {};
   // with `client` flavor, assignments are available at the element
   const gensrcSaved = gensrcFlavor;
 

package/lib/language/.eslintrc.json

@@ -1,4 +1,7 @@
 {
   "root": true,
-  "extends": "../../.eslintrc-ydkjsi.json"
+  "extends": "../../.eslintrc-ydkjsi.json",
+  "rules": {
+    "cds-compiler/space-in-func-decl": "error"
+  }
 }

package/lib/language/antlrParser.js

@@ -164,8 +164,11 @@ function parse( source, filename = '<undefined>.cds',
   if (options.docComment !== false) {
     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');
+        // TODO: think of 'syntax-unexpected-doc-comment'
+        messageFunctions.info( 'syntax-ignoring-doc-comment', parser.tokenLocation(token), {},
+                               'Ignoring doc comment as it is not written at a defined position' );
+        // this is also for position inside some artifact definition, i.e. previous text
+        // "does not belong to any artifact" might be confusing
       }
     }
   }

package/lib/language/docCommentParser.js

@@ -16,7 +16,7 @@ const {
  * @returns {string|null} Parsed contents or if the comment has an invalid format or
  *                        does not have any content, null is returned.
  */
-function parseDocComment(comment) {
+function parseDocComment( comment ) {
   // Also return "null" for empty doc comments so that doc comment propagation
   // can be stopped.
   if (comment.length <= 5) // at least "/***/"
@@ -83,7 +83,7 @@ function parseDocComment(comment) {
  * @param {string[]} lines String split into lines.
  * @param {boolean} ignoreFirstLine Whether to ignore the first line for indentation counting.
  */
-function stripCommentIndentation(lines, ignoreFirstLine) {
+function stripCommentIndentation( lines, ignoreFirstLine ) {
   const n = lines.length;
 
   const minIndent = lines.reduce((min, line, index) => {
@@ -114,7 +114,7 @@ function stripCommentIndentation(lines, ignoreFirstLine) {
  * @param {string} line
  * @returns {string} line without fence
  */
-function removeFence(line) {
+function removeFence( line ) {
   return line.replace(/^\s*[*]\s?/, '');
 }
 
@@ -125,7 +125,7 @@ function removeFence(line) {
  * @param {string} line
  * @returns {string} Header without fence.
  */
-function removeHeaderFence(line) {
+function removeHeaderFence( line ) {
   return line.replace(/^\/[*]{2,}\s?/, '');
 }
 
@@ -138,7 +138,7 @@ function removeHeaderFence(line) {
  * @param {string} line
  * @returns {string} header without fence
  */
-function removeFooterFence(line) {
+function removeFooterFence( line ) {
   return line.replace(/\s*[*]+\/$/, '');
 }
 
@@ -148,7 +148,7 @@ function removeFooterFence(line) {
  *
  * @param {string[]} lines
  */
-function isFencedComment(lines) {
+function isFencedComment( lines ) {
   const index = lines.findIndex((line, i) => {
     const exclude = (i === 0 || i === lines.length - 1);
     return !exclude && !(/^\s*[*]/.test(line));

package/lib/language/errorStrategy.js

@@ -55,8 +55,11 @@ function match( ttype ) {
   const token = this.getCurrentToken();
   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 } );
+  // This is very likely to be dead code: we do not use a simple Identifier
+  // without alternatives in the grammar.  With alternatives, recoverInline() is
+  // the place to go.  (But this code should work with a changed grammar…)
+  this.message( 'syntax-unexpected-reserved-word', token,
+                { code: token.text, delimited: token.text } );
   this._errHandler.reportMatch(this);
   this.consume();
   return token;
@@ -72,7 +75,6 @@ class KeywordErrorStrategy extends DefaultErrorStrategy {
     super( ...args );
 
     this._super = {
-      consumeUntil: super.consumeUntil,
       recoverInline: super.recoverInline,
       getExpectedTokens: super.getExpectedTokens,
     };
@@ -89,6 +91,7 @@ Object.assign( KeywordErrorStrategy.prototype, {
   reportIgnoredWith,
   // getErrorRecoverySet,
   consumeUntil,
+  consumeAndMarkUntil,
   recoverInline,
   getMissingSymbol,
   getExpectedTokensForMessage,
@@ -137,16 +140,19 @@ function sync( recognizer ) {
   }
 
   // Expected token is identifier, current is (reserved) KEYWORD:
-  // TODO: do not use this if "close enough" (1 char diff) to a keyword in nextTokens
+  // TODO: do not use this if "close enough" (1 char diff or prefix)
+  // to a keyword in nextTokens
   //
   // NOTE: it is important to do this only if EPSILON is not in `nextTokens`,
-  // which means that we cannot bring the better special syntax-fragile-ident
+  // which means that we cannot bring the better special syntax-unexpected-reserved
   // in all cases.  Reason: high performance impact of the alternative,
   // i.e. calling method Parser#isExpectedToken() = invoking the ATN
   // 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 } );
+    recognizer.message( 'syntax-unexpected-reserved-word', token,
+                        { code: token.text, delimited: token.text } );
+    // TODO: attach tokens like for 'syntax-unexpected-token'
     token.type = identType;     // make next ANTLR decision assume identifier
     return;
   }
@@ -210,11 +216,11 @@ function reportInputMismatch( recognizer, e, deadEnds ) {
   const expecting = deadEnds !== true && // true: cannot compute expecting
                   this.getExpectedTokensForMessage( recognizer, e.offendingToken, deadEnds );
   const offending = this.getTokenDisplay( e.offendingToken, recognizer );
+  e.offendingToken.$isSkipped = 'offending';
   let err;
   if (expecting && expecting.length) {
-    err = recognizer.error( 'syntax-mismatched-token', e.offendingToken,
-                            { offending, expecting },
-                            'Mismatched $(OFFENDING), expecting $(EXPECTING)' );
+    err = recognizer.error( 'syntax-unexpected-token', e.offendingToken,
+                            { offending, expecting } );
     err.expectedTokens = expecting;
   }
   else {                        // should not really happen anymore... -> no messageId !
@@ -232,11 +238,12 @@ function reportUnwantedToken( recognizer ) {
   this.beginErrorCondition(recognizer);
 
   const token = recognizer.getCurrentToken();
+  token.$isSkipped = 'offending';
   const expecting = this.getExpectedTokensForMessage( recognizer, token );
   const offending = this.getTokenDisplay( token, recognizer );
-  const err = recognizer.error( 'syntax-extraneous-token', token,
-                                { offending, expecting },
-                                'Extraneous $(OFFENDING), expecting $(EXPECTING)' );
+  // Just text variant, no other message id!  Would depend on ANTLR-internals
+  const err = recognizer.error( 'syntax-unexpected-token', token,
+                                { '#': 'unwanted', offending, expecting } );
   err.expectedTokens = expecting; // TODO: remove next token?
   if (!recognizer.avoidErrorListeners) // with --trace-parser or --trace-parser-ambig
     recognizer.notifyErrorListeners( err.message, token, err );
@@ -249,9 +256,11 @@ function reportMissingToken( recognizer ) {
   this.beginErrorCondition(recognizer);
 
   const token = recognizer.getCurrentToken();
+  token.$isSkipped = 'offending';
   const expecting = this.getExpectedTokensForMessage( recognizer, token );
   const offending = this.getTokenDisplay( token, recognizer );
   // TODO: if non-reserved keyword will not been parsed as keyword, use Identifier for offending
+  // Hopefully not too ANTLR-specific, so extra message id is ok:
   const err = recognizer.error( 'syntax-missing-token', token,
                                 { offending, expecting },
                                 'Missing $(EXPECTING) before $(OFFENDING)' );
@@ -264,10 +273,10 @@ function reportIgnoredWith( recognizer, t ) {
   const next = recognizer._interp.atn.states[recognizer.state].transitions[0].target;
   recognizer.state = next.stateNumber; // previous match() does not set the state
   const expecting = this.getExpectedTokensForMessage( recognizer, t );
-  const m = recognizer.warning( 'syntax-ignored-with', t,
-                                { offending: "';'", expecting },
+  const m = recognizer.warning( 'syntax-unexpected-semicolon', t,
+                                { offending: "';'", expecting, keyword: 'with' },
     // eslint-disable-next-line max-len
-                                'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous WITH' );
+                                'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
   m.expectedTokens = expecting;
 }
 
@@ -280,10 +289,10 @@ function consumeUntil( recognizer, set ) {
 
   // let s=this.getTokenDisplay( recognizer.getCurrentToken(), recognizer );
   if (SEMI < 1 || RBRACE < 1) {
-    this._super.consumeUntil.call( this, recognizer, set );
+    this.consumeAndMarkUntil( recognizer, set );
   }
   else if (set.contains(SEMI)) { // do not check for RBRACE here!
-    this._super.consumeUntil.call( this, recognizer, set );
+    this.consumeAndMarkUntil( recognizer, set );
     // console.log('CONSUMED-ORIG:',s,this.getTokenDisplay( recognizer.getCurrentToken(),
     // recognizer ),recognizer.getCurrentToken().line,intervalSetToArray( recognizer, set ));
   }
@@ -295,9 +304,9 @@ function consumeUntil( recognizer, set ) {
     stop.addOne( SEMI );
     // I am not that sure whether to add RBRACE...
     stop.addOne( RBRACE );
-    this._super.consumeUntil.call( this, recognizer, stop );
-    if (recognizer.getTokenStream().LA(1) === SEMI ||
-        recognizer.getTokenStream().LA(1) === RBRACE && !set.contains(RBRACE)) {
+    this.consumeAndMarkUntil( recognizer, stop );
+    const ttype = recognizer.getTokenStream().LA(1);
+    if (ttype === SEMI || ttype === RBRACE && !set.contains(RBRACE)) {
       recognizer.consume();
       this.reportMatch(recognizer); // we know current token is correct
     }
@@ -312,6 +321,15 @@ function consumeUntil( recognizer, set ) {
   }
 }
 
+function consumeAndMarkUntil( recognizer, set ) {
+  let t = recognizer.getTokenStream().LT(1);
+  while (t.type !== antlr4.Token.EOF && !set.contains( t.type )) {
+    if (!t.$isSkipped)
+      t.$isSkipped = true;
+    recognizer.consume();
+    t = recognizer.getTokenStream().LT(1);
+  }
+}
 
 // As the `match` function of the parser `recognizer` does not allow to check
 // against a set of token types, the generated parser code checks against that
@@ -328,7 +346,9 @@ 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 } );
+  // TODO: attach `Identifier` as valid name to message?
+  recognizer.message( 'syntax-unexpected-reserved-word', token,
+                      { code: token.text, delimited: token.text } );
   this.reportMatch(recognizer); // we know current token is correct
   recognizer.consume();
   return token;
@@ -496,14 +516,14 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   // expected.toString(recognizer.literalNames, recognizer.symbolicNames));
   return intervalSetToArray( recognizer, expected );
 
-  function addSet(other) {
+  function addSet( other ) {
     if (!other.contains( hideAltsType ))
       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) {
+  function addInterval( v ) {
     if (v.stop <= identType) {
       origAddInterval.call(this, v);
     }