@sap/cds-compiler 3.0.0 → 3.0.2

package/lib/json/from-csn.js

@@ -88,6 +88,7 @@
  */
 
 const { dictAdd } = require('../base/dictionaries');
+const { quotedLiteralPatterns } = require('../compiler/builtins');
 
 const $location = Symbol.for('cds.$location');
 
@@ -682,15 +683,6 @@ const topLevelSpec = {
   schema,
 };
 
-const validLiteralsExtra = Object.assign( Object.create(null), {
-  // TODO: should we use quotedLiteralPatterns from genericAntlrParser?
-  number: 'string',
-  x: 'string',
-  time: 'string',
-  date: 'string',
-  timestamp: 'string',
-} );
-
 // Module variables, schema compilation, and functors ------------------------
 
 /** @type {(id, location, textOrArguments, texts?) => void} */
@@ -1288,16 +1280,22 @@ function value( val, spec, xsn ) { // for CSN property 'val'
   return ignore( val );
 }
 
-function literal( val, spec, xsn, csn ) {
+function literal( lit, spec, xsn, csn ) {
   // TODO: general: requires other property (here: 'val')
   const type = (csn.val == null) ? 'null' : typeof csn.val;
-  if (val === type)            // also for 'object' which is an error for 'val'
-    return val;
-  if (typeof val === 'string' && validLiteralsExtra[val] === type)
-    return val;
+  if (lit === type)            // also for 'object' which is an error for 'val'
+    return lit;
+  if (typeof lit === 'string' && quotedLiteralPatterns[lit]?.json_type === type) {
+    const p = quotedLiteralPatterns[lit];
+    if (p && (p.test_fn && !p.test_fn(csn.val) || p.test_re && !p.test_re.test(csn.val)))
+      warning( 'syntax-invalid-literal', location(), { '#': p.test_variant } );
+    return lit;
+  }
+  if (lit === 'number' && type === 'string') // special case, not a quoted literal in CDL
+    return lit;
   error( 'syntax-expected-valid', location(true), { prop: spec.msgProp },
          'Expected valid string for property $(PROP)' );
-  return ignore( val );
+  return ignore( lit );
 }
 
 function func( val, spec, xsn ) {
@@ -1535,7 +1533,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
     const zero = s.vZeroFor;
     if (zero) {                 // (potential) CSN v0.1.0 property
       const group = s.xorGroup;
-      if (zero && expected( zero, schema[zero] ) && !(group && xor[group])) {
+      if (expected( zero, schema[zero] ) && !(group && xor[group])) {
         replaceZeroProp( prop, zero );
         if (group)
           xor[group] = prop;
@@ -1555,7 +1553,7 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
                std: 'CSN property $(PROP) is not expected in $(OTHERPROP)',
                top: 'CSN property $(PROP) is not expected top-level',
                def: 'CSN property $(PROP) is not expected by a definition of kind $(KIND)',
-               extend: 'CSN property $(PROP) is not expected by an extend in $(OTHERPROP))',
+               extend: 'CSN property $(PROP) is not expected by an extend in $(OTHERPROP)',
                annotate: 'CSN property $(PROP) is not expected by an annotate in $(OTHERPROP)',
              } );
     // TODO: or still augment it? (but then also handle xorGroup)
@@ -1783,7 +1781,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
 }
 
 
-function augment( csn, filename = 'csn.json', options = {}, messageFunctions ) {
+function augment( csn, filename = 'csn.json', options = {}, messageFunctions = {} ) {
   try {
     return toXsn( csn, filename, options, messageFunctions );
   }
@@ -1793,7 +1791,7 @@ function augment( csn, filename = 'csn.json', options = {}, messageFunctions ) {
   }
 }
 
-function parse( source, filename = 'csn.json', options = {}, messageFunctions ) {
+function parse( source, filename = 'csn.json', options = {}, messageFunctions = {} ) {
   try {
     return augment( JSON.parse(source), filename, options, messageFunctions );
   }

package/lib/json/to-csn.js

@@ -13,6 +13,7 @@
 
 const { locationString } = require('../base/messages');
 const { isBetaEnabled, isDeprecatedEnabled } = require('../base/model');
+const { pathName } = require('../compiler/utils');
 
 const compilerVersion = require('../../package.json').version;
 const creator = `CDS Compiler v${ compilerVersion }`;
@@ -1218,8 +1219,8 @@ function value( node ) {
   if (node.$inferred && gensrcFlavor)
     return undefined;
   if (node.path) {
-    const ref = node.path.map( id => id.id ).join('.');
-    return extra( { '=': node.variant ? `${ ref }#${ node.variant.id }` : ref }, node );
+    const ref = pathName( node.path );
+    return extra( { '=': node.variant ? `${ ref }#${ pathName(node.variant.path) }` : ref }, node );
   }
   if (node.literal === 'enum')
     return extra( { '#': node.sym.id }, node );

package/lib/language/genericAntlrParser.js

@@ -12,7 +12,8 @@ const { dictAdd, dictAddArray } = require('../base/dictionaries');
 const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
 const { parseMultiLineStringLiteral } = require('./multiLineStringParser');
-const { functionsWithoutParens, specialFunctions } = require('../compiler/builtins');
+const { functionsWithoutParens, specialFunctions, quotedLiteralPatterns } = require('../compiler/builtins');
+const { pathName } = require("../compiler/utils");
 
 const $location = Symbol.for('cds.$location');
 
@@ -62,6 +63,8 @@ Object.assign(GenericAntlrParser.prototype, {
   info: function(...args) { return _message( this, 'info', ...args ); },
   attachLocation,
   assignAnnotation,
+  checkExtensionDict,
+  handleExtension,
   startLocation,
   tokenLocation,
   valueWithTokenLocation,
@@ -113,40 +116,6 @@ Object.assign(GenericAntlrParser.prototype, {
   parseMultiLineStringLiteral,
 });
 
-// Patterns for literal token tests and creation.  The value is a map from the
-// `prefix` argument of function `quotedliteral` to the following properties:
-//  - `test_msg`: error message which is issued if `test_fn` or `test_re` fail.
-//  - `test_fn`: function called with argument `value`, fails falsy return value
-//  - `test_re`: regular expression, fails if it does not match argument `value`
-//  - `unexpected_msg`: error message which is issued if `unexpected_char` matches
-//  - `unexpected_char`: regular expression matching an illegal character in `value`,
-//    the error location is only correct for a literal <prefix>'<value>'
-//  - `literal`: the value which is used instead of `prefix` in the AST
-// TODO: we might do a range check (consider leap seconds, i.e. max value 60),
-//       but always allow Feb 29 (no leap year computation)
-// TODO: make it a configurable error (syntax-invalid-literal)
-// TODO: also use for CSN input
-const quotedLiteralPatterns = {
-  x: {
-    test_variant: 'uneven-hex',
-    test_fn: (str => Number.isInteger(str.length / 2)),
-    unexpected_variant: 'invalid-hex',
-    unexpected_char: /[^0-9a-f]/i,
-  },
-  time: {
-    test_variant: 'time',
-    test_re: /^[0-9]{1,2}:[0-9]{1,2}(:[0-9]{1,2})?$/,
-  },
-  date: {
-    test_variant: 'date',
-    test_re: /^[0-9]{4}-[0-9]{1,2}-[0-9]{1,2}$/,
-  },
-  timestamp: {
-    test_variant: 'timestamp',
-    test_re: /^[0-9]{4}-[0-9]{2}-[0-9]{2} [0-9]{2}:[0-9]{2}(:[0-9]{2}(\.[0-9]{1,7})?)?$/,
-  },
-};
-
 // Use the following function for language constructs which we (currently)
 // just being able to parse, in able to run tests from HANA CDS.  As soon as we
 // create ASTs for the language construct and put it into a CSN, a
@@ -355,7 +324,8 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
   const pathname = pathName( path );
   let absolute = '';
   if (name.variant) {
-    absolute = `${ prefix }${ pathname }#${ name.variant.id }`;
+    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
@@ -382,7 +352,8 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
       dictAddArray( art, prop, anno, (n, location, a) => {
         this.error( 'syntax-duplicate-anno', [ location ], { anno: n },
                     'Duplicate assignment with $(ANNO)' );
-        a.$errorReported = true; // do not report again later as anno-duplicate-xyz
+        a.$errorReported = 'syntax-duplicate-anno';
+        // do not report again later as anno-duplicate-xyz
       } );
   }
   if (!prefix) {                // set deprecated $annnotations for cds-lsp
@@ -393,6 +364,36 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
   }
 }
 
+function checkExtensionDict( dict ) {
+  for (const name in dict) {
+    const def = dict[name];
+    if (!def.$duplicates)
+      continue;
+
+    const numDefines = (def.kind === 'annotate')
+          ? 0
+          : def.$duplicates.reduce( addOneForDefinition, addOneForDefinition( 0, def ) );
+    this.handleExtension( def, name, numDefines );
+    for (const dup of def.$duplicates)
+      this.handleExtension( dup, name, numDefines );
+  }
+}
+
+function addOneForDefinition( count, ext ) {
+  return (ext.kind === 'extend') ? count : count + 1;
+}
+
+function handleExtension( ext, name, numDefines ) {
+  if (ext.kind === 'annotate')
+    this.warning( 'syntax-duplicate-annotate', [ ext.name.location ], { name } );
+  else if (ext.kind === 'extend')
+    this.error( 'syntax-duplicate-extend', [ ext.name.location ],
+                { name, '#': (numDefines ? 'define' : 'extend') } );
+  else if (numDefines === 1)
+    ext.$errorReported = 'syntax-duplicate-extend'; // a definition, but not duplicate
+}
+
+
 /**
  * Return start location of `token`, or the first token matched by the current
  * rule if `token` is undefined
@@ -504,7 +505,7 @@ function surroundByParens( expr, open, close, asQuery = false ) {
 }
 
 function unaryOpForParens( query, val ) {
-  const parens = query.$parens;
+  const parens = query?.$parens;
   if (!parens)
     return query;
   const location = parens[parens.length - 1];
@@ -743,10 +744,6 @@ function quotedLiteral( token, literal ) {
   }
 }
 
-function pathName( path, brokenName ) {
-  return (path && !path.broken) ? path.map( id => id.id ).join('.') : brokenName;
-}
-
 function pushIdent( path, ident, prefix ) {
   if (!ident) {
     path.broken = true;
@@ -981,6 +978,9 @@ function handleComposition( cardinality, isComposition ) {
 }
 
 function associationInSelectItem( art ) {
+  if (!art.value) // e.g. `expand` without value (for new structures)
+    return;
+
   const isPath = art.value.path && art.value.path.length
   const isIdentifier = isPath && art.value.path.length === 1;
   if (isIdentifier) {

package/lib/language/language.g4

@@ -398,6 +398,7 @@ artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent`
           this.error( 'syntax-extend-context', $annotate,
                       { code: 'ANNOTATE artifact', kind: defOnly },
                       'No $(CODE) within $(KIND) extensions' );
+        if (!$outer.extensions) $outer.extensions = [];
         this.meltKeywordToIdentifier();
       }
       annotateArtifact[ $art, $outer ] // not kind-specific
@@ -793,6 +794,7 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -809,6 +811,7 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -834,17 +837,18 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       |
         { this.disallowElementExtension( $elemName, $outer, 'actions' ); }
         ACTIONS '{' { $art.actions = this.createDict(); }
-        actionFunctionDef[ $art ]*
+        actionFunctionDef[ $art ]* // TODO: no EXTEND in actions? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.actions ); }
         optionalSemi
       |
         ELEMENTS '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         ENUM '{' { $art.enum = this.createDict(); }
-        enumSymbolDef[ $art ]*
+        enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.enum ); }
         optionalSemi
       )
@@ -862,6 +866,7 @@ extendWithOptElements[ art ]
       '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -873,6 +878,7 @@ extendWithOptElements[ art ]
       '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -892,11 +898,13 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       (
         ACTIONS
         '{' { $art.actions = this.createDict(); }
         annotateAction[ $art ]*
         '}' { this.finalizeDictOrArray( $art.actions ); }
+      { this.checkExtensionDict( $art.actions ); }
       )?
       optionalSemi
     |
@@ -904,6 +912,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       '{' { $art.actions = this.createDict(); }
       annotateAction[ $art ]*
       '}' { this.finalizeDictOrArray( $art.actions ); }
+      { this.checkExtensionDict( $art.actions ); }
       optionalSemi
     |
       '(' { $art.params = this.createDict(); }
@@ -912,11 +921,13 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         annotateParam[ $art ]
       )*
       ')' { this.finalizeDictOrArray( $art.params ); }
+      { this.checkExtensionDict( $art.params ); }
       (
         RETURNS { $art['$'+'syntax'] = 'returns'; }
         '{' { $art.elements = this.createDict(); }
         annotateElement[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -926,6 +937,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
 
     |
@@ -946,6 +958,7 @@ annotateElement[ outer ] locals[ art = {} ]
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -968,11 +981,13 @@ annotateAction [ outer ] locals [ art = {} ]
         annotateParam[ $art ]
       )*
       ')' { this.finalizeDictOrArray( $art.params ); }
+      { this.checkExtensionDict( $art.params ); }
     )?
     (
       RETURNS '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
@@ -1831,7 +1846,7 @@ typeNamedArg[ art ] locals[ arg = '' ]
   :
     name=ident['paramname']
     ':'
-    { if (this.checkTypeFacet( $art, $name.id ))
+    { if ($name.id && this.checkTypeFacet( $art, $name.id ))
         $arg = $name.id.id;
     }
     (
@@ -1868,10 +1883,10 @@ queryExpression returns[ query ] // QLSubqueryComplex, SubqueryComplex
       | op=MINUS  q=DISTINCT?
       )
       qt=queryTerm
-      { $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
+      { if ($qt.query) $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
     )*
-    ( ob=orderByClause[ $query ] { $query = $ob.query; } ) ?
-    ( lc=limitClause[ $query ]   { $query = $lc.query; } ) ?
+    ( ob=orderByClause[ $query ] { if ($ob.query) $query = $ob.query; } ) ?
+    ( lc=limitClause[ $query ]   { if ($lc.query) $query = $lc.query; } ) ?
   ;
 
 orderByClause[ inQuery ] returns [ query ]
@@ -2075,7 +2090,7 @@ tableExpression returns[ table ] // TableOrJoin
       ON cond=condition { $table.on = $cond.cond; }
     |
       crj=CROSS jn=JOIN tt=tableTerm
-      { $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
+      { if (!$table) { $table = {}; } $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
     )*
   ;
 
@@ -2257,9 +2272,11 @@ conditionTerm returns [ cond ]
     |
       { $cond = { args: [ $expr.expr ] }; }
       NOT predicate[ $cond, true ]
+      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
     |
       { $cond = { args: [ $expr.expr ] }; }
       predicate[ $cond, false ]
+      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
     )?                          // optional: for conditions in parentheses
   ;
 
@@ -2687,10 +2704,7 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
 flattenedValue[ assignment ] locals[ val = { name: {} } ]
   :
     at='@'? annotationPath[ $val.name, 'name', $at ]
-    (
-      '#' { this.meltKeywordToIdentifier(); }
-      variant=ident['variant'] { $val.name.variant = $variant.id; }
-    )?
+    ( annotationPathVariant[ $val.name ] )?
     (
       ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
       annoValue[ $val ]
@@ -2739,10 +2753,7 @@ annoSubValue returns[ val = {} ]
     { Object.assign( $val, this.numberLiteral( $num, $plus||$min ) ); }
   |
     at='@'? annotationPath[ $val, 'ref', $at ]
-    (
-      '#' { this.meltKeywordToIdentifier(); }
-      variant=ident['variant'] { $val.variant = $variant.id; }
-    )?
+    ( annotationPathVariant[ $val ] )?
   ;
 
 literalValue returns[ val ] locals[ tok ]
@@ -2800,12 +2811,12 @@ annotationPath[ art, category, headat = null ] locals[ _sync = 'nop' ]
     )*
   ;
 
-annotationPathVariant[ art ]
+annotationPathVariant[ art ] locals[ variant = {} ]
 @after { this.attachLocation($art); }
   :
     // TODO: warning for space after '#'
     '#' { this.meltKeywordToIdentifier(); }
-    variant=ident['variant'] { $art.variant = $variant.id; }
+    simplePath[ $variant, 'variant' ] { $art.variant = $variant; }
   ;
 
 // Identifier and non-reserved keywords --------------------------------------

package/lib/model/csnRefs.js

@@ -907,6 +907,7 @@ function startCsnPath( csnPath, csn ) {
 /**
  * @param {CSN.Path} csnPath
  * @param {CSN.Model} csn
+ * @param {any} resolve
  */
 function analyseCsnPath( csnPath, csn, resolve ) {
   /** @type {object} */

package/lib/model/csnUtils.js

@@ -1056,7 +1056,7 @@ function isValidMappingDialectCombi(sqlDialect, sqlMapping) {
  */
 // eslint-disable-next-line no-unused-vars
 function getElementDatabaseNameOf(elemName, sqlMapping, sqlDialect='plain') {
-  isValidMappingDialectCombi(sqlMapping, sqlDialect)
+  isValidMappingDialectCombi(sqlDialect, sqlMapping)
   if (sqlMapping === 'hdbcds') {
     return elemName;
   }
@@ -1280,19 +1280,30 @@ function copyAnnotationsAndDoc(fromNode, toNode, overwrite = false) {
  * @todo Does _not_ apply param/action/... annotations.
  *
  * @param {CSN.Model} csn
- * @param {{overwrite?: boolean, filter?: (name: string) => boolean}} config
+ * @param {{notFound?: (name: string, index: number) => void, override?: boolean, filter?: (name: string) => boolean}} config
+ *       notFound: Function that is called if the referenced definition can't be found.
+ *                 Second argument is index in `csn.extensions` array.
+ *       override: Whether to ignore existing annotations.
+ *       filter:   Positive filter. If it returns true, annotations for the referenced artifact
+ *                 will be applied.
+ * @todo Improve to also apply element annotations
  */
 function applyAnnotationsFromExtensions(csn, config) {
   if (!csn.extensions)
     return;
 
   const filter = config.filter || ((_name) => true);
-  for (const ext of csn.extensions) {
+  for (let i = 0; i < csn.extensions.length; ++i) {
+    const ext = csn.extensions[i];
     const name = ext.annotate || ext.extend;
-    const def = csn.definitions[name];
-    if (name && def && filter(name)) {
-      copyAnnotationsAndDoc(ext, def, config.overwrite);
-      applyAnnotationsToElements(ext, def);
+    if (name && filter(name)) {
+      const def = csn.definitions[name];
+      if (def) {
+        copyAnnotationsAndDoc(ext, def, config.override);
+        applyAnnotationsToElements(ext, def);
+      } else if (config.notFound) {
+        config.notFound(name, i);
+      }
     }
   }
 
@@ -1309,7 +1320,7 @@ function applyAnnotationsFromExtensions(csn, config) {
     forEach(ext.elements, (key, sourceElem) => {
       const targetElem = def.elements[key];
       if (targetElem) {
-        copyAnnotationsAndDoc(sourceElem, targetElem, config.overwrite);
+        copyAnnotationsAndDoc(sourceElem, targetElem, config.override);
         applyAnnotationsToElements(sourceElem, targetElem);
       }
     });

package/lib/model/revealInternalProperties.js

@@ -131,7 +131,10 @@ function revealInternalProperties( model, nameOrPath ) {
 
     path = path.split('/');
     if (path.length === 1) {
-      return reveal( xsn.definitions[path] || xsn.vocabularies && xsn.vocabularies[path] );
+      const def = xsn.definitions?.[path[0]] || xsn.vocabularies?.[path[0]];
+      if (!def)
+        throw new Error(`reveal xsn: Unknown definition: “${path[0]}”`)
+      return reveal( def );
     }
 
     // with the code below, we might miss the right transformer function