@sap/cds-compiler 3.5.2 → 3.6.0

package/lib/language/language.g4

@@ -113,6 +113,10 @@
 //
 //  * If you want to set a property starting with '$' like $syntax, use
 //    obj['$'+'syntax'] as the ANTLR tool would replace $syntax by $ctx.syntax
+//
+//  * If you want to use Unicode characters, move the corresponding code to
+//    ./genericAntlrParser.js; ANTLR or the TypeScript wrapper might destroy
+//    Unicode characters on certain operating systems.
 
 grammar language;
 options {
@@ -219,8 +223,8 @@ artifactDefOrExtend[ outer, defOnly = false ] locals[ art = {} ] // cannot use `
     annotationAssignment_ll1[ $art ]*
     (
       DEFINE?
-      ( serviceDef[ $art, $outer, defOnly ]
-      | contextDef[ $art, $outer, defOnly ]
+      ( serviceDef[ $art, $outer, $defOnly ]
+      | contextDef[ $art, $outer, $defOnly ]
       | entityDef[ $art, $outer ]
       | typeDef[ $art, $outer ]
       | aspectDef[ $art, $outer ]
@@ -231,10 +235,7 @@ artifactDefOrExtend[ outer, defOnly = false ] locals[ art = {} ] // cannot use `
       )
     |
       extend=EXTEND
-      { if (defOnly)            // TODO: nicer message text
-          this.error( 'syntax-extend-context', $extend,
-                      { code: 'EXTEND artifact', meta: defOnly },
-                      'No $(CODE) within $(META) extensions' );
+      { this.reportUnexpectedExtension( $defOnly, $extend );
         if (!$outer.extensions) $outer.extensions = [];
       }
       // #ATN: EXTEND art, while CONTEXT, ENTITY etc are not reserved
@@ -248,10 +249,7 @@ artifactDefOrExtend[ outer, defOnly = false ] locals[ art = {} ] // cannot use `
       )
     |
       annotate=ANNOTATE
-      { if (defOnly)            // TODO: improve message text
-          this.error( 'syntax-extend-context', $annotate,
-                      { code: 'ANNOTATE artifact', meta: defOnly },
-                      'No $(CODE) within $(META) extensions' );
+      { this.reportUnexpectedExtension( $defOnly, $annotate );
         if (!$outer.extensions) $outer.extensions = [];
         this.meltKeywordToIdentifier();
       }
@@ -515,8 +513,10 @@ actionFunctionDef[ outer ] locals[ art = {} ]
 parameterDef[ outer ] locals[ art = {} ]
 @after { this.attachLocation( $art ); }
   :
-    { this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
+    { this.meltKeywordToIdentifier();; this.docComment( $art ); }
+    ( annotationAssignment_ll1[ $art ]
+      { this.meltKeywordToIdentifier(); }
+    )*
     name=ident['Param']
     { this.addDef( $art, $outer, 'params', 'param', $name.id );
       this.docComment( $art ); }
@@ -532,12 +532,17 @@ parameterListDef[ art ]
     '(' { $art.params = this.createDict(); }
     // also empty param list (we might do some hacking later to allow reserved words)
     // see annotationAssignment_paren
-    (
+    {
+      if (this.isStraightBefore(')')) {
+        this.matchWildcard();   // we know it is the ')' - we do not reach the final match
+        this.finalizeDictOrArray( $art.params );
+        return $ctx;
+      }
+    }
+    parameterDef[ $art ]
+    ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
       parameterDef[ $art ]
-      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        parameterDef[ $art ]
-      )*
-    )?
+    )*
     ')' { this.finalizeDictOrArray( $art.params ); }
   ;
 
@@ -572,7 +577,7 @@ elementDef[ outer ] locals[ $art = {} ]
     elementDefInner[ $art, $outer, false ]
   ;
 
-elementDefInner[ art, outer, allowEq ]
+elementDefInner[ art, outer, mightBeEnum ]
 @after{ this.attachLocation( $art ); }
   :
     // VIRTUAL is keyword, except if before the following tokens texts:
@@ -587,13 +592,11 @@ elementDefInner[ art, outer, allowEq ]
       }
     )?
     { this.setLocalToken( 'ELEMENT', 'ELEMENT', /^[:{@=}]$/ ); }
-    ELEMENT?
+    ( ELEMENT { $mightBeEnum = false; } )? // auto-recognizable at other places
     name=ident['Element']
     { this.addDef( $art, $outer, 'elements', 'element', $name.id );
       this.docComment( $art ); }
     annotationAssignment_fix[ $art ]*
-    // TODO: we can think of making the typeSpec optional and do checks instead:
-    // type optional with '=', type required otherwise
     (
       typeStruct[ $art ]
       ( nullability[ $art ]
@@ -602,15 +605,14 @@ elementDefInner[ art, outer, allowEq ]
       )
     |
       ':'
-      elementType[ $art ]
-    |
-      // this is also called for enum symbols (in EXTEND)
-      eq='=' e=expression       // never introduce AS as syntax variant of '='
-      {
-        if (!$allowEq || $e.expr && !$e.expr.literal )
-          this.error( 'syntax-unsupported-calc-elem', $eq );
-        else if ($e.expr)
-          $art.value = $e.expr;
+      elementType[ $art, $mightBeEnum ]
+    |
+      '=' e=expression       // SQL has syntax variant using AS - we DO NOT
+      { $art.value = $e.expr;
+        // this.setIntroLocation( eq );  -- future
+        if ($mightBeEnum && ($e.expr.val !== undefined || $e.expr.sym !== undefined) &&
+            !$virtual && !$key && !$masked && !$art.elements && !$art.type)
+          $art['$'+'syntax'] = 'enum';
       }
       { this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]* // for enum symbol def via EXTEND
@@ -632,11 +634,11 @@ elementType[ art ]     // TODO: split this monster rule
       typeStruct[ $art.target, true ] optionalSemi
     |
       one=ONE
-      { this.setMaxCardinality( $art, $one, this.numberLiteral( $one, null, '1' ) ); }
+      { this.setMaxCardinality( $art, this.numberLiteral( $one, null, '1' ) ); }
       typeCompoStruct[ $art.target ] optionalSemi
     |
       many=MANY
-      { this.setMaxCardinality( $art, $many, { literal: 'string', val: '*' } ); }
+      { this.setMaxCardinality( $art, { literal: 'string', val: '*' }, $many ); }
       typeCompoStruct[ $art.target ] optionalSemi
     |
       // we do not support `Composition of many { e }` - ambiguity ad-hoc target versus foreign keys!
@@ -657,15 +659,10 @@ elementType[ art ]     // TODO: split this monster rule
       nullability[ $art.items ]?
     | // #ATN: typeRefOptArgs/typeTypeOf can start with TYPE
       ( typeTypeOf[ $art.items ] | typeRefOptArgs[ $art.items ] )
-      nullability[ $art.items ]? // only if not followed by `enum`
+      nullability[ $art.items ]?
       { this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]*
       (
-        { if ($art.items.notNull) {
-          this.message( 'syntax-unexpected-null', $art.items.notNull.location,
-                        { keyword: $art.items.notNull.val ? 'not null' : 'null' } );
-        }
-        }
         ENUM '{' { $art.items.enum = this.createDict(); }
         enumSymbolDef[ $art.items ]*
         '}' { this.finalizeDictOrArray( $art.items.enum ); }
@@ -676,6 +673,7 @@ elementType[ art ]     // TODO: split this monster rule
   |
     l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
     typeRefOptArgs[ $art ]
+    optInvisibleNullability[ $art ]
     { this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     ( elementProperties[ $art ]
@@ -685,6 +683,7 @@ elementType[ art ]     // TODO: split this monster rule
     requiredSemi
   |
     typeTypeOf[ $art ] // Note: Same as the typeRefOptArgs rule below
+    optInvisibleNullability[ $art ]
     { this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
@@ -700,6 +699,7 @@ elementType[ art ]     // TODO: split this monster rule
     requiredSemi                     // also req after foreign key spec
   |
     typeRefOptArgs[ $art ] // Note: Same as the typeTypeOf rule above
+    optInvisibleNullability[ $art ]
     { this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
@@ -717,15 +717,13 @@ elementType[ art ]     // TODO: split this monster rule
 
 elementProperties[ elem ]
   :
+    defaultValue[ $elem ]
+    nullability[ $elem ]?       // placement accoring to SQL spec
+  |
     nullability[ $elem ]
     defaultValue[ $elem ]?
   |
-    defaultValue[ $elem ]
-    nullability[ $elem ]?
-  |
-    eq='='
-    { this.error( 'syntax-unsupported-calc-elem', $eq ); }
-    e=expression { $elem.value = $e.expr; }
+    '=' e=expression { $elem.value = $e.expr; }
   ;
 
 defaultValue[ art ] locals[ elem, elements = {} ]
@@ -756,7 +754,7 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       (
         // all the alternatives from `extendWithOptElementsOrType` --------------
         '{' { $art.elements = this.createDict(); }
-        elementDefOrExtend[ $art ]*
+        elementDefOrExtend[ $art, true ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
         { this.checkExtensionDict( $art.elements ); }
         optionalSemi
@@ -786,7 +784,7 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       |
         DEFINITIONS
         '{' { $art.artifacts = this.createDict(); }
-        artifactDefOrExtend[ $art, true ]*
+        artifactDefOrExtend[ $art, 'definitions' ]*
         '}' { this.finalizeDictOrArray( $art.artifacts ); }
         optionalSemi
       |
@@ -817,7 +815,7 @@ extendService[ art, outer ] locals[ name = {} ]
     simplePath[ $name, 'Service' ]
     { $art.name = $name; this.addItem( $art, $outer, 'extensions', 'extend' ); }
     ( WITH { this.noSemicolonHere(); } )?
-    optArtifactsBlock[ art, 'SERVICE' ]
+    optArtifactsBlock[ art, 'service' ]
   ;
 
 extendContext[ art, outer ] locals[ name = {} ]
@@ -827,7 +825,7 @@ extendContext[ art, outer ] locals[ name = {} ]
     simplePath[ $name, 'Context' ]
     { $art.name = $name; this.addItem( $art, $outer, 'extensions', 'extend' ); }
     ( WITH { this.noSemicolonHere(); } )?
-    optArtifactsBlock[ art, 'CONTEXT' ]
+    optArtifactsBlock[ art, 'context' ]
   ;
 
 extendEntityOrAspect[ art, outer ] locals[ name = {} ]
@@ -924,12 +922,12 @@ extendType[ art, outer ] locals[ name = {} ]
       annotationAssignment_ll1[ $art ]*
       (
         '{' { $art.elements = this.createDict(); }
-        elementDefOrExtend[ $art ]*
+        elementDefOrExtend[ $art, true ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
         { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
-        // extend type|element Art with (length: 10);
+        // extend type Art with (length: 10);
         typeNamedArgList[ $art ]
         requiredSemi
       |
@@ -949,7 +947,7 @@ extendWithOptElementsOrType[ art ]
     annotationAssignment_ll1[ $art ]*
     (
       '{' { $art.elements = this.createDict(); }
-      elementDefOrExtend[ $art ]*
+      elementDefOrExtend[ $art, true ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
       optionalSemi
@@ -979,7 +977,7 @@ extendWithOptElementsNoWith[ art ]
     annotationAssignment_ll1[ $art ]*
     (
       '{' { $art.elements = this.createDict(); }
-      elementDefOrExtend[ $art ]*
+      elementDefOrExtend[ $art, true ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
       optionalSemi
@@ -990,7 +988,7 @@ extendWithOptElementsNoWith[ art ]
 
 // For `extend … with elements` or `extend entity … with`, `extend aspect … with`,
 // i.e. definitions in { … } are never enums
-elementDefOrExtend[ outer ] locals[ art = {} ]
+elementDefOrExtend[ outer, mightBeEnum = false ] locals[ art = {} ]
 @after { /* #ATN 1 */ }  // if ($art) this.attachLocation( $art ); }
   :
     { $art.location = this.startLocation();; this.docComment( $art ); }
@@ -1000,7 +998,7 @@ elementDefOrExtend[ outer ] locals[ art = {} ]
       EXTEND
       extendElement[ $art, $outer ]
     |
-      elementDefInner[ $art, $outer, true ]
+      elementDefInner[ $art, $outer, $mightBeEnum ]
     )
   ;
 
@@ -1158,6 +1156,7 @@ typeSpec[ art ]                 // for parameterDef
         ENUM '{' { $art.enum = this.createDict(); }
         enumSymbolDef[ $art ]*
         '}' { this.finalizeDictOrArray( $art.enum ); }
+        nullability[ $art ]?
       )?
       // TODO: no LOCALIZED ?
     | typeRefOptArgs[ $art ]
@@ -1166,6 +1165,7 @@ typeSpec[ art ]                 // for parameterDef
         ENUM '{' { $art.enum = this.createDict(); }
         enumSymbolDef[ $art ]*
         '}' { this.finalizeDictOrArray( $art.enum ); }
+        nullability[ $art ]?
       )?
     )
   ;
@@ -1184,6 +1184,7 @@ returnTypeSpec[ art ]
         ENUM '{' { $art.returns.enum = this.createDict(); }
         enumSymbolDef[ $art.returns ]*
         '}' { this.finalizeDictOrArray( $art.returns.enum ); }
+        nullability[ $art.returns ]?
       )?
       // TODO: no LOCALIZED ?
     | typeRefOptArgs[ $art.returns ]
@@ -1192,6 +1193,7 @@ returnTypeSpec[ art ]
         ENUM '{' { $art.returns.enum = this.createDict(); }
         enumSymbolDef[ $art.returns ]*
         '}' { this.finalizeDictOrArray( $art.returns.enum ); }
+        nullability[ $art.returns ]?
       )?
     )
 
@@ -1235,21 +1237,11 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
       ( typeStruct[ $art.items ]
         nullability[ $art.items ]?
         optionalSemi
-      | typeTypeOf[ $art.items ]
+      | ( typeTypeOf[ $art.items ] | typeRefOptArgs[ $art.items ] )
         nullability[ $art.items ]?
         { this.docComment( $art ); }
         annotationAssignment_ll1[ $art ]*
-        requiredSemi
-      | typeRefOptArgs[ $art.items ]
-        nullability[ $art.items ]? // only if not followed by `enum`
-        { this.docComment( $art ); }
-        annotationAssignment_ll1[ $art ]*
         (
-          { if ($art.items.notNull) {
-              this.message( 'syntax-unexpected-null', $art.items.notNull.location,
-                { keyword: $art.items.notNull.val ? 'not null' : 'null' } );
-            }
-          }
           ENUM '{' { $art.items.enum = this.createDict(); }
           enumSymbolDef[ $art.items ]*
           '}' { this.finalizeDictOrArray( $art.items.enum ); }
@@ -1348,6 +1340,7 @@ typeArray[ art ]
         ENUM '{' { $art.items.enum = this.createDict(); }
         enumSymbolDef[ $art.items ]*
         '}' { this.finalizeDictOrArray( $art.items.enum ); }
+        nullability[ $art.items ]?
       )?
     | typeRefOptArgs[ $art.items ]
       nullability[ $art.items ]?
@@ -1355,6 +1348,7 @@ typeArray[ art ]
         ENUM '{' { $art.items.enum = this.createDict(); }
         enumSymbolDef[ $art.items ]*
         '}' { this.finalizeDictOrArray( $art.items.enum ); }
+        nullability[ $art.items ]?
       )?
     )
   ;
@@ -1423,14 +1417,14 @@ typeAssociationElementCont[ art ] // including Composition
 typeToOne[ art ]
   :
     one=ONE
-    { this.setMaxCardinality( $art, $one, this.numberLiteral( $one, null, '1' ) ); }
+    { this.setMaxCardinality( $art, this.numberLiteral( $one, null, '1' ) ); }
     simplePath[ $art.target, 'artref' ]
   ;
 
 typeToMany[ art ]
   :
     many=MANY
-    { this.setMaxCardinality( $art, $many, { literal: 'string', val: '*' } ); }
+    { this.setMaxCardinality( $art, { literal: 'string', val: '*' }, $many ); }
     simplePath[ $art.target, 'artref' ]
   ;
 
@@ -1467,13 +1461,18 @@ cardinality[ art ] locals[ card = {} ]
     ']'
   ;
 
+// TO be used when NOT and NULL are already in the lookahead set:
+optInvisibleNullability[ art ]
+  : { this.setLocalTokenForId( 1, { 'NOT': 'HelperToken1', 'NULL': 'HelperToken2' } ); }
+    ( n1=HelperToken1 n2=NULL { this.setNullability( $art, $n1, $n2 ); }
+    | n1=HelperToken2         { this.setNullability( $art, $n1, null ); }
+    )?
+  ;
+
 nullability[ art ]
-  :
-    not=NOT n1=NULL
-    { $art.notNull = this.valueWithTokenLocation( true, $not, $n1 ); }
-  |
-    n2=NULL
-    { $art.notNull = this.valueWithTokenLocation( false, $n2 ); }
+@after{ this.setNullability( $art, $n1, $n2 ); }
+  : n1=NOT n2=NULL
+  | n1=NULL
   ;
 
 foreignKey[ outer ] locals[ art = {}, elem = {} ]
@@ -1806,29 +1805,16 @@ projectionExclusion[ outer ] locals[ art = {} ]
 // Actually, this is a subset if elementDefInner...
 // TODO: the corresponding restrictions must also be checked in the core
 // compiler, as the mixin element could come via CSN
-mixinElementDef[ outer ] locals[ art = {} ]
-@after { /* #ATN 2 */ this.attachLocation($art); }
+mixinElementDef[ outer ] locals[ art = { target: {} } ]
+@after { /* #ATN 1 */ this.attachLocation($art); }
   :
-    name=ident['Mixin']
-    { this.addDef( $art, $outer, 'mixin', 'mixin', $name.id ); }
-    (
-      ':'
-      // #ATN: referenced type name can be ASSOCIATION or COMPOSITION
-      (
-        typeAssociationBase[ $art, false ]
-        // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
-        ( typeToMany[ $art ] | typeToOne[ $art ] | simplePath[ $art.target, 'artref' ] )
-        typeAssociationCont[ $art ]?
-      |
-        typeRefOptArgs[ $art ]
-        ( as='=' expression
-          { this.error( 'syntax-unsupported-calc-elem', $as ); }
-        )?
-      )
-    |
-      as='=' expression
-      { this.error( 'syntax-unsupported-calc-elem', $as ); }
-    )
+    name=ident['Mixin'] ':'
+    typeAssociationBase[ $art, false ]
+    { if ($art.type) this.addDef( $art, $outer, 'mixin', 'mixin', $name.id ); }
+    // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
+    ( typeToMany[ $art ] | typeToOne[ $art ] | simplePath[ $art.target, 'artref' ] )
+    // TODO CC: exclude every token other than ON
+    typeAssociationCont[ $art ]? // better error reporting than simply `ON condition`
     requiredSemi
   ;
 
@@ -1866,7 +1852,6 @@ selectItemDefBody[ art, outer ] locals[ assoc ]
         { this.reportExpandInline( $art, false ); }
         selectItemInlineList[ $art, 'expand' ]
         excludingClause[ $art ]?
-        // TODO: we might alternatively allow AS here
       |
         { this.reportExpandInline( $art, $as || this._input.LT(-1) ); }
         DOTbeforeBRACE          // ...orASTERISK
@@ -2056,7 +2041,7 @@ conditionEOF returns [ cond ]
   ;
 
 condition returns [ cond ] locals[ args = [] ]
-@after{ $cond = this.argsExpression( $args ); }
+@after{ $cond = this.argsExpression( $args, true ); }
   :
     c1=conditionAnd { $args.push($c1.cond); }
     (
@@ -2066,7 +2051,7 @@ condition returns [ cond ] locals[ args = [] ]
   ;
 
 conditionAnd returns [ cond ] locals[ args = [] ]
-@after{ $cond = this.argsExpression( $args, null, 'and' ); } // 'and' used by A2J and checks
+@after{ $cond = this.argsExpression( $args, 'and' ); } // 'and' used by A2J and checks
   :
     c1=conditionTerm { $args.push($c1.cond); }
     (
@@ -2077,7 +2062,7 @@ conditionAnd returns [ cond ] locals[ args = [] ]
 
 // Note: New operators need to be added to functionExpressionOperatorsRequireParentheses[] in toCdl.js.
 conditionTerm returns [ cond ] locals[ args = [] ]
-@after{ $cond = this.argsExpression( $args, null, '=' ); }// op: '=' used by A2J and checks
+@after{ $cond = this.argsExpression( $args, '=' ); }// op: '=' (not nary) used by A2J and checks
   :
     nt=NOT { this.pushXprToken( $args ); }
     ct=conditionTerm { $args.push( $ct.cond ); }
@@ -2133,7 +2118,7 @@ predicate[ args ]
   ;
 
 expression returns [ expr ] locals [ args = [] ]
-@after{ $expr = this.argsExpression( $args ); }
+@after{ $expr = this.argsExpression( $args, true ); }
   :
     e1=expressionSum { $args.push( $e1.expr ); }
     (
@@ -2143,7 +2128,7 @@ expression returns [ expr ] locals [ args = [] ]
   ;
 
 expressionSum returns [ expr ] locals [ args = [] ]
-@after{ $expr = this.argsExpression( $args ); }
+@after{ $expr = this.argsExpression( $args, true ); }
   :
     e1=expressionFactor { $args.push( $e1.expr ); }
     (
@@ -2153,7 +2138,7 @@ expressionSum returns [ expr ] locals [ args = [] ]
   ;
 
 expressionFactor returns [ expr ] locals [ args = [] ]
-@after{ $expr = this.argsExpression( $args ); }
+@after{ $expr = this.argsExpression( $args, true ); }
   :
     e1=expressionTerm { $args.push( $e1.expr ); }
     (
@@ -2163,7 +2148,7 @@ expressionFactor returns [ expr ] locals [ args = [] ]
   ;
 
 expressionTerm returns [ expr ] locals [ args = [] ]
-@after{ /* #ATN 1 */ $expr = this.argsExpression( $args ); }
+@after{ /* #ATN 1 */ $expr = this.argsExpression( $args, false ); }
   :
     ( '+' | '-' )  { this.pushXprToken( $args ); }
     e1=expressionTerm // prefix op or part of the number
@@ -2210,12 +2195,13 @@ expressionTerm returns [ expr ] locals [ args = [] ]
       { $args[0].suffix.push( this.surroundByParens( $over.over, $open, $close ) ); }
     )?
   |
-    ':'
+    colon=':' { this.reportUnexpectedSpace( $colon ); }
     (
       vp=valuePath[ 'paramref', this.startLocation() ]
       {{ const par = $vp.qp;; par.scope = 'param';; $args.push( par ); }}
     |
       pp=Number
+      // TODO: no extra XSN property `param` for this, re-use `val`
       { $args.push( { param: this.numberLiteral( $pp ), scope: 'param' } );
         this.csnParseOnly( 'syntax-unsupported-param', [ $pp ], { '#': 'positional', code: ':' + $pp.text } );
       }
@@ -2224,6 +2210,7 @@ expressionTerm returns [ expr ] locals [ args = [] ]
     qm= '?'                   // is automatically not mentioned as CC candidate
     // if we have an HideAlternatives here, we would block it to use it in
     // parallel to an expression (would produce adaptivePredict() otherwise)
+    // TODO: no extra XSN property `param` for this, re-use `val`
     { $args.push( { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' } );
       this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', code: '?' } );
     }
@@ -2315,7 +2302,7 @@ pathArguments[ pathStep, considerSpecial ]
     // For code completion, we need to handle generic tokens directly after the
     // '('.  To avoid invalidating an assoc `trim` to an entity with parameter
     // `leading` (ok, a bit constructed), we do not do it with named parameters.
-    { if (!this.setLocalTokenForId( { ':': 'HelperToken1', '=>': 'HelperToken2' } ))
+    { if (!this.setLocalTokenForId( 2, { ':': 'HelperToken1', '=>': 'HelperToken2' } ))
         this.prepareGenericKeywords( $considerSpecial ); }
     (
       { $pathStep.args = this.createDict(); $pathStep['$'+'syntax'] = ':'; }
@@ -2366,7 +2353,7 @@ namedExpression[ pathStep, id ]
 
 funcExpression[ pathStep, considerSpecial ] locals[ args = [] ]
 @init { this.prepareGenericKeywords( $considerSpecial ); }
-@after{ $pathStep.args.push( this.argsExpression( $args, true ) ); }
+@after{ $pathStep.args.push( this.argsExpression( $args, false ) ); }
   :
     (
       expr=expression
@@ -2417,9 +2404,8 @@ funcExpression[ pathStep, considerSpecial ] locals[ args = [] ]
   ;
 
 overClause returns[ over ] locals[ args = [] ]
-@after{ $over = this.argsExpression( $args ); }
+@after{ $over = this.argsExpression( $args, false ); }
   :
-    // TODO: empty really allowed?
     ( PARTITION { this.pushXprToken( $args ); } BY { this.pushXprToken( $args ); }
       pb=partitionByClause { $args.push( $pb.expr ); }
     )?
@@ -2432,7 +2418,7 @@ overClause returns[ over ] locals[ args = [] ]
   ;
 
 partitionByClause returns [ expr ] locals[ args = [] ]
-@after{ $expr = this.argsExpression( $args ); }
+@after{ $expr = this.argsExpression( $args, false ); }
   :
     e1=expression { $args.push( $e1.expr ); }
     ( ',' { this.pushXprToken( $args ); }
@@ -2442,7 +2428,7 @@ partitionByClause returns [ expr ] locals[ args = [] ]
 
 // ORDER BY clause in generic functions, e.g. `first_value(id order by name)`
 funcOrderByClause[ args ] returns[ expr ]
-@after{ $expr = this.argsExpression( args, true ); }
+@after{ $expr = this.argsExpression( $args, false, $args[0]?.location ); }
   :
     ORDER { this.pushXprToken( $args ); } BY { this.pushXprToken( $args ); }
     ob=exprOrderByClause { $args.push( $ob.expr ); }
@@ -2450,7 +2436,7 @@ funcOrderByClause[ args ] returns[ expr ]
 
 // ORDER BY clause in generic functions or OVER clause
 exprOrderByClause returns[ expr ] locals[ args = [] ]
-@after{ $expr = this.argsExpression( $args ); }
+@after{ $expr = this.argsExpression( $args, false ); }
   :
     orderBySpecInExpr[ $args ]
     ( ',' { this.pushXprToken( $args ); } orderBySpecInExpr[ $args ] )*
@@ -2468,7 +2454,7 @@ orderBySpecInExpr[ args ]
   ;
 
 windowFrameClause returns[ wf ] locals[ args = [] ]
-@after{ $wf = this.argsExpression( $args ); }
+@after{ $wf = this.argsExpression( $args, false ); }
   :
     (
       windowFrameStartSpec[ $args ]
@@ -2517,7 +2503,7 @@ optionalCardinality[ pathStep ]
   :
     // Make sure to test second token to allow expressions starting with Number
     // without introducing WHERE - that would be @options{k=2}.  The code
-    // completion just produces `:`after having inserted a Number - TODO.
+    // 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 ), location: this.startLocation() }; }
@@ -2547,7 +2533,7 @@ optionalWhereForFilter
 //  - "atn": at the beginning of a column definition
 //
 // want to let the ambiguity in select items (solution: "either" possibility)
-// 
+//
 //   entity E @Anno: Base { … };     // Base is include (chosen w/ warning) or @Anno value?
 //   entity V(p) as select from E {  // either: anno value "ref p", select item -x
 //     @anno :p - x as x;            // or: anno value true, select item :p-x
@@ -2561,7 +2547,7 @@ annotationAssignment_fix[ art ] locals[ assignment ]
     this.docComment( $art );
   }
 } :
-    '@'
+    at='@' { this.reportUnexpectedSpace( $at ); }
     (
       annotationAssignment_paren[ $art ]
     |
@@ -2579,7 +2565,7 @@ annotationAssignment_ll1[ art ] locals[ assignment ]
     this.docComment( $art );
   }
 } :
-    '@'
+    at='@' { this.reportUnexpectedSpace( $at ); }
     (
       annotationAssignment_paren[ $art ]
     |
@@ -2601,7 +2587,7 @@ annotationAssignment_atn[ art ] locals[ assignment ]
     this.docComment( $art );
   }
 } :
-    '@'
+    at='@' { this.reportUnexpectedSpace( $at ); }
     (
       annotationAssignment_paren[ $art ]
     |
@@ -2612,7 +2598,8 @@ annotationAssignment_atn[ art ] locals[ assignment ]
       // -> used to introduce variant name if and only if in same line as previous token
       { this.setLocalToken( '#', 'HelperToken1', null, true ); }
       (
-        HelperToken1 { this.meltKeywordToIdentifier(); }
+        hash=HelperToken1
+        { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
         variant=ident['variant'] { $assignment.name.variant = $variant.id; }
       )?
       // ':' is in the follow set of this rule, as it is used in rule "selectItemDef"
@@ -2624,10 +2611,11 @@ annotationAssignment_atn[ art ] locals[ assignment ]
         (
           val=annoValueBase[ $assignment ]
         |
-          at='@'? annotationPath[ $assignment, 'ref', $at ]
+          atv='@'? annotationPath[ $assignment, 'ref', $atv ]
           { this.setLocalToken( '#', 'HelperToken1', null, true ); } // see above
           (
-            HelperToken1 { this.meltKeywordToIdentifier(); }
+            hash=HelperToken1
+            { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
             variant=ident['variant'] { $assignment.variant = $variant.id; }
           )?
         )
@@ -2638,15 +2626,10 @@ annotationAssignment_atn[ art ] locals[ assignment ]
 annotationAssignment_paren[ art ]
   :
     '('
-    // allow completely useless `@()` with a warning, do not offer it for completion
+    // allow completely useless `@()`; no warning anymore - who cares?
     {
       this.meltKeywordToIdentifier();
       if (this.isStraightBefore(')')) {
-        // TODO: or should we simple accept this without warning? (but still no CC)
-        this.warning( 'syntax-unexpected-right-paren',
-                      this.tokenLocation( this.getCurrentToken() ),
-                      { offending: "')'", expecting: ['Identifier'], code: '@()' },
-                      'Unexpected $(OFFENDING), expecting $(EXPECTING); ignoring $(CODE)' );
         this.matchWildcard();   // we know it is the ')' - we do not reach the final match
         return $ctx;
       }
@@ -2695,7 +2678,7 @@ annotationPathVariant[ art ] locals[ variant = {} ]
 @after { this.attachLocation($art); }
   :
     // TODO: warning for space after '#'
-    '#' { this.meltKeywordToIdentifier(); }
+    hash='#' { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
     simplePath[ $variant, 'variant' ] { $art.variant = $variant; }
   ;
 
@@ -2832,7 +2815,8 @@ literalValue returns[ val ] locals[ tok ]
 @init{ $tok = this.getCurrentToken(); }
 @after { this.attachLocation($val); }
   :
-    '#' name=ident['enumref']
+    hash='#' { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
+    name=ident['enumref']   // TODO v4: remove from this rule (not in enum!)
     { $val = { literal: 'enum', sym: $name.id } }
   |
     NULL