@sap/cds-compiler 5.2.0 → 5.3.2

package/lib/inspect/inspectPropagation.js

@@ -36,7 +36,7 @@ function inspectPropagation( xsn, options, artifactName ) {
 
   if (!artifactXsn) {
     error(null, null, { name: artifactName },
-          // eslint-disable-next-line max-len
+          // eslint-disable-next-line @stylistic/js/max-len
           'Artifact $(NAME) not found, only top-level artifacts and their elements are supported for now');
     return null;
   }

package/lib/json/from-csn.js

@@ -1134,7 +1134,7 @@ function elementsDict( def, spec, xsn ) {
     return elements;
   warning( 'syntax-expecting-returns', elements[$location],
            { prop: 'elements', parentprop: 'returns' },
-           // eslint-disable-next-line max-len
+           // eslint-disable-next-line @stylistic/js/max-len
            'Expecting property $(PROP) to be put into an object for property $(PARENTPROP) when annotating action return structures' );
   xsn.returns = { kind: 'annotate', elements, location: elements[$location] };
   return undefined;
@@ -2076,8 +2076,10 @@ function toXsn( csn, filename, options, messageFunctions ) {
 
   const xsn = new XsnSource( 'json' ); // TODO: 'csn'? LSP does not use $frontend
 
-  // eslint-disable-next-line object-curly-newline
-  ({ message, error, warning, info } = messageFunctions);
+
+  ({
+    message, error, warning, info,
+  } = messageFunctions);
 
   if (csnVersionZero) {
     warning( 'syntax-deprecated-csn-version', location(true), {},

package/lib/json/to-csn.js

@@ -123,7 +123,7 @@ const transformers = {
   value: enumValueOrCalc,       // do not list for select items as elements
   query,
   elements,
-  actions,                      // TODO: just normal dictionary
+  actions: sortedDict,          // TODO: just normal dictionary
   returns,                      // storing the return type of actions
   // special: top-level, cardinality -----------------------------------------
   sources,
@@ -609,6 +609,10 @@ function addLocation( loc, csn ) {
     // is often not the reason for an error or warning.  So we gain little benefit for
     // two more properties. It is also an indication that the location is not exact.
     const val = { file: loc.file, line: loc.line, col: loc.col };
+    if (withLocations === 'withEndPosition' && loc.endLine) {
+      val.endLine = loc.endLine;
+      val.endCol = loc.endCol;
+    }
     Object.defineProperty( csn, '$location', {
       value: val, configurable: true, writable: true, enumerable: withLocations,
     } );
@@ -621,18 +625,11 @@ function insertOrderDict( dict ) {
   return dictionary( dict, keys );
 }
 
-function sortedDict( dict ) {
+function sortedDict( dict, _csn, _node, prop ) {
   const keys = Object.keys( dict );
   if (strictMode)
     keys.sort();
-  return dictionary( dict, keys );
-}
-
-function actions( dict, _csn, node ) {
-  const keys = Object.keys( dict );
-  if (strictMode && node.kind === 'annotate')
-    keys.sort();                // TODO: always sort with --test-mode ?
-  return dictionary( dict, keys, 'actions' );
+  return dictionary( dict, keys, prop );
 }
 
 function params( dict ) {

package/lib/language/antlrParser.js

@@ -20,6 +20,7 @@ const Lexer = require('../gen/languageLexer').default;
 const CdlLexer = require( '../parsers/Lexer' );
 const CdlParser = require( '../gen/CdlParser' );
 const { createMessageFunctions } = require( '../base/messages' );
+const { CompilerAssertion } = require( '../base/error' );
 
 // Error listener used for ANTLR4-generated parser
 class ErrorListener extends antlr4.error.ErrorListener {
@@ -224,10 +225,34 @@ function parseWithNewParser( source, filename, options, messageFunctions, rule )
   const lexer = new CdlLexer( filename, source );
   const parser = new CdlParser( lexer, options, messageFunctions ).init();
   parser.filename = filename;   // LSP compatibility
-  parser.tokenStream = parser;  // LSP compatibility: object with property `tokens`
 
+  const { parseListener, attachTokens } = options;
+  if (parseListener || attachTokens) {
+    const combined = [];
+    const { tokens, comments, docComments } = parser;
+    const length = tokens.length + comments.length + docComments.length;
+    let tokenIdx = 0;
+    let commentIdx = 0;
+    let docCommentIdx = 0;
+    for (let index = 0; index < length; ++index) {
+      if (tokens[tokenIdx].location.tokenIndex === index) // EOF has largest tokenIndex
+        combined.push( tokens[tokenIdx++] );
+      else if (comments[commentIdx]?.location.tokenIndex === index)
+        combined.push( comments[commentIdx++] );
+      else
+        combined.push( docComments[docCommentIdx++] );
+    }
+    if (!combined.at( -1 ))
+      throw new CompilerAssertion( 'Invalid values for `tokenIndex`' );
+    for (const tok of combined)
+      tok.start = lexer.characterPos( tok.location.line, tok.location.col );
+
+    parser._input = { tokens: combined, lexer }; // lexer for characterPos() in cdshi.js
+    parser.getTokenStream = function getTokenStream() {
+      return this._input;
+    };
+  }
   // LSP feature: provide parse listener with ANTLR-like context:
-  const { parseListener } = options;
   if (parseListener) {
     // TODO LSP: we could also call different listener methods: then LSP could
     // have dedicated methods for ANTLR-based and new parser
@@ -252,6 +277,14 @@ function parseWithNewParser( source, filename, options, messageFunctions, rule )
       parseListener.exitEveryRule( $ctx );
       CdlParser.prototype.exit_.apply( this, args );
     };
+    parser.c = function c( ...args ) { // consume
+      CdlParser.prototype.c.apply( this, args );
+      parseListener.visitTerminal( { symbol: this.lb() } );
+    };
+    parser.skipToken_ = function skipToken_( ...args ) { // skip token in error recovery
+      CdlParser.prototype.skipToken_.apply( this, args ); // = `++this.tokenIdx`
+      parseListener.visitErrorNode( { symbol: this.lb() } );
+    };
   }
   const result = {};
   const rulespec = rules[rule];
@@ -268,8 +301,9 @@ function parseWithNewParser( source, filename, options, messageFunctions, rule )
     }
   }
   const ast = result[rulespec?.returns] || (rule === 'cdl' ? new XsnSource( 'cdl' ) : {} );
-  if (options.attachTokens === true || options.attachTokens === filename)
-    ast.tokenStream = parser;   // with property tokens
+  ast.options = options;
+  if (attachTokens === true || attachTokens === filename)
+    ast.tokenStream = parser._input;
   return ast;
 }
 

package/lib/language/errorStrategy.js

@@ -337,7 +337,7 @@ function reportIgnoredWith( recognizer, t ) {
   const expecting = this.getExpectedTokensForMessage( recognizer, t );
   const m = recognizer.warning( 'syntax-unexpected-semicolon', t,
                                 { offending: "';'", expecting, keyword: 'with' },
-    // eslint-disable-next-line max-len
+    // eslint-disable-next-line @stylistic/js/max-len
                                 'Unexpected $(OFFENDING), expecting $(EXPECTING) - ignored previous $(KEYWORD)' );
   m.expectedTokens = expecting;
 }

package/lib/language/genericAntlrParser.js

@@ -280,7 +280,7 @@ function noAssignmentInSameLine() {
   if (t.text === '@' && t.line <= this._input.LT(-1).line) {
     // TODO: use 'syntax-missing-newline'
     this.warning( 'syntax-missing-semicolon', t, { code: ';' },
-                  // eslint-disable-next-line max-len
+                  // eslint-disable-next-line @stylistic/js/max-len
                   'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
   }
 }
@@ -685,7 +685,7 @@ function warnIfColonFollows( anno ) {
   if (t.text === ':') {
     this.warning( 'syntax-missing-parens', anno.name.location,
                   { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
-                  // eslint-disable-next-line max-len
+                  // eslint-disable-next-line @stylistic/js/max-len
                   'When $(CODE) is followed by $(OP), use $(NEWCODE) for annotation assignments at this position' );
   }
 }
@@ -796,7 +796,7 @@ function identAst( token, category, noTokenTypeCheck = false ) {
   }
   else {
     this.message( 'syntax-deprecated-ident', token, { delimited: id },
-                  // eslint-disable-next-line max-len
+                  // eslint-disable-next-line @stylistic/js/max-len
                   'Deprecated delimited identifier syntax, use $(DELIMITED) - strings are delimited by single quotes' );
   }
   const ast = { id, $delimited: true, location: this.tokenLocation( token ) };
@@ -1049,7 +1049,7 @@ function assignAnnotationValue( anno, value ) {
                     {
                       std: 'Annotation number $(RAWVALUE) is put as $(VALUE) into the CSN',
                       rounded: 'Annotation number $(RAWVALUE) is rounded to $(VALUE)',
-                      // eslint-disable-next-line max-len
+                      // eslint-disable-next-line @stylistic/js/max-len
                       infinite: 'Annotation value $(RAWVALUE) is infinite as number and put as string into the CSN',
                     } );
     }

package/lib/language/multiLineStringParser.js

@@ -77,7 +77,7 @@ class MultiLineStringParser {
     this.str = token.text; // Copy because .text is a getter
 
     if (this.str[0] !== '`' || this.str[this.str.length - 1] !== '`')
-      // eslint-disable-next-line max-len
+      // eslint-disable-next-line @stylistic/js/max-len
       throw new CompilerAssertion('Invalid multi-line string sequence: Require string to be surrounded by back-ticks!');
 
     this.output = [];

package/lib/main.d.ts

@@ -154,6 +154,29 @@ declare namespace compiler {
      * @since v2.12.1
      */
     $xsnObjects?: boolean
+    /**
+     * If `true`, the CSN will have an enumerable property `$locations`.
+     * with values for `line` and `col`, i.e. there is only a start position,
+     * but no end position.
+     *
+     * If `false`, the property will be non-enumerable, i.e. it won't be
+     * serialized when using `JSON.stringify()`.
+     *
+     * With value `"withEndPosition"`, the property will be enumerable and
+     * will contain values for the end-position.  Other string values
+     * are not allowed.  This value was introduced in v5.3.0.
+     *
+     * $location is not set on all artifacts, and it only indicates the position
+     * of the _name_ of the artifact.
+     */
+    withLocations?: boolean|string
+    /**
+     * Use the new non-ANTLR based parser for compilation.
+     * Experimental flag!
+     *
+     * @since v5.2.0
+     */
+    newParser?: boolean
     /**
      * Internal option for LSP only!
      * If set, each AST gets a `tokenStream` property containing all lexed tokens.

package/lib/model/cloneCsn.js

@@ -5,16 +5,23 @@ const { ModelError } = require('../base/error');
 const { setHidden } = require('../utils/objectUtils');
 const { isAnnotationExpression } = require('../base/builtins');
 
-const csnDictionaries = [
-  'args',
-  'params',
-  'enum',
-  'mixin',
-  'elements',
-  'actions',
-  'definitions',
-  'vocabularies',
-];
+const csnDictionaries = {
+  __proto__: null,
+  args: 1,
+  params: 1,
+  enum: 1,
+  mixin: 1,
+  elements: 1,
+  actions: 1,
+  definitions: 1,
+  vocabularies: 1,
+};
+
+const sortedCsnDictionaries = {
+  __proto__: null,
+  definitions: 1,
+  actions: 1,
+};
 
 function shallowCopy( val, _options, _sort ) {
   return val;
@@ -74,9 +81,9 @@ function cloneCsn( csn, options, sort ) {
     else if (!val || typeof val !== 'object') {
       r[n] = val;
     }
-    else if (csnDictionaries.includes(n) && !Array.isArray(val)) {
-      const sortDict = n === 'definitions' &&
-        (!options || options.testMode || options.testSortCsn);
+    else if (csnDictionaries[n] && !Array.isArray(val)) {
+      const sortDict = (!options || options.testMode || options.testSortCsn) &&
+        sortedCsnDictionaries[n];
       // Array check for property `args` which may either be a dictionary or an array.
       r[n] = cloneCsnDict(val, options, sort, sortDict);
     }
@@ -122,6 +129,8 @@ function hasNonEnumerable( object, property ) {
  * @param {object} csn
  * @param {CSN.Options} options Only cloneOptions.dictionaryPrototype is
  *                              used and cloneOptions are passed to sortCsn().
+ * @param {boolean} sortProps   Whether to sort CSN properties.
+ * @param {boolean} sortDict    Whether to sort CSN dictionary entries.
  */
 function cloneCsnDict( csn, options, sortProps, sortDict ) {
   const proto = options?.dictionaryPrototype;

package/lib/optionProcessor.js

@@ -254,7 +254,7 @@ optionProcessor.command('O, toOdata')
   .option('-f, --odata-format <format>', { valid: ['flat', 'structured'] })
   .option('-n, --sql-mapping <style>', { valid: ['plain', 'quoted', 'hdbcds'], aliases: [ '--names' ] })
   .option('-s, --service-names <list>')
-  .option('    --fewer-localized-views')
+  .option('    --transitive-localized-views')
   .help(`
   Usage: cdsc toOdata [options] <files...>
 
@@ -293,7 +293,7 @@ optionProcessor.command('O, toOdata')
                                          source (like "quoted", but using element names with dots)
     -s, --service-names <list>    List of comma-separated service names to be rendered
                                   (default) empty, all services are rendered
-   --fewer-localized-views   If set, the backends will not create localized convenience views for
+   --transitive-localized-views  If set, the backends will create localized convenience views for
                              those views, that only have an association to a localized entity/view.
 `);
 
@@ -338,7 +338,7 @@ optionProcessor.command('Q, toSql')
   .option('    --disable-hana-comments')
   .option('    --generated-by-comment')
   .option('    --better-sqlite-session-variables <bool>')
-  .option('    --fewer-localized-views')
+  .option('    --transitive-localized-views')
   .option('    --with-hana-associations <bool>', { valid: [ 'true', 'false' ] })
   .help(`
   Usage: cdsc toSql [options] <files...>
@@ -396,7 +396,7 @@ optionProcessor.command('Q, toSql')
                               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
+   --transitive-localized-views  If set, the backends will create localized convenience views for
                               those views, that only have an association to a localized entity/view.
    --with-hana-associations <bool>
                               Enable and disable rendering of "WITH ASSOCIATIONS" for sqlDialect 'hana'.
@@ -478,7 +478,7 @@ optionProcessor.command('toCsn')
   .option('    --with-localized')
   .option('    --with-locations')
   .option('    --struct-xpr')
-  .option('    --fewer-localized-views')
+  .option('    --transitive-localized-views')
   .help(`
   Usage: cdsc toCsn [options] <files...>
 
@@ -495,8 +495,8 @@ optionProcessor.command('toCsn')
                                 universal: in development (BETA)
        --with-locations   Add $location to CSN artifacts. In contrast to \`--enrich-csn\`,
                           $location is an object with 'file', 'line' and 'col' properties.
-       --fewer-localized-views   If --with-locations and this option are set, the backends
-                          will not create localized convenience views for those views,
+       --transitive-localized-views If --with-locations and this option are set, the backends
+                          will create localized convenience views for those views,
                           that only have an association to a localized entity/view.
 
   Internal options (for testing only, may be changed/removed at any time)

package/lib/parsers/AstBuildingParser.js

@@ -37,6 +37,7 @@ const queryOps = {
 };
 
 const PRECEDENCE_OF_IN_PREDICATE = 10;
+const PRECEDENCE_OF_EQUAL = 10;
 
 class AstBuildingParser extends BaseParser {
   constructor( lexer, keywords, table, options, messageFunctions ) {
@@ -45,6 +46,7 @@ class AstBuildingParser extends BaseParser {
     this.$messageFunctions = messageFunctions;
     this.docComments = [];
     this.docCommentIndex = 0;
+    this.comments = [];
 
     this.afterBrace$ = -1;
     this.topLevel$ = -1;
@@ -165,6 +167,10 @@ class AstBuildingParser extends BaseParser {
   }
 
   isDotForPath() {
+    if (this.dynamic_.inSelectItem == null)
+      return true;
+    // false for outer select item, true for inner; TODO: it would be best to set
+    // this.dynamic_.inSelectItem to null in filters
     const next = this.tokens[this.tokenIdx + 1].type;
     return next !== '*' && next !== '{';
   }
@@ -190,10 +196,103 @@ class AstBuildingParser extends BaseParser {
    * `namespace` is forbidden after a definitions/extend or after previous
    * `namespace`
    */
-  fileSection() {
+  namespaceRestriction() {
     return ++this.topLevel$ < 1;
   }
 
+  /**
+   * `extend`/`annotate` is forbidden inside `extend … with definitions` and
+   * variants
+   */
+  extensionRestriction() {
+    // TODO: use `syntax-unexpected-extension` as message
+    const r = this.dynamic_.inExtension;
+    this.dynamic_.inExtension = true;
+    return !r;
+  }
+
+  /**
+   * `annotation` def is only allowed top-level
+   */
+  vocabularyRestriction( test ) {
+    // TODO: use `syntax-unexpected-vocabulary` as message
+    if (!test)
+      this.dynamic_.inBlock = true;
+    return !this.dynamic_.inBlock;
+  }
+
+  /**
+   * Prepare element restrictions and check validility of final anno assignments.
+   * TODO TOOL: `arg` for actions/conditions
+   *
+   * Called in rule `elementDef` at the following places:
+   * - <prepare> after `:` (before calling `typeExpression`):
+   *   disallow `= calcExpr` and final annotation assignments
+   *   without further <prepare=calcOrDefaultRestriction>
+   * - <prepare> in empty alternative to type expression:
+   *   allow `= calcExpr` and final annotation assignments
+   * - <cond> before final annotation assignments: allowed?
+   *
+   * Called in rule `returnsSpec`:
+   * - <prepare> after `returns`: disallow `default`.
+   */
+  elementRestriction( test ) {
+    if (!test) {                // after `:` for typeExpression, or without type
+      const withoutType = this.lb().type !== ':';
+      const afterReturns = this.lb().keyword === 'returns';
+      this.dynamic_.elementCtx = [ withoutType, withoutType, afterReturns ];
+    }
+    // or before final annotation assignments
+    return this.dynamic_.elementCtx?.[1];
+  }
+
+  /**
+   * Prepare `= calcExpr` restriction and check whether it can be used.
+   *
+   * Called at the following places:
+   * - <prepare> before (optionally) calling rule `nullabilityAndDefault`,
+   *   except for managed associations/compositions:
+   *   allow `= calcExpr`, allow final annotation assignments if not after `}`
+   *   (TODO: should we allow `String @anno:{ … } not null @MoreAnnos`?)
+   * - <cond> before `default`: disallow calc expr (+ restrict default expr),
+   *   allowed? (not for `returns`)
+   * - <cond> before `=` for calc expressions: allowed?
+   *
+   * To have any effect, <prepare=elementRestriction> must have been called.
+   */
+  calcOrDefaultRestriction( test, arg ) {
+    const { elementCtx } = this.dynamic_;
+    if (!test) {                                 // at beginning of rule `nullabilityAndDefault`
+      if (!elementCtx)
+        return true;
+      elementCtx[0] = !arg;  // using `= expr` is ok (except for assoc)
+      elementCtx[1] = this.lb().type !== '}'; // allow final annos not after block
+    }
+    else if (this.l() === '=') { // <cond> before `= calcExpression`
+      return elementCtx?.[0];
+    }
+    else {                      // <cond> before `default`
+      if (elementCtx)
+        elementCtx[0] = false;
+      this.prec_ = PRECEDENCE_OF_EQUAL; // only expressions for DEFAULT expr
+    }
+    return !elementCtx?.[2];    // default allowed?
+  }
+
+  inExpandInline() {            // not as <cond>
+    this.dynamic_.inSelectItem = 'nested';
+  }
+
+  /**
+   * `virtual` and `key` cannot be used inside expand/inline
+   * (also inside sub queries in those, which will be rejected later anyway)
+   */
+  notInExpandInline( test ) {
+    if (!test)
+      this.dynamic_.inSelectItem = true;
+    return this.dynamic_.inSelectItem !== 'nested';
+  }
+
   /**
    * `;` between statements is optional only after a `}` (ex braces of structure
    * values for annotations).
@@ -205,29 +304,31 @@ class AstBuildingParser extends BaseParser {
   }
 
   /**
-   * Annotation assignments at the end of (element) refs are allowed.
+   * For annotations at the beginning of columns outside parentheses
    */
-  allowFinalAnnoAssign() {
-    // TODO: do properly with type expression
-    return this.afterBrace$ !== this.tokenIdx;
-  }
-
-  // TOOL Runtime TODO: provide proto-linked dynamicContext
-  inSameLine() {
-    return this.lb().location.line === this.la().location.line;
+  annoInSameLine( test ) {
+    if (!test)
+      this.dynamic_.safeAnno = true;
+    return this.dynamic_.safeAnno ||
+      this.lb().location.line === this.la().location.line;
   }
 
   /**
-   * `...` can appear in the top-level array value only.
+   * `...` can appear in the top-level array value only and not after `...`
+   * without `up to`.
    */
-  annoTopValue( test ) {
-    if (test)
-      return !this.stack.at( -1 ).$annoTopValue;
-    if (this.stack.at( -2 )?.$annoTopValue)
-      this.stack.at( -1 ).$annoTopValue = 'inner';
-    else if (this.lb().type === '[')
-      this.stack.at( -1 ).$annoTopValue = 'array';
-    return null;
+  ellipsisRestriction( test ) {
+    if (!test) {
+      this.dynamic_.arrayAnno = [ !this.dynamic_.arrayAnno ];
+    }
+    else {                      // on '...'
+      const { arrayAnno } = this.dynamic_;
+      if (!arrayAnno[0])
+        return false;
+      if (this.tokens[this.tokenIdx + 1]?.type === ',')
+        arrayAnno[0] = false;
+    }
+    return true;
   }
 
   beforeColon() {
@@ -255,7 +356,7 @@ class AstBuildingParser extends BaseParser {
     if (this.l() === ':') {
       this.warning( 'syntax-missing-parens', anno.name,
                     { code: '@‹anno›', op: ':', newcode: '@(‹anno›…)' },
-                    // eslint-disable-next-line max-len
+                    // eslint-disable-next-line @stylistic/js/max-len
                     'When $(CODE) is followed by $(OP), use $(NEWCODE) for annotation assignments at this position' );
     }
   }
@@ -264,7 +365,7 @@ class AstBuildingParser extends BaseParser {
     const next = this.la();
     if (next.text === '@' && next.line <= this.lb().endLine) {
       this.warning( 'syntax-missing-semicolon', next, { code: ';' },
-                    // eslint-disable-next-line max-len
+                    // eslint-disable-next-line @stylistic/js/max-len
                     'Add a $(CODE) and/or newline before the annotation assignment to indicate that it belongs to the next statement' );
     }
   }
@@ -403,7 +504,7 @@ class AstBuildingParser extends BaseParser {
       }
       else if (text.charAt(0) !== '!') {
         this.message( 'syntax-deprecated-ident', location, { delimited: id },
-                      // eslint-disable-next-line max-len
+                      // eslint-disable-next-line @stylistic/js/max-len
                       'Deprecated delimited identifier syntax, use $(DELIMITED) - strings are delimited by single quotes' );
       }
     }
@@ -442,11 +543,11 @@ class AstBuildingParser extends BaseParser {
   classifyImplicitName( category, ref ) {
     if (!ref || ref.path) {
       const tokenIndex = ref?.path[ref.path.length - 1]?.location.tokenIndex;
-      const token = this.tokens[tokenIndex ?? this.tokenIdx - 1];
-      const { parsed } = token;
-      if (parsed && parsed !== 'token' && parsed !== 'keyword') {
-        token.parsed = category;
-        return { token, parsed };
+      const token = this.prevTokenWithIndex( tokenIndex ) ?? this.tokens[this.tokenIdx - 1];
+      const { parsedAs } = token;
+      if (parsedAs && parsedAs !== 'token' && parsedAs !== 'keyword') {
+        token.parsedAs = category;
+        return { token, parsedAs };
       }
     }
     return null;
@@ -600,7 +701,7 @@ class AstBuildingParser extends BaseParser {
                     {
                       std: 'Annotation number $(RAWVALUE) is put as $(VALUE) into the CSN',
                       rounded: 'Annotation number $(RAWVALUE) is rounded to $(VALUE)',
-                      // eslint-disable-next-line max-len
+                      // eslint-disable-next-line @stylistic/js/max-len
                       infinite: 'Annotation value $(RAWVALUE) is infinite as number and put as string into the CSN',
                     } );
     }
@@ -639,11 +740,10 @@ class AstBuildingParser extends BaseParser {
       else { // next doc comment between previous & current token
         // With explicit docComment:false, we don't emit a warning.
         if (art.doc && this.options.docComment !== false) {
-          this.docComments[art.doc.location.tokenIndex].parsed = '';
           this.warning( 'syntax-duplicate-doc-comment', art.doc, {},
                         'Doc comment is overwritten by another one below' );
         }
-        token.parsed = 'doc';
+        token.parsedAs = 'doc';
         const val = !this.options.docComment || parseDocComment( token.text );
         art.doc = { val, location: token.location };
       }
@@ -758,8 +858,24 @@ class AstBuildingParser extends BaseParser {
   // TODO: also define method `combineWith` in Location
   combineLocation( { location: start }, { location: end } = this.lb() ) {
     const { file, line, col } = start;
-    // eslint-disable-next-line object-curly-newline
-    return { file, line, col, endLine: end.endLine, endCol: end.endCol };
+
+    return {
+      file, line, col, endLine: end.endLine, endCol: end.endCol,
+    };
+  }
+
+  // `tokenIndex` is index in “combined” token array (parsing-relevant, doc
+  // comments, comments) → cannot be used directly
+  prevTokenWithIndex( tokenIndex ) {
+    if (tokenIndex != null) {
+      let { tokenIdx } = this;
+      while (--tokenIdx >= 0) {
+        const token = this.tokens[tokenIdx];
+        if (token.location.tokenIndex === tokenIndex)
+          return token;
+      }
+    }
+    return null;
   }
 
   // TODO: rename to `valAst`
@@ -831,8 +947,10 @@ class AstBuildingParser extends BaseParser {
           : path[0].$delimited || !functionsWithoutParens.includes( id.toUpperCase() ))
         return this.attachLocation( ref );
 
-      if (location.tokenIndex != null)
-        this.tokens[location.tokenIndex].parsed = 'func';
+      const funcToken = this.prevTokenWithIndex( location.tokenIndex );
+      // TODO: we could have an opt(?) parameter funcToken for speed-up (passing this.lr())
+      if (funcToken)
+        funcToken.parsedAs = 'func';
       // TODO: XSN representation of functions is a bit strange - rework
       const op = { location, val: 'call' };
       return this.attachLocation( { op, func: ref, args } );
@@ -876,7 +994,7 @@ class AstBuildingParser extends BaseParser {
           literal: 'token',
         });
       }
-      this.tokens[method.location.tokenIndex].parsed = 'func';
+      // this.prevTokenWithIndex( method.location.tokenIndex ).parsedAs = 'func';
       const func = {
         op: { location: method.location, val: 'call' },
         func: { path: [ method ] },
@@ -906,7 +1024,7 @@ class AstBuildingParser extends BaseParser {
         return;
       }
     }
-    this.error( 'syntax-unexpected-assoc', this.getCurrentToken(), {},
+    this.error( 'syntax-unexpected-assoc', this.la(), {},
                 'Unexpected association definition in select item' );
   }
 
@@ -1120,7 +1238,7 @@ function relevantDigits( val ) {
 // For compatibility with ANTLR-based parser:
 function antlrName( type ) {
   if (typeof type !== 'string')
-    type = (!type.parsed || type.parsed === 'keyword') && type.keyword || type.type;
+    type = (!type.parsedAs || type.parsedAs === 'keyword') && type.keyword || type.type;
   if (/^[A-Z]+/.test( type ))// eslint-disable-next-line no-nested-ternary
     return (type === 'Id') ? 'Identifier' : (type === 'EOF') ? '<EOF>' : type;
   return (/^[a-z]+/.test( type )) ? type.toUpperCase() : `'${ type }'`;