@sap/cds-compiler 3.5.4 → 3.6.0

package/lib/json/to-csn.js

@@ -14,6 +14,7 @@
 const { locationString } = require('../base/messages');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
 const { pathName } = require('../compiler/utils');
+const { CompilerAssertion } = require('../base/error');
 
 const compilerVersion = require('../../package.json').version;
 const creator = `CDS Compiler v${ compilerVersion }`;
@@ -106,7 +107,7 @@ const transformers = {
   notNull: value,
   default: expression,
   // targetElement: ignore,     // special display of foreign key, renameTo: select
-  value: enumValue,             // do not list for select items as elements
+  value: enumValueOrCalc,       // do not list for select items as elements
   query,
   elements,
   actions,                      // TODO: just normal dictionary
@@ -570,7 +571,7 @@ function standard( node ) {
 function unexpected( val, csn, node, prop ) {
   if (strictMode) {
     const loc = val && val.location || node.location;
-    throw new Error( `Unexpected property ${ prop } in ${ locationString(loc) }` );
+    throw new CompilerAssertion( `Unexpected property ${ prop } in ${ locationString(loc) }` );
   }
   // otherwise, just ignore the unexpected property
 }
@@ -820,7 +821,7 @@ function returns( art, csn, _node, prop ) {
 }
 
 function definition( art, _csn, _node, prop ) {
-  if (!art || typeof art !== 'object')
+  if (!art || typeof art !== 'object' || art.builtin)
     return undefined;           // TODO: complain with strict
   // Do not include namespace definitions or inferred construct (in gensrc):
   if (art.kind === 'namespace' || art.$inferred && gensrcFlavor)
@@ -1049,6 +1050,11 @@ function hasExplicitProp( ref, alsoLikeExplicit ) {
   return ref && (!ref.$inferred || ref.$inferred === alsoLikeExplicit );
 }
 
+/**
+ * @param art
+ * @param user
+ * @return {boolean|string[]}
+ */
 function originRef( art, user ) {
   const r = [];
   // do not use name.element, as we might allow `.`s in name
@@ -1143,7 +1149,7 @@ function artifactRef( node, terse ) {
   const root = Array.isArray(link) ? link[0] : link;
   if (!root) {                  // XSN directly coming from the parser
     if (strictMode && node.scope === 'typeOf')
-      throw new Error( `Unexpected TYPE OF in ${ locationString(node.location) }`);
+      throw new CompilerAssertion( `Unexpected TYPE OF in ${ locationString(node.location) }`);
     return renderArtifactPath( node, path, terse, node.scope );
   }
   const { absolute } = root.name;
@@ -1256,17 +1262,17 @@ function value( node ) {
   return r;
 }
 
-function enumValue( v, csn, node ) {
-  // Enums can have values but if enums are extended, their kind is 'element',
-  // so we check whether the node is inside an extension. (TODO: still?)
-  if (universalCsn && v.$inferred)
-    return;
-  // (with gensrc, the symbol itself would not make it into the CSN)
-  if (node.kind === 'enum' || node._parent && node._parent.kind === 'extend')
+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'
+  if (node.kind === 'enum' || node.$syntax === 'enum')
     Object.assign( csn, expression( v ) );
+  else if (node.$syntax === 'calc') // TODO: || node._parent?.kind === 'extend'
+    return expression( v );
+  return undefined;
 }
 
-
 function onCondition( cond, csn, node ) {
   if (gensrcFlavor) {
     if (node._origin && node._origin.$inferred === 'REDIRECTED')
@@ -1280,14 +1286,14 @@ function onCondition( cond, csn, node ) {
 function condition( node ) {
   const expr = exprInternal( node, 'no' );
   return (Array.isArray( expr ))
-    ? flattenenInternalXpr( expr )
+    ? flattenInternalXpr( expr, node.op?.val )
     : !expr.cast && !expr.func && expr.xpr || [ expr ];
 }
 
 function expression( node ) {
   const expr = exprInternal( node, 'no' );
   return (Array.isArray( expr ))
-    ? { xpr: flattenenInternalXpr( expr ) }
+    ? { xpr: flattenInternalXpr( expr, node.op?.val ) }
     : expr;
 }
 
@@ -1331,8 +1337,9 @@ function exprInternal( node, xprParens ) {
   if (!node.op)                 // parse error
     return { xpr: [] };
 
-  const { val } = node.op;
+  let { val } = node.op;
   switch (val) {
+    case 'nary':
     case 'ixpr':
     case 'xpr':
       break;
@@ -1346,21 +1353,30 @@ function exprInternal( node, xprParens ) {
       const nary = [];
       for (const item of node.args)
         nary.push( { val, literal: 'token' }, item );
+      val = 'nary';
       node = {
-        op: { val: 'ixpr' },
-        args: (nary.length > 2 ? nary.slice(1) : nary),
+        op: { val },
+        args: (nary.length > 2 ? nary.slice(1) : nary), // length 1,2 only with CSN v0
         $parens: node.$parens,
       };
     }
   }
   const rargs = node.args.map( exprInternal );
   if (val === 'xpr' || node.$parens)
-    return extra( { xpr: flattenenInternalXpr( rargs ) }, node, (xprParens === 'no' ? 0 : 1) );
-  return rargs.length === 1 ? rargs[0] : rargs;
-}
-
-function flattenenInternalXpr( array ) {
-  return (structXpr) ? array : array.flat( Infinity );
+    return extra( { xpr: flattenInternalXpr( rargs, val ) }, node, (xprParens === 'no' ? 0 : 1) );
+  return rargs.length === 1 ? rargs[0] : flattenInternalXpr( rargs, val );
+}
+
+function flattenInternalXpr( array, op ) {
+  if (!structXpr)
+    return array.flat( Infinity );
+  if (array.length < 5 || op !== 'nary')
+    return array;
+  let left = array.slice( 0, 3 );
+  let index = 3;
+  while (index < array.length)
+    left = [ left, array[index++], array[index++] ];
+  return left;
 }
 
 function query( node, csn, xsn, _prop, expectedParens = 0 ) {

package/lib/language/antlrParser.js

@@ -164,11 +164,8 @@ function parse( source, filename = '<undefined>.cds',
   if (options.docComment !== false) {
     for (const token of tokenStream.tokens) {
       if (token.type === parser.constructor.DocComment && !token.isUsed) {
-        // 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

@@ -6,6 +6,10 @@ const {
   cdlNewLineRegEx,
 } = require('./textUtils');
 
+const fencedCommentRegEx = /^\s*[*]/;
+const footerFenceRegEx = /\s*[*]+\/$/;
+const hasContentOnFirstLineRegEx = /\/\*+\s*\S/;
+
 /**
  * Get the content of a JSDoc-like comment and remove all surrounding asterisks, etc.
  * If the comment only contains whitespace it is seen as empty and `null` is returned
@@ -36,7 +40,7 @@ function parseDocComment( comment ) {
 
   // If the comment already has content on the first line, i.e. after `/**`,
   // its leading whitespace is ignored for whitespace trimming.
-  const hasContentOnFirstLine = /\/\*+\s*\S/.test(lines[0]);
+  const hasContentOnFirstLine = hasContentOnFirstLineRegEx.test(lines[0]);
 
   // First line, i.e. header, is always trimmed from left.
   lines[0] = removeHeaderFence(lines[0]).trimStart();
@@ -139,7 +143,7 @@ function removeHeaderFence( line ) {
  * @returns {string} header without fence
  */
 function removeFooterFence( line ) {
-  return line.replace(/\s*[*]+\/$/, '');
+  return line.replace(footerFenceRegEx, '');
 }
 
 /**
@@ -151,7 +155,7 @@ function removeFooterFence( line ) {
 function isFencedComment( lines ) {
   const index = lines.findIndex((line, i) => {
     const exclude = (i === 0 || i === lines.length - 1);
-    return !exclude && !(/^\s*[*]/.test(line));
+    return !exclude && !(fencedCommentRegEx.test(line));
   });
   return index === -1 && lines.length > 2;
 }

package/lib/language/errorStrategy.js

@@ -38,6 +38,7 @@ const {
 } = require('antlr4/src/antlr4/PredictionContext');
 const { ATNState } = require('antlr4/src/antlr4/atn/ATNState');
 const { IntervalSet, Interval } = require('antlr4/src/antlr4/IntervalSet');
+const { CompilerAssertion } = require('../base/error');
 
 const keywordRegexp = /^[a-zA-Z]+$/; // we don't have keywords with underscore
 
@@ -317,7 +318,7 @@ function consumeUntil( recognizer, set ) {
     }
     // console.log('CONSUMED:',s,this.getTokenDisplay( recognizer.getCurrentToken(),
     // recognizer ),recognizer.getCurrentToken().line);
-    // throw new Error('Sync')
+    // throw new CompilerAssertion('Sync')
   }
 }
 
@@ -471,7 +472,7 @@ function getExpectedTokensForMessage( recognizer, offendingToken, deadEnds ) {
   if (recognizer.state < 0)
     return [];
   if (recognizer.state >= atn.states.length) {
-    throw new Error( `Invalid state number ${ recognizer.state } for ${
+    throw new CompilerAssertion( `Invalid state number ${ recognizer.state } for ${
       this.getTokenErrorDisplay( offendingToken ) }`);
   }
 

package/lib/language/genericAntlrParser.js

@@ -111,6 +111,10 @@ Object.assign(GenericAntlrParser.prototype, {
   finalizeDictOrArray,
   createPrefixOp,
   setMaxCardinality,
+  setNullability,
+  reportDuplicateClause,
+  reportUnexpectedExtension,
+  reportUnexpectedSpace,
   pushIdent,
   handleComposition,
   associationInSelectItem,
@@ -165,6 +169,7 @@ function noSemicolonHere() {
 // 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`
 function excludeExpected( excludes ) {
   if (excludes) {
     // @ts-ignore
@@ -192,8 +197,8 @@ function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
     ll1.type = this.constructor[tokenName];
 }
 
-function setLocalTokenForId( tokenNameMap ) {
-  const tokenName = tokenNameMap[this._input.LT(2).text || ''];
+function setLocalTokenForId( offset, tokenNameMap ) {
+  const tokenName = tokenNameMap[this._input.LT( offset ).text.toUpperCase() || ''];
   const ll1 = this.getCurrentToken();
   if (tokenName &&
       (ll1.type === this.constructor.Identifier || /^[a-zA-Z_]+$/.test( ll1.text )))
@@ -219,9 +224,9 @@ function setLocalTokenForId( tokenNameMap ) {
 function noAssignmentInSameLine() {
   const t = this.getCurrentToken();
   if (t.text === '@' && t.line <= this._input.LT(-1).line) {
-    this.warning( 'syntax-missing-newline', t, { anno: '‹anno›' }, // TODO: single quotes, @()
+    this.warning( 'syntax-missing-semicolon', t, { code: ';' },
                   // eslint-disable-next-line max-len
-                  'Add a newline before $(ANNO) to indicate that it belongs to the next statement' );
+                  'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
   }
 }
 
@@ -319,7 +324,7 @@ function attachLocation( art ) {
   return art;
 }
 
-function assignAnnotation( art, anno, prefix = '', iHaveVariant = false ) {
+function assignAnnotation( art, anno, prefix = '' ) {
   const { name, $flatten } = anno;
   const { path } = name;
   if (path.broken || !path[path.length - 1].id)
@@ -329,11 +334,9 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant = false ) {
   if (name.variant) {
     const variant = pathName( name.variant.path );
     absolute = `${ prefix }${ pathname }#${ variant }`;
-    if (iHaveVariant) {       // TODO: do we really care in the parser / core compiler?
-      this.error( 'anno-duplicate-variant', [ name.variant.location ],
-                  {},      // TODO: params
-                  'Annotation variant has been already provided' );
-    }
+    // We do not care anymore whether we get a second '#' with flattening.  This
+    // can be produced via CSN and with delimited ids anyway.  If backends care,
+    // they need to have their own check.
   }
   else if (!prefix || pathname !== '$value') {
     absolute = `${ prefix }${ pathname }`;
@@ -343,7 +346,7 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant = false ) {
   }
   if ($flatten) {
     for (const a of $flatten)
-      this.assignAnnotation( art, a, `${ absolute }.`, iHaveVariant || name.variant);
+      this.assignAnnotation( art, a, `${ absolute }.` );
   }
   else {
     name.absolute = absolute;
@@ -682,16 +685,22 @@ function identAst( token, category, noTokenTypeCheck = false ) {
 
 // only to be used in @after
 // TODO: remove compatible stuff (A2J/checks use op: 'and'/'=')
-function argsExpression( args, useFirstLocation, compatible = null ) {
+function argsExpression( args, nary, location ) {
   // console.log('AE:',args);
   if (args.length === 1)
     return args[0];
-  const location = useFirstLocation && args[0] && { ...args[0].location };
-  const op = compatible && args.length === 3 && args[1].val === compatible && args[1];
-  const expr = (op)
-    ? { op: { val: op.val, location: op.location }, args: [ args[0], args[2] ], location }
-    : { op: { val: 'ixpr', location: this.startLocation() }, args, location };
-  return this.attachLocation( expr );
+  if (nary && args.length === 3 && args[1]?.val === nary) {
+    return this.attachLocation( {
+      op: { val: nary, location: args[1].location },
+      args: [ args[0], args[2] ],
+      location: undefined,
+    } );
+  }
+  const op = {
+    val: (nary && nary !== '=' ? 'nary' : 'ixpr'), // there is no n-ary in rule conditionTerm
+    location: this.startLocation(),
+  };
+  return this.attachLocation( { op, args, location: location && { ...location } } );
 }
 
 function pushXprToken( args ) {
@@ -738,7 +747,7 @@ function valuePathAst( ref ) {
 // If a '-' is directly before an unsigned number, consider it part of the number;
 // otherwise (including for '+'), represent it as extra unary prefix operator.
 function signedExpression( args, expr ) {
-  // if (args.length !== 1) throw Error()
+  // if (args.length !== 1) throw new CompilerAssertion()
   const sign = args[0];
   const nval
         = (sign.val === '-' &&
@@ -778,7 +787,7 @@ function numberLiteral( token, sign, text = token.text ) {
   if (!Number.isSafeInteger(num)) {
     if (sign == null) {
       this.error( 'syntax-expecting-unsigned-int', token,
-                  { '#': !text.match(/^[0-9]*$/) ? 'normal' : 'unsafe' } );
+                  { '#': !text.match(/^\d*$/) ? 'normal' : 'unsafe' } );
     }
 
     else if (text !== `${ num }`) {
@@ -845,26 +854,33 @@ function pushIdent( path, ident, prefix ) {
     path.push( ident );
   }
   else {
-    const tokenLoc = this.tokenLocation( prefix );
-    if (tokenLoc.endLine !== ident.location.line ||
-        tokenLoc.endCol !== ident.location.col) {
-      const wsLocation = {
-        file: ident.location.file,
-        line: tokenLoc.endLine,           // !
-        col: tokenLoc.endCol,             // !
-        endLine: ident.location.line,
-        endCol: ident.location.col,
-      };
-      this.error( 'syntax-unexpected-space', wsLocation, {}, // TODO: really Error?
-                  'Expected identifier after \'@\' but found whitespace' );
-    }
-    ident.location.line = tokenLoc.line;
-    ident.location.col = tokenLoc.col;
+    const { location } = ident;
+    const prefixLoc = this.reportUnexpectedSpace( prefix, location );
+    location.line = prefixLoc.line;
+    location.col = prefixLoc.col;
     ident.id = prefix.text + ident.id;
     path.push( ident );
   }
 }
 
+// For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths
+function reportUnexpectedSpace( prefix, location = this.tokenLocation( this._input.LT(1) ) ) {
+  const prefixLoc = this.tokenLocation( prefix );
+  if (prefixLoc.endLine !== location.line ||
+      prefixLoc.endCol !== location.col) {
+    const wsLocation = {
+      file: location.file,
+      line: prefixLoc.endLine,           // !
+      col: prefixLoc.endCol,             // !
+      endLine: location.line,
+      endCol: location.col,
+    };
+    this.warning( 'syntax-unexpected-space', wsLocation, { op: prefix.text },
+                  'Delete the whitespace after $(OP)' );
+  }
+  return prefixLoc;
+}
+
 // Add new definition `art` to dictionary property `env` of node `parent`.
 // Return `art`.
 //
@@ -1038,14 +1054,53 @@ function leftAssocBinaryOp( left, opToken, eToken, right, extraProp = 'quantifie
   return { op, args: [ left, right ], location: left.location };
 }
 
-function setMaxCardinality( art, token, max ) {
-  const location = this.tokenLocation( token );
-  if (!art.cardinality) {
-    art.cardinality = { targetMax: Object.assign( { location }, max ), location };
+const maxCardinalityKeywords = { 1: 'one', '*': 'many' };
+
+function setMaxCardinality( art, targetMax, token ) {  // - val
+  if (token)
+    targetMax.location = this.tokenLocation( token );
+  if (art.cardinality) {
+    this.reportDuplicateClause( 'cardinality', targetMax, art.cardinality.targetMax,
+                                maxCardinalityKeywords );
   }
   else {
-    this.warning( 'syntax-duplicate-cardinality', location, { keyword: token.text },
-                  'The target cardinality has already been specified - ignoring $(KEYWORD)' );
+    art.cardinality = { targetMax, location: targetMax.location };
+  }
+}
+
+const notNullKeywords = { false: 'null', true: 'not null' };
+
+function setNullability( art, token1, token2 ) {
+  const notNull = this.valueWithTokenLocation( !!token2, token1, token2 );
+  if (art.notNull)
+    this.reportDuplicateClause( 'notNull', art.notNull, notNull, notNullKeywords );
+  art.notNull = notNull;
+}
+
+function reportDuplicateClause( prop, errorneous, chosen, keywords ) {
+  // probably easier for message linters not to use (?:) for the message id...?
+  const args = {
+    '#': prop,
+    code: keywords[chosen.val] || chosen.val,
+    line: chosen.location.line,
+    col: chosen.location.col,
+  };
+  if (errorneous.val === chosen.val)
+    this.warning( 'syntax-duplicate-equal-clause', errorneous.location, args );
+  else
+    this.message( 'syntax-duplicate-clause', errorneous.location, args );
+}
+
+const extensionsCode = {
+  definitions: 'extend … with definitions',
+  context: 'extend context',
+  service: 'extend service',
+};
+
+function reportUnexpectedExtension( defOnly, token ) {
+  if (defOnly) {
+    this.error( 'syntax-unexpected-extension', token,
+                { keyword: token.text, code: extensionsCode[defOnly] } );
   }
 }