@sap/cds-compiler 4.9.4 → 5.0.6

package/lib/json/csnVersion.js

@@ -32,7 +32,7 @@ function isNewCSN( csn, options ) {
 function checkCSNVersion( csn, options ) {
   if (!isNewCSN(csn, options)) {
     // the new transformer works only with new CSN
-    // eslint-disable-next-line global-require
+
     const { makeMessageFunction } = require('../base/messages');
     const { error, throwWithAnyError } = makeMessageFunction(csn, options);
 

package/lib/json/from-csn.js

@@ -650,7 +650,7 @@ const schema = compileSchema( {
     prop: '@‹anno›',            // which property name do messages use for annotation assignments?
     type: annotation,
     // allowed in all definitions except mixins (including columns and extensions)
-    inKind: _kind => true, // TODO(v5): (kind !== 'mixin')
+    inKind: kind => (kind !== 'mixin'),
     schema: {
       '-expr': { // '-expr' and '-' must not exist top-level
         prop: '@‹anno›',
@@ -1495,9 +1495,6 @@ function annotation( val, spec, xsn, csn, name ) {
   if (!id)              // `"@": …` is already syntax-unknown-property
     message( 'syntax-invalid-name', location(true), { '#': '{}' } );
 
-  if (xsn && xsn.kind === 'mixin') // TODO(v5): Remove, adapt spec['@'].inKind
-    message('anno-unexpected-mixin', location(true));
-
   const n = { id, location: location() };
   const r = annoValue( val, spec );
   r.name = n;
@@ -1784,7 +1781,8 @@ function getSpec( parentSpec, csn, prop, xor, expected, kind ) {
         return { prop, type: ignore };
       return { prop, type: extra };
     }
-    // TODO v5: No warning with --sloppy
+    // TODO v6: No warning with --sloppy (does not exist, yet)
+    //          Intention: Ignore unknown properties.
     warning( 'syntax-unknown-property', location(true), { prop },
              'Unknown CSN property $(PROP)' );
     return { type: ignore };
@@ -2076,8 +2074,7 @@ function toXsn( csn, filename, options, messageFunctions ) {
   inExtensions = null;
   vocabInDefinitions = null;
 
-  const xsn = new XsnSource();
-  xsn.$frontend = 'json';
+  const xsn = new XsnSource( 'json' ); // TODO: 'csn'? LSP does not use $frontend
 
   // eslint-disable-next-line object-curly-newline
   ({ message, error, warning, info } = messageFunctions);

package/lib/json/to-csn.js

@@ -93,8 +93,7 @@ const transformers = {
   cardinality,                 // also in pathItem: after 'id', before 'where'
   targetAspect,
   target,
-  $filtered: value,            // assoc+filter v4
-  $enclosed: value,            // comp+filter v5
+  $enclosed: value,            // comp+filter since v5
   foreignKeys,
   enum: enumDict,
   items,
@@ -120,7 +119,7 @@ const transformers = {
   // definitions, extensions, members ----------------------------------------
   notNull: value,
   default: expression,
-  // targetElement: ignore,     // special display of foreign key, renameTo: select
+  targetElement,                // special display of foreign key
   value: enumValueOrCalc,       // do not list for select items as elements
   query,
   elements,
@@ -344,18 +343,24 @@ function sources( srcDict, csn, model ) {
   let names = model._sources || Object.keys( srcDict );
   const $sources = names.length && srcDict[names[0]].$sources;
   if ($sources) {
-    setHidden( csn, '$sources', $sources );
+    setHidden( csn, '$sources', normalize$sources( $sources ) );
     return undefined;
   }
   if (model._sortedSources)
     names = model._sortedSources.map( s => s.realname );
-  setHidden( csn, '$sources', (!strictMode) ? names : names.map( relativeName ) );
+  names = (!strictMode) ? names : normalize$sources( names.map( relativeName ) );
+  setHidden( csn, '$sources', names );
   return undefined;
 
   function relativeName( name ) {
     const loc = srcDict[name].location;
     return loc && loc.file || name;
   }
+  function normalize$sources( src ) {
+    return strictMode
+      ? src.map( name => locationString( name, true ) )
+      : src;
+  }
 }
 
 function attachAnnotations( annotate, prop, dict, inferred, insideReturns = false ) {
@@ -666,19 +671,19 @@ function returns( art, csn, node, prop ) {
   return definition( art, csn, node, prop );
 }
 
-function definition( art, _csn, _node, prop ) {
+function definition( art, csn, _node, prop ) {
   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)
     return undefined;
-  if (art.kind === 'key') {      // foreignkey
-    const key = addExplicitAs( { ref: art.targetElement.path.map( pathItem ) },
-                               art.name, neqPath( art.targetElement ) );
-    if (!art.$inferred)
+  if (art.kind === 'key') { // foreign key
+    const key = standard( art );
+    if (!art.$inferred) // override location; otherwise only alias would be used
       addLocation( art.targetElement.location, key );
     return extra( key, art );
   }
+
   const c = standard( art );
   // The XSN of actions in extensions do not contain a returns yet - TODO?
   const elems = c.elements;
@@ -946,7 +951,7 @@ function originRef( art, user ) {
     const name = parent.name || parent._outer.name;
     if (name.id && parent.kind !== '$inline' || !r.length)
       // Return parameter is in XSN - kind: 'param', name.id: ''
-      // eslint-disable-next-line no-nested-ternary, max-len
+      // eslint-disable-next-line no-nested-ternary
       r.push( !nkind ? name.id : name.id ? { [nkind]: name.id } : { returns: true } );
     parent = parent._parent;
   }
@@ -1142,10 +1147,16 @@ function value( node ) {
   return r;
 }
 
+function targetElement( val, csn, node ) {
+  const key = addExplicitAs( { ref: val.path.map( pathItem ) },
+                             node.name, neqPath( val ) );
+  Object.assign(csn, key);
+}
+
 function enumValueOrCalc( v, csn, node ) {
   if (v.$inferred && (universalCsn || gensrcFlavor))
     return undefined;
-  // Enums values in CSN are without outer `value: { … }`:
+  // Enum values in CSN are without outer `value: { … }`:
   if (node.kind === 'enum') {
     Object.assign( csn, expression( v ) );
   }

package/lib/language/antlrParser.js

@@ -20,7 +20,6 @@ const Lexer = require('../gen/languageLexer').default;
 // Error listener used for ANTLR4-generated parser
 class ErrorListener extends antlr4.error.ErrorListener {
   // method which is called by generated parser with --trace-parser[-amg]:
-  // eslint-disable-next-line class-methods-use-this
   syntaxError( recognizer, offendingSymbol, line, column, msg, e ) {
     if (!(e instanceof CompileMessage)) // not already reported
       // Ignore warning, because only relevant for --trace-parser
@@ -50,7 +49,7 @@ class RewriteTypeTokenStream extends antlr4.CommonTokenStream {
     }
     else if (t.type === this.NEW) {
       const n = super.LT(k + 1);
-      // TODO v5: rewrite token in grammar via `this.setLocalToken`
+      // TODO: rewrite token in grammar via `this.setLocalToken`
       if (n?.type === this.Identifier) {
         const o = super.LT(k + 2);
         if (o?.type === this.PAREN)
@@ -84,6 +83,7 @@ function initTokenRewrite( recognizer, ts ) { // ts = tokenStream
   ts.AT = tokenTypeOf( recognizer, "'@'" );
   ts.SEMICOLON = tokenTypeOf( recognizer, "';'" );
   ts.NEW = Parser.NEW;
+  ts.RETURNS = Parser.RETURNS;
   ts.Identifier = Parser.Identifier;
   ts.PAREN = tokenTypeOf( recognizer, "'('" );
 

package/lib/language/errorStrategy.js

@@ -29,7 +29,6 @@
 'use strict';
 
 const antlr4 = require('antlr4');
-// eslint-disable-next-line camelcase
 const Antlr4LL1Analyzer = require('antlr4/src/antlr4/LL1Analyzer');
 const { DefaultErrorStrategy } = require('antlr4/src/antlr4/error/ErrorStrategy');
 const { InputMismatchException } = require('antlr4/src/antlr4/error/Errors');

package/lib/language/genericAntlrParser.js

@@ -447,6 +447,7 @@ function checkExtensionDict( dict ) {
       for (const prop of Object.keys( dup )) {
         if (prop.charAt(0) === '@') {
           this.addAnnotation( def, prop, dup[prop] );
+          delete dup[prop]; // we want to keep $duplicates, but not have duplicate props
         }
         else if (prop === 'doc') {
           // With explicit docComment:false, we don't emit a warning.
@@ -455,11 +456,13 @@ function checkExtensionDict( dict ) {
                           'Doc comment is overwritten by another one below' );
           }
           def.doc = dup.doc;
+          delete dup[prop]; // we want to keep $duplicates for LSP, but not have duplicate props
         }
         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
+          delete dup[prop]; // we want to keep $duplicates for LSP, but not have duplicate props
         }
       }
       if (dup.$annotations) {   // update deprecated $annotations for cds-lsp / annotation modeler
@@ -469,7 +472,9 @@ function checkExtensionDict( dict ) {
           def.$annotations = dup.$annotations;
       }
     }
-    def.$duplicates = null;
+
+    // We keep duplicate statements for LSP, as it needs to traverse all identifiers;
+    // annotations were removed above to avoid traversing annotations twice.
   }
 }
 
@@ -709,14 +714,26 @@ function docComment( node ) {
   node.doc = this.valueWithTokenLocation( val, token );
 }
 
-// Classify token (identifier category) for implicit names,
-// to be used in the empty alternative to AS <explicitName>.
-function classifyImplicitName( category, ref, tokpos = 1 ) {
-  if (!ref || ref.path && this.getCurrentToken().text !== '.') {
-    const implicit = this._input.LT( tokpos - 1 || -1 );
-    if (implicit.isIdentifier)
+/**
+ * Classify token (identifier category) for implicit names. To be used in the
+ * empty alternative to AS <explicitName>.  If `ref` is given, uses the last
+ * path segment's `tokenIndex`.  The return value can be used to reset the
+ * token's category, e.g. for inline select items.
+ *
+ * @param {string} category
+ * @param [ref]
+ */
+function classifyImplicitName( category, ref ) {
+  if (!ref || ref.path) {
+    const tokenIndex = ref?.path[ref.path.length - 1]?.location.tokenIndex;
+    const implicit = (tokenIndex === undefined) ? this._input.LT(-1) : this._input.get(tokenIndex);
+    if (implicit.isIdentifier) {
+      const previous = implicit.isIdentifier;
       implicit.isIdentifier = category;
+      return { token: implicit, previous };
+    }
   }
+  return null;
 }
 
 function fragileAlias( ast, safe = false ) {
@@ -942,8 +959,7 @@ function numberLiteral( sign, text = this._input.LT(-1).text ) {
       token.stop + 1 === nextToken.start &&
       (nextToken.type === this.constructor.Identifier ||
        nextToken.type < this.constructor.Identifier && /^[a-z]+$/i.test( nextToken.text ))) {
-    // TODO: Make it an error in v5
-    this.warning('syntax-expecting-space', nextToken, {},
+    this.message('syntax-expecting-space', nextToken, {},
                  'Expecting a space between a number and a keyword/identifier');
   }
 
@@ -1111,7 +1127,8 @@ function pushItem( array, val ) {
 
 // For :param, #variant, #symbol, @(…) and @Begin and `@` inside annotation paths
 function reportUnexpectedSpace( prefix = this._input.LT(-1),
-                                location = this.tokenLocation( this._input.LT(1) ) ) {
+                                location = this.tokenLocation( this._input.LT(1) ),
+                                isError = false ) {
   const prefixLoc = this.tokenLocation( prefix );
   if (prefixLoc.endLine !== location.line ||
       prefixLoc.endCol !== location.col) {
@@ -1122,8 +1139,14 @@ function reportUnexpectedSpace( prefix = this._input.LT(-1),
       endLine: location.line,
       endCol: location.col,
     };
-    this.warning( 'syntax-unexpected-space', wsLocation, { op: prefix.text },
-                  'Delete the whitespace after $(OP)' );
+    if (isError) {
+      this.message( 'syntax-invalid-space', wsLocation, { op: prefix.text },
+                    'Delete the whitespace after $(OP)' );
+    }
+    else {
+      this.warning( 'syntax-unexpected-space', wsLocation, { op: prefix.text },
+                    'Delete the whitespace after $(OP)' );
+    }
   }
   return prefixLoc;
 }

package/lib/language/multiLineStringParser.js

@@ -256,7 +256,7 @@ class MultiLineStringParser {
     try {
       this.output.push(String.fromCodePoint(n));
     }
-    catch (e) {
+    catch {
       // RangeError is thrown if number isn't a valid code point
       reportInvalidCodePoint();
     }
@@ -484,7 +484,7 @@ class MultiLineStringParser {
    * @param {string} code
    * @private
    */
-  _makeCode(code) { // eslint-disable-line class-methods-use-this
+  _makeCode(code) {
     // For characters that may be rendered as newline,
     // see <https://www.unicode.org/reports/tr14/tr14-32.html>.
     //
@@ -500,6 +500,7 @@ class MultiLineStringParser {
     //
     // For Visualization, see <https://en.wikipedia.org/wiki/Newline#Unicode>
     //   U+23CE: ⏎
+    // eslint-disable-next-line no-control-regex
     const allNewLineCharacters = /[\u{000A}\u{000B}\u{000C}\u{000D}\u{0085}\u{2028}\u{2029}]/ug;
     return code.replace(allNewLineCharacters, '\u{23CE}');
   }

package/lib/language/textUtils.js

@@ -1,6 +1,7 @@
 'use strict';
 
 /** Whitespace characters without line-breaks. */
+// eslint-disable-next-line no-control-regex
 const whitespaceRegEx = /[\t\u{000B}\u{000C} \u{00A0}\u{FEFF}\p{Zs}]/u;
 const cdlNewLineRegEx = /\r\n?|\n|\u2028|\u2029/u;
 

package/lib/main.d.ts

@@ -68,18 +68,22 @@ declare namespace compiler {
      *                additional "extend" or "annotate" statements, but not suitable
      *                for consumption by clients or backends.
      *  - universal : In development (BETA)
+     *
+     * @default 'client'
      */
     csnFlavor?: string | 'client' | 'gensrc' | 'universal'
     /**
-     * If set, backends will not create localized convenience views for those views,
-     * that only have an association to a localized entity/view.  Views will only get
-     * a convenience view, if they themselves contain localized elements (i.e. either
+     * If set to false, backends will create localized convenience views for those views,
+     * that only have an association to a localized entity/view.  If set to true, views will
+     * only get a convenience view, if they themselves contain localized elements (i.e. either
      * have simple projection on localized elements and CDL-casts to a localized element).
      *
-     * The OData backend will not set `$localized: true` markers for such cases.
+     * If true, the OData backend will not set `$localized: true` markers for such cases.
      *
      * Does not work for backends to.hdi(), to.hdbcds() or to.sql() with `sqlDialect: 'hana'`,
      * since in all those dialects, associations still exist in generated artifacts.
+     *
+     * @default true
      */
     fewerLocalizedViews?: boolean
   }
@@ -698,10 +702,6 @@ declare namespace compiler {
    * @param config.noMessageId
    *     If true, will _not_ show the message ID (+ explanation hint) in the output.
    *
-   * @param config.idInBrackets
-   *     If true, the message ID (if there is one and noMessageId is falsey) will be put in brackets.
-   *     This will be the default in cds-compiler v5.
-   *
    * @param config.noHome
    *     If true, will _not_ show message's semantic location.
    *
@@ -714,7 +714,6 @@ declare namespace compiler {
   export function messageString(msg: CompileMessage, config?: {
     normalizeFilename?: boolean
     noMessageId?: boolean
-    idInBrackets?: boolean
     noHome?: boolean
     module?: string
   }): string;
@@ -1379,6 +1378,26 @@ declare namespace compiler {
      * @private
      */
     function getArtifactName(artifact: object): object;
+
+    type LspSemanticTokenEvent = {
+      event: 'reference' | 'definition',
+      semanticToken: object,
+      hint?: string
+      node?: object
+    }
+    /**
+     * Traverse the given XSN model and yield all _semantic tokens_ that are required by
+     * the LSP.  These semantic tokens mostly include _identifiers_, that is, references
+     * or definitions.  They also include the `returns` structure, as it is an annotation
+     * target as well.
+     */
+    function traverseSemanticTokens(xsn: object, options: CompileOptions): Generator<LspSemanticTokenEvent>;
+    /**
+     * Given an XSN reference object, e.g. the `semanticToken` value of a `traverseSemanticTokens`
+     * event, return a generator that yields the reference's target and their origins until the
+     * base definition is reached.
+     */
+    function getSemanticTokenOrigin(obj: LspSemanticTokenEvent): Generator<object>;
   }
 
   /**

package/lib/main.js

@@ -29,6 +29,7 @@ const define = lazyload('./compiler/define');
 const builtins = lazyload('./base/builtins');
 const base = lazyload('./compiler/base');
 const finalizeParseCdl = lazyload('./compiler/finalize-parse-cdl');
+const lsp = lazyload('./compiler/lsp-api');
 
 // The compiler version (taken from package.json)
 function version() {
@@ -94,7 +95,7 @@ module.exports = {
       value: messages.CompilationError,
       writable: false,
       configurable: false,
-      enumerable: false
+      enumerable: true
     });
     return messages.CompilationError;
   },
@@ -183,7 +184,9 @@ module.exports = {
   $lsp: {
     parse: (...args) => compiler.parseX(...args),
     compile: (...args) => compiler.compileX(...args),
-    getArtifactName: (...args) => base.getArtifactName(...args),
+    getArtifactName: (art) => base.getArtifactName(art),
+    traverseSemanticTokens: (xsn, options) => lsp.traverseSemanticTokens(xsn, options),
+    getSemanticTokenOrigin: (obj) => lsp.getSemanticTokenOrigin(obj),
   },
 
   // CSN Model related functionality
@@ -201,7 +204,7 @@ module.exports = {
 function lazyload(moduleName) {
   let module;
   return new Proxy(((...args) => {
-    if (!module) // eslint-disable-next-line global-require
+    if (!module)
       module = require(moduleName);
 
     if (module.apply && typeof module.apply === 'function')
@@ -209,7 +212,7 @@ function lazyload(moduleName) {
     return module; // for destructured calls
   }), {
     get(target, name) {
-      if (!module) // eslint-disable-next-line global-require
+      if (!module)
         module = require(moduleName);
 
       return module[name];

package/lib/model/csnRefs.js

@@ -511,6 +511,8 @@ function csnRefs( csn, universalReady ) {
 
   function initNode( art, parent, kind, name ) {
     setCache( art, '_parent', parent );
+    if (art.keys)
+      setCache(art, '_keys', getKeysDict( art ));
     if (kind === 'target') {
       // Prevent re-initialization of anonymous aspect with initDefinition():
       // (that would be with parent: null which would be wrong)
@@ -650,9 +652,12 @@ function csnRefs( csn, universalReady ) {
           return resolvePath( path, elemParent.elements[head], null, 'query' );
       }
       if (!query) {                // outside queries - TODO: items?
-        let art = parent.elements[head];
-        // Ref to up_ in anonymous aspect
-        if (!art && head === 'up_') {
+        let art = parent.elements?.[head];
+        if (parent.keys) {
+          const keysDict = getCache( parent, '_keys' );
+          art = keysDict[head];
+        } // Ref to up_ in anonymous aspect
+        else if (!art && head === 'up_') {
           const up = getCache( parent, '_parent' );
           const target = up && typeof up.target === 'string' && csn.definitions[up.target];
           if (target && target.elements) {
@@ -989,6 +994,17 @@ function csnRefs( csn, universalReady ) {
   }
 }
 
+/**
+ * Foreign keys are stored in an array; for easier name resolution, create
+ * a dictionary of them.
+ */
+function getKeysDict( art ) {
+  const dict = Object.create(null);
+  for (const key of art.keys)
+    dict[key.as || implicitAs( key.ref )] = key;
+  return dict;
+}
+
 /**
  * Return value of a query SELECT for the query node, or the main artifact,
  * i.e. a value with an `elements` property.
@@ -1180,7 +1196,7 @@ function analyseCsnPath( csnPath, csn, resolve ) {
 
     const prop = csnPath[index];
     if (refCtx === 'annotation' && typeof obj === 'object') {
-      // we do not know yet whether the annotation value is a expression or not →
+      // we do not know yet whether the annotation value is an expression or not →
       // loop over outer array and records (structure values):
       if (Array.isArray( obj ) || !isAnnotationExpression( obj )) {
         obj = obj[prop];

package/lib/model/csnUtils.js

@@ -706,7 +706,6 @@ function isEdmPropertyRendered( elementCsn, options ) {
  * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database name for (absolute) 'artifactName', depending on the current naming mode.
  */
-// eslint-disable-next-line no-unused-vars
 function getArtifactDatabaseNameOf( artifactName, sqlMapping, csn, sqlDialect = 'plain' ) {
   if (csn && typeof csn === 'object' && csn.definitions) {
     isValidMappingDialectCombi(sqlDialect, sqlMapping);
@@ -826,7 +825,6 @@ function isValidMappingDialectCombi( sqlDialect, sqlMapping ) {
  * @param {('sqlite'|'hana'|'plain'|string)} [sqlDialect='plain'] The SQL dialect to use
  * @returns {string} The resulting database element name for 'elemName', depending on the current naming mode.
  */
-// eslint-disable-next-line no-unused-vars
 function getElementDatabaseNameOf( elemName, sqlMapping, sqlDialect = 'plain' ) {
   isValidMappingDialectCombi(sqlDialect, sqlMapping);
   if (sqlMapping === 'hdbcds')

package/lib/model/revealInternalProperties.js

@@ -385,7 +385,7 @@ function quoted( name, undef = '‹undefined›' ) {
 // To be used for tracing, e.g. by
 // require('../model/revealInternalProperties').log(model, 'E_purposes')
 function logXsnModel( model, name ) {
-  // eslint-disable-next-line no-console, global-require
+  // eslint-disable-next-line no-console
   console.log( require('util').inspect( revealInternalProperties( model, name ), false, null ) );
 }
 

package/lib/modelCompare/compare.js

@@ -67,7 +67,7 @@ function validateCsnVersions(beforeModel, afterModel, options) {
   }
   if (beforeVersionParts[0] > afterVersionParts[0] && !(options && options.allowCsnDowngrade)) {
     const { error, throwWithAnyError } = makeMessageFunction(afterModel, options, 'modelCompare');
-    // eslint-disable-next-line global-require
+
     const { version } = require('../../package.json');
     error(null, null, { value: afterVersion, othervalue: beforeVersion, version },
           'Incompatible CSN versions: $(VALUE) is a major downgrade from $(OTHERVALUE). Is @sap/cds-compiler version $(VERSION) outdated?');

package/lib/optionProcessor.js

@@ -1,3 +1,11 @@
+// Compiler options
+
+// Remarks:
+// - The specification is client-tool centric (bin/cdsc.js):
+//   an option named `fooBar` is “produced” by `.option('  --foo-bar')`.
+// - Also list the option in the `help` text, used with `cdsc -h`.
+// - Specify valid values for non-boolean options in lib/api/validate.js.
+
 'use strict';
 
 const { createOptionProcessor } = require('./base/optionProcessorHelper');
@@ -34,7 +42,7 @@ optionProcessor
   .option('    --beta <list>')
   .option('    --deprecated <list>')
   .option('    --direct-backend')
-  .option('    --fallback-parser <type>', { valid: ['cdl', 'csn', 'csn!'] })
+  .option('    --fallback-parser <type>', { valid: [ 'auto!', 'cdl', 'csn', 'csn!' ] })
   .option('    --shuffle <seed>') // 0 | 1..4294967296
   .option('    --test-mode')
   .option('    --test-sort-csn')
@@ -117,9 +125,10 @@ optionProcessor
                               eagerPersistenceForGeneratedEntities
        --fallback-parser <type>  If the language cannot be deduced by the file's extensions, use this
                                  parser as a fallback. Valid values are:
-                                   cdl  : Use CDL parser
-                                   csn  : Use CSN parser
-                                   csn! : Use CSN parser even with extension cds, cdl, hdbcds and hdbdd
+                                   cdl   : Use CDL parser
+                                   csn   : Use CSN parser
+                                   csn!  : Use CSN parser even with extension cds, cdl, hdbcds and hdbdd
+                                   auto! : Ignore file extension; use CSN parser if file content starts with '{'
        --direct-backend     Do not compile the given CSN but directly pass it to the backend.
                             Can only be used with certain new CSN based backends. Combination with
                             other flags is limited, e.g. --test-mode will not run a consistency check.
@@ -161,6 +170,8 @@ optionProcessor
   Environment variables
     NO_COLOR                If set, compiler messages (/output) will not be colored.
                             Can be overwritten by '--color'
+    FORCE_COLOR             If set, compiler messages (/output) will be colored. Overrides NO_COLOR.
+                            Can be overwritten by '--color'
     CDSC_TRACE_TIME         If set, additional timing information is printed to stderr.
     CDSC_TRACE_API          If set, additional API calling information is printed to stderr.
 `);
@@ -318,9 +329,9 @@ optionProcessor.command('Q, toSql')
   .option('    --pre2134ReferentialConstraintNames')
   .option('    --disable-hana-comments')
   .option('    --generated-by-comment')
-  .option('    --better-sqlite-session-variables')
+  .option('    --better-sqlite-session-variables <bool>')
   .option('    --fewer-localized-views')
-  .option('    --without-hana-associations')
+  .option('    --with-hana-associations <bool>', { valid: [ 'true', 'false' ] })
   .help(`
   Usage: cdsc toSql [options] <files...>
 
@@ -372,11 +383,17 @@ optionProcessor.command('Q, toSql')
    --pre2134ReferentialConstraintNames   Do not prefix the constraint identifier with "c__"
    --disable-hana-comments    Disable rendering of doc comments as SAP HANA comments.
    --generated-by-comment     Enable rendering of the initial SQL comment for HDI-based artifacts
-   --better-sqlite-session-variables    Enable better-sqlite compatible rendering of $user. Only
-                              active if sqlDialect is \`sqlite\`
+   --better-sqlite-session-variables <bool>
+                              Enable better-sqlite compatible rendering of $user. Only
+                              active if sqlDialect is \`sqlite\`:
+                                true  : (default) Render better-sqlite session_context(…)
+                                false : Render session variables as string literals, used e.g. with sqlite3 driver
    --fewer-localized-views    If set, the backends will not create localized convenience views for
                               those views, that only have an association to a localized entity/view.
-   --without-hana-associations   If set, the backend will not render a "WITH ASSOCIATIONS" for sqlDialect 'hana'
+   --with-hana-associations <bool>
+                              Enable and disable rendering of "WITH ASSOCIATIONS" for sqlDialect 'hana'.
+                                true  : (default) Render "WITH ASSOCIATIONS"
+                                false : Do not render "WITH ASSOCIATIONS"
 `);
 
 optionProcessor.command('toRename')
@@ -482,6 +499,7 @@ optionProcessor.command('toCsn')
 optionProcessor.command('parseCdl')
   .option('-h, --help')
   .positionalArgument('<file>')
+  .option('    --with-locations')
   .help(`
   Usage: cdsc parseCdl [options] <file>
 
@@ -489,6 +507,7 @@ optionProcessor.command('parseCdl')
   resolve imports, apply extensions or expand any queries.
 
   Options
+       --with-locations   Add $location to CSN artifacts.
    -h, --help             Show this help text
 `);
 

package/lib/render/manageConstraints.js

@@ -58,7 +58,7 @@ function alterConstraintsWithCsn( csn, options, messageFunctions ) {
 // TODO: Remove / Move to api/options.js once alterConstraintsWithCsn is available outside bin/cdsc
 function _transformSqlOptions( csn, options ) {
   const { src } = options;
-  // eslint-disable-next-line global-require
+
   const prepareOptions = require('../api/options');
   options = prepareOptions.to.sql(options);
   options.src = src;