@sap/cds-compiler 2.12.0 → 2.15.2

package/lib/language/genericAntlrParser.js

@@ -14,6 +14,7 @@ const { parseDocComment } = require('./docCommentParser');
 const { parseMultiLineStringLiteral } = require('./multiLineStringParser');
 const { functionsWithoutParens, specialFunctions } = require('../compiler/builtins');
 
+const $location = Symbol.for('cds.$location');
 
 // Push message `msg` with location `loc` to array of errors:
 function _message( parser, severity, id, loc, ...args ) {
@@ -35,6 +36,19 @@ function GenericAntlrParser( ...args ) {
   // ANTLR restriction: we cannot add parameters to the constructor.
   antlr4.Parser.call( this, ...args );
   this.buildParseTrees = false;
+
+  // Common properties.
+  // We set them here so that they are available in the prototype.
+  // This improved performance by 25% for certain scenario tests.
+  // Probably because there was no need to look up the prototype chain anymore.
+  this.$adaptExpectedToken = null;
+  this.$adaptExpectedExcludes = [ ];
+  this.$nextTokensToken = null;
+  this.$nextTokensContext = null;
+
+  this.prepareGenericKeywords();
+  this.options = {};
+
   return this;
 }
 
@@ -55,6 +69,8 @@ GenericAntlrParser.prototype = Object.assign(
     valueWithTokenLocation,
     previousTokenAtLocation,
     combinedLocation,
+    createDict,
+    setDictEndLocation,
     surroundByParens,
     unaryOpForParens,
     leftAssocBinaryOp,
@@ -70,15 +86,19 @@ GenericAntlrParser.prototype = Object.assign(
     docComment,
     addDef,
     addItem,
+    artifactForElementAnnotateOrExtend,
     assignProps,
     createPrefixOp,
     setOnce,
     setMaxCardinality,
     pushIdent,
     handleComposition,
+    associationInSelectItem,
     reportExpandInline,
+    checkTypeFacet,
     notSupportedYet,
     csnParseOnly,
+    disallowElementExtension,
     noAssignmentInSameLine,
     noSemicolonHere,
     setLocalToken,
@@ -213,6 +233,22 @@ function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
 //     // throw new antlr4.error.InputMismatchException(this);
 // }
 
+/**
+ * For element extensions (`extend E:elem` syntax).
+ * If `elemName.path` is set, remove the last extension from `$outer` and
+ * emit an error that the extension is invalid.
+ *
+ * @param {object} elemName
+ * @param {object} outer
+ * @param {string} extensionVariant
+ */
+function disallowElementExtension(elemName, outer, extensionVariant) {
+  if (elemName.path) {
+    this.message( 'syntax-invalid-extend', this.tokenLocation(this.getCurrentToken()), { 'kind': extensionVariant } );
+    outer.extensions.length = outer.extensions.length - 1; // remove last, i.e. new extension
+  }
+}
+
 function noAssignmentInSameLine() {
   const t = this.getCurrentToken();
   if (t.text === '@' && t.line <= this._input.LT(-1).line) {
@@ -373,6 +409,20 @@ function combinedLocation( start, end ) {
   return locUtils.combinedLocation( start, end );
 }
 
+function createDict( location = null ) {
+  const dict = Object.create(null);
+  dict[$location] = location || this.startLocation( this._input.LT(-1) );
+  return dict;
+}
+
+function setDictEndLocation( dict ) {
+  const stop = this._input.LT(-1);
+  Object.assign( dict[$location], {
+    endLine: stop.line,
+    endCol: stop.stop - stop.start + stop.column + 2,
+  } );
+}
+
 function surroundByParens( expr, open, close, asQuery = false ) {
   if (!expr)
     return expr;
@@ -546,11 +596,11 @@ function numberLiteral( token, sign, text = token.text ) {
     location.endCol = endCol;
     text = sign.text + text;
   }
+
   const num = Number.parseFloat( text || '0' ); // not Number.parseInt() !
   if (!Number.isSafeInteger(num)) {
     if (sign == null) {
-      this.error( 'syntax-no-integer', token, {},
-                  'An integer number is expected here' );
+      this.error( 'syntax-expected-integer', token, { '#': !text.match(/^[0-9]*$/) ? 'normal' : 'unsafe'} );
     }
     else if (text !== `${num}`) {
       return { literal: 'number', val: text, location };
@@ -664,13 +714,13 @@ function addDef( parent, env, kind, name, annos, props, location ) {
     }
   }
   else if (name && name.id == null) {
-    name.id = pathName(name.path ); // A.B.C -> 'A.B.C'
+    name.id = pathName( name.path ); // A.B.C -> 'A.B.C'
   }
   const art = this.assignProps( { name }, annos, props, location );
   if (kind)
     art.kind = kind;
-  if (!parent[env])
-    parent[env] = Object.create(null);
+  if (!parent[env])      // TODO: dump with --test-mode, env !== 'artifacts'
+    parent[env] = env === 'args' ? Object.create(null) : this.createDict( { ...location } );
   if (!art.name || art.name.id == null) {
     // no id was parsed, but with error recovery: no further error
     // TODO: add to  parent[env]['']
@@ -727,6 +777,31 @@ function addItem( parent, env, kind, annos, props, location ) {
   return art;
 }
 
+/**
+ * For `annotate/extend E:elem.sub`, create the `elements` structure
+ * that can be used by the core compiler to annotate/extend elements.
+ *
+ * @param {string} kind Either `annotate` or `extend`
+ * @param {object} artifact Main artifact that shall have `elements`.
+ * @param {XSN.Path} elementPath Path as returned by `simplePath` token.
+ * @param {object[]} annos  Existing annotations that shall be added to the _last_ path step.
+ * @param {XSN.Location} artifactLocation Start location of the `annotate` statement.
+ * @returns {object} Deepest element
+ */
+function artifactForElementAnnotateOrExtend(kind, artifact, elementPath, annos, artifactLocation ) {
+  if (!Array.isArray(elementPath) || elementPath.broken || elementPath.length < 1)
+    return artifact;
+
+  for (const seg of elementPath.slice(0, -1)) {
+    artifact = this.addDef( artifact, 'elements', kind,
+      { path: [seg], location: seg.location }, null, {}, artifactLocation );
+  }
+  const last = elementPath[elementPath.length - 1];
+  artifact = this.addDef( artifact, 'elements', kind,
+    { path: [ last ], location: last.location }, annos, {}, artifactLocation );
+  return artifact;
+}
+
 /** Assign all non-empty (undefined, null, {}, []) properties in argument
  * `props` and argument `annos` as property `$annotations` to `target`
  * and return it.  Hack: if argument `annos` is exactly `true`, return
@@ -829,6 +904,31 @@ function handleComposition( cardinality, isComposition ) {
   this.excludeExpected( [ [ "'}'", 'COMPOSITIONofBRACE' ], brace1, ...manyOne ] );
 }
 
+function associationInSelectItem( art ) {
+  const isPath = art.value.path && art.value.path.length
+  const isIdentifier = isPath && art.value.path.length === 1;
+  if (isIdentifier) {
+    if (!art.name) {
+      art.name = art.value.path[0];
+    } else {
+      // Use alias if provided, i.e. ignore art.value.path.
+      this.error( 'query-unexpected-alias', art.name.location, {},
+        'Unexpected alias for association' );
+    }
+    delete art.value;
+  } else {
+    const loc = isPath ? art.value.path[1].location : art.value.location;
+    // If neither path nor alias are present, `query-req-name` is emitted in `populate.js`.
+    if (isPath || art.name) {
+      this.error( 'query-expected-identifier', loc, { '#': 'assoc' } );
+      if (isPath) {
+        art.name = art.value.path[art.value.path.length - 1];
+      }
+      delete art.value;
+    }
+  }
+}
+
 function reportExpandInline( clauseName ) {
   let token = this.getCurrentToken();
   // improve error location when using "inline" `.{…}` after ref (arguments and
@@ -840,6 +940,24 @@ function reportExpandInline( clauseName ) {
               'Unexpected nested $(PROP), can only be used after a reference' );
 }
 
+function checkTypeFacet( art, argIdent ) {
+  const id = argIdent.id;
+  if (id === 'length' || id === 'scale' || id === 'precision' || id === 'srid') {
+    if (art[id] !== undefined) {
+      this.error( 'syntax-duplicate-argument', argIdent.location,
+        { '#': 'duplicate', code: id } );
+      this.error( 'syntax-duplicate-argument', art[id].location,
+        { '#': 'duplicate', code: id } );
+    }
+    return true;
+
+  } else {
+    this.error( 'syntax-duplicate-argument', argIdent.location,
+      { '#': 'unknown', code: id } );
+    return false;
+  }
+}
+
 module.exports = {
   genericAntlrParser: GenericAntlrParser,
 };