@sap/cds-compiler 5.2.0 → 5.3.2

package/lib/parsers/CdlGrammar.g4

@@ -42,9 +42,9 @@ tokens{                         // reserved words
 start returns[ source = new XsnSource( 'cdl' ) ]
   :
     (
-      ( <cond=fileSection> namespaceDeclaration[ $source ]
+      ( <cond=namespaceRestriction> namespaceDeclaration[ $source ]
       | usingDeclaration[ $source ]
-      | artifactDefOrExtend[ $source ] <setCondition=fileSection>
+      | artifactDefOrExtend[ $source ] <setCondition=namespaceRestriction>
       )
       ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
     )*
@@ -53,7 +53,8 @@ start returns[ source = new XsnSource( 'cdl' ) ]
 
 artifactsBlock[ art, start = undefined ]
   :
-    '{' { $art.artifacts = this.createDict( $start ); $art.extensions = []; }
+    '{'<setCondition=vocabularyRestriction>
+    { $art.artifacts = this.createDict( $start ); $art.extensions = []; }
     (
       artifactDefOrExtend[ $art ]
       ( ';' | <exitLoop> | <repeatLoop=afterBrace> { this.noAssignmentInSameLine(); } )
@@ -70,7 +71,7 @@ artifactDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
       DEFINE?
       ( serviceDef[ $art, $outer ]
       | contextDef[ $art, $outer ]
-      | annotationDef[ $art, $outer ] // TODO: <cond> for syntax-unexpected-vocabulary
+      | <cond=vocabularyRestriction>annotationDef[ $art, $outer ]
       | typeDef[ $art, $outer ]
       | aspectDef[ $art, $outer ]
       | entityDef[ $art, $outer ]
@@ -79,9 +80,8 @@ artifactDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
       | actionMainDef[ $art, $outer ]
       | functionMainDef[ $art, $outer ]
       )
-      // TODO: condition to disable ANNOTATE/EXTEND in EXTEND … WITH DEFINITION
     |
-      EXTEND { $art.kind = 'extend'; }
+      <cond=extensionRestriction> EXTEND { $art.kind = 'extend'; }
       ( extendArtifact[ $art, $outer ]
       | extendService[ $art, $outer ]
         // Non-streamlined Syntax; we would neither add new clauses to them, nor
@@ -92,7 +92,7 @@ artifactDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
       | <hide> extendProjection[ $art, $outer ]
       )
     |
-      ANNOTATE annotateArtifact[ $art, $outer ]
+      <cond=extensionRestriction> ANNOTATE annotateArtifact[ $art, $outer ]
     )
   ;
 
@@ -384,16 +384,16 @@ paramDef[ outer ] locals[ art = new XsnArtifact() ]
       elementsBlock[ $art ]
       nullability[ $art ]?
     |
-      ':' // s/th like <setCondition=allowDefaultOrCalc>
+      ':'
       typeExpression[ $art ]    // was elementType, with NOT? NULL / DEFAULT
-      { this.docComment( $art ); } annoAssignStd[ $art ]*
     )
   ;
 
 returnsSpec[ outer ] locals[ art = new XsnArtifact() ]
 @finally{ this.attachLocation( $art ); }
   :
-    RETURNS { $art.kind = 'param'; $outer.returns = $art; }
+    RETURNS<setCondition=elementRestriction>
+    { $art.kind = 'param'; $outer.returns = $art; }
     { this.docComment( $art ); } annoAssignStd[ $art ]*
     typeExpression[ $art ]
   ;
@@ -428,18 +428,22 @@ elementDef[ outer, art = undefined ]
       elementsBlock[ $art ]
       nullability[ $art ]?
     |
-      ':' // s/th like <setCondition=allowDefaultOrCalc>
+      ':'<setCondition=elementRestriction>
       typeExpression[ $art ]    // was elementType, with NOT? NULL / DEFAULT
-    )?
+    |
+      // <setCondition=elementRestriction> // TODO TOOL: allow this
+      { this.elementRestriction(); }<always> // workaround
+    )
     (
-      // <cond=allowDefaultOrCalc>
-      '='
+      <cond=calcOrDefaultRestriction> '='
+      // TODO TOOL: add to "expected set" if failing here?  Or have some "do not
+      // consider for rule exit if condition failure on `=`"?
       expr=expression { $art.value = $expr; }
       ( STORED { $art.value.stored = this.valueWithLocation( true ); } )?
       // TODO: why have `stored` as property of the value?
+      { this.docComment( $art ); } // TODO: also restricted
+      ( <cond=elementRestriction> annoAssignStd[ $art ] )*
     )?
-    { this.docComment( $art ); }
-    ( <cond=allowFinalAnnoAssign> annoAssignStd[ $art ] )*
   ;
 
 enumSymbolsBlock[ art ]
@@ -583,7 +587,7 @@ extendArtifact[ art, outer ]
       |
         typeNamedArgsList[ $art ]
       |
-        COLUMNS selectItemsList[ $art, 'columns', this.lb() ]
+        COLUMNS selectItemsList[ $art, this.lb() ]
       |
         DEFINITIONS artifactsBlock[ $art, this.lb() ]
       )?
@@ -789,20 +793,7 @@ elementDefOrExtend[ outer ] locals[ art = new XsnArtifact() ]
 
 // Type expressions -------------------------------------------------------------
 
-// in language.g4:
-// - elementType: full stuff + enum + localized + null + default ( + calc ), managed-compo
-// - in type def: typeSpecSemi: elementsBlock, : elementsBlock, assoc, localized
-// - param def = default + typeSpec: elementsBlock + :typeSpecCont (no assoc!)
-// - returns = typeSpecCont: elementsBlock + null, typeArray, typeOf (+ enum), ref+null+enum,
-// - typeArray: +enum + null + typeof
-
-// - select item: redirected to + type of / localized, ref, assoc (published assoc)
-// - mixin: only assoc
-// - cast: just refoptargs
-// - extend: just the type args
-
-// -> typeExpression, typeForColumn, typeForMixin, typeRefOptArgs
-
+// For `type` and `annotation` definitions:
 typeOrIncludesSpec[ art ]
   :
     elementsBlock[ $art ]
@@ -815,11 +806,15 @@ typeOrIncludesSpec[ art ]
       <priority>
       ref=simplePath { $art.type = $ref; }
       (
-        ( typeRefOptArgs[ $art ]<atAltStart> )?
-        nullability[ $art ]?
-        { this.docComment( $art ); } annoAssignStd[ $art ]*
-        enumSymbolsBlock[ $art ]?
-        nullabilityAndDefault[ $art ]?
+        // <default> does not work here
+        typeRefOptArgs[ $art ]<atAltStart>
+        ( typeExpression[ $art ]<atAltStart>
+        | { this.docComment( $art ); }
+        )
+      |
+        typeExpression[ $art ]<atAltStart>
+      |
+        { this.docComment( $art ); }
       |
         { $art.includes = [ $art.type ]; delete $art.type; }
         (
@@ -835,36 +830,82 @@ typeOrIncludesSpec[ art ]
     )
   ;
 
+// Type expression (after the `:`) and “final” annotation assignment.  Type
+// expressions include `null`/`not null` and `default`, the latter is forbidden in
+// the `returns` type.
+//
+// If used in a definition with additional clauses (currently just `= expr` for
+// elements), these clauses must be guarded with <cond=…>.
+//
+// No annotation assignments are allowed after element and enum blocks, because
+// these would conflict with the optional `;` after those blocks.  To lower the
+// impact with enums, the “final” annotation assignments are actually moved before
+// the keyword `enum` (only allowed if not after `many`/`array of`).
+//
+// This rule is not used when the type expression is restricted: CDL-style cast in
+// `select` items, `cast` function, `mixin` definition.
+
 typeExpression[ art ]
+// TODO: really introduce <exitRule>
   :
     elementsBlock[ $art ]
     nullability[ $art ]?
   |
     ( typeRefOptArgs[ $art ] | typeTypeOf[ $art ] )
+    (<altRuleStart>)
     nullability[ $art ]?
-    { this.docComment( $art ); } annoAssignStd[ $art ]*
-    enumSymbolsBlock[ $art ]?
-    nullabilityAndDefault[ $art ]?
+    // <setCondition=calcOrDefaultRestriction> // TODO TOOL: allow this
+    { this.calcOrDefaultRestriction(); }<always> // workaround
+    (
+      nullabilityAndDefault[ $art ]
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
+    |
+      enumSymbolsBlock[ $art ]
+      nullabilityAndDefault[ $art ]?
+    |
+      { this.docComment( $art ); } annoAssignStd[ $art ]+
+      ( enumSymbolsBlock[ $art ]
+        // <setCondition=calcOrDefaultRestriction> // TODO TOOL: allow this
+        { this.calcOrDefaultRestriction(); }<always> // workaround
+        nullabilityAndDefault[ $art ]?
+      )?
+    |
+      { this.docComment( $art ); }
+    )
   |
-    LOCALIZED { $art.localized = this.valueWithLocation( true ); }
-    typeRefOptArgs[ $art ]
-    { this.docComment( $art ); } annoAssignStd[ $art ]*
+    LOCALIZED
+    { $art.localized = this.valueWithLocation( true ); }
+    typeRefOptArgs[ $art ]      // TODO: why no TYPE OF ?
+    // <setCondition=calcOrDefaultRestriction> // TODO TOOL: allow this
+    { this.calcOrDefaultRestriction(); }<always> // workaround
     nullabilityAndDefault[ $art ]?
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
   |
     assoc=ASSOCIATION cardinality[ $art ]? TO card=ONE/MANY?
     target=simplePath { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+    // final anno assignments allowed also with fkeys (also in ANTLR-based parser)
+    // <prepare=calcOrDefaultRestriction,arg=true> // TODO TOOL: allow this
+    { this.calcOrDefaultRestriction(false,true); }<always> // workaround
+
     ( ON cond=condition { $art.on = $cond; }
-    | foreignKeysBlock[ $art ]? nullabilityAndDefault[ $art ]?
+    | foreignKeysBlock[ $art ]?
+      nullabilityAndDefault[ $art ]?
+      // scalar default - hm..., what about calc expression?
     )
+    { this.docComment( $art ); } annoAssignStd[ $art ]*
   |
     assoc=COMPOSITION cardinality[ $art ]? OF card=ONE/MANY?
     (
       target=simplePath { this.setAssocAndComposition( $art, $assoc, $card, $target ); }
+      // final anno assignments allowed also with fkeys (also in ANTLR-based parser) - TODO: really?
+      // <prepare=calcOrDefaultRestriction,arg=true> // TODO TOOL: allow this
+      { this.calcOrDefaultRestriction(false,true); }<always> // workaround
       ( ON cond=condition { $art.on = $cond; }
-      | foreignKeysBlock[ $art ]? nullabilityAndDefault[ $art ]?
+      | foreignKeysBlock[ $art ]?
+        nullabilityAndDefault[ $art ]?
       )
+      { this.docComment( $art ); } annoAssignStd[ $art ]*
     |
-      // TODO: really do SyntaxOnly/GrammarAmbiguities/CompositionOfMany.cds ?
       { $target = {}; this.setAssocAndComposition( $art, $assoc, $card, $target ); }
       elementsBlock[ $target ]
       { $target.location = $target.elements[Symbol.for('cds.$location')]; }
@@ -879,9 +920,11 @@ typeExpression[ art ]
     |
       ( typeRefOptArgs[ $art.items ] | typeTypeOf[ $art.items ] )
       nullability[ $art.items ]?
-      { this.docComment( $art.items ); } annoAssignStd[ $art.items ]*
-      enumSymbolsBlock[ $art.items ]?
-      nullability[ $art.items ]?
+      ( enumSymbolsBlock[ $art.items ]
+        nullability[ $art.items ]? // TODO: only with enum
+      |
+        { this.docComment( $art ); } annoAssignStd[ $art ]*
+      )
     )
   ;
 
@@ -1000,9 +1043,12 @@ targetCardinality[ card, atAlt = false ]
 nullabilityAndDefault[ art ]
   :
     nullability[ $art ]
-    ( DEFAULT expr=expression { $art.default = $expr; } )?
+    ( <cond=calcOrDefaultRestriction> DEFAULT expr=expression
+      { $art.default = $expr; }
+    )?
   |
-    DEFAULT expr=expression { $art.default = $expr; }
+    <cond=calcOrDefaultRestriction> DEFAULT expr=expression
+    { $art.default = $expr; }
     nullability[ $art ]?
     // TODO TOOL: when `followUnion` does not contain `Id`, `RuleEnd_` does not
     // need to induce prediction (here for `default`).
@@ -1161,7 +1207,7 @@ tableOrQueryParens returns[ default expr ]
       { $expr = this.taggedIfQuery( $expr ); $expr.name = this.fragileAlias(); }
     |
       // <setCondition=setPrecInCallingRule> // TODO TOOL: allow this
-      { this.setPrecInCallingRule(); } // workaround
+      { this.setPrecInCallingRule(); }<always> // workaround
     )
   ;                             // change #10799 for ANTLR-based parser
 
@@ -1194,10 +1240,15 @@ fromRefWithOptAlias returns[ default expr = { path: [] } ]
       } }
       fromPath[ $expr, 'ref']
     )?
-    ( AS Id['FromAlias'] { $expr.name = this.identAst(); }
-    | <hide, cond=tableAlias> Id_restricted['FromAlias']
+    (
+      AS Id['FromAlias'] { $expr.name = this.identAst(); }
+    |
+      <hide, cond=tableAlias>
+      Id_restricted['FromAlias']
       { $expr.name = this.fragileAlias(); }
-    | { this.classifyImplicitName( $expr.scope ? 'FromElemImplicit' : 'FromImplicit', $expr ); }
+    |
+      <default=fallback>
+      { this.classifyImplicitName( $expr.scope ? 'FromElemImplicit' : 'FromImplicit', $expr ); }
     )
   ;
 
@@ -1288,9 +1339,24 @@ excludingClause[ query ]
     { this.finalizeDictOrArray( $query.excludingDict ); }
   ;
 
-selectItemsList[ query, clause = 'columns', start = undefined ]
+selectItemsList[ query, start = undefined ]
+  :
+    '{'<setCondition=notInExpandInline>
+    { $query.columns = this.createArray( $start ); }
+    (
+      ( '*' { $query.columns.push( this.valueWithLocation() ); }
+      | selectItemDef[ $query.columns ]
+      )
+      ( ',' | <exitLoop> )
+    )*
+    '}'<setCondition=afterBrace>
+    { this.finalizeDictOrArray( $query.columns ); }
+  ;
+
+nestedSelectItemsList[ query, clause ]
   :
-    '{' { $query[$clause] = this.createArray( $start ); }
+    '{'<setCondition=inExpandInline>
+    { $query[$clause] = this.createArray(); }
     (
       ( '*' { $query[$clause].push( this.valueWithLocation() ); }
       | selectItemDef[ $query[$clause] ]
@@ -1306,32 +1372,34 @@ selectItemDef[ columns ] locals[ art = new XsnArtifact(), alias ]
   :
     { $columns.push( $art ); }  // TODO: probably too early
     { this.docComment( $art ); } annoAssignCol[ $art ]*
-    // TODO: <cond> for VIRTUAL/KEY only top-level
-    ( VIRTUAL { $art.virtual = this.valueWithLocation( true ); } )?
-    ( KEY { $art.key = this.valueWithLocation( true ); } )?
+    ( <cond=notInExpandInline> VIRTUAL
+      { $art.virtual = this.valueWithLocation( true ); } )?
+    ( <cond=notInExpandInline> KEY
+      { $art.key = this.valueWithLocation( true ); } )?
     (
       expr=expression { $art.value = $expr; }
       ( as=AS Id['ItemAlias'] { $art.name = this.identAst(); }
       | Id_restricted['ItemAlias'] { $art.name = this.fragileAlias( true ); }
       | { $alias = this.classifyImplicitName( 'ItemImplicit', $expr ); }
       )
-      // TODO: <cond> for expand/inline only with ref,
+      // TODO: <cond> instead `reportExpandInline` for "expand/inline only w/ ref"
       (
         { this.reportExpandInline( $art, false ); }
-        selectItemsList[ $art, 'expand' ]
+        nestedSelectItemsList[ $art, 'expand' ]
         excludingClause[ $art ]?
       |
-        '.' { this.reportExpandInline( $art, $as || true ); }
-        { if ($alias) $alias.token.parsed = $alias.parsed; }
+        '.'
+        { this.reportExpandInline( $art, $as || true ); }
+        { if ($alias) $alias.token.parsedAs = $alias.parsedAs; }
         (
-          selectItemsList[ $art, 'inline' ]
+          nestedSelectItemsList[ $art, 'inline' ]
           excludingClause[ $art ]?
         |
           '*' { $art.inline = [ this.valueWithLocation() ]; }
         )
       )?
     |
-      selectItemsList[ $art, 'expand' ]
+      nestedSelectItemsList[ $art, 'expand' ]
       excludingClause[ $art ]?
       AS Id['ItemAlias'] { $art.name = this.identAst(); }
     )
@@ -1442,7 +1510,7 @@ expression returns[ default expr ]
       (
         Id_all['paramref']
         { $expr = { path: [ this.identAst() ], location: this.startLocation(), scope: 'param' }; }
-        ( <cond=isDotForPath> valuePath[ ...$ ]<atAltStart>
+        ( valuePath[ ...$ ]<atAltStart>
           { $expr = this.valuePathAst( $expr ); }
         | { this.attachLocation( $expr ); }
         )
@@ -1597,6 +1665,7 @@ castFunction returns[ default expr = {} ]
   ;
 
 argumentsAndFilter[ pathStep ]
+// TODO: what about valuePath with EXISTS, after `:` etc (also in ANTLR-based parser)?
 options{ minTokensMatched = 1 }
   :
     (
@@ -1606,7 +1675,6 @@ options{ minTokensMatched = 1 }
       // TOOL? at least msg)
       (
         <default=fallback>      // TODO TOOL: allow in loop
-        { ; }                   // TODO TOOL: we need an idle action here, for <default>
         (
           expr=funcExpression { $pathStep.args.push( $expr ); }
           (
@@ -1623,6 +1691,9 @@ options{ minTokensMatched = 1 }
           )?
         )?
       |
+        // TODO: if we want perfect CC and error recovery, `isNamedArg` would work
+        // like keyword prediction and also do something similar to the (future)
+        // "identifier confirmation prediction" (consider argument `(par ‡ : 42)`
         <cond=isNamedArg> id=Id_all['paramname']
         (
           ':' { $pathStep.args = this.createDict( $open ); $pathStep.$syntax = ':'; }
@@ -1679,11 +1750,11 @@ funcExpression returns[ default expr ] locals[ args ]
     )*
   ;
 
-GenericExpr // options { representingTokens = representingExpr; }
+GenericExpr
   : Id_all | '*' ;
-GenericIntro // options { representingTokens = representingIntro; }
+GenericIntro
   : Id_all ;
-GenericSeparator // options { representingTokens = representingSeparator; }
+GenericSeparator
   : Id_all ;
 
 overClause[ outer ] locals[ over = [] ]
@@ -1791,7 +1862,7 @@ literalValue returns[ default expr = {} ]
 annoAssignStd[ art ]
 @finally{ this.docComment( $art ); }
   :
-    '@'<setCondition=inSameLine> { this.reportUnexpectedSpace(); }
+    '@'<setCondition=annoInSameLine> { this.reportUnexpectedSpace(); }
     ( annoAssignParen[ ...$ ]
     | annoAssignBase[ ...$ ]
     )
@@ -1809,16 +1880,16 @@ annoAssignCol[ art ]
 annoAssignMid[ art ]
 @finally{ this.docComment( $art ); }
   :
-    '@'<setCondition=inSameLine> { this.reportUnexpectedSpace(); }
+    '@'<setCondition=annoInSameLine> { this.reportUnexpectedSpace(); }
     ( annoAssignParen[ ...$ ]
-    | name=annoNamePath
+    | name=annoNamePath         // !
       { this.assignAnnotation( $art, {}, $name ); this.warnIfColonFollows( $name ); }
     )
   ;
 
 annoAssignParen[ art ]
   :
-    '('<setCondition=inSameLine>
+    '('<setCondition=annoInSameLine>
     ( annoAssignBase[ $art ]
       ( ',' | <exitLoop> )
     )*
@@ -1829,7 +1900,7 @@ annoAssignBase[ art ] locals[ value = {} ]
 @finally{ this.assignAnnotation( $art, $value, $name || {} ); }
   :
     name=annoNamePath
-    ( <cond=inSameLine> ':' value=annoValue )?
+    ( <cond=annoInSameLine> ':' value=annoValue )?
   ;
 
 annoNamePath[ category = 'anno' ] returns[ default name = new XsnName() ]
@@ -1844,7 +1915,7 @@ annoNamePath[ category = 'anno' ] returns[ default name = new XsnName() ]
         Id_all[ $category ] { $name.path.push( this.identAstWithPrefix( $at ) ); }
       )
     )*
-    ( <cond=inSameLine> annoPathVariant[ $name ] )?
+    ( <cond=annoInSameLine> annoPathVariant[ $name ] )?
   ;
 
 annoPath[ nameOrRef, category = 'annoref' ]
@@ -1878,7 +1949,7 @@ annoStructValue returns[ default value = {} ] locals[ name = new XsnName()  ]
 @finally{ $value.name = $name; }
   :
     annoPath[ $name, 'name' ] { this.attachLocation( $name ); }
-    ( ':'<setCondition=annoTopValue> // make it inherit “non-top” status
+    ( ':'
       $value=annoValue
     |
       { this.attachLocation( $value ); }
@@ -1895,13 +1966,15 @@ annoValue returns[ default value = {} ]
   |
     annoPath[ $value, 'annoref' ]
   |
-    '{'<setCondition=annoTopValue>
+    '{'
     {
-      if (this.annoTopValue(true)) $value.$flatten = [];
+      if (!this.dynamic_.arrayAnno) $value.$flatten = [];
       else { $value.struct = Object.create(null); $value.literal = 'struct'; }
     }
     (
       // TODO: complain about empty loop if top-level as before
+      // TOOL TODO → allow `<cond=…> '}'` below where the condition rejects `}`
+      // after `{` if top-level
       sub=annoStructValue
       {
         if ($value.$flatten) $value.$flatten.push( $sub );
@@ -1911,13 +1984,13 @@ annoValue returns[ default value = {} ]
     )*
     '}'                         // Do NOT use <setCondition=afterBrace> here!
   |
-    '['<setCondition=annoTopValue>
+    '['<setCondition=ellipsisRestriction>
     { $value.val = []; $value.literal = 'array' }
     // no need for createArray() here, $value.location is set above
     (
       ( sub=annoValue { $value.val.push( $sub ) }
       |
-        ellipsis='...'
+        <cond=ellipsisRestriction> ellipsis='...'
         ( UP TO upTo=annoValue | { $upTo = undefined; } )
         { $value.val.push( { literal: 'token', val: '...', location: $ellipsis.location, upTo: $upTo } ); }
       )

package/lib/parsers/Lexer.js

@@ -42,9 +42,9 @@ class Token {
   text;
   keyword;
   location;
-  parsed;
+  parsedAs;
   get isIdentifier() {          // compatibility method
-    return this.parsed !== 'keyword' && this.parsed !== 'token' && this.parsed;
+    return this.parsedAs !== 'keyword' && this.parsedAs !== 'token' && this.parsedAs;
   }
   get tokenIndex() {
     return this.location.tokenIndex;
@@ -92,7 +92,7 @@ class Lexer {
         endLine: line,
         endCol: col + text.length,
         // remark: end positions of multi-line tokens must be set by function
-        tokenIndex: parser.tokens.length,
+        tokenIndex: parser.tokens.length + parser.docComments.length + parser.comments.length,
       };
       let keyword;
       if (typeof type !== 'function' ||
@@ -103,7 +103,7 @@ class Lexer {
           text,
           keyword,
           location: this.location,
-          parsed: undefined,
+          parsedAs: undefined,
         } );
       }
     }
@@ -116,7 +116,7 @@ class Lexer {
       col: endCol,
       endLine: line,
       endCol,
-      tokenIndex: parser.tokens.length,
+      tokenIndex: parser.tokens.length + parser.docComments.length + parser.comments.length,
     };
     parser.tokens.push( {
       __proto__: Token.prototype,
@@ -124,7 +124,7 @@ class Lexer {
       text: '',
       keyword: false,
       location,
-      parsed: undefined,
+      parsedAs: undefined,
     } );
   }
 }
@@ -141,14 +141,24 @@ function comment( text, lexer, parser, beg ) {
   }
   else if (text === '/*' && lexer.input.charAt( rulesRegexp.lastIndex ) === '*' &&
            rulesRegexp.lastIndex + 2 < re.lastIndex) { // not just `/**/`
-    lexer.location.tokenIndex = parser.docComments.length;
     parser.docComments.push( {
       __proto__: Token.prototype,
       type: 'DocComment',
       text: lexer.input.substring( beg, re.lastIndex ),
       keyword: false,
       location: lexer.location,
-      parsed: undefined,
+      parsedAs: undefined,
+    } );
+    adaptEndLocation( lexer, re.lastIndex ); // also works after push ?
+  }
+  else {                        // TODO: only attach with option `attachTokens` ?
+    parser.comments.push( {
+      __proto__: Token.prototype,
+      type: 'Comment',
+      text: lexer.input.substring( beg, re.lastIndex ),
+      keyword: false,
+      location: lexer.location,
+      parsedAs: undefined,
     } );
     adaptEndLocation( lexer, re.lastIndex ); // also works after push ?
   }
@@ -187,7 +197,7 @@ function string( text, lexer, parser, beg ) {
                     multi: 'The multi-line string literal must end with $(NEWCODE)',
                   } );
     keyword = 0;
-    // TODO: set parsed to 0 → no further error if string is not expected?
+    // TODO: set parsedAs to 0 → no further error if string is not expected?
     prefix = null;           // no combination with date/time/…
   }
   adaptEndLocation( lexer, (rulesRegexp.lastIndex = lastIndex || lexer.input.length) );
@@ -221,7 +231,7 @@ function ident( text, lexer, parser, beg ) {
                     ident: 'The delimited id must end with $(NEWCODE) before the end of line',
                   } );
     keyword = 0;
-    // TODO: set parsed to 0 → no further error if string is not expected?
+    // TODO: set parsedAs to 0 → no further error if string is not expected?
   }
   adaptEndLocation( lexer, (rulesRegexp.lastIndex = lastIndex || lexer.input.length) );
   return [ 'Id', lexer.input.substring( beg, rulesRegexp.lastIndex ), keyword ];