@sap/cds-compiler 2.10.4 → 2.12.0

package/lib/render/toCdl.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const {
-  getTopLevelArtifactNameOf, getLastPartOf,
+  getLastPartOf,
   getLastPartOfRef,
 } = require('../model/csnUtils');
 const {
@@ -10,7 +10,7 @@ const {
 const keywords = require('../base/keywords');
 const { renderFunc, beautifyExprArray, findElement } = require('./utils/common');
 const { checkCSNVersion } = require('../json/csnVersion');
-const timetrace = require('../utils/timetrace');
+const { timetrace } = require('../utils/timetrace');
 const { csnRefs } = require('../model/csnRefs');
 const { forEachDefinition } = require('../model/csnUtils');
 const enrichUniversalCsn = require('../transform/universalCsnEnricher');
@@ -40,11 +40,11 @@ function toCdsSourceCsn(csn, options) {
 
   checkCSNVersion(csn, options);
 
-  const result = Object.create(null);
+  const cdlResult = Object.create(null);
 
   const main = 'model';
 
-  result[main] = `${options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`}`;
+  cdlResult[main] = options.testMode ? '' : `// ${generatedByCompilerVersion()} \n`;
 
   const subelementAnnotates = [];
 
@@ -52,7 +52,7 @@ function toCdsSourceCsn(csn, options) {
     const env = createEnv();
     const sourceStr = renderArtifact(artifactName, artifact, env); // Must come first because it populates 'env.topLevelAliases'
     if (sourceStr !== '')
-      result[main] += `${sourceStr}\n`;
+      cdlResult[main] += `${sourceStr}\n`;
   });
 
   // Apply possible subelement/action return annotations with an "annotate X with"
@@ -70,7 +70,7 @@ function toCdsSourceCsn(csn, options) {
         if (elementName) // action returns do not have element name - we need less {} there
           sourceStr += '  }\n';
         sourceStr += '}\n';
-        result[main] += `${sourceStr}\n`;
+        cdlResult[main] += `${sourceStr}\n`;
       }
     }
   }
@@ -117,13 +117,13 @@ function toCdsSourceCsn(csn, options) {
         sourceStr = renderTypeOrAnnotation(annotationName, anno, env, 'annotation');
 
       if (sourceStr !== '')
-        result[main] += `${sourceStr}\n`;
+        cdlResult[main] += `${sourceStr}\n`;
     }
   }
 
   if (csn.namespace) {
-    result[csn.namespace] = `namespace ${renderArtifactName(csn.namespace)};\n`;
-    result[csn.namespace] += `using from './${main}.cds';`;
+    cdlResult[csn.namespace] = `namespace ${renderArtifactName(csn.namespace)};\n`;
+    cdlResult[csn.namespace] += `using from './${main}.cds';`;
   }
 
 
@@ -132,11 +132,11 @@ function toCdsSourceCsn(csn, options) {
   if (csn.extensions) {
     const env = createEnv();
     const sourceStr = renderUnappliedExtensions(csn.extensions, env);
-    result.unappliedExtensions = renderUsings('', env) + sourceStr;
+    cdlResult.unappliedExtensions = renderUsings('', env) + sourceStr;
   }
 
   timetrace.stop();
-  return result;
+  return cdlResult;
 
   /**
    * Render unapplied 'extend' and 'annotate' statements from the 'extensions array'
@@ -579,7 +579,7 @@ function toCdsSourceCsn(csn, options) {
    * @return {string}
    */
   function renderQueryActionsAndFunctions(artifactName, art, env) {
-    let result = renderDocComment(art, env) + renderActionsAndFunctions(art, env);
+    let result = renderActionsAndFunctions(art, env);
     // Even if we have seen actions/functions, they might all have been ignored
     if (result !== '')
       result = `${env.indent}extend entity ${artifactName} with${result};`;
@@ -612,7 +612,7 @@ function toCdsSourceCsn(csn, options) {
     }
     // Now iterate elements - render an annotation if it is different from the column's
     const childEnv = increaseIndent(env);
-    let result = renderDocComment(art, env);
+    let result = '';
     for (const elemName in art.elements) {
       let elemAnnotations = '';
       const elem = art.elements[elemName];
@@ -996,35 +996,35 @@ function toCdsSourceCsn(csn, options) {
     /**
      * Utility function to make sure that we continue with the same indentation in WHERE, GROUP BY, ... after a closing curly brace and beyond
      *
-     * @param {string} result
-     * @param {CdlRenderEnvironment} env
+     * @param {string} str
+     * @param {CdlRenderEnvironment} indentEnv
      * @return {string}
      */
-    function continueIndent(result, env) {
-      if (result.endsWith('}') || result.endsWith('})')) {
+    function continueIndent(str, indentEnv) {
+      if (str.endsWith('}') || str.endsWith('})')) {
         // The preceding clause ended with '}', just append after that
         return ' ';
       }
       // Otherwise, start new line and indent normally
-      return `\n${increaseIndent(env).indent}`;
+      return `\n${increaseIndent(indentEnv).indent}`;
     }
 
     /**
      * Render a query's LIMIT clause, which may have also have OFFSET.
      *
      * @param {CSN.QueryLimit} limit
-     * @param {CdlRenderEnvironment} env
+     * @param {CdlRenderEnvironment} limitEnv
      * @return {string}
      */
-    function renderLimit(limit, env) {
-      let result = '';
+    function renderLimit(limit, limitEnv) {
+      let limitStr = '';
       if (limit.rows !== undefined)
-        result += `limit ${renderExpr(limit.rows, env)}`;
+        limitStr += `limit ${renderExpr(limit.rows, limitEnv)}`;
 
       if (limit.offset !== undefined)
-        result += `${result !== '' ? `\n${increaseIndent(env).indent}` : ''}offset ${renderExpr(limit.offset, env)}`;
+        limitStr += `${limitStr !== '' ? `\n${increaseIndent(limitEnv).indent}` : ''}offset ${renderExpr(limit.offset, limitEnv)}`;
 
-      return result;
+      return limitStr;
     }
   }
 
@@ -1335,7 +1335,7 @@ function toCdsSourceCsn(csn, options) {
     // Primitive: string, number, boolean
 
     // Quote strings, leave all others as they are
-    return (typeof x === 'string') ? `'${x.replace(/'/g, '\'\'')}'` : x;
+    return (typeof x === 'string') ? renderString(x, env) : x;
   }
 
   /**
@@ -1385,7 +1385,7 @@ function toCdsSourceCsn(csn, options) {
           case 'timestamp':
             return `${x.literal}'${x.val}'`;
           case 'string':
-            return `'${x.val.replace(/'/g, '\'\'')}'`;
+            return renderString(x.val, env);
           case 'object':
             if (x.val === null)
               return 'null';
@@ -1404,6 +1404,12 @@ function toCdsSourceCsn(csn, options) {
         // FIXME: no extra magic with x.param or x.global
         return `${(x.param || x.global) ? ':' : ''}${x.ref.map(renderPathStep).join('.')}`;
       }
+      else if (x.xpr && x.func) {
+        // window function
+        const funcDef = renderFunc( x.func, x, null, a => renderArgs(a, '=>', env) );
+        const windowFunctionOperator = x.xpr.shift(); // OVER ...
+        return `${funcDef} ${windowFunctionOperator} ( ${renderExpr(x.xpr, env, true)} )`;
+      }
       // Function call, possibly with args (use '=>' for named args)
       else if (x.func) {
         // test for non-regular HANA identifier that needs to be quoted
@@ -1636,66 +1642,38 @@ function toCdsSourceCsn(csn, options) {
   }
 
   /**
-   * Render a single annotation assignment 'ann' with fully qualified name 'name' (no trailing LF).
-   * We might see variants like 'A.B.C#foo' or even 'A.B#foo.C'. In both cases, the #foo must be ignored
-   * when resolving the name, but must stay in the rendered output (quoted as necessary).
+   * Render a single annotation assignment 'anno' with fully qualified name 'name' (no trailing LF).
+   * We might see variants like 'A.B.C#foo' or even 'A.B#foo.C'. The latter needs to be quoted as
+   * dots in the variant are not recognized by the compiler.
    *
-   * @param {any} ann Annotation value
+   * @param {any} anno Annotation value
    * @param {string} name Annotation name, e.g. `@A.B.C#foo.C`
    * @param {CdlRenderEnvironment} env
-   * @return {string}
+   * @return {string} Rendered annotation, possibly quoted: `@![A.B.C#foo.C]: value`
    */
-  function renderAnnotationAssignment(ann, name, env) {
-    // Take the annotation assignment apart into <nameBeforeVariant>[#<variant>[.<nameAfterVariant>]]
-    //                      @1111111  3333333   5555
-    const parts = name.match(/@([^#]+)(#([^.]+)(\.(.+))?)?/);
-    const nameBeforeVariant = parts[1];
-    const variant = parts[3];
-    const nameAfterVariant = parts[5];
-    const topLevelName = getTopLevelArtifactNameOf(nameBeforeVariant, csn);
-    let result = `${env.indent}@`;
-    if (topLevelName) {
-      // Checked annotation, with declaration - must render top-level absolute name with proper using and alias
-      // Annotation names are never flattened
-      result += renderAbsoluteNameWithQuotes(topLevelName);
-      if (topLevelName !== nameBeforeVariant)
-        result += `.${quotePathString(nameBeforeVariant.substring(topLevelName.length + 1))}`;
-    }
-    else {
-      // Unchecked annotation, just render the name as it is
-      result += nameBeforeVariant;
-    }
-    // Append '#'-variant if any
-    if (variant) {
-      // FIXME: Unfortunately, the compiler does not yet understand an inner variant with proper quoting,
-      // i.e. like "__A"."B"#"foo"."C". As a workaround, we present the '#'-variant as a quoted part of the
-      // previous path step, i.e as "__A"."B#foo"."C" (which yields the same result). This hack is only necessary
-      // for inner '#'-variants, i.e. for those followed by a <nameAfterVariant>.
-      // FIXME: Won't work for inner variants on the top-level artifact, because the USING no longer matches
-      // for something like "__A#foo"."B"."C"
-      if (nameAfterVariant) {
-        const resultSteps = result.split('.');
-        // Take all paths steps from the result (which is now essentially 'nameBeforeVariant' with USING
-        // adaptations) except the last step
-        result = resultSteps.slice(0, -1).join('.');
-        // Append a combination of last path step and '#'-variant (quoted)
-        let lastStep = resultSteps[resultSteps.length - 1];
-        if (lastStep.includes('"')) {
-          // Last step was already quoted - strip off the existing quotes
-          lastStep = lastStep.slice(1, -1);
-        }
-        result += `.${quoteIdIfRequired(`${lastStep}#${variant}`)}`;
-      }
-      else {
-        // No hack required for trailing '#'-variant
-        result += `#${quoteIdIfRequired(variant)}`;
-      }
-    }
-    // Append anything that might have come after the variant
-    if (nameAfterVariant)
-      result += `.${quotePathString(nameAfterVariant)}`;
+  function renderAnnotationAssignment(anno, name, env) {
+    name = name.substring(1);
+    // Take the annotation assignment apart into <nameBeforeVariant>#<variantAndRest>
+    const parts = name.split('#');
+    const nameBeforeVariant = parts[0];
+    const variant = parts[1];
+
+    // Identifier according to our grammar: /[$_a-zA-Z][$_a-zA-Z0-9]*/
+    // We expand this pattern to also include dots after the first character.
+    // If the annotation does not follow this pattern `ident(.@ident)*`, it must be quoted:
+    // `@identifier@identifier` must be quoted but `@identifier.@identifier` should not.
+    const annoRequiresQuoting = !/^[$_a-zA-Z][$_a-zA-Z0-9.]*(?:\.@[$_a-zA-Z][$_a-zA-Z0-9.]*)*$/.test(nameBeforeVariant);
+    // Unfortunately, the compiler does not allow `.` after the first variant identifier,
+    // even though that is the result after flattening.
+    const variantRequiresQuoting = variant && !/^[$_a-zA-Z][$_a-zA-Z0-9]*$/.test(variant);
+
+    let result;
+    if (annoRequiresQuoting || variantRequiresQuoting)
+      result = `${env.indent}@${quote(name)}`;
+    else
+      result = `${env.indent}@${name}`;
 
-    result += ` : ${renderAnnotationValue(ann, env)}`;
+    result += ` : ${renderAnnotationValue(anno, env)}`;
     return `${result}\n`;
   }
 
@@ -1742,6 +1720,8 @@ function toCdsSourceCsn(csn, options) {
       topLevelAliases: Object.create(null),
       // Current name prefix (including trailing dot if not empty)
       namePrefix: '',
+      artifactName: null,
+      elementName: null,
     };
   }
 
@@ -1786,11 +1766,21 @@ function toCdsSourceCsn(csn, options) {
   function quoteIdIfRequired(id) {
     // Quote if required for CDL
     if (requiresQuotingForCdl(id))
-      return `![${id.replace(/]/g, ']]')}]`;
+      return quote(id);
 
     return id;
   }
 
+  /**
+   * Quotes the identifier using CDL-style ![]-quotes.
+   *
+   * @param id
+   * @returns {string}
+   */
+  function quote(id) {
+    return `![${id.replace(/]/g, ']]')}]`;
+  }
+
   /**
    * Returns true if 'id' requires quotes for CDL, i.e. if 'id'
    *  1. starts with a digit
@@ -1891,6 +1881,136 @@ function toCdsSourceCsn(csn, options) {
   }
 }
 
+const controlCharacters = /[\u{0000}-\u{0009}\u{000B}\u{001F}]/u;
+const highSurrogate = /[\u{D800}-\u{DBFF}]/u;
+const lowSurrogate = /[\u{DC00}-\u{DFFF}]/u;
+
+/**
+ * Render the given string.  Uses back-tick strings.
+ * env is used for indentation for three-back-tick strings.
+ *
+ * @param str
+ * @param env
+ * @returns {string}
+ */
+function renderString(str, env) {
+  if (isSimpleString(str))
+    return `'${str.replace(/'/g, '\'\'')}'`;
+
+  const output = [];
+
+  // We try to work similar to how JavaScript implements JSON.stringify.
+  // JSON.stringify, however, checks for unpaired unicode surrogates (see §25.5.2.2,
+  // <https://tc39.es/ecma262/#sec-quotejsonstring>), which we do not do here.
+
+  for (let i = 0; i < str.length; ++i) {
+    const char = str[i];
+
+    switch (char) {
+      case '$':
+        output.push('\\$');
+        break;
+      case '`':
+        output.push('\\`');
+        break;
+      case '\\':
+        output.push('\\\\');
+        break;
+        // Replace commonly known escape sequences for control characters
+        // See lib/language/multiLineStringParser.js
+      case '\f':
+        output.push('\\f');
+        break;
+      case '\v':
+        output.push('\\v');
+        break;
+      case '\t':
+        output.push('\\t');
+        break;
+      case '\b':
+        output.push('\\b');
+        break;
+      // If CR, LS, or PS appear, they have been encoded explicitly.  If we don't escape
+      // them, a recompilation may yield different results because of newline normalization.
+      case '\r':
+        output.push('\\r');
+        break;
+      case '\u{2028}':
+        output.push('\\u{2028}');
+        break;
+      case '\u{2029}':
+        output.push('\\u{2029}');
+        break;
+      default: {
+        // Control Characters: C0
+        // See <https://en.wikipedia.org/wiki/C0_and_C1_control_codes#Basic_ASCII_control_codes>
+        //
+        // JSON.stringify is not required to escape all control characters, but if used, files may
+        // be interpreted as binary.  Therefore, we replace them.
+        //
+        // We exclude LF from this list (\u000A). Characters with "nice" escapes have been replaced above.
+        if (controlCharacters.test(char)) {
+          const hex = char.codePointAt(0).toString(16);
+          output.push(`\\u{${hex}}`);
+          break;
+        }
+
+        // Unicode Surrogates
+        // These characters appear in _pairs_.  A high surrogate must be followed by a low surrogate.
+        // If this is not the case, either needs to be encoded.  This is also done by JSON.
+        // See also <https://docs.microsoft.com/en-us/globalization/encoding/surrogate-pairs>
+        if (highSurrogate.test(char)) {
+          if (i + 1 >= str.length || !lowSurrogate.test(str[i + 1])) {
+            const hex = char.codePointAt(0).toString(16);
+            output.push(`\\u{${hex}}`);
+          }
+          else {
+            output.push(char);
+            ++i;
+            output.push(str[i]);
+          }
+        }
+        else if (lowSurrogate.test(char)) {
+          const hex = char.codePointAt(0).toString(16);
+          output.push(`\\u{${hex}}`);
+        }
+        else {
+          output.push(char);
+        }
+      }
+    }
+  }
+  str = output.join('');
+  // Note: String is normalized, only \n is the line separator.
+  const lines = str.split('\n');
+  // We don't know whether a text block was used or not.  But if there
+  // are more than three lines, text blocks with indentation "look nicer".
+  // This value was chosen by personal taste.
+  if (lines.length > 3) {
+    str = lines.join(`\n${env.indent}`);
+    return `\`\`\`\n${env.indent}${str}\n${env.indent}\`\`\``;
+  }
+
+  return `\`${str}\``;
+}
+
+/**
+ * Returns true if the given string can be represented by using single quotes.
+ * @param {string} str
+ */
+function isSimpleString(str) {
+  // A single-line string allows everything except certain line separators/breaks.
+  // See ANTLR grammar for specifics.
+  // Furthermore, if control characters \u{0000}-\u{001F} are used, we escape them,
+  // as these are explicitly mentioned in the JSON spec (§9):
+  // <https://www.ecma-international.org/wp-content/uploads/ECMA-404_2nd_edition_december_2017.pdf>
+  // On top, as (invalid) surrogate pairs need to be handled, we check for them as well.
+  // v3: Not a simple string if ' (\u0027) is in string.
+  return str === '' || (/^[^\u{0000}-\u{001F}\u2028\u2029]+$/u.test(str) &&
+    !highSurrogate.test(str) &&
+    !lowSurrogate.test(str));
+}
+
 /**
  * @typedef CdlRenderEnvironment Rendering environment used throughout the render process.
  *