@sap/cds-compiler 2.5.0 → 2.10.4

package/lib/language/antlrParser.js

@@ -10,7 +10,7 @@
 
 const antlr4 = require('antlr4');
 
-const { makeMessageFunction, CompileMessage } = require('../base/messages');
+const { CompileMessage } = require('../base/messages');
 const errorStrategy = require('./errorStrategy');
 
 const Parser = require('../gen/languageParser').languageParser;
@@ -112,7 +112,7 @@ const rules = {
   expr: { func: 'conditionEOF', returns: 'cond' }, // yes, condition
 };
 
-function parse( source, filename = '<undefined>.cds', options = {}, rule = 'cdl' ) {
+function parse( source, filename = '<undefined>.cds', options = {}, messageFunctions, rule = 'cdl' ) {
   const lexer = new Lexer( new antlr4.InputStream(source) );
   const tokenStream = new RewriteTypeTokenStream(lexer);
   /** @type {object} */
@@ -121,7 +121,7 @@ function parse( source, filename = '<undefined>.cds', options = {}, rule = 'cdl'
 
   parser.filename = filename;
   parser.options = options;
-  parser.$message = makeMessageFunction( parser, options, 'parse' ); // sets parser.messages
+  parser.$messageFunctions = messageFunctions;
 
   initTokenRewrite( parser, tokenStream );
   // comment the following 2 lines if you want to output the parser errors directly:
@@ -162,6 +162,7 @@ function parse( source, filename = '<undefined>.cds', options = {}, rule = 'cdl'
   if (rulespec.$frontend)
     ast.$frontend = rulespec.$frontend;
 
+  // TODO: clarify with LSP colleagues: still necessary?
   if (parser.messages) {
     Object.defineProperty( ast, 'messages',
                            { value: parser.messages, configurable: true, writable: true } );

package/lib/language/errorStrategy.js

@@ -245,6 +245,7 @@ function reportIgnoredWith( recognizer, t ) {
 }
 
 function consumeUntil( recognizer, set ) {
+  // TODO: add trace
   if (SEMI == null)
     SEMI = recognizer.literalNames.indexOf( "';'" );
   if (RBRACE == null)

package/lib/language/genericAntlrParser.js

@@ -13,6 +13,14 @@ const locUtils = require('../base/location');
 const { parseDocComment } = require('./docCommentParser');
 const { functionsWithoutParens, specialFunctions } = require('../compiler/builtins');
 
+
+// Push message `msg` with location `loc` to array of errors:
+function _message( parser, severity, id, loc, ...args ) {
+  const msg = parser.$messageFunctions[severity]; // set in antlrParser.js
+  return msg( id,
+              (loc instanceof antlr4.CommonToken) ? parser.tokenLocation(loc) : loc, ...args );
+}
+
 // Class which is to be used as grammar option with
 //   grammar <name> options { superclass = genericAntlrParser; }
 //
@@ -34,10 +42,10 @@ function GenericAntlrParser( ...args ) {
 
 GenericAntlrParser.prototype = Object.assign(
   Object.create( antlr4.Parser.prototype ), {
-    message: function(...args) { return message.call(this, 'message', ...args); },
-    error: function(...args) { return message.call(this, 'error', ...args); },
-    warning: function(...args) { return message.call(this, 'warning', ...args); },
-    info: function(...args) { return message.call(this, 'info', ...args); },
+    message: function(...args) { return _message( this, 'message', ...args ); },
+    error: function(...args) { return _message( this, 'error', ...args ); },
+    warning: function(...args) { return _message( this, 'warning', ...args ); },
+    info: function(...args) { return _message( this, 'info', ...args ); },
     attachLocation,
     startLocation,
     tokenLocation,
@@ -69,6 +77,7 @@ GenericAntlrParser.prototype = Object.assign(
     noAssignmentInSameLine,
     noSemicolonHere,
     setLocalToken,
+    setLocalTokenIfBefore,
     excludeExpected,
     isStraightBefore,
     meltKeywordToIdentifier,
@@ -110,14 +119,6 @@ const quotedLiteralPatterns = {
   },
 };
 
-
-// Push message `msg` with location `loc` to array of errors:
-function message( severity, id, loc, ...args ) {
-  const msg = this.$message[severity];
-  return msg( id,   // function $message is set in antlrParser.js
-              (loc instanceof antlr4.CommonToken) ? this.tokenLocation(loc) : loc, ...args );
-}
-
 // Use the following function for language constructs which we (currently)
 // just being able to parse, in able to run tests from HANA CDS.  As soon as we
 // create ASTs for the language construct and put it into a CSN, a
@@ -183,6 +184,14 @@ function setLocalToken( string, tokenName, notBefore, inSameLine ) {
     ll1.type = this.constructor[tokenName];
 }
 
+function setLocalTokenIfBefore( string, tokenName, before, inSameLine ) {
+  const ll1 = this.getCurrentToken();
+  if (ll1.text.toUpperCase() === string &&
+      (!inSameLine || this._input.LT(-1).line === ll1.line) &&
+      (!before || before && before.test( this._input.LT(2).text )))
+    ll1.type = this.constructor[tokenName];
+}
+
 // // Special function for rule `requiredSemi` before return $ctx
 // function braceForSemi() {
 //   if (RBRACE == null)

package/lib/language/language.g4

@@ -20,7 +20,7 @@
 //    allow integers at certain places), one token type for non-quoted and
 //    quoted identifiers.
 //
-//  * Keep the number of keywords as small as possibile.  Thus, built-ins is a
+//  * Keep the number of keywords as small as possible.  Thus, built-ins is a
 //    topic for the semantic analysis, not the grammar.  Examples: no keywords
 //    for built-in types or built-in SQL functions.  This also avoids noise in
 //    the grammar and a huge/slow generated parser.
@@ -43,7 +43,7 @@
 //    is not enough for a decision), write a comment starting with `#ATN:`
 //    which describes the ambiguity.  Additionally, put a comment `/* #ATN n
 //    */` INSIDE an (`@after`) action of a rule if the corresponding function
-//    in '../gen/langageParser.js' contains `n` occurrences of
+//    in '../gen/languageParser.js' contains `n` occurrences of
 //    `adaptivePredict` calls.  This is checked in 'test/testCompiler.js',
 //    which also counts the total number of `adaptivePredict` occurrences.
 //  └─────────────────────────────────────────────────────────────────────────┘
@@ -55,6 +55,10 @@
 //    good idea anyway to avoid calls to `adaptivePredict`, see the rules
 //    starting with `annotationAssignment_`.
 //
+//  * Factoring out a sub rule into a named rule influences the error recovery:
+//    the parser tries to consume all tokens which are neither in the follow
+//    set of loops and named rules.  So be careful.
+//
 //  * Do not use actions in the lexer.  Examples: de-quote string literals not
 //    in the lexer, but in the parser; do not throw errors, but produce error
 //    tokens if necessary.
@@ -106,6 +110,9 @@
 //
 //  * The ANTLR error "missing attribute access on rule reference c in $c" can
 //    be solved with using $ctx.c instead of $c
+//
+//  * If you want to set a property starting with '$' like $syntax, use
+//    obj['$'+'syntax'] as the ANTLR tool would replace $syntax by $ctx.syntax
 
 grammar language;
 options {
@@ -114,6 +121,7 @@ options {
 }
 tokens {
   VIRTUAL,                      // used with setLocalToken()
+  OVER,                         // used with setLocalTokenIfBefore()
   HelperToken1,                 // used with setLocalToken(), does not appear in messages
   HelperToken2,                 // used with setLocalToken(), does not appear in messages
   HideAlternatives,             // hide alternative tokens (no token seq!)
@@ -818,7 +826,7 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {} ]
       )*
       ')'
       (
-        RETURNS '{'
+        RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
         annotateElement[ $art ]*
         '}'
         optionalSemi
@@ -826,7 +834,7 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {} ]
         requiredSemi
       )
     |
-      RETURNS '{'
+      RETURNS '{' { $art['$'+'syntax'] = 'returns'; }
       annotateElement[ $art ]*
       '}'
       optionalSemi
@@ -1124,13 +1132,7 @@ bracedSelectItemListDef[ query ]
     '{'
     { if (!$query.columns) $query.columns = []; }  // set it early to avoid "wildcard" errors
     (
-      ( star='*'                // TODO: allow everywhere
-        {
-          $query.columns = [ this.tokenLocation( $star, undefined, '*' ) ];
-        }
-      |
-        selectItemDef[ $query.columns ]
-      )
+      selectItemDef[ $query.columns ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemDef[ $query.columns ]
       )*
@@ -1139,8 +1141,11 @@ bracedSelectItemListDef[ query ]
   ;
 
 selectItemDef[ outer ] locals[ annos = [] ]
-@after{ this.attachLocation($art.art); }
+@after{ if ($ctx.art) this.attachLocation($art.art); }
   :
+    star='*'
+    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+  |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
     // VIRTUAL is keyword, except if before the following tokens texts:
@@ -1159,6 +1164,8 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
   :
     (
       e=expression
+      // we cannot use 'condition' instead, as long as we allow aliases without
+      // AS (using rule 'ident' instead of 'identNoKeyword') -> ambiguities
       {
         $art = this.addItem( $outer, null, null, $annos, { value: $e.expr } );
       }
@@ -1218,11 +1225,7 @@ selectItemInlineList[ art, clause ]
     '{'
     { $art[$clause] = []; }
     (
-      ( star='*'                // TODO: allow everywhere
-        { $art[$clause].push( this.tokenLocation( $star, undefined, '*' ) ); }
-      |
-        selectItemInlineDef[ $art[$clause] ]
-      )
+      selectItemInlineDef[ $art[$clause] ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemInlineDef[ $art[$clause] ]
       )*
@@ -1231,8 +1234,11 @@ selectItemInlineList[ art, clause ]
   ;
 
 selectItemInlineDef[ outer ] locals[ annos = [] ]
-@after{ this.attachLocation($art.art); }
+@after{ if ($ctx.art) this.attachLocation($art.art); }
   :
+    star='*'
+    { $outer.push( this.tokenLocation( $star, undefined, '*' ) ); }
+  |
     { this.docComment( $annos ); }
     annotationAssignment_atn[ $annos ]*
     art=selectItemDefBody[ $outer, $annos ]
@@ -1407,6 +1413,8 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
   |
     ':'
     // #ATN: typeRefOptArgs can start with ARRAY or MANY or ASSOCIATION or TYPE or LOCALIZED
+    // Nevertheless, MANY '{' is handled by local token rewrite:
+    { this.setLocalToken( 'MANY', 'HelperToken1', /^[^\{]/ ); }
     (
       typeStruct[ $art ]
       optionalSemi
@@ -1416,6 +1424,12 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
       ( typeToMany[ $art ] | typeToOne[ $art ] | simplePath[ $art.target, 'artref' ] )
       typeAssociationCont[ $art ]?
       requiredSemi                       // and if its the ';'...
+    |
+      many=HelperToken1         // rewritten MANY before '{'
+      { $art.items = { location: this.tokenLocation( $many ) };}
+      typeStruct[ $art.items ]
+      nullability[ $art.items ]?
+      optionalSemi
     |
       (
         array=ARRAY of=OF
@@ -1455,6 +1469,7 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
       annotationAssignment_ll1[ $annos ]*
       requiredSemi
     |
+      // alt lookahead includes MANY '{'
       { $art.type = {}; }
       simplePath[ $art.type, 'artref' ]
       (
@@ -1462,8 +1477,20 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         head=Number
         { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
         ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-          tail=Number
-          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+          (
+            v=VARIABLE
+            { $art['$'+'typeArgs'].push(
+              { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
+            }
+          |
+            f=FLOATING
+            { $art['$'+'typeArgs'].push(
+              { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
+            }
+          |
+            tail=Number
+            { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+          )
         )*
         ')'
         { this.docComment( $annos ); }
@@ -1687,8 +1714,20 @@ typeRefOptArgs[ art ]
       head=Number
       { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        tail=Number
-        { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+        (
+          v=VARIABLE
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
+          }
+        |
+          f=FLOATING
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
+          }
+        |
+          tail=Number
+          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+        )
       )*
       ')'
     |
@@ -1723,6 +1762,30 @@ orderByClause[ inQuery ] returns [ query ]
     ( ',' obn=orderBySpec  { $query.orderBy.push( $obn.ob ); } )*
   ;
 
+overOrderByClause returns [ expr ]
+  :
+    o=ORDER b=BY { $expr = { op: this.tokenLocation($o, $b, 'orderBy' ) , args: [] }}
+    ob1=orderBySpec { $expr.args.push( $ob1.ob ); }
+    ( ',' obn=orderBySpec { $expr.args.push( $obn.ob ); } )*
+  ;
+
+partitionByClause returns [ expr ]
+  :
+    p=PARTITION b=BY { $expr = { op: this.tokenLocation($p, $b, 'partitionBy' ) , args: [] }}
+    e1=expression { $expr.args.push( $e1.expr ); }
+    ( ',' en=expression { $expr.args.push( $en.expr ); } )*
+  ;
+
+overClause returns [ over ]
+@after { this.attachLocation($over); }
+  :
+    o=OVER { $over = { op: this.tokenLocation( $o, null, 'over' ) , args: []  } }
+    '('
+      ( pb=partitionByClause { $over.args.push( $pb.expr ); } )?
+      ( ob=overOrderByClause { $over.args.push( $ob.expr ); } )?
+    ')'
+  ;
+
 limitClause[ inQuery ] returns [ query ]
   :
     limkw=LIMIT { $query = this.unaryOpForParens( $inQuery, '$'+'query' ); }
@@ -1781,13 +1844,7 @@ queryPrimary returns[ query = {} ]
       { $query.quantifier = this.tokenLocation( $ad, undefined, $ad.text.toLowerCase() ); }
       )?
       { $query.columns = []; }  // set it early to avoid "wildcard" errors
-      ( star='*'
-        {
-          $query.columns = [ this.tokenLocation( $star, undefined, '*' ) ];
-        }
-      |
-        selectItemDef[ $query.columns ]
-      )
+      selectItemDef[ $query.columns ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemDef[ $query.columns ]
       )*
@@ -1945,7 +2002,7 @@ fromPath[ qp, idkind ]
 condition returns [ cond ] locals [ args = [], orl = [] ]
 @after{
   $cond = ($args.length == 1)
-    ? $args[0]
+    ? this.attachLocation( $args[0] )
     : this.attachLocation({ op: $orl[0], args: $args });
 }
   :
@@ -2106,6 +2163,10 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         this.notSupportedYet( $ne ); }
     |
       vp=valuePath[ 'ref', null ] { $expr = this.valuePathAst( $vp.qp ); }
+      { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
+      (
+        over=overClause { $expr.suffix = [ $over.over ] }
+      )?
     |
       ':'
       ( vp=valuePath[ 'paramref', this.startLocation() ]
@@ -2306,7 +2367,7 @@ optionalCardinality[ pathStep ]
     // completion just produces `:`after having inserted a Number - TODO.
     { if (this._input.LT(2).text !== ':') return $ctx; }
     ( trgMax=Number ':'
-      { if ($pathStep) $pathStep.cardinality = { targetMax: this.numberLiteral( $trgMax ) } }
+      { if ($pathStep) $pathStep.cardinality = { targetMax: this.numberLiteral( $trgMax ), location: this.startLocation() }; }
     )
   ;
 
@@ -2557,6 +2618,7 @@ ident[ category ] returns[ id ]
   | EXCLUDING
   | EXTEND
   | FIRST
+  | FLOATING
   | FULL
   | FUNCTION
   | GROUP
@@ -2587,6 +2649,7 @@ ident[ category ] returns[ id ]
   | ORDER
   | OUTER
   | PARAMETERS
+  | PARTITION
   | PROJECTION
   | REDIRECTED
   | RETURNS
@@ -2599,6 +2662,7 @@ ident[ category ] returns[ id ]
   | TO
   | TYPE
   | USING
+  | VARIABLE
   | VIEW
   | YEAR
   ;
@@ -2715,6 +2779,7 @@ EXCEPT : [eE][xX][cC][eE][pP][tT] ;
 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] ;
 FULL : [fF][uU][lL][lL] ;
 FUNCTION : [fF][uU][nN][cC][tT][iI][oO][nN] ;
 GROUP : [gG][rR][oO][uU][pP] ;
@@ -2744,7 +2809,9 @@ ONE : [oO][nN][eE] ;
 OR : [oO][rR] ;
 ORDER : [oO][rR][dD][eE][rR] ;
 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] ;
 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] ;
@@ -2757,6 +2824,7 @@ TO : [tT][oO] ;                 // or make reserved? (is in SQL-92)
 TYPE : [tT][yY][pP][eE] ;
 UNION : [uU][nN][iI][oO][nN] ;
 USING : [uU][sS][iI][nN][gG] ;
+VARIABLE : [vV][aA][rR][iI][aA][bB][lL][eE] ;
 VIEW : [vV][iI][eE][wW] ;
 // VIRTUAL: [vV][iI][rR][tT][uU][aA][lL] ; see tokens {}
 YEAR : [yY][eE][aA][rR] ;

package/lib/main.d.ts

@@ -107,12 +107,81 @@ declare namespace compiler {
       constructor(messages: any, model: any, text: any, ...args);
       messages: any[];
       toString(): string;
+      /**
+       * If `options.attachValidNames` is set, this non-enumerable property holds the CSN model.
+       * @internal
+       */
+      model?: CSN;
+      /**
+       * Used by `cdsc` to indicate whether the message was already printed to stderr.
+       * @private
+       */
+      hasBeenReported: boolean;
   }
 
-  export function sortMessages(messages: any[]): void;
-  export function sortMessagesSeverityAware(messages: any[]): void;
+  /**
+   * Sort the given messages according to their location.  Messages are sorted
+   * in ascending order according to their:
+   *
+   *  - file name
+   *  - start line
+   *  - start column
+   *  - end line
+   *  - end column
+   *  - semantic location (“home”)
+   *  - message text
+   *
+   * If both messages do not have a location, they are sorted by their semantic
+   * location and then by their message text.  If only one message has a file
+   * location, that message is sorted prior to those that don't have one.
+   *
+   * _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”)
+   * B.cds:3:12: Warning id-4: Message text         (in entity:“B”/element:“d”)
+   * B.cds:3:12: Error   id-4: Message text         (in entity:“B”/element:“e”)
+   * ```
+   *
+   * If you also want to sort according to message's severity,
+   * see {@link sortMessagesSeverityAware}.
+   *
+   * @returns The same messages array as the input parameter.
+   */
+  export function sortMessages(messages: CompileMessage[]): CompileMessage[];
+
+  /**
+   * Sort the given messages in severity aware order.  Messages are sorted first
+   * by severity where 'Error' comes first, then 'Warning' and so forth.
+   * Messages of the same severity are sorted the same as by {@link sortMessages}.
+   *
+   * _Note_: Sorting is done in-place.
+   *
+   * @returns The same messages array as the input parameter.
+   */
+  export function sortMessagesSeverityAware(messages: CompileMessage[]): CompileMessage[];
 
-  export function deduplicateMessages(messages: any[]): void;
+  /**
+   * Removes duplicate messages from the given messages array without destroying
+   * references to the array, i.e. removes them in-place.
+   *
+   * _Note_: Does NOT keep the original order!
+   *
+   * Two messages are the same if they have the same message hash (see below).
+   * If one of the two is more precise, then it replaces the other.
+   * A message is more precise if it is contained in the other or if
+   * the first does not have an `endLine`/`endCol`.
+   *
+   * A “message hash” is the string representation of the message.  If the
+   * message does not have a semantic location (“home”), the message hash
+   * is the result of {@link messageString}.  If the message has a semantic
+   * location, the file location is stripped before being passed to
+   * {@link messageString}.
+   */
+  export function deduplicateMessages(messages: CompileMessage[]): void;
 
   /**
    * Returns a message string with file- and semantic location if present in compact
@@ -205,6 +274,15 @@ declare namespace compiler {
   export function preparedCsnToEdmx(csn: CSN, service: string, options: any): any;
 
   export namespace parse {
+      /**
+       * Parse the given CDL in parseCdl mode and return its corresponding CSN representation.
+       *
+       * @param cdl      CDL source as string.
+       * @param filename Filename to be used in compiler messages.
+       * @param options  Compiler options. Note that if `options.messages` is not set, messages will be printed to stderr.
+       */
+      function cdl(cdl: string, filename: string, options?: Options): any;
+
       /**
        * Parse the given CQL and return its corresponding CSN representation.
        *

package/lib/main.js

@@ -16,10 +16,12 @@
 const backends = require('./backends');
 const { odata, cdl, sql, hdi, hdbcds, edm, edmx } = require('./api/main');
 const { getArtifactDatabaseNameOf, getElementDatabaseNameOf } = require('./model/csnUtils');
-const { sortMessages, sortMessagesSeverityAware, deduplicateMessages } = require('./base/messages');
+const { traverseCsn } = require('./model/api');
+const { createMessageFunctions, sortMessages, sortMessagesSeverityAware, deduplicateMessages } = require('./base/messages');
 
 const parseLanguage = require('./language/antlrParser');
 const { parseX, compileX, compileSyncX, compileSourcesX, InvocationError } = require('./compiler');
+const { define } = require('./compiler/definer');
 
 // The compiler version (taken from package.json)
 function version() {
@@ -31,7 +33,6 @@ const {
   messageString,
   messageStringMultiline,
   messageContext,
-  handleMessages,
   hasErrors,
   explainMessage,
   hasMessageExplanation
@@ -39,15 +40,34 @@ const {
 
 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 messageFunctions = createMessageFunctions( options, 'parse', model );
+  model.$messageFunctions = messageFunctions;
+
+  const xsn = parseLanguage( cdl, filename, Object.assign( { parseOnly: true }, options ),
+                             messageFunctions );
+  sources[filename] = xsn;
+  define( model );
+  messageFunctions.throwWithError();
+  return compactModel( model );
+}
+
 function parseCql( cdl, filename = '<query>.cds', options = {} ) {
-  let xsn = parseLanguage( cdl, filename, Object.assign( {parseOnly:true}, options ), 'query' );
-  handleMessages( xsn, options );
+  const messageFunctions = createMessageFunctions( options, 'parse' );
+  const xsn = parseLanguage( cdl, filename, Object.assign( { parseOnly: true }, options ),
+                             messageFunctions, 'query' );
+  messageFunctions.throwWithError();
   return compactQuery( xsn );
 }
 
 function parseExpr( cdl, filename = '<expr>.cds', options = {} ) {
-  let xsn = parseLanguage( cdl, filename, Object.assign( {parseOnly:true}, options ), 'expr' );
-  handleMessages( xsn, options );
+  const messageFunctions = createMessageFunctions( options, 'parse' );
+  const xsn = parseLanguage( cdl, filename, Object.assign( { parseOnly: true }, options ),
+                             messageFunctions, 'expr' );
+  messageFunctions.throwWithError();
   return compactExpr( xsn );
 }
 
@@ -79,7 +99,7 @@ module.exports = {
   preparedCsnToEdm :  (csn, service, options) => { return backends.preparedCsnToEdm(csn, service, options).edmj},
 
   // additional API:
-  parse: { cql: parseCql, expr: parseExpr }, // preferred names
+  parse: { cdl: parseCdl, cql: parseCql, expr: parseExpr }, // preferred names
   /**
    * @deprecated Use parse.cql instead
    */
@@ -92,6 +112,9 @@ module.exports = {
   getArtifactCdsPersistenceName: getArtifactDatabaseNameOf,
   getElementCdsPersistenceName: getElementDatabaseNameOf,
 
+  // Other API functions:
+  traverseCsn,
+
   // INTERNAL functions for the cds-lsp package and friends - before you use
   // it, you MUST talk with us - there can be potential incompatibilities with
   // new releases (even having the same major version):