@sap/cds-compiler 2.10.2 → 2.11.4

package/lib/language/genericAntlrParser.js

@@ -49,6 +49,8 @@ GenericAntlrParser.prototype = Object.assign(
     attachLocation,
     startLocation,
     tokenLocation,
+    multiLineTokenLocation,
+    previousTokenAtLocation,
     combinedLocation,
     surroundByParens,
     unaryOpForParens,
@@ -245,9 +247,12 @@ function prepareGenericKeywords( pathItem ) {
   // TODO: If not just at the beginning, we need a stack for $genericKeywords,
   // as we can have nested special functions
   this.$genericKeywords.argFull = Object.keys( spec );
+  // @ts-ignore
   const token = this.getCurrentToken() || { text: '' };
-  if (spec[token.text.toUpperCase()] === 'argFull')
+  if (spec[token.text.toUpperCase()] === 'argFull') {
+    // @ts-ignore
     token.type = this.constructor.GenericArgFull;
+  }
 }
 
 // Attach location matched by current rule to node `art`.  If a location is
@@ -297,7 +302,7 @@ function tokenLocation( token, endToken, val ) {
     file: this.filename,
     line: token.line,
     col: token.column + 1,
-    // we only have single-line tokens
+    // we only have single-line tokens, except for docComments
     endLine: endToken.line,
     endCol: endToken.stop - endToken.start + endToken.column + 2, // after the last char (special for EOF?)
   };
@@ -306,6 +311,52 @@ function tokenLocation( token, endToken, val ) {
   return r;
 }
 
+/**
+ * Return location of `token`.  In contrast to `tokenLocation()`, this function
+ * can handle multiline tokens.
+ */
+function multiLineTokenLocation(token, val) {
+  if (!token)
+    return undefined;
+
+  // 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) { // ASCII code for '\n'
+      newLineCount++;
+      lastNewlineIndex = i;
+    }
+  }
+  if (newLineCount === 0)
+    // endCol calculation below requires at least one newLine.
+    return this.tokenLocation(token, token, val);
+
+  /** @type {CSN.Location} */
+  const r = {
+    file: this.filename,
+    line: token.line,
+    col: token.column + 1,
+    endLine: token.line + newLineCount,
+    endCol: token.stop - lastNewlineIndex + 1, // after the last char (special for EOF?)
+  };
+  if (val !== undefined)
+    return { location: r, val };
+  return r;
+}
+
+function previousTokenAtLocation( location ) {
+  let k = -1;
+  let token = this._input.LT(k);
+  while (token.line > location.line ||
+         token.line === location.line && token.column >= location.col)
+    token = this._input.LT(--k);
+  return (token.line === location.line && token.column + 1 === location.col) && token;
+}
+
 // Create a location with location properties `filename` and `start` from
 // argument `start`, and location property `end` from argument `end`.
 function combinedLocation( start, end ) {
@@ -342,16 +393,20 @@ function unaryOpForParens( query, val ) {
 //  - would influence the prediction, probably even induce adaptivePredict() calls,
 //  - is only slightly "more declarative" in the grammar.
 function docComment( node ) {
-  if (!this.options.docComment)
-    return;
   const token = this._input.getHiddenTokenToLeft( this.constructor.DocComment );
   if (!token)
     return;
+
+  // This token is actually used by / assigned to an artifact.
+  token.isUsed = true;
+
+  if (!this.options.docComment)
+    return;
   if (node.doc) {
     this.warning( 'syntax-duplicate-doc-comment', token, {},
                   'Repeated doc comment - previous doc is replaced' );
   }
-  node.doc = this.tokenLocation( token, token, parseDocComment( token.text ) );
+  node.doc = this.multiLineTokenLocation( token, parseDocComment( token.text ) );
 }
 
 // Classify token (identifier category) for implicit names,
@@ -435,14 +490,18 @@ function valuePathAst( ref ) {
     path.length = 1;
   }
   const { args, id, location } = path[0];
-  if (args) {
-    if (path[0].$syntax !== ':')
-      return { op: { location, val: 'call' }, func: ref, location: ref.location, args };
-  }
-  else if (!path[0].$delimited && functionsWithoutParens.includes( id.toUpperCase() )) {
-    return { op: { location, val: 'call' }, func: ref, location: ref.location };
-  }
-  return ref;
+  if (args
+      ? path[0].$syntax === ':'
+      : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
+    return ref;
+
+  const implicit = this.previousTokenAtLocation( location );
+  if (implicit && implicit.isIdentifier)
+    implicit.isIdentifier = 'func';
+  const op = { location, val: 'call' };
+  return (args)
+    ? { op, func: ref, location: ref.location, args }
+    : { op, func: ref, location: ref.location };
 }
 
 // If a '-' is directly before an unsigned number, consider it part of the number;
@@ -601,7 +660,7 @@ function addDef( parent, env, kind, name, annos, props, location ) {
     // which could be tested in name search (then no undefined-ref error)
     return art;
   }
-  else if (env === 'artifacts') {
+  else if (env === 'artifacts' || env === 'vocabularies') {
     dictAddArray( parent[env], art.name.id, art );
   }
   else if (kind || this.options.parseOnly) {

package/lib/language/language.g4

@@ -498,6 +498,8 @@ projectionSpec returns[ query ] locals[ src ]
       fromPath[ $src, 'ref']
     )?
     ( AS aliasName=ident['FromAlias'] { $src.name = $aliasName.id } )?
+    // ANTLR errors are better if we use ( A )? instead of ( A | ):
+    { if (!$src.name) this.classifyImplicitName( $src.scope ? 'FromAlias' : 'Without' ); }
     bracedSelectItemListDef[ $query ]?
     excludingClause[ $query ]?
   ;
@@ -1499,7 +1501,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         ':' // with element, e.g. `type T : E:elem enum { ... }`
@@ -1511,7 +1514,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         { this.docComment( $annos ); }
@@ -1520,7 +1524,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
             { $art.enum = Object.create(null); }
             enumSymbolDef[ $art ]*
           '}'
-          optionalSemi | requiredSemi
+          optionalSemi
+        | requiredSemi
         )
       |
         // TODO: complain if used in anno def?
@@ -1776,6 +1781,62 @@ partitionByClause returns [ expr ]
     ( ',' en=expression { $expr.args.push( $en.expr ); } )*
   ;
 
+windowFrameClause returns [ wf ]
+  :
+    r=ROWS { $wf = { op: this.tokenLocation($r, null, 'rows' ) , args: [] }}
+    wfe=windowFrameExtentSpec { $wf.args.push( $wfe.wfe ); }
+  ;
+
+windowFrameExtentSpec returns[ wfe ]
+  :
+    { $wfe = {} }
+    windowFrameStartSpec [ $wfe ]
+  |
+    b=BETWEEN
+    { $wfe = { op: this.tokenLocation( $b, null, 'frameBetween' ), args: [] } }
+    wfb1=windowFrameBoundSpec { $wfe.args.push( $wfb1.wfb ); }
+    AND
+    wfb2=windowFrameBoundSpec { $wfe.args.push( $wfb2.wfb ); }
+  ;
+
+windowFrameBoundSpec returns [ wfb ]
+@after{ /* #ATN 1 */ }
+  :
+    // #ATN:  Not ll1 because `UNBOUNDED` could also be part of the windowFrameStartSpec
+    //        `UNBOUNDED` would then be immediately followed by `PRECEDING`
+    u=UNBOUNDED f=FOLLOWING
+    { $wfb = { op: this.tokenLocation($u, $f, 'unboundedFollowing' ), args: []} }
+  |
+    // #ATN:  Not ll1 because `Number` could also be part of the windowFrameStartSpec
+    //        `Number` would then be immediately followed by `PRECEDING`
+    n=Number f=FOLLOWING
+    { $wfb = { op: this.tokenLocation($n, $f, 'following' ), args: [ this.numberLiteral( $n ) ]} }
+  |
+    { $wfb = {} }
+    windowFrameStartSpec [ $wfb ]
+  ;
+
+windowFrameStartSpec [ wf ]
+  :
+    u=UNBOUNDED p=PRECEDING
+    {
+      $wf.op = this.tokenLocation($u, $p, 'unboundedPreceding' );
+      $wf.args = [];
+    }
+  |
+    n=Number p=PRECEDING
+    {
+      $wf.op = this.tokenLocation($p, null, 'preceding' );
+      $wf.args = [ this.numberLiteral( $n ) ];
+    }
+  | 
+    c=CURRENT r=ROW
+    {
+      $wf.op = this.tokenLocation($c, $r, 'currentRow' );
+      $wf.args = [];
+    }
+  ;
+
 overClause returns [ over ]
 @after { this.attachLocation($over); }
   :
@@ -1783,6 +1844,7 @@ overClause returns [ over ]
     '('
       ( pb=partitionByClause { $over.args.push( $pb.expr ); } )?
       ( ob=overOrderByClause { $over.args.push( $ob.expr ); } )?
+      ( wf=windowFrameClause { $over.args.push( $wf.wf ); } )?
     ')'
   ;
 
@@ -1948,6 +2010,8 @@ tableTerm returns [ table ]
       // if we would use rule `ident`, we would either had to make all JOIN
       // kinds reserved or introduce ATN
     )?
+    // ANTLR errors are better if we use ( A | B )? instead of ( A | B | ):
+    { if (!$table.name) this.classifyImplicitName( $table.scope ? 'FromAlias' : 'Without' ); }
   |
     open='('
     // #ATN: The following alternative is not LL1, because both can start with
@@ -2602,6 +2666,7 @@ ident[ category ] returns[ id ]
   | COMPOSITION
   | CONTEXT
   | CROSS
+  | CURRENT
   | DAY
   | DEFAULT
   | DEFINE
@@ -2619,6 +2684,7 @@ ident[ category ] returns[ id ]
   | EXTEND
   | FIRST
   | FLOATING
+  | FOLLOWING
   | FULL
   | FUNCTION
   | GROUP
@@ -2650,10 +2716,13 @@ ident[ category ] returns[ id ]
   | OUTER
   | PARAMETERS
   | PARTITION
+  | PRECEDING
   | PROJECTION
   | REDIRECTED
   | RETURNS
   | RIGHT
+  | ROW
+  | ROWS
   | SECOND
   | SERVICE
   | THEN
@@ -2662,6 +2731,7 @@ ident[ category ] returns[ id ]
   | TO
   | TYPE
   | USING
+  | UNBOUNDED
   | VARIABLE
   | VIEW
   | YEAR
@@ -2763,6 +2833,7 @@ BOTH : [bB][oO][tT][hH] ;
 COMPOSITION : [cC][oO][mM][pP][oO][sS][iI][tT][iI][oO][nN] ;
 CONTEXT : [cC][oO][nN][tT][eE][xX][tT] ;
 CROSS : [cC][rR][oO][sS][sS] ;
+CURRENT : [cC][uU][rR][rR][eE][nN][tT] ;
 DAY : [dD][aA][yY] ;
 DEFAULT : [dD][eE][fF][aA][uU][lL][tT] ;
 DEFINE : [dD][eE][fF][iI][nN][eE] ;
@@ -2780,6 +2851,7 @@ EXCLUDING : [eE][xX][cC][lL][uU][dD][iI][nN][gG] ;
 EXTEND : [eE][xX][tT][eE][nN][dD] ;
 FIRST : [fF][iI][rR][sS][tT] ;
 FLOATING : [fF][lL][oO][aA][tT][iI][nN][gG] ;
+FOLLOWING : [fF][oO][lL][lL][oO][wW][iI][nN][gG] ;
 FULL : [fF][uU][lL][lL] ;
 FUNCTION : [fF][uU][nN][cC][tT][iI][oO][nN] ;
 GROUP : [gG][rR][oO][uU][pP] ;
@@ -2812,10 +2884,13 @@ OUTER : [oO][uU][tT][eE][rR] ;
 // OVER : [oO][vV][eE][rR] ;
 PARAMETERS : [pP][aA][rR][aA][mM][eE][tT][eE][rR][sS] ;
 PARTITION: [pP][aA][rR][tT][iI][tT][iI][oO][nN] ;
+PRECEDING: [pP][rR][eE][cC][eE][dD][iI][nN][gG] ;
 PROJECTION : [pP][rR][oO][jJ][eE][cC][tT][iI][oO][nN] ;
 REDIRECTED : [rR][eE][dD][iI][rR][eE][cC][tT][eE][dD] ;
 RETURNS : [rR][eE][tT][uU][rR][nN][sS] ;
 RIGHT : [rR][iI][gG][hH][tT] ;
+ROW : [rR][oO][wW] ;
+ROWS : [rR][oO][wW][sS] ;
 SECOND : [sS][eE][cC][oO][nN][dD] ;
 SERVICE : [sS][eE][rR][vV][iI][cC][eE] ;
 THEN : [tT][hH][eE][nN] ;
@@ -2823,6 +2898,7 @@ TRAILING : [tT][rR][aA][iI][lL][iI][nN][gG] ;
 TO : [tT][oO] ;                 // or make reserved? (is in SQL-92)
 TYPE : [tT][yY][pP][eE] ;
 UNION : [uU][nN][iI][oO][nN] ;
+UNBOUNDED : [uU][nN][bB][oO][uU][nN][dD][eE][dD] ;
 USING : [uU][sS][iI][nN][gG] ;
 VARIABLE : [vV][aA][rR][iI][aA][bB][lL][eE] ;
 VIEW : [vV][iI][eE][wW] ;

package/lib/main.d.ts

@@ -4,6 +4,10 @@
 //
 // These types are improved step by step and use a lot any types at the moment.
 
+// Author's note: All "options" interfaces should actually be types.  However, due to
+//                https://github.com/TypeStrong/typedoc/issues/1519 we can't use
+//                intersection types at the moment.
+
 export = compiler;
 
 declare namespace compiler {
@@ -11,7 +15,7 @@ declare namespace compiler {
   /**
    * Options used by the core compiler and all backends.
    */
-  export type Options = {
+  export interface Options {
     [option: string]: any,
 
     /**
@@ -57,6 +61,180 @@ declare namespace compiler {
     dictionaryPrototype?: any
   }
 
+  /**
+   * Options used by OData backends.  Includes options for the OData
+   * transformer as well as for rendering EDM and EDMX.
+   */
+  export interface ODataOptions extends Options {
+    /**
+     * OData version for output files.  Either 'v4' or 'v2'.
+     *
+     * @default 'v4'
+     */
+    odataVersion?: string | 'v4' | 'v2'
+    /**
+     * Whether to generate OData as flat or as structured.
+     * Structured is only supported for OData v4.
+     *
+     * @default 'flat'
+     */
+    odataFormat?: string | 'flat' | 'structured'
+    /**
+     * Naming mode used by the corresponding SQL.
+     *
+     * @default 'plain'
+     */
+    sqlMapping?: string | 'plain' | 'quoted' | 'hdbcds'
+    /**
+     * If `true`, `cds.Compositions` are rendered as `edm:NavigationProperty` with the additional
+     * attribute `ContainsTarget="true"` and all contained entities (composition targets) have no
+     * `edm.EntitySet`.
+     *
+     * @note Only available for OData v4 EDM(X) rendering.
+     * @default false
+     */
+    odataContainment?: boolean
+    /**
+     * If `true`, render generated foreign keys for managed associations.
+     * By default foreign keys are never visible in structured OData APIs.
+     *
+     * @note Only available for structured OData v4 EDM(X) rendering.
+     * @default false
+     */
+    odataForeignKeys?: boolean
+    /**
+     * If `true`, association targets outside of the current service are added as
+     * `edm.EntityType` that only exposes their primary keys and have no `edm.EntitySet`.
+     * If the original association target is a service member, a corresponding `edm.Schema`
+     * representing the namespace of that service is added to `edm.Services`.  All association
+     * targets that are no service members are collected in an `edm.Schema` with namespace `root`.
+     *
+     * @note Only valid for structured OData v4 EDM(X) rendering.
+     * @default false
+     * @since v2.1.0
+     */
+    odataProxies?: boolean
+    /**
+     * This option is an extension to `odataProxies`.
+     * If `true`, an `edm:Reference` instead of a proxy `edm.EntityType` is rendered for each
+     * association target that is a service member outside the current service instead of proxies.
+     *
+     * @note Only valid for structured OData v4 EDM(X) rendering.
+     * @default false
+     * @since v2.1.0
+     */
+    odataXServiceRefs?: boolean
+    /**
+     * The OData specification requires that all primary keys of the principal must be used as
+     * referential constraints.  If an association is modelled with only a partial key, no
+     * referential constraints are added.  If `true`, partial constraints are rendered for
+     * backwards compatibility and mocking scenarios.  A spec violation warning is raised for
+     * each incomplete constraint.
+     *
+     * @note Only valid for OData v2 CSN transformation.
+     * @default false
+     * @since v2.2.6
+     */
+    odataV2PartialConstr?: boolean
+    /**
+     * Service name for which EDMX or EDM shall be rendered.
+     *
+     * @note Only available for `to.edmx()` and `to.edm()`.  For `to.edmx.all()`
+     *       and `to.edm.all()`, use `serviceNames` instead.
+     *
+     * @see serviceNames
+     */
+    service?: string
+    /**
+     * Array of service names for which EDMX or EDM shall be rendered.
+     * If unspecified, all services are rendered.
+     *
+     * @note Only available for `to.edmx.all()` and `to.edm.all()`.  For `to.edmx()`
+     *       and `to.edm()`, use `service` instead.
+     *
+     * @see service
+     */
+    serviceNames?: string[]
+  }
+
+  /**
+   * Options used by SQL `to.sql()` backend.
+   *
+   * @see to.sql()
+   */
+  export interface SqlOptions extends Options {
+    /**
+     * The SQL naming mode decides how names are represented.
+     * Among others, this includes whether identifiers are quoted or not (note
+     * that "smart quoting" is handled by `sqlDialect`).
+     *
+     * - `plain`:
+     *   In this naming mode, dots are replaced by underscores.
+     *   Names are neither upper-cased nor quoted, unless "smart-quoting" is used.
+     *   This mode can be used with all SQL dialects.
+     * - `quoted`:
+     *   In this mode, all identifiers are quoted.  Dots are not replaced in table
+     *   and view names but are still replaced by underscores in element names.
+     *   This mode can only be used with SQL dialect `hana`.
+     * - `hdbcds`:
+     *   This mode uses names that are compatible to SAP HANA CDS.
+     *   In this mode, all identifiers are quoted.  Dots are neither replaced in table
+     *   nor element names.  Namespace identifiers are separated from the remaining
+     *   identifier by `::`, i.e. the dot is replaced.  For example `Ns.Books`
+     *   becomes `"Ns::Books"`.
+     *   This mode can only be used with SQL dialect `hana`.
+     *
+     * @default 'plain'
+     */
+    sqlMapping?: string | 'plain' | 'quoted' | 'hdbcds'
+    /**
+     * Use this option to specify what dialect of SQL you want.
+     *
+     * Different databases may support different feature sets of SQL.
+     * For example, timestamps are handled differently.  Furthermore, "smart-quoting"
+     * is enabled for `sqlite` and `hana`.  This is useful if identifiers
+     * collide with reserved keywords.
+     *
+     * - `plain`:
+     *   Use this option for best compatibility with standard SQL.
+     *   Note that "smart-quoting" is not available for this mode.
+     *   Requires `sqlMapping: 'plain'`.
+     * - `sqlite`:
+     *   This SQL dialect ensures compatibility with SQLite, which may not support
+     *   all SQL features used in your CDS files.  For example, `$at.from`/`$at.to` are
+     *   handled differently to ensure correctness for SQLite.  "smart-quoting"
+     *   quotes identifiers that are reserved keywords, but does not upper-case them.
+     *   Requires `sqlMapping: 'plain'`.
+     * - `hana`:
+     *   Use this SQL dialect for best compatibility with SAP HANA.
+     *   "smart-quoting" upper-cases and quotes identifiers.
+     *
+     * @default 'plain'
+     */
+    sqlDialect?: string | 'plain' | 'sqlite' | 'hana'
+    /**
+     * Object containing magic variables.  These magic variables are
+     * used as placeholder values.
+     *
+     * @since 2.11.0
+     */
+    variableReplacements?: {
+      [option: string]: string | object,
+      /**
+       * Commonly used placeholders for user's name and locale.
+       */
+      $user?: {
+        [option: string]: string | object,
+        id?: string
+        locale?: string
+      },
+      /**
+       * Commonly used placeholders for session variables.
+       */
+      $session?: Record<string, string | object>
+    }
+  }
+
   /**
    * The compiler's package version.
    * For more details on versioning and SemVer, see `doc/Versioning.md`
@@ -83,6 +261,7 @@ declare namespace compiler {
    * {@link CompilationError} containing a vector of individual errors.
    *
    * @param filenames Array of files that should be compiled.
+   * @param dir Working directory. Relative paths in `filenames` will be resolved relatively to this directory.
    * @param options  Compiler options. If you do not set `messages`, they will be printed to console.
    * @param fileCache A dictionary of absolute file names to the file content with values:
    *  - false: the file does not exist
@@ -138,7 +317,7 @@ declare namespace compiler {
    * _Note_: Sorting is done in-place.
    *
    * Example of sorted messages:
-   * ```txt
+   * ```
    * A.cds:1:11: Info    id-3: First message text   (in entity:“E”/element:“c”)
    * A.cds:8:11: Error   id-5: Another message text (in entity:“C”/element:“g”)
    * B.cds:3:10: Debug   id-7: First message text   (in entity:“B”/element:“e”)
@@ -188,10 +367,11 @@ declare namespace compiler {
    * form (i.e. one line)
    *
    * Example:
-   * ```txt
+   * ```
    * <source>.cds:3:11: Error message-id: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
    * ```
    *
+   * @param msg               Compiler message which shall be stringified.
    * @param normalizeFilename If true, the file path will be normalized to use `/` as the path separator.
    * @param noMessageId       If true, the message ID will _not_ be part of the string.
    * @param noHome            If true, the semantic location will _not_ be part of the string.
@@ -201,26 +381,30 @@ declare namespace compiler {
   /**
    * Returns a message string with file- and semantic location if present
    * in multiline form.
-   * The error (+ message id) will be colored according to their severity if
-   * run on a TTY.
+   * The error (+ message id) can colored according to their severity.
    *
    * Example:
-   * ```txt
-   * Error[message-id]: Can't find type `nu` in this scope (in entity:“E”/element:“e”)
+   * ```
+   * Error[message-id]: Can't find type `nu` in this scope
    *    |
-   *   <source>.cds:3:11, at entity:“E”
+   *   <source>.cds:3:11, at entity:“E”/element:“e”
    * ```
    *
    * @param config.normalizeFilename If true, the file path will be normalized to use `/` as the path separator.
    * @param config.noMessageId       If true, no messages id (in brackets) will be shown.
    * @param config.hintExplanation   If true, messages with explanations will get a "…" marker, see {@link hasMessageExplanation}.
    * @param config.withLineSpacer    If true, an additional line (with `|`) will be inserted between message and location.
+   * @param config.color             If true, ANSI escape codes will be used for coloring the severity.  If false, no
+   *                                 coloring will be used.  If 'auto', we will decide based on certain factors such
+   *                                 as whether the shell is a TTY and whether the environment variable 'NO_COLOR' is
+   *                                 unset.
    */
   export function messageStringMultiline(msg: CompileMessage, config?: {
     normalizeFilename?: boolean
     noMessageId?: boolean
     hintExplanation?: boolean
     withLineSpacer?: boolean
+    color?: boolean | 'auto'
   }): string;
 
   /**
@@ -233,16 +417,24 @@ declare namespace compiler {
    * All lines are prepended by a pipe (`|`) and show the corresponding line number.
    *
    * Example Output:
-   * ```txt
+   * ```
    *     |
    *  13 |     num * nu
    *     |           ^^
    * ```
    *
-   * @param sourceLines The source code split up into lines, e.g. by `str.split(/\r\n?|\n/);`.
-   * @param msg         Message whose location is used to print the message context.
+   * @param sourceLines  The source code split up into lines, e.g. by `str.split(/\r\n?|\n/);`.
+   * @param msg          Message whose location is used to print the message context.
+   * @param config       Configuration for the message context.
+   * @param config.color If true, ANSI escape codes will be used for coloring the severity.  If false, no
+   *                     coloring will be used.  If 'auto', we will decide based on certain factors such
+   *                     as whether the shell is a TTY and whether the environment variable 'NO_COLOR' is
+   *                     unset.
+
    */
-  export function messageContext(sourceLines: string[], msg: CompileMessage): string;
+  export function messageContext(sourceLines: string[], msg: CompileMessage, config?: {
+    color?: boolean | 'auto'
+  }): string;
 
   /**
    * Get an explanatory text for a complicated compiler message with ID
@@ -316,21 +508,26 @@ declare namespace compiler {
    * @alias for
    */
   export namespace For {
-    function odata(): any;
+    /**
+     * Transform the given (generic) CSN into one that is used for OData.
+     * Changes include flattening, type resolution and more, according to
+     * the provided options.
+     */
+    function odata(csn: CSN, options: ODataOptions): any;
   }
 
   export namespace to {
       function cdl(csn: CSN, options: Options): object;
-      function sql(csn: CSN, options: Options): any;
+      function sql(csn: CSN, options: SqlOptions): any;
 
-      function edm(csn: CSN, options: Options): any;
+      function edm(csn: CSN, options: ODataOptions): any;
       namespace edm {
-          function all(csn: CSN, options: Options): any;
+          function all(csn: CSN, options: ODataOptions): any;
       }
 
-      function edmx(csn: CSN, options: Options): any;
+      function edmx(csn: CSN, options: ODataOptions): any;
       namespace edmx {
-          function all(csn: CSN, options: Options): any;
+          function all(csn: CSN, options: ODataOptions): any;
       }
 
       function hdbcds(csn: CSN, options: Options): any;

package/lib/main.js

@@ -21,6 +21,7 @@ const { createMessageFunctions, sortMessages, sortMessagesSeverityAware, dedupli
 
 const parseLanguage = require('./language/antlrParser');
 const { parseX, compileX, compileSyncX, compileSourcesX, InvocationError } = require('./compiler');
+const { fns } = require('./compiler/shared');
 const { define } = require('./compiler/definer');
 
 // The compiler version (taken from package.json)
@@ -43,13 +44,14 @@ const { compactModel, compactQuery, compactExpr } = require('./json/to-csn')
 function parseCdl( cdl, filename, options = {} ) {
   options = Object.assign( {}, options, { parseCdl: true } );
   const sources = Object.create(null);
-  const model = { sources, options };
+  const model = { sources, options, $functions: {}, $volatileFunctions: {} };
   const messageFunctions = createMessageFunctions( options, 'parse', model );
   model.$messageFunctions = messageFunctions;
 
   const xsn = parseLanguage( cdl, filename, Object.assign( { parseOnly: true }, options ),
                              messageFunctions );
   sources[filename] = xsn;
+  fns( model );
   define( model );
   messageFunctions.throwWithError();
   return compactModel( model );