@sap/cds-compiler 2.15.8 → 3.1.0

package/lib/language/language.g4

@@ -125,14 +125,17 @@ tokens {
   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!)
-  GenericArgFull,               // via token rewriting according to specialFunctions
+  GenericExpr,                  // via token rewriting according to specialFunctions
+  GenericSeparator,             // via token rewriting according to specialFunctions
+  GenericIntro,                 // via token rewriting according to specialFunctions
   DOTbeforeBRACE,               // via token rewrite
   COMPOSITIONofBRACE            // via token rewrite in rule typeAssociationBase
 }
 
 // Top-Level -----------------------------------------------------------------
 
-start returns [ source = { kind: 'source' } ] locals [ _sync = 'recover' ]
+start returns [ source ] locals [ _sync = 'recover' ]
+@init{ $source = this.createSource(); }
   :
     usingDeclaration[$source]*
     (
@@ -161,53 +164,46 @@ namespaceDeclaration[ source ] locals[ decl = {} ]
     NAMESPACE simplePath[ $decl, 'Namespace' ] ';'
   ;
 
-usingDeclaration[ source ] locals[ decl ]
-@after { if ($decl) this.attachLocation($decl); }
+usingDeclaration[ source ] locals[ decl = {} ]
+@after { this.attachLocation($decl); }
   :
+    { $decl.location = this.startLocation(); }
     USING
     (
       FROM str=String
-       {
-         if (!$source.dependencies) $source.dependencies = [];
-         $source.dependencies.push( this.quotedLiteral( $str, 'string' ) );
-      }
+       { $source.dependencies.push( this.quotedLiteral( $str, 'string' ) ); }
     |
       path=externalPath
-      { $decl = this.addItem( $source, 'usings', 'using', [], { extern: $path.extern } ); }
+      { this.addItem( $decl, $source, 'usings', 'using' );; $decl.extern = $path.extern; }
       ( AS name=ident['Using'] { $decl.name = $name.id; }
       | { this.classifyImplicitName( 'Using' ); }
       )
       ( FROM str=String
-        {
-          if (!$source.dependencies) $source.dependencies = [];
-          $source.dependencies.push( $decl.fileDep = this.quotedLiteral( $str, 'string' ) );
-        }
+        { $source.dependencies.push( $decl.fileDep = this.quotedLiteral( $str, 'string' ) );         }
       )?
     |
-      { $decl = this.addItem( $source, 'usings', 'using', [] ); }
+      { this.addItem( $decl, $source, 'usings', 'using' ); }
       // We could just create "independent" USING declaration, but if we want
       // to have some check in the future whether the external artifacts are
       // really in the FROM source...
-      '{'
+      '{' { $decl.usings = this.createArray(); }
       innerUsing[ $decl ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         innerUsing[ $decl ] )*
-      '}'
+      '}' { this.finalizeDictOrArray( $decl.usings ); }
       ( FROM str=String
-        {
-          if (!$source.dependencies) $source.dependencies = [];
-          $source.dependencies.push( $decl.fileDep = this.quotedLiteral( $str, 'string' ) );
-        }
+        { $source.dependencies.push( $decl.fileDep = this.quotedLiteral( $str, 'string' ) ); }
       )?
     )
     ';'
   ;
 
-innerUsing[ using ] locals[ decl ]
-@after { if ($decl) this.attachLocation($decl); }
+innerUsing[ using ] locals[ decl = {} ]
+@after { this.attachLocation($decl); }
   :
+    { $decl.location = this.startLocation(); }
     path=externalPath
-    { $decl = this.addItem( $using, 'usings', 'using', null, { extern: $path.extern } ); }
+    { this.addItem( $decl, $using, 'usings', 'using' );; $decl.extern = $path.extern; }
     ( AS name=ident['Using'] { $decl.name = $name.id; }
     | { this.classifyImplicitName( 'Using' ); }
     )
@@ -225,18 +221,18 @@ externalPath returns [ extern = {} ]
 //     @anno :p - x as x;            // or: anno value true, select item :p-x
 //   }
 
-annotationAssignment_1[ annos ] locals[ assignment = { name: {} } ]
-@after { $annos.push( this.attachLocation($assignment) ); }
+annotationAssignment_1[ art ] locals[ assignment = { name: {} } ]
+@after { this.assignAnnotation( $art, $assignment ); }
   :
     annotationPath[ $assignment.name, 'anno' ]
     annotationPathVariant[ $assignment.name ]?
     (
       ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
-      val=annoValue { $assignment.value = $val.val; }
+      val=annoValue[ $assignment ]
     )?
   ;
 
-annotationAssignment_paren[ annos ]
+annotationAssignment_paren[ art ]
   :
     '('
     // allow completely useless `@()` with a warning, do not offer it for completion
@@ -251,28 +247,28 @@ annotationAssignment_paren[ annos ]
         return $ctx;
       }
     }
-    annotationAssignment_1[ $annos ]
+    annotationAssignment_1[ $art ]
     ( ','
       {
         this.meltKeywordToIdentifier();
         if (this.isStraightBefore(')')) break; // allow ',' before ')'
       }
-      annotationAssignment_1[ $annos ]
+      annotationAssignment_1[ $art ]
     )*
     ')'
   ;
 
-annotationAssignment_fix[ annos ] locals[ assignment ]
+annotationAssignment_fix[ art ] locals[ assignment ]
 // value outside @(...)
 @after {
   if ($assignment) {
-    $annos.push( this.attachLocation($assignment) );
-    this.docComment( $annos );
+    this.assignAnnotation( $art, $assignment );
+    this.docComment( $art );
   }
 } :
     '@'
     (
-      annotationAssignment_paren[ annos ]
+      annotationAssignment_paren[ $art ]
     |
       { $assignment = { name: {} }; }
       annotationPath[ $assignment.name, 'anno' ]
@@ -287,38 +283,38 @@ annotationAssignment_fix[ annos ] locals[ assignment ]
     )
   ;
 
-annotationAssignment_ll1[ annos ] locals[ assignment ]
+annotationAssignment_ll1[ art ] locals[ assignment ]
 @after {
   if ($assignment) {
-    $annos.push( this.attachLocation($assignment) );
-    this.docComment( $annos );
+    this.assignAnnotation( $art, $assignment );
+    this.docComment( $art );
   }
 } :
     '@'
     (
-      annotationAssignment_paren[ annos ]
+      annotationAssignment_paren[ $art ]
     |
       { $assignment = { name: {} }; }
       annotationPath[ $assignment.name, 'anno' ]
       annotationPathVariant[ $assignment.name ]?
       (
         ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
-        val=annoValue { $assignment.value = $val.val; }
+        val=annoValue[ $assignment ]
       )?
     )
   ;
 
 // Has previously used ATN, now via local token rewrite
-annotationAssignment_atn[ annos ] locals[ assignment ]
+annotationAssignment_atn[ art ] locals[ assignment ]
 @after {
   if ($assignment) {
-    $annos.push( this.attachLocation($assignment) );
-    this.docComment( $annos );
+    this.assignAnnotation( $art, $assignment );
+    this.docComment( $art );
   }
 } :
     '@'
     (
-      annotationAssignment_paren[ annos ]
+      annotationAssignment_paren[ $art ]
     |
       { $assignment = { name: {} }; }
       annotationPath[ $assignment.name, 'anno' ]
@@ -337,14 +333,13 @@ annotationAssignment_atn[ annos ] locals[ assignment ]
       ( HelperToken2                        // ':'
         { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
         (
-          val=annoValueBase { $assignment.value = $val.val; }
+          val=annoValueBase[ $assignment ]
         |
-          { $assignment.value = {}; }              // TODO: think about expression value representation
-          at='@'? annotationPath[ $assignment.value, 'ref', $at ]
+          at='@'? annotationPath[ $assignment, 'ref', $at ]
           { this.setLocalToken( '#', 'HelperToken1', null, true ); } // see above
           (
             HelperToken1 { this.meltKeywordToIdentifier(); }
-            variant=ident['variant'] { $assignment.value.variant = $variant.id; }
+            variant=ident['variant'] { $assignment.variant = $variant.id; }
           )?
         )
       )?
@@ -364,97 +359,95 @@ optionalSemi
     ';'?
   ;
 
-artifactDef[ outer, defOnly = false ] locals[ annos = [] ] // cannot use `parent` as parameter name!
+artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent` as parameter name!
 @after{ /* #ATN 1 */ }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { $art.location = this.startLocation(); this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       DEFINE?
-      ( contextDef[ $outer, this.startLocation(), $annos, defOnly ]
-      | entityDef[ $outer, this.startLocation(), $annos ]
-      | typeDef[ $outer, this.startLocation(), $annos ]
-      | aspectDef[ $outer, this.startLocation(), $annos ]
-      | annotationDef[ $outer, this.startLocation(), $annos ]
-      | viewDef[ $outer, this.startLocation(), $annos ]
-      | eventDef[ $outer, this.startLocation(), $annos ]
-      | actionFunctionMainDef[ $outer, this.startLocation(), $annos ]
+      ( contextDef[ $art, $outer, defOnly ]
+      | entityDef[ $art, $outer ]
+      | typeDef[ $art, $outer ]
+      | aspectDef[ $art, $outer ]
+      | annotationDef[ $art, $outer ]
+      | viewDef[ $art, $outer ]
+      | eventDef[ $art, $outer ]
+      | actionFunctionMainDef[ $art, $outer ]
       )
     |
       extend=EXTEND
-      { if (defOnly) // this is a syntax restriction which is ensured in CSN in
-                     // another way
+      { if (defOnly)
           this.error( 'syntax-extend-context', $extend,
                       { code: 'EXTEND artifact', kind: defOnly },
-                      'No $(CODE) within $(KIND) extensions' ); }
+                      'No $(CODE) within $(KIND) extensions' );
+        if (!$outer.extensions) $outer.extensions = [];
+      }
       // #ATN: EXTEND elem, while CONTEXT, ENTITY etc are not reserved
-      ( extendContext[ $outer, this.startLocation(), $annos ]
-      | extendEntity[ $outer, this.startLocation(), $annos ]
-      | extendProjection[ $outer, this.startLocation(), $annos ]
-      | extendType[ $outer, this.startLocation(), $annos ]
-      | extendAspect[ $outer, this.startLocation(), $annos ]
+      ( extendContext[ $art, $outer ]
+      | extendEntity[ $art, $outer ] // or aspect
+      | extendProjection[ $art, $outer ]
+      | extendType[ $art, $outer ]
       // Streamlined Syntax
-      | extendArtifact[ $outer, this.startLocation(), $annos ]
+      | extendArtifact[ $art, $outer ]
       )
     |
       annotate=ANNOTATE
-      { if (defOnly) // this is a syntax restriction which is ensured in CSN in
-                     // another way
+      { if (defOnly)
           this.error( 'syntax-extend-context', $annotate,
                       { code: 'ANNOTATE artifact', kind: defOnly },
                       'No $(CODE) within $(KIND) extensions' );
+        if (!$outer.extensions) $outer.extensions = [];
         this.meltKeywordToIdentifier();
       }
-      annotateArtifact[ $outer, this.startLocation(), $annos ] // not kind-specific
+      annotateArtifact[ $art, $outer ] // not kind-specific
     )
   ;
 
-contextDef[ outer, loc, annos, defOnly = false ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+contextDef[ art, outer, defOnly = false ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     ( CONTEXT | service=SERVICE ) simplePath[ $name, $service ? 'Service' : 'Context' ]
-    { $art = this.addDef( $outer, 'artifacts', $service ? 'service' : 'context', $name, $annos,
-                          {}, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { this.addDef( $art, $outer, 'artifacts', $service ? 'service' : 'context', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     (
-      '{' { $art.artifacts = this.createDict(); }
+      '{' { $art.artifacts = this.createDict(); $art.extensions = []; }
       artifactDef[ $art, defOnly ]*
-      '}' { this.setDictEndLocation( $art.artifacts ); }
+      '}' { this.finalizeDictOrArray( $art.artifacts ); }
       optionalSemi
     |
       requiredSemi
     )
   ;
 
-extendContext[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+extendContext[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
-    ( CONTEXT | service=SERVICE ) simplePath[ $name, $service ? 'Service' : 'Context' ] // not 'Extend' here
-    { $art = this.addItem( $outer, 'extensions', 'extend', $annos,
-                           { name: $name, expectedKind: $service ? 'service' : 'context' },
-                           $loc );  }
+    ( CONTEXT { $art.expectedKind = 'context'; } | service=SERVICE { $art.expectedKind = 'service'; })
+    simplePath[ $name, $service ? 'Service' : 'Context' ] // not 'Extend' here
+    { $art.name = $name; this.addItem( $art, $outer, 'extensions', 'extend' ); }
     ( WITH { this.noSemicolonHere(); } )?
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       '{' { $art.artifacts = this.createDict(); }
       artifactDef[ $art, $service ? 'SERVICE' : 'CONTEXT' ]*
-      '}' { this.setDictEndLocation( $art.artifacts ); }
+      '}' { this.finalizeDictOrArray( $art.artifacts ); }
       optionalSemi
     |
       requiredSemi
     )
   ;
 
-entityDef[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+entityDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     ENTITY simplePath[ $name, 'Entity' ]
-    { $art = this.addDef( $outer, 'artifacts', 'entity', $name, $annos, {}, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
-    entityParameters[ $art ]?
+    { this.addDef( $art, $outer, 'artifacts', 'entity', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
+    parameterListDef[ $art ]?
     (
       ( ':'
         includeRef[ $art ]
@@ -462,15 +455,14 @@ entityDef[ outer, loc, annos ] locals[ art, name = {} ]
           includeRef[ $art ]
         )*
       )?
-      '{'
-      { $art.elements = this.createDict(); } // better for include and annotate
+      '{' { $art.elements = this.createDict(); }
       elementDef[ $art ]*
-      '}' { this.setDictEndLocation( $art.elements ); }
+      '}' { this.finalizeDictOrArray( $art.elements ); }
       // TODO: action definitions in a specific section?
       (
         ACTIONS '{' { $art.actions = this.createDict(); }
         actionFunctionDef[ $art ]*
-        '}' { this.setDictEndLocation( $art.actions ); }
+        '}' { this.finalizeDictOrArray( $art.actions ); }
       )?
       optionalSemi
     |
@@ -480,7 +472,7 @@ entityDef[ outer, loc, annos ] locals[ art, name = {} ]
         (
           ACTIONS '{' { $art.actions = this.createDict(); }
           actionFunctionDef[ $art ]*
-          '}' { this.setDictEndLocation( $art.actions ); }
+          '}' { this.finalizeDictOrArray( $art.actions ); }
           optionalSemi
         | requiredSemi
         )
@@ -490,7 +482,7 @@ entityDef[ outer, loc, annos ] locals[ art, name = {} ]
         (
           ACTIONS '{' { $art.actions = this.createDict(); }
           actionFunctionDef[ $art ]*
-          '}' { this.setDictEndLocation( $art.actions ); }
+          '}' { this.finalizeDictOrArray( $art.actions ); }
         )?
         optionalSemi            // TODO: not fully correct without columns or excluding
       )
@@ -514,7 +506,7 @@ projectionSpec returns[ query ] locals[ src ]
     ( AS aliasName=ident['FromAlias'] { $src.name = $aliasName.id } )?
     // ANTLR errors are better if we use ( A )? instead of ( A | ):
     { if (!$src.name) this.classifyImplicitName( $src.scope ? 'FromAlias' : 'Without' ); }
-    bracedSelectItemListDef[ $query ]?
+    bracedSelectItemListDef[ $query, 'columns' ]?
     excludingClause[ $query ]?
   ;
 
@@ -541,35 +533,37 @@ excludingClause[ query ]
     ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
       projectionExclusion[ $query ]
     )*
-    '}' { this.setDictEndLocation( $query.excludingDict ); }
+    '}' { this.finalizeDictOrArray( $query.excludingDict ); }
   ;
 
-projectionExclusion[ outer ] locals[ art ]
+projectionExclusion[ outer ] locals[ art = {} ]
 @after { this.attachLocation($art); }
   :
     name=ident['ref']
-    { $art = this.addDef( $outer, 'excludingDict', '', $name.id ); }
+    { this.addDef( $art, $outer, 'excludingDict', '', $name.id ); }
   ;
 
-extendEntity[ outer, loc, annos ] locals[ art, name = {} ]
-@after { /* #ATN 1 */ this.attachLocation($art); }
+// also used for aspect
+extendEntity[ art, outer ] locals[ name = {} ]
+@after { /* #ATN 1 */ this.attachLocation( $art ); }
   :
-    ENTITY simplePath[ $name, 'Extend' ]
-    { $art = this.addItem( $outer, 'extensions', 'extend', $annos,
-                           { name: $name, expectedKind: 'entity' }, $loc );  }
+    kind=(ASPECT | ENTITY) simplePath[ $name, 'Extend' ]
+    { $art.expectedKind = $kind.text.toLowerCase(); $art.name = $name;
+      this.addItem( $art, $outer, 'extensions', 'extend' );
+    }
     (
-      WITH { this.noSemicolonHere(); this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]*
+      WITH { this.noSemicolonHere(); this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
       // ATN: the ref can start with ACTIONS
       (
-        includeRef[ $art ]
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
         extendForEntity[ $art ]
       )
     |
-      { this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]*
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
       extendForEntity[ $art ]
     )
   ;
@@ -578,33 +572,32 @@ extendForEntity[ art ]
   :
     '{' { $art.elements = this.createDict(); }
     elementDefOrExtend[ $art ]*
-    '}' { this.setDictEndLocation( $art.elements ); }
+    '}' { this.finalizeDictOrArray( $art.elements ); }
     (
       ACTIONS '{' { $art.actions = this.createDict(); }
       actionFunctionDef[ $art ]*
-      '}' { this.setDictEndLocation( $art.actions ); }
+      '}' { this.finalizeDictOrArray( $art.actions ); }
     )?
     optionalSemi
   |
     ACTIONS '{' { $art.actions = this.createDict(); }
     actionFunctionDef[ $art ]*
-    '}' { this.setDictEndLocation( $art.actions ); }
+    '}' { this.finalizeDictOrArray( $art.actions ); }
     optionalSemi
   |
     requiredSemi
   ;
 
-extendProjection[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+extendProjection[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     expected=PROJECTION simplePath[ $name, 'Extend' ]
-    {
-      $art = this.addItem( $outer, 'extensions', 'extend', $annos,
-                           { name: $name, expectedKind: 'entity' }, // or 'projection'?
-                           $loc );  }
+    { $art.expectedKind = 'entity'; $art.name = $name;
+      this.addItem( $art, $outer, 'extensions', 'extend' );
+    }
     ( WITH { this.noSemicolonHere(); } )?
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       '{' { $art.columns = []; }
       (
@@ -617,13 +610,13 @@ extendProjection[ outer, loc, annos ] locals[ art, name = {} ]
       (
         ACTIONS '{' { $art.actions = this.createDict(); }
         actionFunctionDef[ $art ]*
-        '}' { this.setDictEndLocation( $art.actions ); }
+        '}' { this.finalizeDictOrArray( $art.actions ); }
       )?
       optionalSemi
     |
       ACTIONS '{' { $art.actions = this.createDict(); }
       actionFunctionDef[ $art ]*
-      '}' { this.setDictEndLocation( $art.actions ); }
+      '}' { this.finalizeDictOrArray( $art.actions ); }
       optionalSemi
     |
       requiredSemi
@@ -631,53 +624,53 @@ extendProjection[ outer, loc, annos ] locals[ art, name = {} ]
   ;
 
 // TODO: no action extension?
-actionFunctionDef[ outer ] locals[ art, annos = [] ]
-@after { this.attachLocation($art); }
+actionFunctionDef[ outer ] locals[ art = {} ]
+@after { this.attachLocation( $art ); }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       ACTION name=ident['BoundAction']
-      { $art = this.addDef( $outer, 'actions', 'action', $name.id, $annos );
-        this.docComment( $annos ); }
-      annotationAssignment_fix[ $annos ]*
+      { this.addDef( $art, $outer, 'actions', 'action', $name.id );
+        this.docComment( $art ); }
+      annotationAssignment_fix[ $art ]*
       parameterListDef[ $art ]
-      ( returnTypeSpec[ $art, $annos ] | requiredSemi )
+      ( returnTypeSpec[ $art ] | requiredSemi )
     |
       FUNCTION name=ident['BoundAction']
-      { $art = this.addDef( $outer, 'actions', 'function', $name.id, $annos );
-        this.docComment( $annos ); }
-      annotationAssignment_fix[ $annos ]*
+      { this.addDef( $art, $outer, 'actions', 'function', $name.id );
+        this.docComment( $art ); }
+      annotationAssignment_fix[ $art ]*
       parameterListDef[ $art ]
-      returnTypeSpec[ $art, $annos ]
+      returnTypeSpec[ $art ]
     )
   ;
 
-actionFunctionMainDef[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+actionFunctionMainDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     ACTION simplePath[ $name, 'Action' ]
-    { $art = this.addDef( $outer, 'artifacts', 'action', $name, $annos, {}, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { this.addDef( $art, $outer, 'artifacts', 'action', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     parameterListDef[ $art ]
-    ( returnTypeSpec[ $art, $annos ] | requiredSemi )
+    ( returnTypeSpec[ $art ] | requiredSemi )
   |
     FUNCTION simplePath[ $name, 'Action' ]
-    { $art = this.addDef( $outer, 'artifacts', 'function', $name, $annos, {}, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { this.addDef( $art, $outer, 'artifacts', 'function', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     parameterListDef[ $art ]
-    returnTypeSpec[ $art, $annos ]
+    returnTypeSpec[ $art ]
   ;
 
-eventDef[ outer, loc, annos ] locals[ art, name = {} ]
-@after { /* #ATN 1 */ this.attachLocation($art); }
+eventDef[ art, outer ] locals[ name = {} ]
+@after { /* #ATN 1 */ this.attachLocation( $art ); }
   :
     EVENT simplePath[ $name, 'Event' ]
-    { $art = this.addDef( $outer, 'artifacts', 'event', $name, $annos, {}, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { this.addDef( $art, $outer, 'artifacts', 'event', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     (
       typeStruct[ $art ] optionalSemi
     |
@@ -693,8 +686,8 @@ eventDef[ outer, loc, annos ] locals[ art, name = {} ]
           )*
           typeStruct[ $art ] optionalSemi
         |
-          { this.docComment( $annos ); }
-          annotationAssignment_ll1[ $annos ]*
+          { this.docComment( $art ); }
+          annotationAssignment_ll1[ $art ]*
           requiredSemi
         )
       |
@@ -708,18 +701,18 @@ eventDef[ outer, loc, annos ] locals[ art, name = {} ]
     )
   ;
 
-aspectDef[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+aspectDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     ( ASPECT | ( abs=ABSTRACT | HideAlternatives ) ent=ENTITY )
     simplePath[ $name, 'Type' ]
-    { $art = this.addDef( $outer, 'artifacts', 'aspect', $name, $annos, {}, $loc );
+    { this.addDef( $art, $outer, 'artifacts', 'aspect', $name );
       // backends do not like ['$'+'syntax']: ($ent ? 'entity' : 'aspect')
       if ($ent)
         this.warning( 'syntax-deprecated-abstract', this.tokenLocation( $abs, $ent ), {},
                       'Abstract entity definitions are deprecated; use aspect definitions instead' );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     ( ':'
       (
         includeRef[ $art ]
@@ -730,99 +723,84 @@ aspectDef[ outer, loc, annos ] locals[ art, name = {} ]
     )?
     '{' { $art.elements = this.createDict(); }
     ( elementDef[ $art ]* )
-    '}' { this.setDictEndLocation( $art.elements ); }
+    '}' { this.finalizeDictOrArray( $art.elements ); }
     // TODO: action definitions in a specific section?
     (
       ACTIONS '{' { $art.actions = this.createDict(); }
       actionFunctionDef[ $art ]*
-      '}' { this.setDictEndLocation( $art.actions ); }
+      '}' { this.finalizeDictOrArray( $art.actions ); }
     )?
     optionalSemi
   ;
 
-typeDef[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+typeDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     TYPE simplePath[ $name, 'Type' ]
-    { $art = this.addDef( $outer, 'artifacts', 'type', $name, $annos, {}, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
-    typeSpecSemi[ $art, $annos ]
+    { this.addDef( $art, $outer, 'artifacts', 'type', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
+    typeSpecSemi[ $art ]
   ;
 
-extendType[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+extendType[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     // aspects are types, i.e. kind is 'type' for aspects
     TYPE simplePath[ $name, 'Extend' ]
-    { $art = this.addItem( $outer, 'extensions', 'extend', $annos,
-                           { name: $name, expectedKind: 'type' },
-                           $loc );  }
-    extendWithOptElements[ $art, $annos ]
-  ;
-
-extendAspect[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
-  :
-    // aspects are types, i.e. kind is 'type' for aspects
-    ASPECT simplePath[ $name, 'Extend' ]
-    { $art = this.addItem( $outer, 'extensions', 'extend', $annos,
-                           { name: $name, expectedKind: 'aspect' },
-                           $loc );  }
-    extendWithOptElements[ $art, $annos ]
+    { $art.expectedKind = 'type'; $art.name = $name;
+      this.addItem( $art, $outer, 'extensions', 'extend' );
+    }
+    extendWithOptElements[ $art, $art ]
   ;
 
-annotationDef[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+annotationDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     annotation=ANNOTATION simplePath[ $name, 'AnnoDef' ]
     { if ($outer.kind !== 'source') { // this is a syntax restriction to avoid confusion
-        this.error( 'syntax-no-inner-vocabulary', $annotation, {},
-                    'Annotation definitions can\'t be defined inside contexts or services' );
+        this.error( 'syntax-unexpected-vocabulary', $annotation, { '#': $outer.kind } );
         $art = {}; }
-      else
-        $art = this.addDef( $outer, 'vocabularies', 'annotation', $name, $annos, {}, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
-    typeSpecSemi[ $art, $annos ] // also 'includes'...
+      else {
+        if (!$outer.vocabularies) $outer.vocabularies = Object.create(null);
+        this.addDef( $art, $outer, 'vocabularies', 'annotation', $name );
+      }
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
+    typeSpecSemi[ $art ] // also 'includes'...
   ;
 
-extendArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
-@after{ /* #ATN 1 */ this.attachLocation($art); }
+extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
+@after{ /* #ATN 1 */ this.attachLocation( $art ); }
   :
     simplePath[ $name, 'Extend' ]
+    ( ':' simplePath[ $elemName, 'Element'] )?
+    { this.addExtension( $art, $outer, 'extend', $name, $elemName.path ); }
     (
-      { $art = this.addItem( $outer, 'extensions', 'extend', $annos, { name: $name }, $loc );  }
-    |
-      ':'
-      simplePath[ $elemName, 'ref']
-      {{
-        const def = this.addItem( $outer, 'extensions', 'extend', null, { name: $name }, $loc );
-        $art = this.artifactForElementAnnotateOrExtend( 'extend', def, $elemName.path, $annos, $loc );
-      }}
-    )
-    (
-      { this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]*
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
       (
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
-        '}' { this.setDictEndLocation( $art.elements ); }
+        '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
       )
     |
-      WITH { this.noSemicolonHere(); this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]*
+      WITH { this.noSemicolonHere(); this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
       // #ATN: DEFINITIONS, COLUMNS, ACTIONS etc are not reserved and could be identifiers (ref).
+      // TODO: exclude "expected" according to disallowElementExtension()
       (
-        includeRef[ $art ]
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
-        '}' { this.setDictEndLocation( $art.elements ); }
+        '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -831,7 +809,7 @@ extendArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
         DEFINITIONS
         '{' { $art.artifacts = this.createDict(); }
         artifactDef[ $art, true ]*
-        '}' { this.setDictEndLocation( $art.artifacts ); }
+        '}' { this.finalizeDictOrArray( $art.artifacts ); }
         optionalSemi
       |
         { this.disallowElementExtension( $elemName, $outer, 'columns' ); }
@@ -848,85 +826,82 @@ extendArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
       |
         { this.disallowElementExtension( $elemName, $outer, 'actions' ); }
         ACTIONS '{' { $art.actions = this.createDict(); }
-        actionFunctionDef[ $art ]*
-        '}' { this.setDictEndLocation( $art.actions ); }
+        actionFunctionDef[ $art ]* // TODO: no EXTEND in actions? (ok, would just allow annos)
+        '}' { this.finalizeDictOrArray( $art.actions ); }
         optionalSemi
       |
         ELEMENTS '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
-        '}' { this.setDictEndLocation( $art.elements ); }
+        '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         ENUM '{' { $art.enum = this.createDict(); }
-        enumSymbolDef[ $art ]*
-        '}' { this.setDictEndLocation( $art.enum ); }
+        enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
+        '}' { this.finalizeDictOrArray( $art.enum ); }
         optionalSemi
       )
     )
   ;
 
-extendWithOptElements[ art, annos ]
+extendWithOptElements[ art ]
   :
-    WITH { this.noSemicolonHere(); this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    WITH { this.noSemicolonHere(); this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
-      includeRef[ $art ]
+      includeRef[ $art ] ( ',' includeRef[ $art ] )*
       requiredSemi
     |
       '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
-      '}' { this.setDictEndLocation( $art.elements ); }
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
     )
   |
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       '{' { $art.elements = this.createDict(); }
       elementDefOrExtend[ $art ]*
-      '}' { this.setDictEndLocation( $art.elements ); }
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
     )
   ;
 
-annotateArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
-@after { this.attachLocation($art); }
+annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
+@after { this.attachLocation( $art ); }
   :
     simplePath[ $name, 'Annotate' ]
-    (
-      { $art = this.addItem( $outer, 'extensions', 'annotate', $annos, { name: $name }, $loc ); }
-    |
-      ':'
-      simplePath[ $elemName, 'ref']
-      {{
-        const def = this.addItem( $outer, 'extensions', 'annotate', null, { name: $name }, $loc );
-        $art = this.artifactForElementAnnotateOrExtend( 'annotate', def, $elemName.path, $annos, $loc );
-      }}
-    )
-
+    ( ':' simplePath[ $elemName, 'Element'] )?
+    { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
     ( WITH { this.noSemicolonHere(); } )?
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}' { this.setDictEndLocation( $art.elements ); }
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       (
         ACTIONS
         '{' { $art.actions = this.createDict(); }
         annotateAction[ $art ]*
-        '}' { this.setDictEndLocation( $art.actions ); }
+        '}' { this.finalizeDictOrArray( $art.actions ); }
+      { this.checkExtensionDict( $art.actions ); }
       )?
       optionalSemi
     |
       ACTIONS
       '{' { $art.actions = this.createDict(); }
       annotateAction[ $art ]*
-      '}' { this.setDictEndLocation( $art.actions ); }
+      '}' { this.finalizeDictOrArray( $art.actions ); }
+      { this.checkExtensionDict( $art.actions ); }
       optionalSemi
     |
       '(' { $art.params = this.createDict(); }
@@ -934,12 +909,14 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
         annotateParam[ $art ]
       )*
-      ')' { this.setDictEndLocation( $art.params ); }
+      ')' { this.finalizeDictOrArray( $art.params ); }
+      { this.checkExtensionDict( $art.params ); }
       (
         RETURNS { $art['$'+'syntax'] = 'returns'; }
         '{' { $art.elements = this.createDict(); }
         annotateElement[ $art ]*
-        '}' { this.setDictEndLocation( $art.elements ); }
+        '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
         requiredSemi
@@ -948,7 +925,8 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
       RETURNS { $art['$'+'syntax'] = 'returns'; }
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}' { this.setDictEndLocation( $art.elements ); }
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
 
     |
@@ -956,74 +934,77 @@ annotateArtifact[ outer, loc, annos ] locals[ art, name = {}, elemName = {} ]
     )
   ;
 
-annotateElement[ outer ] locals[ art, annos = [] ]
-@after{ this.attachLocation($art); }
+annotateElement[ outer ] locals[ art = {} ]
+@after{ this.attachLocation( $art ); }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     name=ident['Element']
-    { $art = this.addDef( $outer, 'elements', 'annotate', $name.id, $annos );
-      this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.addDef( $art, $outer, 'elements', 'annotate', $name.id );
+      this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}' { this.setDictEndLocation( $art.elements ); }
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
     )
   ;
 
-annotateAction [ outer ] locals [ art, annos = [] ]
-@after{ this.attachLocation($art); }
+annotateAction [ outer ] locals [ art = {} ]
+@after{ this.attachLocation( $art ); }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     name=ident['BoundAction']
-    { $art = this.addDef( $outer, 'actions', 'annotate', $name.id, $annos );
-      this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.addDef( $art, $outer, 'actions', 'annotate', $name.id );
+      this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
       '(' { $art.params = this.createDict(); }
       annotateParam[ $art ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
         annotateParam[ $art ]
       )*
-      ')' { this.setDictEndLocation( $art.params ); }
+      ')' { this.finalizeDictOrArray( $art.params ); }
+      { this.checkExtensionDict( $art.params ); }
     )?
     (
       RETURNS '{' { $art.elements = this.createDict(); }
       annotateElement[ $art ]*
-      '}' { this.setDictEndLocation( $art.elements ); }
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
       requiredSemi
     )
   ;
 
-annotateParam [ outer ] locals [ art, annos = [] ]
-@after{ this.attachLocation($art); }
+annotateParam [ outer ] locals [ art = {} ]
+@after{ this.attachLocation( $art ); }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     param=ident['Param']
-    { $art = this.addDef( $outer, 'params', 'annotate', $param.id, $annos );
-      this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.addDef( $art, $outer, 'params', 'annotate', $param.id );
+      this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
   ;
 
 // Element definition and its helpers ----------------------------------------
 
-enumSymbolDef[ outer ] locals[ art, annos = [] ]
-@after { this.attachLocation($art); }
+enumSymbolDef[ outer ] locals[ art = {} ]
+@after { this.attachLocation( $art ); }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     name=ident['Enum']
-    { $art = this.addDef( $outer, 'enum', 'enum', $name.id, $annos );
-      this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.addDef( $art, $outer, 'enum', 'enum', $name.id );
+      this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     ( '='
       { this.excludeExpected( ['Boolean', 'QuotedLiteral', "'#'", 'NULL'] ); }
       (
@@ -1033,8 +1014,8 @@ enumSymbolDef[ outer ] locals[ art, annos = [] ]
         ( plus='+' | min='-' ) num=Number
         { $art.value = this.numberLiteral( $num, $plus||$min ); }
       )
-      { this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]*
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
     )?
     requiredSemi
   ;
@@ -1045,37 +1026,35 @@ defaultValue[ art ] locals[ elem, elements = {} ]
   DEFAULT expr=expression { $art.default = $expr.expr; }
   ;
 
-elementDefOrExtend[ outer ] locals[ annos = [] ]
-@after { /* #ATN 1 */ if ($ctx.art) this.attachLocation($art.art); }
-// tool complains if I test for ($art)
+elementDefOrExtend[ outer ] locals[ art = {} ]
+@after { /* #ATN 1 */ }  // if ($art) this.attachLocation( $art ); }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     // #ATN: element name for definition can be EXTEND
     (
       EXTEND
-      extendElement[ $outer, this.startLocation(), $annos ]
+      extendElement[ $art, $outer ]
     |
-      art = elementDefInner[ $outer, this.startLocation(), $annos, true ]
+      elementDefInner[ $art, $outer, true ]
     )
   ;
 
-elementDef[ outer ] locals[ annos = [] ]
-@after { this.attachLocation($art.art); }
+elementDef[ outer ] locals[ $art = {} ]
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
-    art = elementDefInner[ $outer, this.startLocation(), $annos, false ]
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    elementDefInner[ $art, $outer, false ]
   ;
 
 // 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 ]
+mixinElementDef[ outer ] locals[ art = {} ]
 @after { /* #ATN 2 */ this.attachLocation($art); }
   :
     name=ident['Mixin']
-    { $art = this.addDef( $outer, 'mixin', 'mixin', $name.id ); }
+    { this.addDef( $art, $outer, 'mixin', 'mixin', $name.id ); }
     (
       ':'
       // #ATN: referenced type name can be ASSOCIATION or COMPOSITION
@@ -1097,33 +1076,30 @@ mixinElementDef[ outer ] locals[ art ]
     requiredSemi
   ;
 
-misplacedAnnotations[ annos, messageId ]
-  :
-    // No docComment() here
-    annotationAssignment_ll1[ $annos ]+
-    { if ($messageId)           // issue specified in central registry
-        this.message( messageId, this.tokenLocation( $ctx.start, this.getCurrentToken() ) );
-    }
-  ;
-
-elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
-@after{ /* #ATN 5 */ }
+elementDefInner[ art, outer, allowEq ]
+@after{ /* #ATN 5 */ this.attachLocation( $art ); }
   :
     // TODO: it would be excellent to remove ELEMENT...
     // or have a special ident rule without the ELEMENT
     // Reason: it would be good for error recovery to start a major block without LL1 ambiguity
     // VIRTUAL is keyword, except if before the following tokens texts:
     { this.setLocalToken( 'VIRTUAL', 'VIRTUAL', /^[:{@=}]$/ ); }
-    virtual=VIRTUAL? key=KEY?
+    ( virtual=VIRTUAL { $art.virtual = this.valueWithTokenLocation( true, $virtual ); } )?
+    ( key=KEY { $art.key = this.valueWithTokenLocation( true, $key ); } )?
     // #ATN: element name can be MASKED or ELEMENT (2x)
-    masked=MASKED?    // TODO: order?
+    ( masked=MASKED
+      {
+        $art.masked = this.valueWithTokenLocation( true, $masked ) ;
+        this.message( 'syntax-invalid-masked', $masked, { keyword: 'masked' },
+                      'Keyword $(KEYWORD) not supported' );
+      }
+    )?
+    // TODO: order?
     ELEMENT?
     name=ident['Element']
-    { $art = this.addDef( $outer, 'elements', 'element', $name.id, $annos,
-                          { virtual: $virtual, key: $key, masked: $masked },
-                          $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { 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
     (
@@ -1138,7 +1114,6 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
       (
         typeStruct[ $art ]
         nullability[ $art ]?
-        misplacedAnnotations[ $annos, 'syntax-anno-after-struct' ]?
         requiredSemi
       |
         typeAssociationBase[ $art, true ]
@@ -1155,11 +1130,11 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
           typeCompoStruct[ $art.target ] optionalSemi
         |
           // we do not support `Composition of many { e }` - ambiguity ad-hoc target versus foreign keys!
-          typeToMany[ $art ] typeAssociationElementCont[ $art, $annos ]
+          typeToMany[ $art ] typeAssociationElementCont[ $art ]
         |
-          typeToOne[ $art ] typeAssociationElementCont[ $art, $annos ]
+          typeToOne[ $art ] typeAssociationElementCont[ $art ]
         |
-          simplePath[ $art.target, 'artref' ] typeAssociationElementCont[ $art, $annos ]
+          simplePath[ $art.target, 'artref' ] typeAssociationElementCont[ $art ]
         )
       |
         (
@@ -1171,52 +1146,55 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
         // #ATN: typeRefOptArgs can start with TYPE
         ( typeStruct[ $art.items ]
           nullability[ $art.items ]?
-          misplacedAnnotations[ $annos, 'syntax-anno-after-struct' ]?
         | typeTypeOf[ $art.items ]
           nullability[ $art.items ]?
-          { this.docComment( $annos ); }
-          annotationAssignment_ll1[ $annos ]*
+          { this.docComment( $art ); }
+          annotationAssignment_ll1[ $art ]*
         | typeRefOptArgs[ $art.items ]
-          nullability[ $art.items ]?
-          { this.docComment( $annos ); }
-          annotationAssignment_ll1[ $annos ]*
+          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.setDictEndLocation( $art.items.enum ); }
-            misplacedAnnotations[ $annos, 'syntax-anno-after-enum' ]?
+            '}' { this.finalizeDictOrArray( $art.items.enum ); }
+            nullability[ $art.items ]?
           )?
         )
         requiredSemi                     // also req after struct/enum
       |
         typeTypeOf[ $art ] elementProperties[ $art ]?
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
         requiredSemi                     // also req after foreign key spec
       |
         l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
         typeRefOptArgs[ $art ]
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
         ( elementProperties[ $art ]
-          { this.docComment( $annos ); }
-          annotationAssignment_ll1[ $annos ]*
+          { this.docComment( $art ); }
+          annotationAssignment_ll1[ $art ]*
         )?
         requiredSemi
       |
         typeRefOptArgs[ $art ]
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
         (
           ENUM '{' { $art.enum = this.createDict(); }
           enumSymbolDef[ $art ]*
-          '}' { this.setDictEndLocation( $art.enum ); }
+          '}' { this.finalizeDictOrArray( $art.enum ); }
           elementProperties[ $art ]?
-          misplacedAnnotations[ $annos, 'syntax-anno-after-enum' ]?
         |
           elementProperties[ $art ]
-          { this.docComment( $annos ); }
-          annotationAssignment_ll1[ $annos ]*
+          { this.docComment( $art ); }
+          annotationAssignment_ll1[ $art ]*
         )?
         requiredSemi                     // also req after enum spec
       )
@@ -1229,65 +1207,45 @@ elementDefInner[ outer, loc, annos, allowEq ] returns[ art ]
         else if ($e.expr)
           $art.value = $e.expr;
       }
-      { this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]* // for enum symbol def via EXTEND
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]* // for enum symbol def via EXTEND
       requiredSemi
     )
   ;
 
-extendElement[ outer, loc, annos ] locals[ art ]
-@after{ /* #ATN 1 */ this.attachLocation($art); }
+extendElement[ art, outer ]
+@after{ /* #ATN 1 */ this.attachLocation( $art ); }
   :
     // #ATN: element name can be ELEMENT
-    expected=ELEMENT? name=ident['Element']
-    { $art = this.addDef( $outer, 'elements', 'extend', $name.id, $annos,
-                          { expectedKind: $expected && 'element' },
-                          $loc ); }
-    extendWithOptElements[ $art, $annos ]
-  ;
-
-bracedSelectItemListDef[ query ]
-  :
-    '{'
-    { if (!$query.columns) $query.columns = []; }  // set it early to avoid "wildcard" errors
-    (
-      selectItemDef[ $query.columns ]
-      ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
-        selectItemDef[ $query.columns ]
-      )*
-    )?
-    '}'
+    ( expected=ELEMENT { $art.expectedKind = 'element'; } )?
+    name=ident['Element']
+    { this.addDef( $art, $outer, 'elements', 'extend', $name.id ); }
+    extendWithOptElements[ $art, $art ]
   ;
 
-selectItemDef[ outer ] locals[ annos = [] ]
-@after{ if ($ctx.art) this.attachLocation($art.art); }
+selectItemDef[ outer ] locals[ art ]
+@after{ if ($art) this.attachLocation( $art ); }
   :
     star='*'
     { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
   |
-    { this.docComment( $annos ); }
-    annotationAssignment_atn[ $annos ]*
+    { $art = {};; this.docComment( $art ); }
+    annotationAssignment_atn[ $art ]*
     // VIRTUAL is keyword, except if before the following tokens texts:
     { this.setLocalToken( 'VIRTUAL', 'VIRTUAL', /^([,.:\[@]|as)$/i ) ; } // not '{'
-    virtual=VIRTUAL?
-    key=KEY?
-    art=selectItemDefBody[ $outer, $annos ]
-    {
-      if ($virtual) $art.art.virtual = this.valueWithTokenLocation( true, $virtual );
-      if ($key) $art.art.key = this.valueWithTokenLocation( true, $key );
-    }
+    ( virtual=VIRTUAL { $art.virtual = this.valueWithTokenLocation( true, $virtual ); } )?
+    ( key=KEY { $art.key = this.valueWithTokenLocation( true, $key ); } )?
+    selectItemDefBody[ $art, $outer ]
   ;
 
-selectItemDefBody[ outer, annos ] returns[ art = {} ]
-@after{ /* #ATN 2 */ this.attachLocation($art); }
+selectItemDefBody[ art, outer ]
+@after{ /* #ATN 2 */ }
   :
+    { $outer.push( $art ); }
     (
-      e=expression
+      e=expression { $art.value = $e.expr; }
       // 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 } );
-      }
       ( AS n1=ident['Item'] { $art.name = $n1.id }
       | n2=ident['Item'] { $art.name = this.fragileAlias( $n2.id, true ); }
       | { if (this.getCurrentToken().text !== '.') this.classifyImplicitName( 'Item', $e.expr ); }
@@ -1311,13 +1269,12 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
         )
       )?
     |
-      { $art = this.addItem( $outer, null, null, $annos ); }
       selectItemInlineList[ $art, 'expand' ]
       excludingClause[ $art ]?
       AS n1=ident['Item'] { $art.name = $n1.id }
     )
-    { this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     ( ':'
       // #ATN: typeRefOptArgs can start with TYPE, REDIRECTED
       ( re=REDIRECTED to=TO
@@ -1326,15 +1283,15 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
         (
           typeAssociationCont[ $art ]
         |
-          { this.docComment( $annos ); }
-          annotationAssignment_ll1[ $annos ]*
+          { this.docComment( $art ); }
+          annotationAssignment_ll1[ $art ]*
         )
       | typeTypeOf[ $art ]
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
-      | typeRefOptArgs[ $art ]         // TODO: annos here?
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
+      | typeRefOptArgs[ $art ]
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
       |
         typeAssociationBase[ $art, false ]
         // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
@@ -1345,28 +1302,39 @@ selectItemDefBody[ outer, annos ] returns[ art = {} ]
     )?
   ;
 
+bracedSelectItemListDef[ query ]
+  :
+    '{' { $query.columns = this.createArray(); }
+    (
+      selectItemDef[ $query.columns ]
+      ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
+        selectItemDef[ $query.columns ]
+      )*
+    )?
+    '}' { this.finalizeDictOrArray( $query.columns ); }
+  ;
+
 selectItemInlineList[ art, clause ]
   :
-    '{'
-    { $art[$clause] = []; }
+    '{' { $art[$clause] = this.createArray(); }
     (
       selectItemInlineDef[ $art[$clause] ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
         selectItemInlineDef[ $art[$clause] ]
       )*
     )?
-    '}'
+    '}' { this.finalizeDictOrArray( $art[$clause] ); }
   ;
 
-selectItemInlineDef[ outer ] locals[ annos = [] ]
-@after{ if ($ctx.art) this.attachLocation($art.art); }
+selectItemInlineDef[ outer ] locals[ art ]
+@after{ if ($art) this.attachLocation( $art ); }
   :
     star='*'
     { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
   |
-    { this.docComment( $annos ); }
-    annotationAssignment_atn[ $annos ]*
-    art=selectItemDefBody[ $outer, $annos ]
+    { $art = {};; this.docComment( $art ); }
+    annotationAssignment_atn[ $art ]*
+    selectItemDefBody[ $art, $outer ]
   ;
 
 parameterListDef[ art ]
@@ -1380,51 +1348,22 @@ parameterListDef[ art ]
         parameterDef[ $art ]
       )*
     )?
-    ')' { this.setDictEndLocation( $art.params ); }
+    ')' { this.finalizeDictOrArray( $art.params ); }
   ;
 
-parameterDef[ outer ] locals[ art, annos = [] ]
-@after { this.attachLocation($art); }
+parameterDef[ outer ] locals[ art = {} ]
+@after { this.attachLocation( $art ); }
   :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     name=ident['Param']
-    { $art = this.addDef( $outer, 'params', 'param', $name.id, $annos );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { this.addDef( $art, $outer, 'params', 'param', $name.id );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     typeSpec[ $art ]
     defaultValue[ $art ]?
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
-  ;
-
-entityParameters[ art ]
-  :
-    '(' { $art.params = this.createDict(); }
-    // also empty param list (we might do some hacking later to allow reserved words)
-    // see annotationAssignment_paren
-    (
-      entityParameterDef[ $art ]
-      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        entityParameterDef[ $art ]
-      )*
-    )?
-    ')' { this.setDictEndLocation( $art.params ); }
-  ;
-
-entityParameterDef[ outer ] locals[ art, annos = [] ]
-@after { this.attachLocation($art); }
-  :
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
-    name=ident['Param']
-    { $art = this.addDef( $outer, 'params', 'param', $name.id, $annos );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
-    typeSpec[ $art ]
-    defaultValue[ $art ]?
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
   ;
 
 nullability[ art ]
@@ -1451,21 +1390,25 @@ elementProperties[ elem ]
 
 // View definitions ----------------------------------------------------------
 
-viewDef[ outer, loc, annos ] locals[ art, name = {} ]
-@after { this.attachLocation($art); }
+viewDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
     v=VIEW simplePath[ $name, 'Entity' ]
-    { $art = this.addDef( $outer, 'artifacts', 'entity', $name, $annos, { ['$'+'syntax']: 'view' }, $loc );
-      this.docComment( $annos ); }
-    annotationAssignment_fix[ $annos ]*
+    { $art['$'+'syntax'] = 'view';
+      this.addDef( $art, $outer, 'artifacts', 'entity', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     (
-      entityParameters[ $art ]
+      parameterListDef[ $art ]
     |
-      ( HideAlternatives | WITH ) PARAMETERS
-      entityParameterDef[ $art ]
-      ( ',' entityParameterDef[ $art ] )* // no optional final ',' here
+      // TODO: warning deprecated?
+      ( HideAlternatives | WITH ) { $art.params = this.createDict(); }
+      PARAMETERS
+      parameterDef[ $art ]
+      ( ',' parameterDef[ $art ] )* // no optional final ',' here
+      { this.finalizeDictOrArray( $art.params ); }
     )?
-    AS qe=queryExpression { $art.query = $qe.query; } // beta-mode test now in definer
+    AS qe=queryExpression { $art.query = $qe.query; }
     // TODO check ANTLR: bad msg with 'view V as'<eof> but 'view V as FOO' is fine
     requiredSemi
   ;
@@ -1496,12 +1439,12 @@ typeSpec[ art ]                 // for params
       (
         ENUM '{' { $art.enum = this.createDict(); }
         enumSymbolDef[ $art ]*
-        '}' { this.setDictEndLocation( $art.enum ); }
+        '}' { this.finalizeDictOrArray( $art.enum ); }
       )?
     )
   ;
 
-returnTypeSpec[ art, annos ]
+returnTypeSpec[ art ]
 @after{ /* #ATN 1 */ }
   :
     ret=RETURNS { $art.returns = { location: this.tokenLocation( $ret ), kind: 'param' }; }
@@ -1517,17 +1460,15 @@ returnTypeSpec[ art, annos ]
       (
         ENUM '{' { $art.returns.enum = this.createDict(); }
         enumSymbolDef[ $art.returns ]*
-        '}' { this.setDictEndLocation( $art.returns.enum ); }
-      |
-        misplacedAnnotations[ $annos, 'syntax-anno-after-params' ]
+        '}' { this.finalizeDictOrArray( $art.returns.enum ); }
       )?
     )
 
-    requiredSemi // currently for all - might change if we get rid of the misplaced annos
+    requiredSemi // currently for all - might change if we get rid of the misplaced annos (TODO: Now removed)
   ;
 
 
-typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
+typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
 @after{ /* #ATN 3 */ }
   :
     typeStruct[ $art ]
@@ -1565,18 +1506,28 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
         optionalSemi
       | typeTypeOf[ $art.items ]
         nullability[ $art.items ]?
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
         requiredSemi
       | typeRefOptArgs[ $art.items ]
-        nullability[ $art.items ]?
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
+        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.setDictEndLocation( $art.items.enum ); }
-          optionalSemi
+          '}' { this.finalizeDictOrArray( $art.items.enum ); }
+          (
+            nullability[ $art.items ]
+            requiredSemi
+          |
+            optionalSemi
+          )
         |
           requiredSemi
         )
@@ -1584,64 +1535,32 @@ typeSpecSemi[ art, annos ]      // with 'includes', for type and annotation defs
     |
       typeTypeOf[ $art ]
       defaultValue[ $art ]?
-      { this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]* requiredSemi
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]* requiredSemi
     |
       l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
       typeRefOptArgs[ $art ]
       defaultValue[ $art ]?
-      { this.docComment( $annos ); }
-      annotationAssignment_ll1[ $annos ]*
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
       requiredSemi
     |
       // alt lookahead includes MANY '{'
       { $art.type = {}; }
+      // Can't use typeRefOptArgs because of clash with include rule below (ATN would change)
       simplePath[ $art.type, 'artref' ]
       (
-        typeRefArgs[ $art ]
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
-        (
-          ENUM '{' { $art.enum = this.createDict(); }
-          enumSymbolDef[ $art ]*
-          '}' { this.setDictEndLocation( $art.enum ); }
-          (
-            optionalSemi
-          |
-            defaultValue[ $art ]
-            requiredSemi
-          )
-        |
-          defaultValue[ $art ]?
-          requiredSemi
-        )
-      |
-        ':' // with element, e.g. `type T : E:elem enum { ... }`
-        { $art.type.scope = $art.type.path.length; }
-        simplePath[ $art.type, 'ref']
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
-        (
-          ENUM '{' { $art.enum = this.createDict(); }
-          enumSymbolDef[ $art ]*
-          '}' { this.setDictEndLocation( $art.enum ); }
-          (
-            optionalSemi
-          |
-            defaultValue[ $art ]
-            requiredSemi
-          )
-        |
-          defaultValue[ $art ]?
-          requiredSemi
-        )
-      |
-        { this.docComment( $annos ); }
-        annotationAssignment_ll1[ $annos ]*
+        ( typeRefArgs[ $art ]
+        | ':' // with element, e.g. `type T : E:elem enum { ... }`
+          { $art.type.scope = $art.type.path.length; }
+          simplePath[ $art.type, 'ref']
+        )?
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
         (
           ENUM '{' { $art.enum = this.createDict(); }
           enumSymbolDef[ $art ]*
-          '}' { this.setDictEndLocation( $art.enum ); }
+          '}' { this.finalizeDictOrArray( $art.enum ); }
           (
             optionalSemi
           |
@@ -1669,7 +1588,7 @@ typeStruct[ art, attachLoc = false ]
   :
     '{' { $art.elements = this.createDict(); }
     elementDef[ $art ]*
-    '}' { this.setDictEndLocation( $art.elements ); }
+    '}' { this.finalizeDictOrArray( $art.elements ); }
   ;
 
 typeCompoStruct[ art ]
@@ -1677,7 +1596,7 @@ typeCompoStruct[ art ]
   :
     COMPOSITIONofBRACE { $art.elements = this.createDict(); }
     elementDef[ $art ]*
-    '}' { this.setDictEndLocation( $art.elements ); }
+    '}' { this.finalizeDictOrArray( $art.elements ); }
   ;
 
 typeArray[ art ]
@@ -1699,7 +1618,7 @@ typeArray[ art ]
       (
         ENUM '{' { $art.items.enum = this.createDict(); }
         enumSymbolDef[ $art.items ]*
-        '}' { this.setDictEndLocation( $art.items.enum ); }
+        '}' { this.finalizeDictOrArray( $art.items.enum ); }
       )?
     )
   ;
@@ -1728,33 +1647,31 @@ typeAssociationCont[ art ]
   :
     (
       '{' { $art.foreignKeys = this.createDict(); }
-      { this.addDef( $art, 'foreignKeys' ); }
       (
         foreignKey[ $art ]
         ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
           foreignKey[ $art ]
         )*
       )?
-      '}' { this.setDictEndLocation( $art.foreignKeys ); }
+      '}' { this.finalizeDictOrArray( $art.foreignKeys ); }
     |
       ON cond=condition
       { $art.on=$cond.cond; }
     )
   ;
 
-typeAssociationElementCont[ art, annos ] // including Composition
+typeAssociationElementCont[ art ] // including Composition
 // optional NULL / NOT NULL for managed association only
   :
     (
       '{' { $art.foreignKeys = this.createDict(); }
-      { this.addDef( $art, 'foreignKeys' ); }
       (
         foreignKey[ $art ]
         ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
           foreignKey[ $art ]
         )*
       )?
-      '}' { this.setDictEndLocation( $art.foreignKeys ); }
+      '}' { this.finalizeDictOrArray( $art.foreignKeys ); }
       nullability[ $art ]?
     |
       ON cond=condition
@@ -1762,8 +1679,8 @@ typeAssociationElementCont[ art, annos ] // including Composition
     |
       nullability[ $art ]
     )?
-    { this.docComment( $annos ); }
-    annotationAssignment_ll1[ $annos ]*
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     requiredSemi                     // also req after foreign key spec
   ;
 
@@ -1817,10 +1734,9 @@ cardinality[ art ] locals[ card = {} ]
 foreignKey[ outer ] locals[ art = {}, elem = {} ]
 @after { this.attachLocation($art); }
   :
-    simplePath[ $elem, 'ref' ]
+    simplePath[ $elem, 'ref' ] { $art.targetElement = $elem; }
     ( AS name=ident['Key'] )?
-    { $art = this.addDef( $outer, 'foreignKeys', 'key', ($ctx.name) ? $name.id : $elem.path,
-                          undefined, { targetElement: $elem } ); }
+    { this.addDef( $art, $outer, 'foreignKeys', 'key', ($ctx.name) ? $name.id : $elem.path ); }
   ;
 
 typeTypeOf[ art ] locals[ _sync = 'nop' ]
@@ -1852,11 +1768,11 @@ typeRefOptArgs[ art ]
 
 typeRefArgs[ art ]
   :
-    paren='('
+    paren='(' { $art['$'+'typeArgs'] = this.createArray(); }
     (
       // unnamed arguments
       head=Number
-      { $art['$'+'typeArgs'] = [ this.numberLiteral( $head ) ]; }
+      { $art['$'+'typeArgs'].push( this.numberLiteral( $head ) ); }
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
         (
           v=VARIABLE
@@ -1880,14 +1796,14 @@ typeRefArgs[ art ]
         typeNamedArg[ $art ]
       )*
     )
-    ')'
+    ')'{ this.finalizeDictOrArray( $art['$'+'typeArgs']); }
   ;
 
 typeNamedArg[ art ] locals[ arg = '' ]
   :
     name=ident['paramname']
     ':'
-    { if (this.checkTypeFacet( $art, $name.id ))
+    { if ($name.id && this.checkTypeFacet( $art, $name.id ))
         $arg = $name.id.id;
     }
     (
@@ -1924,10 +1840,10 @@ queryExpression returns[ query ] // QLSubqueryComplex, SubqueryComplex
       | op=MINUS  q=DISTINCT?
       )
       qt=queryTerm
-      { $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
+      { if ($qt.query) $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
     )*
-    ( ob=orderByClause[ $query ] { $query = $ob.query; } ) ?
-    ( lc=limitClause[ $query ]   { $query = $lc.query; } ) ?
+    ( ob=orderByClause[ $query ] { if ($ob.query) $query = $ob.query; } ) ?
+    ( lc=limitClause[ $query ]   { if ($lc.query) $query = $lc.query; } ) ?
   ;
 
 orderByClause[ inQuery ] returns [ query ]
@@ -2026,7 +1942,7 @@ overClause returns [ over ]
 @after { this.attachLocation( $over ); }
   :
     o=OVER { $over = { op: this.valueWithTokenLocation( 'over', $o ) , args: []  } }
-    '('
+    '('                         // TODO: check whether an extra location could be useful
       ( pb=partitionByClause { $over.args.push( $pb.expr ); } )?
       ( ob=overOrderByClause { $over.args.push( $ob.expr ); } )?
       ( wf=windowFrameClause { $over.args.push( $wf.wf ); } )?
@@ -2079,13 +1995,13 @@ queryPrimary returns[ query = {} ]
       (
         mixin=MIXIN '{' { $query.mixin = this.createDict(); }
         mixinElementDef[ $query ]*
-        '}' { this.setDictEndLocation( $query.mixin ); }
+        '}' { this.finalizeDictOrArray( $query.mixin ); }
         INTO
       )?
       ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
       { $query.quantifier = this.valueWithTokenLocation( $ad.text.toLowerCase(), $ad ); }
       )?
-      bracedSelectItemListDef[ $query ]?
+      bracedSelectItemListDef[ $query, 'columns' ]?
       excludingClause[ $query ]?
     |
       ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
@@ -2131,7 +2047,7 @@ tableExpression returns[ table ] // TableOrJoin
       ON cond=condition { $table.on = $cond.cond; }
     |
       crj=CROSS jn=JOIN tt=tableTerm
-      { $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
+      { if (!$table) { $table = {}; } $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
     )*
   ;
 
@@ -2313,9 +2229,11 @@ conditionTerm returns [ cond ]
     |
       { $cond = { args: [ $expr.expr ] }; }
       NOT predicate[ $cond, true ]
+      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
     |
       { $cond = { args: [ $expr.expr ] }; }
       predicate[ $cond, false ]
+      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
     )?                          // optional: for conditions in parentheses
   ;
 
@@ -2429,7 +2347,9 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
         }
       )
     |
-      qm=( HideAlternatives | '?' )
+      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)
       { $expr = { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' };
         this.csnParseOnly( 'Dynamic parameter "?" is not supported', $qm );
       }
@@ -2457,39 +2377,12 @@ expressionTerm returns [ expr ] locals [ op, args = [] ]
   ;
 
 specialFunction returns [ ret = { } ] locals[ art = {} ]
-@after{ /* #ATN 1 */ }
   :
-    fun=TRIM open='('
-    { $ret = this.functionAst( $fun, $open ); }
-    // #ATN: we do not want to reserve these three optional keywords
-    (
-      t=( LEADING | TRAILING | BOTH ) { $ret.args[0].args.push( $t.text ); }
-      ( e=expression { $ret.args[0].args.push( $e.expr ); } )?
-      t=FROM e=expression { $ret.args[0].args.push( $t.text, $e.expr ); }
-    |
-      e=expression
-      (
-        { $ret.args[0].args.push( $e.expr ); }
-        t=FROM e=expression
-        { $ret.args[0].args.push( $t.text, $e.expr ); }
-      |
-        { $ret.args[0] = $e.expr; }
-      )
-    )
-    ')'
-  |
-    fun=EXTRACT open='('
-    { $ret = this.functionAst( $fun, $open ); }
-    t=( YEAR | MONTH | DAY | HOUR | MINUTE | SECOND )
-    f=FROM e=expression
-    { $ret.args[0].args.push( $t.text, $f.text, $e.expr ); }
-    ')'
-  |
-    ca=CAST open='('
+    ca=CAST '('                 // see createArray() in action
     {
       $ret = {
         op: this.valueWithTokenLocation( 'cast', $ca ),
-        args: [ ],
+        args: this.createArray(),
         location: this.tokenLocation( $ca )
       };
     }
@@ -2497,8 +2390,7 @@ specialFunction returns [ ret = { } ] locals[ art = {} ]
     {
       $ret.args.push( $e.expr );
     }
-    ')'
-    // TODO: ROUND - see also resolver.js
+    ')' { this.finalizeDictOrArray( $ret.args ); }
   ;
 
 // query path includes aggregation:
@@ -2524,36 +2416,52 @@ valuePath[ category, location = null ] returns[ qp = { path: [] } ] locals[ _syn
   ;
 
 fromArguments[ pathStep ]
+@init{ if (!$pathStep) $pathStep = {}; } // grammar robustness, see test/negative/parser/NamedExpression.cds
   :
-    paren='('
-    namedExpression[ $pathStep ]
+    '(' { $pathStep.args = this.createDict(); $pathStep['$'+'syntax'] = ':'; } // necessary?
+    name=ident['paramname'] ':'
+    namedExpression[ $pathStep, $name.id ]
     ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-      namedExpression[ $pathStep ]
+      name=ident['paramname'] ':'
+      namedExpression[ $pathStep, $name.id ]
     )*
-    ')'
+    ')' { this.finalizeDictOrArray( $pathStep.args ); }
   ;
 
 pathArguments[ pathStep, considerSpecial ]
-@after{ /* #ATN 1 */ }
+@init{
+  if (!$pathStep) $pathStep = {}; // grammar robustness, see test/negative/parser/NamedExpression.cds
+  this.genericFunctionsStack.push( this['$'+'genericKeywords'] );
+}
   :
     { this.excludeExpected([ 'ORDER' ]); }
-    paren='('
-    { this.prepareGenericKeywords( $considerSpecial ); }
-    // ATN, LL2: Identifier can start both named arguments and the positional.
+    '('                         // dict or array, see below
     // Make sure that we do not introduce A:B paths in expressions!
-    (
-      namedExpression[ $pathStep ]
+    // Need to avoid adaptPredict(), otherwise Generic keywords won't work in funcExpression
+    //
+    // 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' } ))
+        this.prepareGenericKeywords( $considerSpecial ); }
+    (
+      { $pathStep.args = this.createDict(); $pathStep['$'+'syntax'] = ':'; }
+      id=HelperToken1 ':'
+      namedExpression[ $pathStep, this.identAst( $id, 'paramname', true ) ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        namedExpression[ $pathStep ]
+        name=ident['paramname'] ':'
+        namedExpression[ $pathStep, $name.id ]
       )*
     |
-      { $pathStep.args = Object.create(null); }  // TODO: XSN func path cleanup
-      arrowedExpression[ $pathStep ]
+      { $pathStep.args = this.createDict(); }  // TODO: XSN func path cleanup
+      id=HelperToken2 '=>'
+      namedExpression[ $pathStep, this.identAst( $id, 'paramname', true ) ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        arrowedExpression[ $pathStep ]
+        name=ident['paramname'] '=>'
+        namedExpression[ $pathStep, $name.id ]
       )*
     |
-      { $pathStep.args = []; }
+      { $pathStep.args = this.createArray(); }
       funcExpression[ $pathStep, $considerSpecial ]
       ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
         funcExpression[ $pathStep, $considerSpecial ]
@@ -2566,47 +2474,82 @@ pathArguments[ pathStep, considerSpecial ]
         }
       )?
     |
-      a=ALL { $pathStep.quantifier = this.valueWithTokenLocation( 'all', $a ); }
-      e1=expression { $pathStep.args = [ $e1.expr ]; }
-    |
-      d=DISTINCT { $pathStep.quantifier = this.valueWithTokenLocation( 'distinct', $d ); }
-      e1=expression { $pathStep.args = [ $e1.expr ]; }
-      ( ',' e2=expression { $pathStep.args.push( $e2.expr ); } )*
-    |
-      star='*'
-      { $pathStep.args = [ { location: this.tokenLocation( $star ), val: '*', literal: 'token' } ]; }
-    |
-      { $pathStep.args = []; }
+      { $pathStep.args = this.createArray(); }
     )
-    ')'
+    ')' { this.finalizeDictOrArray( $pathStep.args ); }
   ;
+  finally {                     // see @init
+    if (!$pathStep.args) $pathStep.args = [];
+    this['$'+'genericKeywords'] = this.genericFunctionsStack.pop();
+  }
 
-namedExpression[ pathStep ]
+namedExpression[ pathStep, id ]
   :
-    name=ident['paramname'] ':' elem=expression
-    { if ($pathStep && $name.id) {
-        this.addDef( $pathStep, 'args', 0, $name.id, true,
-                     ($ctx.elem) ? $elem.expr : { location: $name.id.location } );
-        $pathStep['$'+'syntax'] = ':';
+    elem=expression
+    { if ($pathStep && $id) {
+      this.addDef( ($ctx.elem) ? $elem.expr : { location: $id.location },
+                   $pathStep, 'args', 0, $id );
       }
     }
   ;
 
-arrowedExpression[ pathStep ]
-  :
-    name=ident['paramname'] a='=>' elem=expression
-    { if ($name.id) this.addDef( $pathStep, 'args', 0, $name.id, true,
-                                 ($ctx.elem) ? $elem.expr : { location: $name.id.location } ); }
-  ;
-
-funcExpression[ pathStep, considerSpecial ]
+funcExpression[ pathStep, considerSpecial ] locals[ args ]
 @init { this.prepareGenericKeywords( $considerSpecial ); }
   :
-    only=GenericArgFull
-    { $pathStep.args.push( { location: this.tokenLocation($only), val: $only.text, literal: 'token' } ); }
-  |
-    expr=expression
-    { $pathStep.args.push( $expr.expr ); }
+    (
+      expr=expression
+      { $pathStep.args.push( $expr.expr ); }
+    |
+      GenericExpr       // keyword as replacement for expression, like '*'
+      { $pathStep.args.push( this.xprToken() ); }
+    |
+      GenericIntro      // keyword as introduction of expression, like DISTINCT
+      { $pathStep.args.push( this.xprToken() ); }
+      expr=expression
+      { $args = this.setLastAsXpr( $pathStep.args );
+        $args.push( $expr.expr ); }
+    |
+      // Rule 'pathArguments' makes a decision based on the first two lookahead
+      // tokens of this rule → we need to list tokens which would be changed to
+      // GenericExpr or GenericIntro, and are not already covered by 'expression'
+      { this.reportErrorForGenericKeyword(); }
+      ( HideAlternatives | '*' | ALL | DISTINCT )
+      // now continue parsing like GenericExpr:
+      { $pathStep.args.push( this.xprToken() ); }
+    )
+    (
+      { if (!$args) $args = this.setLastAsXpr( $pathStep.args ); }
+      (
+        { this.prepareGenericKeywords( $considerSpecial, 'separator' ); }
+        (
+           GenericSeparator
+        |
+          // For ANTLR's lookahead calculations, we need to list tokens here
+          // which could be changed to GenericSeparator.  Do not invent a
+          // keyword token which is just used here (Identifier does work
+          // perfectly)!  If we want, we could add all non-reserved keywords
+          // except ORDER, and most reserved.
+          { this.reportErrorForGenericKeyword(); }
+          ( HideAlternatives | Identifier | FROM | IN | WITH | GROUP )
+        )
+        { $args.push( this.xprToken() );
+          this.prepareGenericKeywords( $considerSpecial, 'expr' );
+        }
+        (
+          expr=expression
+          { $args.push( $expr.expr ); }
+        |
+          GenericExpr
+          { $args.push( this.xprToken() ); }
+        |
+          { this.reportErrorForGenericKeyword(); }
+          // Again, we need to list tokens which could make it to GenericExpr
+          // and which do not start an expression
+          ( HideAlternatives | ALL )
+          { $args.push( this.xprToken() ); }
+        )
+      )+
+    )?
   ;
 
 cardinalityAndFilter[ pathStep ] locals [ _sync = 'nop' ]
@@ -2648,32 +2591,41 @@ optionalWhereForFilter
 
 // Simple paths and values ---------------------------------------------------
 
-annoValueBase returns[ val ] locals [ seenEllipsis = false ]
-@after { this.attachLocation($val); }
+annoValue[ assignment ]
   :
-    { $val = { literal: 'struct', location: this.startLocation() }; }
-    '{'
-    { this.meltKeywordToIdentifier(); }
-    namedValue[ $val ]
+    base=annoValueBase[ $assignment ]
+  |
+    // no docComment() here
+    // this alternative is done with token rewrite in rule "annotationAssignment_atn"
+    at='@'? annotationPath[ $assignment, 'ref', $at ]
+    annotationPathVariant[ $assignment ]?
+  ;
+
+annoValueBase[ assignment ] locals [ seenEllipsis = false ]
+@after { this.attachLocation( $assignment ); }
+  :
+    '{'                         // no location here, we flatten
+    { $assignment['$'+'flatten'] = []; this.meltKeywordToIdentifier(); }
+    flattenedValue[ $assignment ]
     (
       ',' {
         this.meltKeywordToIdentifier();
         if (this.isStraightBefore("}")) break; // allow ',' before ')'
       }
-      namedValue[ $val ]
+      flattenedValue[ $assignment ]
     )*
     '}'
   |
-    { $val = { literal: 'array', location: this.startLocation(), val: [] }; }
-    '['
+    '['                 // no need for createArray() here, $assignment.location is set
+    { $assignment.val = []; $assignment.literal = 'array'; }
     (
       (
-        head=arrayValue  { $val.val.push( $head.val ); }
+        head=annoSubValue  { $assignment.val.push( $head.val ); }
       |
-        e='...' ( UP TO upTo=arrayValue )?
+        e='...' ( UP TO upTo=annoSubValue )?
         {{
           const item = { literal: 'token', val: '...', location: this.tokenLocation($e) };
-          $val.val.push( item );
+          $assignment.val.push( item );
           if ($ctx.upTo) item.upTo = $upTo.val;
           $seenEllipsis = !$ctx.upTo || 'upTo';
         }}
@@ -2681,17 +2633,16 @@ annoValueBase returns[ val ] locals [ seenEllipsis = false ]
       (
         ',' { if (this.isStraightBefore(']')) break; } // allow ',' before ']'
         (
-          tail=arrayValue { $val.val.push( $tail.val ); }
+          tail=annoSubValue { $assignment.val.push( $tail.val ); }
         |
           { $ctx.upTo = null; } // is not reset
-          e='...' ( UP TO upTo=arrayValue )?
+          e='...' ( UP TO upTo=annoSubValue )?
           {{
             const item = { literal: 'token', val: '...', location: this.tokenLocation($e) };
             if ($ctx.upTo) item.upTo = $upTo.val;
-            $val.val.push( item );
+            $assignment.val.push( item );
             if ($seenEllipsis === true) // TODO: adapt msg to UP TO
-              this.error( 'syntax-unexpected-ellipsis', $e, { code: '...' },
-                          'Expected no more than one $(CODE)' );
+              this.error( 'syntax-unexpected-ellipsis', $e, { '#': 'std', code: '...' } );
             else
               $seenEllipsis = !$ctx.upTo || 'upTo';
           }}
@@ -2706,80 +2657,65 @@ annoValueBase returns[ val ] locals [ seenEllipsis = false ]
                    'Expecting an array item $(NEWCODE) after an item with $(CODE)' );
     }
   |
-    v1=literalValue { $val = $v1.val; }
+    v1=literalValue { Object.assign( $assignment, $v1.val ); }
   |
     ( plus='+' | min='-' ) num=Number
-    { $val = this.numberLiteral( $num, $plus||$min ); }
+    {  Object.assign( $assignment, this.numberLiteral( $num, $plus||$min ) ); }
   ;
 
-annoValue returns[ val ]
+flattenedValue[ assignment ] locals[ val = { name: {} } ]
   :
-    base=annoValueBase { $val = $base.val }
-  |
-    { $val = {}; }              // TODO: think about expression value representation
-    at='@'? annotationPath[ $val, 'ref', $at ]
-    annotationPathVariant[ $val ]?
-  ;
-
-namedValue[ struct ] locals[ namedVal = { name: {} } ]
-  :
-    at='@'? annotationPath[ $namedVal.name, 'name', $at ]
-    (
-      '#' { this.meltKeywordToIdentifier(); }
-      variant=ident['variant'] { $namedVal.name.variant = $variant.id; }
-    )?
+    at='@'? annotationPath[ $val.name, 'name', $at ]
+    ( annotationPathVariant[ $val.name ] )?
     (
       ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
-      elem=annoValue
+      annoValue[ $val ]
     )?
-    { this.addItem( $struct, '_struct', null, true, // TODO: re-check _struct
-                    ($ctx.elem) ? Object.assign($namedVal, $elem.val) : $namedVal ); }
+    { $assignment['$'+'flatten'].push( $val ); }
   ;
 
-arrayValue returns[ val ]
+namedValue[ struct ] locals[ val = { name: {} } ]
+  :
+    at='@'? annotationPath[ $val.name, 'name', $at ]
+    ( ':' sub=annoSubValue { Object.assign( $val, $sub.val ); } )?
+    {
+      if (!$val.location) $val.location = $val.name.location;
+      this.addDef( $val, $struct, 'struct', null, $val.name ); // TODO: re-check name
+    }
+  ;
+
+annoSubValue returns[ val = {} ]
 @after { this.attachLocation($val); }
   :
-    { $val = { literal: 'struct', location: this.startLocation() }; }
-    '{'
+    '{'                         // no need for createDict() here, $val.location is set
+    { $val.struct = Object.create(null); $val.literal = 'struct'; }
     { this.meltKeywordToIdentifier(); }
-    namedValueInArray[ $val ]
+    namedValue[ $val ]
     ( ','
       {
         this.meltKeywordToIdentifier();
         if (this.isStraightBefore("}")) break; // allow ',' before '}'
       }
-      namedValueInArray[ $val ]
+      namedValue[ $val ]
     )*
     '}'
   |
-    { $val = { literal: 'array', location: this.startLocation(), val: [] }; }
-    '['
-    ( head=arrayValue { $val.val.push( $head.val ); }
+    '['                 // no need for createArray() here, $val.location is set
+    { $val.val = []; $val.literal = 'array'; }
+    ( head=annoSubValue { $val.val.push( $head.val ); }
       ( ',' { if (this.isStraightBefore(']')) break; } // allow ',' before ']'
-        tail=arrayValue { $val.val.push( $tail.val ); }
+        tail=annoSubValue { $val.val.push( $tail.val ); }
       )*
     )?
     ']'
   |
-    v1=literalValue { $val = $v1.val; }
+    v1=literalValue { Object.assign( $val, $v1.val ); }
   |
     ( plus='+' | min='-' ) num=Number
-    { $val = this.numberLiteral( $num, $plus||$min ); }
+    { Object.assign( $val, this.numberLiteral( $num, $plus||$min ) ); }
   |
-    { $val = {}; }              // TODO: think about expression value representation
     at='@'? annotationPath[ $val, 'ref', $at ]
-    (
-      '#' { this.meltKeywordToIdentifier(); }
-      variant=ident['variant'] { $val.variant = $variant.id; }
-    )?
-  ;
-
-namedValueInArray[ struct ] locals[ name = {} ]
-  :
-    at='@'? annotationPath[ $name, 'name', $at ]
-    ( ':' elem=arrayValue )?
-    { this.addDef( $struct, 'struct', null, $name, true,
-                   ($ctx.elem) ? $elem.val : { location: $name.location } ); }
+    ( annotationPathVariant[ $val ] )?
   ;
 
 literalValue returns[ val ] locals[ tok ]
@@ -2837,12 +2773,12 @@ annotationPath[ art, category, headat = null ] locals[ _sync = 'nop' ]
     )*
   ;
 
-annotationPathVariant[ art ]
+annotationPathVariant[ art ] locals[ variant = {} ]
 @after { this.attachLocation($art); }
   :
-    // TODO: warning for space before and after '#'
+    // TODO: warning for space after '#'
     '#' { this.meltKeywordToIdentifier(); }
-    variant=ident['variant'] { $art.variant = $variant.id; }
+    simplePath[ $variant, 'variant' ] { $art.variant = $variant; }
   ;
 
 // Identifier and non-reserved keywords --------------------------------------
@@ -2871,13 +2807,11 @@ ident[ category ] returns[ id ]
   | ASPECT
   | ASSOCIATION
   | BETWEEN
-  | BOTH
   | COLUMNS
   | COMPOSITION
   | CONTEXT
   | CROSS
   | CURRENT
-  | DAY
   | DEFAULT
   | DEFINE
   | DEFINITIONS
@@ -2901,14 +2835,12 @@ ident[ category ] returns[ id ]
   | FUNCTION
   | GROUP
   | HAVING
-  | HOUR
   | INNER
   | INTERSECT
   | INTO
   | IS
   | JOIN
   | LAST
-  | LEADING
   | LEFT
   | LIKE
   | LIMIT
@@ -2916,9 +2848,7 @@ ident[ category ] returns[ id ]
   | MANY
   | MASKED
   | MINUS
-  | MINUTE
   | MIXIN
-  | MONTH
   | NAMESPACE
   | NULLS
   | OFFSET
@@ -2935,10 +2865,8 @@ ident[ category ] returns[ id ]
   | RIGHT
   | ROW
   | ROWS
-  | SECOND
   | SERVICE
   | THEN
-  | TRAILING
   | UNION
   | UP
   | TO
@@ -2947,7 +2875,6 @@ ident[ category ] returns[ id ]
   | UNBOUNDED
   | VARIABLE
   | VIEW
-  | YEAR
   ;
 
 //----------------------------------------------------------------------------
@@ -3039,7 +2966,6 @@ CASE : [cC][aA][sS][eE] ;
 CAST : [cC][aA][sS][tT] ;
 DISTINCT : [dD][iI][sS][tT][iI][nN][cC][tT] ;
 EXISTS : [eE][xX][iI][sS][tT][sS] ;
-EXTRACT : [eE][xX][tT][rR][aA][cC][tT] ;
 // FALSE: see Boolean
 FROM : [fF][rR][oO][mM] ;
 IN : [iI][nN] ;
@@ -3052,7 +2978,6 @@ ON : [oO][nN] ;
 SELECT : [sS][eE][lL][eE][cC][tT] ;
 SOME : [sS][oO][mM][eE] ;
 WHEN : [wW][hH][eE][nN] ;
-TRIM : [tT][rR][iI][mM] ;
 // TRUE: see Boolean
 WHERE : [wW][hH][eE][rR][eE] ;
 WITH : [wW][iI][tT][hH] ;
@@ -3066,6 +2991,7 @@ Number                          // DO NOT RENAME OR MOVE THIS RULE !!!
   ;
 
 // Unreserved keywords (are case-insensitive): -------------------------------
+// Do not add keywords just for specialFunctions!
 
 ABSTRACT : [aA][bB][sS][tT][rR][aA][cC][tT] ;
 ACTION : [aA][cC][tT][iI][oO][nN] ;
@@ -3078,13 +3004,11 @@ ASC : [aA][sS][cC] ;
 ASPECT : [aA][sS][pP][eE][cC][tT] ;
 ASSOCIATION : [aA][sS][sS][oO][cC][iI][aA][tT][iI][oO][nN] ;
 BETWEEN : [bB][eE][tT][wW][eE][eE][nN] ;
-BOTH : [bB][oO][tT][hH] ;
 COLUMNS : [cC][oO][lL][uU][mM][nN][sS];
 COMPOSITION : [cC][oO][mM][pP][oO][sS][iI][tT][iI][oO][nN] ;
 CONTEXT : [cC][oO][nN][tT][eE][xX][tT] ;
 CROSS : [cC][rR][oO][sS][sS] ;
 CURRENT : [cC][uU][rR][rR][eE][nN][tT] ;
-DAY : [dD][aA][yY] ;
 DEFAULT : [dD][eE][fF][aA][uU][lL][tT] ;
 DEFINE : [dD][eE][fF][iI][nN][eE] ;
 DEFINITIONS : [dD][eE][fF][iI][nN][iI][tT][iI][oO][nN][sS] ;
@@ -3108,14 +3032,12 @@ FULL : [fF][uU][lL][lL] ;
 FUNCTION : [fF][uU][nN][cC][tT][iI][oO][nN] ;
 GROUP : [gG][rR][oO][uU][pP] ;
 HAVING : [hH][aA][vV][iI][nN][gG] ;
-HOUR : [hH][oO][uU][rR] ;
 INNER : [iI][nN][nN][eE][rR] ;
 INTERSECT : [iI][nN][tT][eE][rR][sS][eE][cC][tT] ;
 INTO : [iI][nN][tT][oO] ;
 IS : [iI][sS] ;
 JOIN : [jJ][oO][iI][nN] ;
 LAST : [lL][aA][sS][tT] ;
-LEADING : [lL][eE][aA][dD][iI][nN][gG] ;
 LEFT : [lL][eE][fF][tT] ;
 LIKE : [lL][iI][kK][eE] ;
 LIMIT : [lL][iI][mM][iI][tT] ;
@@ -3123,9 +3045,7 @@ LOCALIZED: [lL][oO][cC][aA][lL][iI][zZ][eE][dD];
 MANY : [mM][aA][nN][yY] ;
 MASKED : [mM][aA][sS][kK][eE][dD] ;
 MINUS : [mM][iI][nN][uU][sS] ;
-MINUTE : [mM][iI][nN][uU][tT][eE] ;
 MIXIN : [mM][iI][xX][iI][nN] ;
-MONTH : [mM][oO][nN][tT][hH] ;
 NAMESPACE : [nN][aA][mM][eE][sS][pP][aA][cC][eE] ;
 NULLS : [nN][uU][lL][lL][sS] ;
 OFFSET : [oO][fF][fF][sS][eE][tT] ;
@@ -3143,10 +3063,8 @@ RETURNS : [rR][eE][tT][uU][rR][nN][sS] ;
 RIGHT : [rR][iI][gG][hH][tT] ;
 ROW : [rR][oO][wW] ;
 ROWS : [rR][oO][wW][sS] ;
-SECOND : [sS][eE][cC][oO][nN][dD] ;
 SERVICE : [sS][eE][rR][vV][iI][cC][eE] ;
 THEN : [tT][hH][eE][nN] ;
-TRAILING : [tT][rR][aA][iI][lL][iI][nN][gG] ;
 TO : [tT][oO] ;                 // or make reserved? (is in SQL-92)
 TYPE : [tT][yY][pP][eE] ;
 UNION : [uU][nN][iI][oO][nN] ;
@@ -3156,7 +3074,6 @@ 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] ;
 
 // Identifiers, must BE LAST, DIRECTLY AFTER the unreserved keywords ---------