@sap/cds-compiler 3.0.2 → 3.1.0

package/lib/inspect/.eslintrc.json

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

package/lib/inspect/index.js

@@ -0,0 +1,14 @@
+// cds-compiler Inspect Module
+// Used by `cdsc inspect` to gather details about the model such as statistics, etc.
+
+'use strict';
+
+const { inspectModelStatistics } = require('./inspectModelStatistics');
+const { inspectPropagation } = require('./inspectPropagation');
+const { stringRefToPath } = require('./inspectUtils');
+
+module.exports = {
+  inspectModelStatistics,
+  inspectPropagation,
+  stringRefToPath,
+};

package/lib/inspect/inspectModelStatistics.js

@@ -0,0 +1,81 @@
+'use strict';
+
+const { forEach } = require('../utils/objectUtils');
+const { term } = require('../utils/term');
+
+/**
+ * Return a string representation of the inspected results.
+ *
+ * @param {XSN.Model} xsn
+ * @param {CSN.Options} options
+ * @returns {string}
+ */
+function inspectModelStatistics(xsn, options) {
+  let result = '';
+
+  // Default color mode is 'auto'
+  const color = term(options.color || 'auto');
+
+  const defCount = countDefinitionKinds(xsn);
+  const sources = {
+    cdl: Object.keys(xsn.sources).filter(name => xsn.sources[name].$frontend === 'cdl').length,
+    csn: Object.keys(xsn.sources).filter(name => xsn.sources[name].$frontend === 'csn').length,
+  };
+
+  result += `cds-compiler model statistics:
+
+${ color.underline('files') }:         ${ Object.keys(xsn.sources).length }
+  cdl sources: ${ sources.cdl }
+  csn sources: ${ sources.csn }
+
+${ color.underline('definitions') }:  ${ defCount.definitions }
+  entities:   ${ defCount.entity }
+  queries:    ${ defCount.view }
+  aspects:    ${ defCount.aspect }
+  events:     ${ defCount.event }
+  types:      ${ defCount.type }
+  services:   ${ defCount.service }
+  context:    ${ defCount.context }
+  actions:    ${ defCount.action }
+  functions:  ${ defCount.function }
+  namespaces: ${ defCount.namespace } (explicitly in CDL)
+
+${ color.underline('vocabularies') }: ${ Object.keys(xsn.vocabularies || {}).length }
+`;
+  return result;
+}
+
+function countDefinitionKinds(xsn) {
+  const result = {
+    definitions: 0,
+    entity: 0,
+    action: 0,
+    function: 0,
+    aspect: 0,
+    event: 0,
+    type: 0,
+    service: 0,
+    context: 0,
+    namespace: 0,
+    // non-kind
+    view: 0,
+  };
+  forEach(xsn.definitions || {}, (name, def) => {
+    if (def.builtin)
+      return;
+    ++result.definitions;
+
+    if (def.query || def.projection)
+      ++result.view;
+    else if (result[def.kind] !== undefined)
+      ++result[def.kind];
+    else
+      throw new Error(`Unhandled kind: ${ def.kind } for ${ name }`);
+  });
+  return result;
+}
+
+
+module.exports = {
+  inspectModelStatistics,
+};

package/lib/inspect/inspectPropagation.js

@@ -0,0 +1,189 @@
+'use strict';
+
+const { createMessageFunctions } = require('../base/messages');
+const { locationString } = require('../base/location');
+const { findArtifact, stringRefToPath } = require('./inspectUtils');
+const { term } = require('../utils/term');
+
+/**
+ * @param {XSN.Model} xsn
+ * @param {CSN.Options} options
+ * @param {string} artifactName
+ * @returns {string|null}
+ */
+function inspectPropagation(xsn, options, artifactName) {
+  const { error } = createMessageFunctions(options, 'inspect', xsn);
+  const result = [];
+
+  // Default color mode is 'auto'
+  const color = term(options.color || 'auto');
+
+  const path = stringRefToPath(artifactName);
+  if (!path) {
+    error(null, null, { name: artifactName },
+          'Artifact $(NAME) is not a valid path; expected format `<def>[:element]`');
+    return null;
+  }
+
+  const artifactXsn = findArtifact(xsn, path);
+
+  if (!artifactXsn) {
+    error(null, null, { name: artifactName },
+          // eslint-disable-next-line max-len
+          'Artifact $(NAME) not found, only top-level artifacts and their elements are supported for now');
+    return null;
+  }
+  result.push(color.underline('analyzing propagation for artifact:'));
+  result.push(`  name: ${ artifactXsn.name.id }`);
+  result.push(`  kind: ${ artifactXsn.kind }`);
+
+  if (artifactXsn.$inferred)
+    result.push(`  inferred: ${ artifactXsn.$inferred }`);
+
+  result.push('');
+  result.push(`  ${ color.underline('annotation propagation:') }`);
+  result.push(..._indent(_inspectAnnotations(artifactXsn)));
+
+  result.push('');
+  result.push(`  ${ color.underline('element propagation:') }`);
+  result.push(..._indent(_inspectElements(artifactXsn)));
+
+  return result.join('\n');
+}
+
+/**
+ @param {string[]} lines
+ @param {string} indent
+ * @returns {string[]}
+ */
+function _indent(lines, indent = '    ') {
+  return lines.map(str => `${ indent }${ str }`);
+}
+
+/**
+ * @param {XSN.Artifact} artifactXsn
+ * @returns {string[]}
+ * @private
+ */
+function _inspectAnnotations(artifactXsn) {
+  const result = [];
+  const annos = Object.keys(artifactXsn).filter(str => str.startsWith('@')).sort();
+
+  if (annos.length === 0)
+    return [ 'no annotations' ];
+
+  let maxAnnoLength = 30; // chosen arbitrarily, hopefully average
+  for (const anno of annos) {
+    const annoXsn = artifactXsn[anno];
+    const loc = locationString(annoXsn.name.location);
+    let origin;
+    switch (annoXsn.$priority) {
+      case false:
+        if (annoXsn.$inferred)
+          origin = 'propagation';
+        else
+          origin = 'direct';
+        break;
+
+      case 'extend':
+      case 'annotate':
+        origin = annoXsn.$priority;
+        break;
+
+      case undefined:
+        if (annoXsn.$inferred === '$generated') {
+          origin = 'generated';
+          break;
+        }
+        // fallthrough
+      default:
+        throw new Error(`inspect anno: Unhandled Case: ${ annoXsn.$priority }`);
+    }
+
+    maxAnnoLength = Math.max(maxAnnoLength, anno.length);
+
+    // origin: assume max length 11 of 'propagation'
+    // anno: use max length of all annotations till now
+    result.push([ origin.padStart(11), anno.padEnd(maxAnnoLength), loc ].join(' | '));
+  }
+  return result;
+}
+
+/**
+ * @param {XSN.Artifact} artifactXsn
+ * @returns {string[]}
+ * @private
+*/
+function _inspectElements(artifactXsn) {
+  if (!artifactXsn.elements)
+    return [ 'does not have elements' ];
+
+  const result = [];
+  const elements = Object.keys(artifactXsn.elements);
+
+  let maxElemLength = 12;
+
+  const inferredNiceOutput = {
+    '*': 'wildcard',
+    'expand-element': 'expanded',
+    'expand-param': 'expanded',
+    'aspect-composition': 'composition',
+  };
+
+  for (const element of elements) {
+    const elementXsn = artifactXsn.elements[element];
+    const loc = locationString(_origin(elementXsn).name.location);
+    let origin;
+
+    if (elementXsn.$inferred) {
+      // Use nice(r) output for known $inferred
+      if (inferredNiceOutput[elementXsn.$inferred])
+        origin = inferredNiceOutput[elementXsn.$inferred];
+      else
+        origin = elementXsn.$inferred;
+    }
+    else if (!isContainedInParentLocation(elementXsn, artifactXsn)) {
+      // just a heuristic
+      origin = 'extend';
+    }
+    else {
+      origin = 'direct';
+    }
+
+    maxElemLength = Math.max(maxElemLength, element.length);
+
+    // origin: assume max length 11 of 'composition'
+    // element: assume average length of 30, chosen randomly
+    result.push([ origin.padStart(11), element.padEnd(maxElemLength), loc ].join(' | '));
+  }
+  return result;
+}
+
+function _origin(elementXsn) {
+  while (elementXsn._origin)
+    elementXsn = elementXsn._origin;
+  return elementXsn;
+}
+
+/**
+ * Returns true if `art` is contained in `parent` according to its location.
+ *
+ * @param art
+ * @param parent
+ * @returns {boolean}
+ */
+function isContainedInParentLocation(art, parent) {
+  const artLoc = art.location;
+  const parentLoc = parent.location;
+  if (artLoc.file !== parentLoc.file)
+    return false;
+  if (artLoc.line < parentLoc.line || artLoc.line > parentLoc.endLine)
+    return false;
+  // Good enough for now
+  // TODO: Check columns
+  return true;
+}
+
+module.exports = {
+  inspectPropagation,
+};

package/lib/inspect/inspectUtils.js

@@ -0,0 +1,44 @@
+'use strict';
+
+/**
+ * Reference (string) to path (array) that can be used to identify an artifact
+ * @param str
+ * @returns {*[]|*}
+ */
+function stringRefToPath(str) {
+  // e.g. `ns.service.E:sub.elem.structured`
+  const path = str.split(':');
+  if (path.length === 1)
+    return path;
+  if (path.length > 2)
+    return null;
+  return [ path[0], ...path[1].split('.') ];
+}
+
+/**
+ * @param {XSN.Model} xsn
+ * @param {string} path
+ * @private
+ */
+function findArtifact(xsn, path) {
+  const segments = [ ...path ];
+  const topLevelName = segments[0];
+  let art = (xsn.definitions && xsn.definitions[topLevelName]) ||
+    (xsn.vocabularies && xsn.vocabularies[topLevelName]);
+  if (!art)
+    return null;
+  segments.shift();
+  if (segments.length === 0)
+    return art;
+  while (segments.length && art) {
+    const segment = segments.shift();
+    art = (art.items?.elements || art.elements)?.[segment];
+  }
+  return art || null;
+}
+
+
+module.exports = {
+  stringRefToPath,
+  findArtifact,
+};

package/lib/json/from-csn.js

@@ -103,6 +103,7 @@ const ourpropsRegex = /^[_$]?[a-zA-Z]+[0-9]*$/;
 const typeProperties = [
   // do not include CSN v0.1.0 properties here:
   'target', 'elements', 'enum', 'items',
+  'cardinality', // for association publishing in views
   'type', 'length', 'precision', 'scale', 'srid', 'localized', 'notNull',
   'keys', 'on',                 // only with 'target'
 ];
@@ -228,7 +229,7 @@ const schema = compileSchema( {
     dictionaryOf: definition,
     defaultKind: 'action',
     validKinds: [ 'action', 'function' ],
-    inKind: [ 'entity', 'annotate', 'extend' ],
+    inKind: [ 'entity', 'aspect', 'annotate', 'extend' ],
   },
   params: {
     dictionaryOf: definition,
@@ -1287,7 +1288,7 @@ function literal( lit, spec, xsn, csn ) {
     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)))
+    if (p && p.test_fn && !p.test_fn(csn.val))
       warning( 'syntax-invalid-literal', location(), { '#': p.test_variant } );
     return lit;
   }

package/lib/json/to-csn.js

@@ -127,9 +127,6 @@ const transformers = {
   // location is not renamed to $location as the name is well established in
   // XSN and too many places (also outside the compiler) had to be adapted
   location,                     // non-enumerable $location in CSN
-  $a2j: (e, csn) => {           // on artifact level
-    Object.assign( csn, e );
-  },
   $extra: (e, csn) => {
     Object.assign( csn, e );
   },
@@ -185,9 +182,11 @@ const propertyOrder = (function orderPositions() {
 }());
 
 // sync with definition in from-csn.js:
+// Note: Order here is also the property order in CSN.
 const typeProperties = [
-  'target', 'elements', 'enum', 'items', // TODO: notNull?
-  'type', 'length', 'precision', 'scale', 'srid', 'localized',
+  'target', 'elements', 'enum', 'items',
+  'cardinality', // for association publishing in views
+  'type', 'length', 'precision', 'scale', 'srid', 'localized', // TODO: notNull?
   'foreignKeys', 'on',      // for explicit ON/keys with REDIRECTED
 ];
 
@@ -1276,8 +1275,11 @@ function expression( node, dollarExtra ) {
     return { ref: [ node.param.val ], param: true }; // CDL rule for runtimes
   }
   if (node.path) {
+    const ref = node.path.map( pathItem );
+    if (node.path.$prefix)
+      ref.unshift( node.path.$prefix );
     // we would need to consider node.global here if we introduce that
-    return extra( { ref: node.path.map( pathItem ) }, dollarExtraNode );
+    return extra( { ref }, dollarExtraNode );
   }
   if (node.literal) {
     if (typeof node.val === node.literal || node.val === null)

package/lib/language/genericAntlrParser.js

@@ -63,10 +63,13 @@ Object.assign(GenericAntlrParser.prototype, {
   info: function(...args) { return _message( this, 'info', ...args ); },
   attachLocation,
   assignAnnotation,
+  addAnnotation,
   checkExtensionDict,
-  handleExtension,
+  handleDuplicateExtension,
   startLocation,
   tokenLocation,
+  isMultiLineToken,
+  fixMultiLineTokenEndLocation,
   valueWithTokenLocation,
   previousTokenAtLocation,
   combinedLocation,
@@ -190,12 +193,12 @@ function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
 }
 
 function setLocalTokenForId( tokenNameMap ) {
+  const tokenName = tokenNameMap[ this._input.LT(2).text || '' ];
   const ll1 = this.getCurrentToken();
-  if (ll1.type === this.constructor.Identifier || /^[a-zA-Z_]+$/.test( ll1.text )) {
-    const tokenName = tokenNameMap[ this._input.LT(2).text || '' ];
-    if (tokenName)
-      ll1.type = this.constructor[tokenName];
-  }
+  if (tokenName &&
+      (ll1.type === this.constructor.Identifier || /^[a-zA-Z_]+$/.test( ll1.text )))
+    ll1.type = this.constructor[tokenName];
+  return !!tokenName;
 }
 
 // // Special function for rule `requiredSemi` before return $ctx
@@ -267,9 +270,6 @@ function prepareGenericKeywords( pathItem, expected = null) {
   const func = pathItem?.id && specialFunctions[pathItem.id.toUpperCase()];
   const spec = func && func[argPos] || specialFunctions[''][argPos ? 1 : 0];
   this.$genericKeywords = spec;
-  // currently, we only have 'TODO', i.e. a keyword which is alternative to expression
-  // TODO: If not just at the beginning, we need a stack for $genericKeywords,
-  // as we can have nested special functions
   // @ts-ignore
   const token = this.getCurrentToken() || { text: '' };
   const text = token.text.toUpperCase();
@@ -308,15 +308,26 @@ function reportErrorForGenericKeyword() {
 function attachLocation( art ) {
   if (!art || art.$parens)
     return art;
-  if (!art.location)
-    art.location = this.startLocation();
-  const { stop } = this._ctx;
-  art.location.endLine = stop.line;
-  art.location.endCol = stop.stop - stop.start + stop.column + 2; // after the last char (special for EOF?)
+  if (!art.location) {
+    art.location = this.tokenLocation(this._ctx.start, this._ctx.stop);
+    return art;
+  }
+
+  // The last token (this._ctx.stop) may be a multi-line string literal, in which
+  // case we can't rely on `this._ctx.stop.line`.
+  if (this.isMultiLineToken(this._ctx.stop)) {
+    this.fixMultiLineTokenEndLocation(this._ctx.stop, art.location);
+
+  } else {
+    const { stop } = this._ctx;
+    art.location.endLine = stop.line;
+    art.location.endCol = stop.stop - stop.start + stop.column + 2; // after the last char (special for EOF?)
+  }
+
   return art;
 }
 
-function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
+function assignAnnotation( art, anno, prefix = '', iHaveVariant = false ) {
   const { name, $flatten } = anno;
   const { path } = name;
   if (path.broken || !path[path.length - 1].id)
@@ -344,19 +355,9 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
   }
   else {
     name.absolute = absolute;
-    const prop = '@' + absolute;
-    const old = art[prop];
-    if (old && old.$inferred)
-      art[prop] = anno;
-    else
-      dictAddArray( art, prop, anno, (n, location, a) => {
-        this.error( 'syntax-duplicate-anno', [ location ], { anno: n },
-                    'Duplicate assignment with $(ANNO)' );
-        a.$errorReported = 'syntax-duplicate-anno';
-        // do not report again later as anno-duplicate-xyz
-      } );
+    this.addAnnotation( art, '@' + absolute, anno );
   }
-  if (!prefix) {                // set deprecated $annnotations for cds-lsp
+  if (!prefix) {                // set deprecated $annotations for cds-lsp
     if (!art.$annotations)
       art.$annotations = [];
     const location = locUtils.combinedLocation( anno.name, anno );
@@ -364,18 +365,53 @@ function assignAnnotation( art, anno, prefix = '', iHaveVariant ) {
   }
 }
 
+function addAnnotation( art, prop, anno ) {
+  dictAddArray( art, prop, anno, (n, location, a) => {
+    // if we would make it a warning, we would still need to keep it an error
+    // with '...'; otherwise parse.cdl would have to split annotate statements
+    this.error( 'syntax-duplicate-anno', [ location ], { anno: n },
+                'Duplicate assignment with $(ANNO)' );
+    a.$errorReported = 'syntax-duplicate-anno';
+    // do not report again later as anno-duplicate-xyz
+  } );
+}
+
+const extensionDicts = { elements: true, enum: true, params: true, returns: true };
+
 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 );
+    if (def.kind !== 'annotate') {
+      const numDefines =
+            def.$duplicates.reduce( addOneForDefinition, addOneForDefinition( 0, def ) );
+      this.handleDuplicateExtension( def, name, numDefines );
+      for (const dup of def.$duplicates)
+        this.handleDuplicateExtension( dup, name, numDefines );
+      continue;
+    }
+    // move annotations, 'doc' and 'elements' etc to main member
+    for (const dup of def.$duplicates) {
+      for (const prop of Object.keys( dup )) {
+        if (prop.charAt(0) === '@') {
+          this.addAnnotation( def, prop, dup[prop] )
+        }
+        else if (prop === 'doc') {
+          if (def.doc)
+            this.warning( 'syntax-duplicate-doc-comment', def.doc.location, {},
+                          'Doc comment is overwritten by another one below' );
+          def.doc = dup.doc;
+        }
+        else if (extensionDicts[prop]) {
+          if (def[prop])
+            this.message( 'syntax-duplicate-annotate', [ def.name.location ], { name, prop } );
+          def[prop] = dup[prop]; // continuation semantics: last wins
+        }
+      }
+    }
+    def.$duplicates = null;
   }
 }
 
@@ -383,10 +419,15 @@ 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')
+/**
+ * Handle duplicate extensions.  Does not handle `annotate`.
+ *
+ * @param {XSN.Extension} ext
+ * @param {string} name
+ * @param {number} numDefines
+ */
+function handleDuplicateExtension( ext, name, numDefines ) {
+  if (ext.kind === 'extend')
     this.error( 'syntax-duplicate-extend', [ ext.name.location ],
                 { name, '#': (numDefines ? 'define' : 'extend') } );
   else if (numDefines === 1)
@@ -434,31 +475,49 @@ function tokenLocation( token, endToken = null ) {
 
   // This check is done for performance reason. No need to access a token's
   // data if we know that it spans only one single line.
-  const isMultiLineToken = (
-    endToken.type === this.constructor.DocComment ||
-    endToken.type === this.constructor.String ||
-    endToken.type === this.constructor.UnterminatedLiteral
+  if (this.isMultiLineToken(token))
+    this.fixMultiLineTokenEndLocation(token, loc);
+
+  return loc;
+}
+
+function isMultiLineToken(token) {
+  return (
+    token.type === this.constructor.DocComment ||
+    token.type === this.constructor.String ||
+    token.type === this.constructor.UnterminatedLiteral
   );
-  if (isMultiLineToken) {
-    // Count the number of newlines in the token.
-    const source = endToken.source[1].data;
-    let newLineCount = 0;
-    let lastNewlineIndex = endToken.start;
-    for (let i = endToken.start; i < endToken.stop; i++) {
-      // Note: We do NOT check for CR, LS, and PS (/[\r\u2028\u2029]/)
-      //       because ANTLR only uses LF for line break detection.
-      if (source[i] === 10) { // code point of '\n'
-        newLineCount++;
-        lastNewlineIndex = i;
-      }
-    }
-    if (newLineCount > 0) {
-      loc.endLine = endToken.line + newLineCount;
-      loc.endCol = endToken.stop - lastNewlineIndex + 1;
+}
+
+/**
+ * Adapt end location of `location` according to `token`, assuming that `token` is a multi-line
+ * token such as a multi-line string or doc comment.
+ *
+ * Sets `endLine`/`endCol`, respecting newline characters in the token.
+ *
+ * @param token
+ * @param {CSN.Location} location
+ */
+function fixMultiLineTokenEndLocation( token, location ) {
+  // Count the number of newlines in the token.
+  const source = token.source[1].data;
+  let newLineCount = 0;
+  let lastNewlineIndex = token.start;
+  for (let i = token.start; i < token.stop; i++) {
+    // Note: We do NOT check for CR, LS, and PS (/[\r\u2028\u2029]/)
+    //       because ANTLR only uses LF for line break detection.
+    if (source[i] === 10) { // code point of '\n'
+      newLineCount++;
+      lastNewlineIndex = i;
     }
   }
-
-  return loc;
+  if (newLineCount > 0) {
+    location.endLine = token.line + newLineCount;
+    location.endCol = token.stop - lastNewlineIndex + 1;
+  } else {
+    location.endLine = token.line;
+    location.endCol = token.stop - token.start + token.column + 2; // after the last char (special for EOF?)
+  }
 }
 
 /**
@@ -531,8 +590,8 @@ function docComment( node ) {
   if (!this.options.docComment)
     return;
   if (node.doc) {
-    this.warning( 'syntax-duplicate-doc-comment', token, {},
-                  'Repeated doc comment - previous doc is replaced' );
+    this.warning( 'syntax-duplicate-doc-comment', node.doc.location, {},
+                  'Doc comment is overwritten by another one below' );
   }
   node.doc = this.valueWithTokenLocation( parseDocComment( token.text ), token );
 }
@@ -716,8 +775,7 @@ function quotedLiteral( token, literal ) {
     literal = token.text.slice( 0, pos - 1 ).toLowerCase();
   const p = quotedLiteralPatterns[literal] || {};
 
-  if ((p.test_fn && !p.test_fn(val) || p.test_re && !p.test_re.test(val)) &&
-      !this.options.parseOnly)
+  if (p.test_fn && !p.test_fn(val) && !this.options.parseOnly)
     this.warning( 'syntax-invalid-literal', location, { '#': p.test_variant } );
 
   if (p.unexpected_char) {