@sap/cds-compiler 3.4.2 → 3.5.0

package/lib/language/language.g4

@@ -120,6 +120,8 @@ options {
   superClass = genericAntlrParser;
 }
 tokens {
+  ELEMENT,                      // used with setLocalToken()
+  MASKED,                       // used with setLocalToken()
   VIRTUAL,                      // used with setLocalToken()
   OVER,                         // used with setLocalTokenIfBefore()
   HelperToken1,                 // used with setLocalToken(), does not appear in messages
@@ -132,6 +134,20 @@ tokens {
   COMPOSITIONofBRACE            // via token rewrite in rule typeAssociationBase
 }
 
+// Content:
+//  - top-level: USING, NAMESPACE, artifactDefOrExtend (start rule: start)
+//  - main definitions and annotation def
+//  - member definitions
+//  - EXTEND and ANNOTATE
+//  - type expressions
+//  - queries: the main query hierarchy (start rule: queryEOF)
+//  - queries: columns and other clauses
+//  - conditions and expressions (start rule: conditionEOF)
+//  - paths and functions
+//  - annotation assignments
+//  - literal values and identifiers
+//  - Lexer: spaces, literal values, reserved keywords, unreserved keywords, identifier
+
 // Top-Level -----------------------------------------------------------------
 
 start returns [ source ] locals [ _sync = 'recover' ]
@@ -140,24 +156,14 @@ start returns [ source ] locals [ _sync = 'recover' ]
     usingDeclaration[$source]*
     (
       namespaceDeclaration[$source]
-      ( usingDeclaration[$source] | artifactDef[$source] )*
+      ( usingDeclaration[$source] | artifactDefOrExtend[$source] )*
     |
-      artifactDef[$source]
-      ( usingDeclaration[$source] | artifactDef[$source] )*
+      artifactDefOrExtend[$source]
+      ( usingDeclaration[$source] | artifactDefOrExtend[$source] )*
     )?
     EOF
   ;
 
-queryEOF returns [ query ]
-  :
-    q=queryExpression { $query = $q.query; } EOF
-  ;
-
-conditionEOF returns [ cond ]
-  :
-    c=condition { $cond = $c.cond; } EOF
-  ;
-
 namespaceDeclaration[ source ] locals[ decl = {} ]
 @after { $source.namespace = this.attachLocation($decl); }
   :
@@ -173,13 +179,9 @@ usingDeclaration[ source ] locals[ decl = {} ]
       FROM str=String
        { $source.dependencies.push( this.quotedLiteral( $str, 'string' ) ); }
     |
-      path=externalPath
-      { this.addItem( $decl, $source, 'usings', 'using' );; $decl.extern = $path.extern; }
-      ( AS name=ident['Using'] { $decl.name = $name.id; }
-      | { this.classifyImplicitName( 'Using' ); }
-      )
+      usingProxy[ $source, $decl ]
       ( FROM str=String
-        { $source.dependencies.push( $decl.fileDep = this.quotedLiteral( $str, 'string' ) );         }
+        { $source.dependencies.push( $decl.fileDep = this.quotedLiteral( $str, 'string' ) ); }
       )?
     |
       { this.addItem( $decl, $source, 'usings', 'using' ); }
@@ -187,9 +189,9 @@ usingDeclaration[ source ] locals[ decl = {} ]
       // to have some check in the future whether the external artifacts are
       // really in the FROM source...
       '{' { $decl.usings = this.createArray(); }
-      innerUsing[ $decl ]
+      usingProxy[ $decl, {} ]
       ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
-        innerUsing[ $decl ] )*
+        usingProxy[ $decl, {} ] )*
       '}' { this.finalizeDictOrArray( $decl.usings ); }
       ( FROM str=String
         { $source.dependencies.push( $decl.fileDep = this.quotedLiteral( $str, 'string' ) ); }
@@ -198,175 +200,27 @@ usingDeclaration[ source ] locals[ decl = {} ]
     ';'
   ;
 
-innerUsing[ using ] locals[ decl = {} ]
-@after { this.attachLocation($decl); }
+usingProxy[ outer, proxy ]
+@after { this.attachLocation($proxy); }
   :
-    { $decl.location = this.startLocation(); }
-    path=externalPath
-    { this.addItem( $decl, $using, 'usings', 'using' );; $decl.extern = $path.extern; }
-    ( AS name=ident['Using'] { $decl.name = $name.id; }
+    { if (!$proxy.location) $proxy.location = this.startLocation();
+      $proxy.extern = {}; }
+    simplePath[ $proxy.extern, 'global' ]
+    { this.addItem( $proxy, $outer, 'usings', 'using' ); }
+    ( AS name=ident['Using'] { $proxy.name = $name.id; }
     | { this.classifyImplicitName( 'Using' ); }
     )
   ;
 
-externalPath returns [ extern = {} ]
-  :
-    simplePath[ $extern, 'global' ]
-  ;
-
-// We have two versions of the annotation assignment rule, because we do not
-// want to let the ambiguity in select items (solution: "either" possibility)
-// creep into all annotation assignments:
-//   view 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
-//   }
-
-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 ]
-    )?
-  ;
-
-annotationAssignment_paren[ art ]
-  :
-    '('
-    // allow completely useless `@()` with a warning, do not offer it for completion
-    {
-      this.meltKeywordToIdentifier();
-      if (this.isStraightBefore(')')) {
-        this.warning( 'syntax-anno-useless',
-                      this.tokenLocation( this._input.LT(-2), this.getCurrentToken() ),
-                      { code: '@()' },
-                      'Ignored useless $(CODE)' );
-        this.matchWildcard();   // we know it is the ')' - we do not reach the final match
-        return $ctx;
-      }
-    }
-    annotationAssignment_1[ $art ]
-    ( ','
-      {
-        this.meltKeywordToIdentifier();
-        if (this.isStraightBefore(')')) break; // allow ',' before ')'
-      }
-      annotationAssignment_1[ $art ]
-    )*
-    ')'
-  ;
-
-annotationAssignment_fix[ art ] locals[ assignment ]
-// value outside @(...)
-@after {
-  if ($assignment) {
-    this.assignAnnotation( $art, $assignment );
-    this.docComment( $art );
-  }
-} :
-    '@'
-    (
-      annotationAssignment_paren[ $art ]
-    |
-      { $assignment = { name: {} }; }
-      annotationPath[ $assignment.name, 'anno' ]
-      annotationPathVariant[ $assignment.name ]?
-      {
-        var t = this.getCurrentToken();
-        if (t.text === ':')
-          this.warning( 'syntax-anno-short', $assignment.name.location,
-                        { code: '@(...)' },
-                        'Better use $(CODE) for annotation assignments here' );
-      }
-    )
-  ;
-
-annotationAssignment_ll1[ art ] locals[ assignment ]
-@after {
-  if ($assignment) {
-    this.assignAnnotation( $art, $assignment );
-    this.docComment( $art );
-  }
-} :
-    '@'
-    (
-      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 ]
-      )?
-    )
-  ;
-
-// Has previously used ATN, now via local token rewrite
-annotationAssignment_atn[ art ] locals[ assignment ]
-@after {
-  if ($assignment) {
-    this.assignAnnotation( $art, $assignment );
-    this.docComment( $art );
-  }
-} :
-    '@'
-    (
-      annotationAssignment_paren[ $art ]
-    |
-      { $assignment = { name: {} }; }
-      annotationPath[ $assignment.name, 'anno' ]
-      // '#' is in the follow set of this rule, as it is used in rule "selectItemDef"
-      // before an "expression" which can start with a '#' for an enum value
-      // -> used to introduce variant name if and only if in same line as previous token
-      { this.setLocalToken( '#', 'HelperToken1', null, true ); }
-      (
-        HelperToken1 { this.meltKeywordToIdentifier(); }
-        variant=ident['variant'] { $assignment.name.variant = $variant.id; }
-      )?
-      // ':' is in the follow set of this rule, as it is used in rule "selectItemDef"
-      // before an "expression" which can start with a ':' for a parameter reference
-      // -> used to introduce assignment value if and only if in same line as previous token
-      { this.setLocalToken( ':', 'HelperToken2', null, true ); }
-      ( HelperToken2                        // ':'
-        { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
-        (
-          val=annoValueBase[ $assignment ]
-        |
-          at='@'? annotationPath[ $assignment, 'ref', $at ]
-          { this.setLocalToken( '#', 'HelperToken1', null, true ); } // see above
-          (
-            HelperToken1 { this.meltKeywordToIdentifier(); }
-            variant=ident['variant'] { $assignment.variant = $variant.id; }
-          )?
-        )
-      )?
-    )
-  ;
-
-// Main artifact definitions -------------------------------------------------
-
-requiredSemi
-  : ';'
-  | { return $ctx; }            // do not actually parse the closing brace
-    '}'
-  ;
-
-optionalSemi
-  : { this.noAssignmentInSameLine(); } // issue warning for } @Anno \n? NextDef
-    ';'?
-  ;
-
-artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent` as parameter name!
+artifactDefOrExtend[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent` as parameter name!
 @after{ /* #ATN 1 */ }
   :
     { $art.location = this.startLocation(); this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
       DEFINE?
-      ( contextDef[ $art, $outer, defOnly ]
+      ( serviceDef[ $art, $outer, defOnly ]
+      | contextDef[ $art, $outer, defOnly ]
       | entityDef[ $art, $outer ]
       | typeDef[ $art, $outer ]
       | aspectDef[ $art, $outer ]
@@ -377,26 +231,27 @@ artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent`
       )
     |
       extend=EXTEND
-      { if (defOnly)
+      { if (defOnly)            // TODO: nicer message text
           this.error( 'syntax-extend-context', $extend,
-                      { code: 'EXTEND artifact', kind: defOnly },
-                      'No $(CODE) within $(KIND) extensions' );
+                      { code: 'EXTEND artifact', meta: defOnly },
+                      'No $(CODE) within $(META) extensions' );
         if (!$outer.extensions) $outer.extensions = [];
       }
-      // #ATN: EXTEND elem, while CONTEXT, ENTITY etc are not reserved
-      ( extendContext[ $art, $outer ]
-      | extendEntity[ $art, $outer ] // or aspect
+      // #ATN: EXTEND art, while CONTEXT, ENTITY etc are not reserved
+      ( extendService[ $art, $outer ]
+      | extendContext[ $art, $outer ]
+      | extendEntityOrAspect[ $art, $outer ] // or aspect
       | extendProjection[ $art, $outer ]
       | extendType[ $art, $outer ]
-      // Streamlined Syntax
+      // Streamlined Syntax; we won't add more kinds of the non-streamlined variants:
       | extendArtifact[ $art, $outer ]
       )
     |
       annotate=ANNOTATE
-      { if (defOnly)
+      { if (defOnly)            // TODO: improve message text
           this.error( 'syntax-extend-context', $annotate,
-                      { code: 'ANNOTATE artifact', kind: defOnly },
-                      'No $(CODE) within $(KIND) extensions' );
+                      { code: 'ANNOTATE artifact', meta: defOnly },
+                      'No $(CODE) within $(META) extensions' );
         if (!$outer.extensions) $outer.extensions = [];
         this.meltKeywordToIdentifier();
       }
@@ -404,16 +259,14 @@ artifactDef[ outer, defOnly = false ] locals[ art = {} ] // cannot use `parent`
     )
   ;
 
-contextDef[ art, outer, defOnly = false ] locals[ name = {} ]
+optArtifactsBlock[ art, defOnly = false ]
 @after { this.attachLocation( $art ); }
   :
-    ( CONTEXT | service=SERVICE ) simplePath[ $name, $service ? 'Service' : 'Context' ]
-    { this.addDef( $art, $outer, 'artifacts', $service ? 'service' : 'context', $name );
-      this.docComment( $art ); }
+    { this.docComment( $art ); }
     annotationAssignment_fix[ $art ]*
     (
       '{' { $art.artifacts = this.createDict(); $art.extensions = []; }
-      artifactDef[ $art, defOnly ]*
+      artifactDefOrExtend[ $art, defOnly ]*
       '}' { this.finalizeDictOrArray( $art.artifacts ); }
       optionalSemi
     |
@@ -421,25 +274,110 @@ contextDef[ art, outer, defOnly = false ] locals[ name = {} ]
     )
   ;
 
-extendContext[ art, outer ] locals[ name = {} ]
+requiredSemi
+  : ';'
+  | { return $ctx; }            // do not actually parse the closing brace
+    '}'
+  ;
+
+optionalSemi
+  : { this.noAssignmentInSameLine(); } // issue warning for } @Anno \n? NextDef
+    ';'?
+  ;
+
+// Annotation def and main definitions ------------------------------------------
+
+annotationDef[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    ( 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( $art ); }
-    annotationAssignment_ll1[ $art ]*
+    annotation=ANNOTATION simplePath[ $name, 'AnnoDef' ]
+    { if ($outer.kind !== 'source') { // this is a syntax restriction to avoid confusion
+        this.error( 'syntax-unexpected-vocabulary', $annotation, { '#': $outer.kind } );
+        $art = {}; }
+      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'...
+  ;
+
+serviceDef[ art, outer, defOnly = false ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
+  :
+    SERVICE simplePath[ $name, 'Service' ]
+    { this.addDef( $art, $outer, 'artifacts', 'service', $name ); }
+    optArtifactsBlock[ $art, defOnly ]
+  ;
+
+contextDef[ art, outer, defOnly = false ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
+  :
+    CONTEXT simplePath[ $name, 'Context' ]
+    { this.addDef( $art, $outer, 'artifacts', 'context', $name ); }
+    optArtifactsBlock[ $art, defOnly ]
+  ;
+
+eventDef[ art, outer ] locals[ name = {} ]
+@after { /* #ATN 1 */ this.attachLocation( $art ); }
+  :
+    EVENT simplePath[ $name, 'Event' ]
+    { this.addDef( $art, $outer, 'artifacts', 'event', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     (
-      '{' { $art.artifacts = this.createDict(); }
-      artifactDef[ $art, $service ? 'SERVICE' : 'CONTEXT' ]*
-      '}' { this.finalizeDictOrArray( $art.artifacts ); }
-      optionalSemi
+      typeStruct[ $art ] optionalSemi
     |
-      requiredSemi
+      ':'
+      // #ATN: includeRef can be / start with PROJECTION
+      (
+        { $art.type = {}; }
+        simplePath[ $art.type, 'artref' ]
+        (
+          { $art.includes = [ $art.type ]; delete $art.type; }
+          ( ',' { if (this.isStraightBefore('{')) break; } // allow ',' before '{' // }}
+            includeRef[ $art ]
+          )*
+          typeStruct[ $art ] optionalSemi
+        |
+          { this.docComment( $art ); }
+          annotationAssignment_ll1[ $art ]*
+          requiredSemi
+        )
+      |
+        typeStruct[ $art ] optionalSemi
+      |
+        qp=projectionSpec
+        { $art.query = $qp.query; $art['$'+'syntax'] = 'projection'; }
+        optionalSemi // TODO: not fully correct without columns or excluding
+      )
     )
   ;
 
+viewDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
+  :
+    v=VIEW simplePath[ $name, 'Entity' ]
+    { $art['$'+'syntax'] = 'view';
+      this.addDef( $art, $outer, 'artifacts', 'entity', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
+    (
+      parameterListDef[ $art ]
+    |
+      // 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; }
+    // TODO check ANTLR: bad msg with 'view V as'<eof> but 'view V as FOO' is fine
+    requiredSemi
+  ;
+
 entityDef[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
@@ -458,7 +396,6 @@ entityDef[ art, outer ] locals[ name = {} ]
       '{' { $art.elements = this.createDict(); }
       elementDef[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
-      // TODO: action definitions in a specific section?
       (
         ACTIONS '{' { $art.actions = this.createDict(); }
         actionFunctionDef[ $art ]*
@@ -489,161 +426,48 @@ entityDef[ art, outer ] locals[ name = {} ]
     )
   ;
 
-projectionSpec returns[ query ] locals[ src ]
-@after { this.attachLocation($query); }
+aspectDef[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
-    proj=PROJECTION ON               // FIXME: First draft only, details unclear/unspecified
-    // now a simplified `tableTerm`:
-    {
-      $src = { path: [], scope: 0 };
-      $query = { op: this.valueWithTokenLocation( 'SELECT', $proj ), from: $src, location: this.startLocation() };
-    }
-    fromPath[ $src, 'artref']
+    ( ASPECT | ( abs=ABSTRACT | HideAlternatives ) ent=ENTITY )
+    simplePath[ $name, 'Type' ]
+    { this.addDef( $art, $outer, 'artifacts', 'aspect', $name );
+      if ($ent)
+        this.warning( 'syntax-deprecated-abstract', this.tokenLocation( $abs, $ent ) );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
     ( ':'
-      { $src.scope = $src.path.length; }
-      fromPath[ $src, 'ref']
-    )?
-    ( 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, 'columns' ]?
-    excludingClause[ $query ]?
-  ;
-
-projectionClauses[ query ]
-@after { this.attachLocation($query); }
-  :
-    ( WHERE cond=condition { $query.where = $cond.cond; } )?
-    (
-      GROUP BY
-      e1=expression { $query.groupBy = [ $e1.expr ]; }
-      ( ',' en=expression { $query.groupBy.push( $en.expr ); } )*
-    )?
-    ( HAVING having=condition { $query.having = $having.cond; } )?
-    ( ob=orderByClause[ $query ] { $query = $ob.query; } ) ?
-    ( lc=limitClause[ $query ]   { $query = $lc.query; } ) ?
-  ;
-
-excludingClause[ query ]
-  :
-    // syntax is less than ideal - EXCLUDING is only useful for `*` - with
-    // this syntax, people wonder what happens with explicit select items
-    EXCLUDING '{' { $query.excludingDict = this.createDict(); }
-    projectionExclusion[ $query ]
-    ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
-      projectionExclusion[ $query ]
-    )*
-    '}' { this.finalizeDictOrArray( $query.excludingDict ); }
-  ;
-
-projectionExclusion[ outer ] locals[ art = {} ]
-@after { this.attachLocation($art); }
-  :
-    name=ident['ref']
-    { this.addDef( $art, $outer, 'excludingDict', '', $name.id ); }
-  ;
-
-// also used for aspect
-extendEntity[ art, outer ] locals[ name = {} ]
-@after { /* #ATN 1 */ this.attachLocation( $art ); }
-  :
-    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( $art ); }
-      annotationAssignment_ll1[ $art ]*
-      // ATN: the ref can start with ACTIONS
-      (
-        includeRef[ $art ] ( ',' includeRef[ $art ] )*
-        requiredSemi
-      |
-        extendForEntity[ $art ]
-      )
-    |
-      { this.docComment( $art ); }
-      annotationAssignment_ll1[ $art ]*
-      extendForEntity[ $art ]
-    )
-  ;
-
-extendForEntity[ art ]
-  :
-    '{' { $art.elements = this.createDict(); }
-    elementDefOrExtend[ $art ]*
-    '}' { this.finalizeDictOrArray( $art.elements ); }
-    (
-      ACTIONS '{' { $art.actions = this.createDict(); }
-      actionFunctionDef[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.actions ); }
-    )?
-    optionalSemi
-  |
-    ACTIONS '{' { $art.actions = this.createDict(); }
-    actionFunctionDef[ $art ]*
-    '}' { this.finalizeDictOrArray( $art.actions ); }
-    optionalSemi
-  |
-    requiredSemi
-  ;
-
-extendProjection[ art, outer ] locals[ name = {} ]
-@after { this.attachLocation( $art ); }
-  :
-    expected=PROJECTION simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'entity'; $art.name = $name;
-      this.addItem( $art, $outer, 'extensions', 'extend' );
-    }
-    ( WITH { this.noSemicolonHere(); } )?
-    { this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    (
-      '{' { $art.columns = []; }
       (
-        selectItemDef[ $art.columns ]
-        ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
-          selectItemDef[ $art.columns ]
+        includeRef[ $art ]
+        ( ',' { if (this.isStraightBefore('{')) break; } // allow ',' before '{' // }}
+          includeRef[ $art ]
         )*
       )?
-      '}'
+    )?
+    ( // `aspect MyAspect {};`
+      '{' { $art.elements = this.createDict(); }
+      ( elementDef[ $art ]* )
+      '}' { this.finalizeDictOrArray( $art.elements ); }
       (
         ACTIONS '{' { $art.actions = this.createDict(); }
         actionFunctionDef[ $art ]*
         '}' { this.finalizeDictOrArray( $art.actions ); }
       )?
       optionalSemi
-    |
-      ACTIONS '{' { $art.actions = this.createDict(); }
-      actionFunctionDef[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.actions ); }
-      optionalSemi
-    |
+    | // `aspect MyAspect;`, e.g. for annotation aspects.
+      { this.aspectWithoutElements( $art ); }
       requiredSemi
     )
   ;
 
-// TODO: no action extension?
-actionFunctionDef[ outer ] locals[ art = {} ]
+typeDef[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    { $art.location = this.startLocation();; this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    (
-      ACTION name=ident['BoundAction']
-      { this.addDef( $art, $outer, 'actions', 'action', $name.id );
-        this.docComment( $art ); }
-      annotationAssignment_fix[ $art ]*
-      parameterListDef[ $art ]
-      ( returnTypeSpec[ $art ] | requiredSemi )
-    |
-      FUNCTION name=ident['BoundAction']
-      { this.addDef( $art, $outer, 'actions', 'function', $name.id );
-        this.docComment( $art ); }
-      annotationAssignment_fix[ $art ]*
-      parameterListDef[ $art ]
-      returnTypeSpec[ $art ]
-    )
+    TYPE simplePath[ $name, 'Type' ]
+    { this.addDef( $art, $outer, 'artifacts', 'type', $name );
+      this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
+    typeSpecSemi[ $art ]
   ;
 
 actionFunctionMainDef[ art, outer ] locals[ name = {} ]
@@ -664,127 +488,273 @@ actionFunctionMainDef[ art, outer ] locals[ name = {} ]
     returnTypeSpec[ $art ]
   ;
 
-eventDef[ art, outer ] locals[ name = {} ]
-@after { /* #ATN 1 */ this.attachLocation( $art ); }
+// Member definitions: actions, elements, enums, parameters: --------------------
+
+actionFunctionDef[ outer ] locals[ art = {} ]
+@after { this.attachLocation( $art ); }
   :
-    EVENT simplePath[ $name, 'Event' ]
-    { this.addDef( $art, $outer, 'artifacts', 'event', $name );
-      this.docComment( $art ); }
-    annotationAssignment_fix[ $art ]*
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
     (
-      typeStruct[ $art ] optionalSemi
+      ACTION name=ident['BoundAction']
+      { this.addDef( $art, $outer, 'actions', 'action', $name.id );
+        this.docComment( $art ); }
+      annotationAssignment_fix[ $art ]*
+      parameterListDef[ $art ]
+      ( returnTypeSpec[ $art ] | requiredSemi )
     |
-      ':'
-      // #ATN: includeRef can be / start with PROJECTION
-      (
-        { $art.type = {}; }
-        simplePath[ $art.type, 'artref' ]
-        (
-          { $art.includes = [ $art.type ]; delete $art.type; }
-          ( ',' { if (this.isStraightBefore('{')) break; } // allow ',' before '{' // }}
-            includeRef[ $art ]
-          )*
-          typeStruct[ $art ] optionalSemi
-        |
-          { this.docComment( $art ); }
-          annotationAssignment_ll1[ $art ]*
-          requiredSemi
-        )
-      |
-        typeStruct[ $art ] optionalSemi
-      |
-        qp=projectionSpec
-        { $art.query = $qp.query; $art['$'+'syntax'] = 'projection'; }
-        optionalSemi // TODO: not fully correct without columns or excluding
-
-      )
+      FUNCTION name=ident['BoundAction']
+      { this.addDef( $art, $outer, 'actions', 'function', $name.id );
+        this.docComment( $art ); }
+      annotationAssignment_fix[ $art ]*
+      parameterListDef[ $art ]
+      returnTypeSpec[ $art ]
     )
   ;
 
-aspectDef[ art, outer ] locals[ name = {} ]
+parameterDef[ outer ] locals[ art = {} ]
 @after { this.attachLocation( $art ); }
   :
-    ( ASPECT | ( abs=ABSTRACT | HideAlternatives ) ent=ENTITY )
-    simplePath[ $name, 'Type' ]
-    { 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( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    name=ident['Param']
+    { this.addDef( $art, $outer, 'params', 'param', $name.id );
       this.docComment( $art ); }
     annotationAssignment_fix[ $art ]*
-    ( ':'
-      (
-        includeRef[ $art ]
-        ( ',' { if (this.isStraightBefore('{')) break; } // allow ',' before '{' // }}
-          includeRef[ $art ]
-        )*
-      )?
-    )?
-    ( // `aspect MyAspect {};`
-      '{' { $art.elements = this.createDict(); }
-      ( elementDef[ $art ]* )
-      '}' { this.finalizeDictOrArray( $art.elements ); }
-      // TODO: action definitions in a specific section?
-      (
-        ACTIONS '{' { $art.actions = this.createDict(); }
-        actionFunctionDef[ $art ]*
-        '}' { this.finalizeDictOrArray( $art.actions ); }
-      )?
-      optionalSemi
-    | // `aspect MyAspect;`, e.g. for annotation aspects.
-      { this.aspectWithoutElements( $art ); }
-      requiredSemi
-    )
+    typeSpec[ $art ]
+    defaultValue[ $art ]?
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
   ;
 
-typeDef[ art, outer ] locals[ name = {} ]
-@after { this.attachLocation( $art ); }
+parameterListDef[ art ]
   :
-    TYPE simplePath[ $name, 'Type' ]
-    { this.addDef( $art, $outer, 'artifacts', 'type', $name );
-      this.docComment( $art ); }
-    annotationAssignment_fix[ $art ]*
-    typeSpecSemi[ $art ]
+    '(' { $art.params = this.createDict(); }
+    // also empty param list (we might do some hacking later to allow reserved words)
+    // see annotationAssignment_paren
+    (
+      parameterDef[ $art ]
+      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+        parameterDef[ $art ]
+      )*
+    )?
+    ')' { this.finalizeDictOrArray( $art.params ); }
   ;
 
-extendType[ art, outer ] locals[ name = {} ]
+enumSymbolDef[ outer ] locals[ art = {} ]
 @after { this.attachLocation( $art ); }
   :
-    // aspects are types, i.e. kind is 'type' for aspects
-    TYPE simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'type'; $art.name = $name;
-      this.addItem( $art, $outer, 'extensions', 'extend' );
-    }
-    extendWithOptElementsOrType[ $art, $art ]
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    name=ident['Enum']
+    { this.addDef( $art, $outer, 'enum', 'enum', $name.id );
+      this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    ( '='
+      { this.excludeExpected( ['Boolean', 'QuotedLiteral', "'#'", 'NULL'] ); }
+      (
+        val=literalValue
+        { $art.value = $val.val; }
+      |
+        ( plus='+' | min='-' ) num=Number
+        { $art.value = this.numberLiteral( $num, $plus||$min ); }
+      )
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+    )?
+    requiredSemi
   ;
 
-annotationDef[ art, outer ] locals[ name = {} ]
-@after { this.attachLocation( $art ); }
+elementDef[ outer ] locals[ $art = {} ]
   :
-    annotation=ANNOTATION simplePath[ $name, 'AnnoDef' ]
-    { if ($outer.kind !== 'source') { // this is a syntax restriction to avoid confusion
-        this.error( 'syntax-unexpected-vocabulary', $annotation, { '#': $outer.kind } );
-        $art = {}; }
-      else {
-        if (!$outer.vocabularies) $outer.vocabularies = Object.create(null);
-        this.addDef( $art, $outer, 'vocabularies', 'annotation', $name );
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    elementDefInner[ $art, $outer, false ]
+  ;
+
+elementDefInner[ art, outer, allowEq ]
+@after{ this.attachLocation( $art ); }
+  :
+    // VIRTUAL is keyword, except if before the following tokens texts:
+    { this.setLocalToken( 'VIRTUAL', 'VIRTUAL', /^[:{@=}]$/ ); }
+    ( virtual=VIRTUAL { $art.virtual = this.valueWithTokenLocation( true, $virtual ); } )?
+    ( key=KEY { $art.key = this.valueWithTokenLocation( true, $key ); } )?
+    { this.setLocalToken( 'MASKED', 'MASKED', /^[:{@=}]$/ ); }
+    ( masked=MASKED
+      {
+        $art.masked = this.valueWithTokenLocation( true, $masked ) ;
+        this.message( 'syntax-unsupported-masked', $masked, { keyword: 'masked' } );
       }
+    )?
+    { this.setLocalToken( 'ELEMENT', 'ELEMENT', /^[:{@=}]$/ ); }
+    ELEMENT?
+    name=ident['Element']
+    { this.addDef( $art, $outer, 'elements', 'element', $name.id );
       this.docComment( $art ); }
     annotationAssignment_fix[ $art ]*
-    typeSpecSemi[ $art ] // also 'includes'...
+    // TODO: we can think of making the typeSpec optional and do checks instead:
+    // type optional with '=', type required otherwise
+    (
+      typeStruct[ $art ]
+      ( nullability[ $art ]
+        requiredSemi
+      | optionalSemi            // NOT and NULL are reserved...
+      )
+    |
+      ':'
+      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;
+      }
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]* // for enum symbol def via EXTEND
+      requiredSemi
+    )
+  ;
+
+elementType[ art ]     // TODO: split this monster rule
+@after{ /* #ATN 3 */ this.attachLocation( $art ); }
+  :
+    // #ATN: referenced type name can be ASSOCIATION or ARRAY or TYPE or LOCALIZED
+    typeStruct[ $art ]
+    nullability[ $art ]?
+    requiredSemi
+  |
+    typeAssociationBase[ $art, true ]
+    // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
+    (
+      typeStruct[ $art.target, true ] optionalSemi
+    |
+      one=ONE
+      { this.setMaxCardinality( $art, $one, this.numberLiteral( $one, null, '1' ) ); }
+      typeCompoStruct[ $art.target ] optionalSemi
+    |
+      many=MANY
+      { this.setMaxCardinality( $art, $many, { literal: 'string', val: '*' } ); }
+      typeCompoStruct[ $art.target ] optionalSemi
+    |
+      // we do not support `Composition of many { e }` - ambiguity ad-hoc target versus foreign keys!
+      typeToMany[ $art ] typeAssociationElementCont[ $art ]
+    |
+      typeToOne[ $art ] typeAssociationElementCont[ $art ]
+    |
+      simplePath[ $art.target, 'artref' ] typeAssociationElementCont[ $art ]
+    )
+  |
+    (
+      array=ARRAY of=OF
+      { $art.items = { location: this.tokenLocation( $array, $of ) }; }
+    | many=MANY
+      { $art.items = { location: this.tokenLocation( $many ) };}
+    )
+    ( typeStruct[ $art.items ]
+      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`
+      { 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 ); }
+        nullability[ $art.items ]?
+      )?
+    )
+    requiredSemi                     // also req after struct/enum
+  |
+    l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
+    typeRefOptArgs[ $art ]
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    ( elementProperties[ $art ]
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+    )?
+    requiredSemi
+  |
+    typeTypeOf[ $art ] // Note: Same as the typeRefOptArgs rule below
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    (
+      ENUM '{' { $art.enum = this.createDict(); }
+      enumSymbolDef[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.enum ); }
+      elementProperties[ $art ]?
+    |
+      elementProperties[ $art ]
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+    )?
+    requiredSemi                     // also req after foreign key spec
+  |
+    typeRefOptArgs[ $art ] // Note: Same as the typeTypeOf rule above
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    (
+      ENUM '{' { $art.enum = this.createDict(); }
+      enumSymbolDef[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.enum ); }
+      elementProperties[ $art ]?
+    |
+      elementProperties[ $art ]
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+    )?
+    requiredSemi                     // also req after enum spec
+  ;
+
+elementProperties[ elem ]
+  :
+    nullability[ $elem ]
+    defaultValue[ $elem ]?
+  |
+    defaultValue[ $elem ]
+    nullability[ $elem ]?
+  |
+    eq='='
+    { this.error( 'syntax-unsupported-calc-elem', $eq ); }
+    e=expression { $elem.value = $e.expr; }
+  ;
+
+defaultValue[ art ] locals[ elem, elements = {} ]
+  :
+  // TODO: We may support structured default values here.
+  DEFAULT expr=expression { $art.default = $expr.expr; }
   ;
 
+// Extend and annotate ----------------------------------------------------------
+
 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 ); }
     (
-      { this.docComment( $art ); }
+      ':' simplePath[ $elemName, 'Element']
+      { this.addExtension( $art, $outer, 'extend', $name, $elemName.path ); }
+      extendWithOptElementsOrType[ art ]
+    |
+      { this.addExtension( $art, $outer, 'extend', $name ); }
+      extendWithOptElementsNoWith[ art ]
+    |
+      { this.addExtension( $art, $outer, 'extend', $name ); }
+      WITH { this.noSemicolonHere(); this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]*
+      // #ATN: ELEMENTS, ENUM, DEFINITIONS, COLUMNS, ACTIONS are not reserved and
+      // could be includeRef
       (
+        // all the alternatives from `extendWithOptElementsOrType` --------------
         '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
@@ -792,32 +762,34 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         optionalSemi
       |
         requiredSemi
-      )
-    |
-      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 ] )*
-        requiredSemi
       |
-        '{' { $art.elements = this.createDict(); }
+        ELEMENTS '{' { $art.elements = this.createDict(); }
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
+        ENUM '{' { $art.enum = this.createDict(); }
+        enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
+        '}' { this.finalizeDictOrArray( $art.enum ); }
+        optionalSemi
+      |
+        // extend Art with (length: 10);
+        // `with` is required, or we could have `extend String(length:10);`.
+        // future `extend Action with (param: Type)` now has ambiguity
+        typeNamedArgList[ $art ]
+        requiredSemi
+      |
+        // extension alternatives for main definitions --------------------------
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
-        { this.disallowElementExtension( $elemName, $outer, 'definitions' ); }
         DEFINITIONS
         '{' { $art.artifacts = this.createDict(); }
-        artifactDef[ $art, true ]*
+        artifactDefOrExtend[ $art, true ]*
         '}' { this.finalizeDictOrArray( $art.artifacts ); }
         optionalSemi
       |
-        { this.disallowElementExtension( $elemName, $outer, 'columns' ); }
         COLUMNS
         '{' { $art.columns = []; }
         (
@@ -829,85 +801,239 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         '}'
         optionalSemi
       |
-        { this.disallowElementExtension( $elemName, $outer, 'actions' ); }
         ACTIONS '{' { $art.actions = this.createDict(); }
         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.finalizeDictOrArray( $art.elements ); }
-        { this.checkExtensionDict( $art.elements ); }
-        optionalSemi
-      |
-        ENUM '{' { $art.enum = this.createDict(); }
-        enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
-        '}' { this.finalizeDictOrArray( $art.enum ); }
-        optionalSemi
-      |
-        // extend Art with (length: 10);
-        // `with` is required, or we could have `extend String(length:10);`.
-        typeNamedArgList[ $art ]
-        requiredSemi
       )
+      // TODO: what about adding both ELEMENTS and ACTIONS? (TODO: csn input test & to-cdl)
     )
   ;
 
-extendWithOptElementsOrType[ art ]
+extendService[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
   :
-    WITH { this.noSemicolonHere(); this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    (
-      includeRef[ $art ] ( ',' includeRef[ $art ] )*
-      requiredSemi
-    |
-      '{' { $art.elements = this.createDict(); }
-      elementDefOrExtend[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
-      optionalSemi
-    |
-      // extend type|element Art with (length: 10);
-      typeNamedArgList[ $art ]
-      requiredSemi
-    |
-      requiredSemi
-    )
-  |
-    { this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    (
-      '{' { $art.elements = this.createDict(); }
-      elementDefOrExtend[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
-      optionalSemi
-    |
-      requiredSemi
-    )
+    SERVICE { $art.expectedKind = 'service'; }
+    simplePath[ $name, 'Service' ]
+    { $art.name = $name; this.addItem( $art, $outer, 'extensions', 'extend' ); }
+    ( WITH { this.noSemicolonHere(); } )?
+    optArtifactsBlock[ art, 'SERVICE' ]
   ;
 
-annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
+extendContext[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    simplePath[ $name, 'Annotate' ]
-    ( ':' simplePath[ $elemName, 'Element'] )?
-    { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
+    CONTEXT { $art.expectedKind = 'context'; }
+    simplePath[ $name, 'Context' ]
+    { $art.name = $name; this.addItem( $art, $outer, 'extensions', 'extend' ); }
     ( WITH { this.noSemicolonHere(); } )?
-    { this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
+    optArtifactsBlock[ art, 'CONTEXT' ]
+  ;
+
+extendEntityOrAspect[ art, outer ] locals[ name = {} ]
+@after { /* #ATN 1 */ this.attachLocation( $art ); }
+  :
+    kind=(ASPECT | ENTITY) simplePath[ $name, 'Extend' ]
+    { $art.expectedKind = $kind.text.toLowerCase(); $art.name = $name;
+      this.addItem( $art, $outer, 'extensions', 'extend' );
+    }
     (
-      '{' { $art.elements = this.createDict(); }
-      annotateElement[ $art ]*
-      '}' { this.finalizeDictOrArray( $art.elements ); }
-      { this.checkExtensionDict( $art.elements ); }
+      WITH { this.noSemicolonHere(); this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+      // ATN: the ref can start with ACTIONS
       (
-        ACTIONS
-        '{' { $art.actions = this.createDict(); }
-        annotateAction[ $art ]*
-        '}' { this.finalizeDictOrArray( $art.actions ); }
-      { this.checkExtensionDict( $art.actions ); }
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
+        requiredSemi
+      |
+        extendForEntity[ $art ]
+      )
+    |
+      { this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+      extendForEntity[ $art ]
+    )
+  ;
+
+extendForEntity[ art ]
+  :
+    '{' { $art.elements = this.createDict(); }
+    elementDefOrExtend[ $art ]*
+    '}' { this.finalizeDictOrArray( $art.elements ); }
+    (
+      ACTIONS '{' { $art.actions = this.createDict(); }
+      actionFunctionDef[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.actions ); }
+    )?
+    optionalSemi
+  |
+    ACTIONS '{' { $art.actions = this.createDict(); }
+    actionFunctionDef[ $art ]*
+    '}' { this.finalizeDictOrArray( $art.actions ); }
+    optionalSemi
+  |
+    requiredSemi
+  ;
+
+extendProjection[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
+  :
+    expected=PROJECTION simplePath[ $name, 'Extend' ]
+    { $art.expectedKind = 'entity'; $art.name = $name;
+      this.addItem( $art, $outer, 'extensions', 'extend' );
+    }
+    ( WITH { this.noSemicolonHere(); } )?
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    (
+      '{' { $art.columns = []; }
+      (
+        selectItemDef[ $art.columns ]
+        ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
+          selectItemDef[ $art.columns ]
+        )*
+      )?
+      '}'
+      (
+        ACTIONS '{' { $art.actions = this.createDict(); }
+        actionFunctionDef[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.actions ); }
+      )?
+      optionalSemi
+    |
+      ACTIONS '{' { $art.actions = this.createDict(); }
+      actionFunctionDef[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.actions ); }
+      optionalSemi
+    |
+      requiredSemi
+    )
+  ;
+
+extendType[ art, outer ] locals[ name = {} ]
+@after { this.attachLocation( $art ); }
+  :
+    TYPE simplePath[ $name, 'Extend' ]
+    { $art.expectedKind = 'type'; $art.name = $name;
+      this.addItem( $art, $outer, 'extensions', 'extend' );
+    }
+    // extendWithOptElementsOrType + includeRef:
+    (
+      extendWithOptElementsNoWith[ art ]
+    |
+      WITH { this.noSemicolonHere(); this.docComment( $art ); }
+      annotationAssignment_ll1[ $art ]*
+      (
+        '{' { $art.elements = this.createDict(); }
+        elementDefOrExtend[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.elements ); }
+        { this.checkExtensionDict( $art.elements ); }
+        optionalSemi
+      |
+        // extend type|element Art with (length: 10);
+        typeNamedArgList[ $art ]
+        requiredSemi
+      |
+        requiredSemi
+      |
+        includeRef[ $art ] ( ',' includeRef[ $art ] )*
+        requiredSemi
+      )
+    )
+  ;
+
+extendWithOptElementsOrType[ art ]
+  :
+    extendWithOptElementsNoWith[ art ]
+  |
+    WITH { this.noSemicolonHere(); this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    (
+      '{' { $art.elements = this.createDict(); }
+      elementDefOrExtend[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
+      optionalSemi
+    |
+      ELEMENTS '{' { $art.elements = this.createDict(); }
+      elementDefOrExtend[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
+      optionalSemi
+    |
+      ENUM '{' { $art.enum = this.createDict(); }
+      enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
+      '}' { this.finalizeDictOrArray( $art.enum ); }
+      optionalSemi
+    |
+      // extend type|element Art with (length: 10);
+      typeNamedArgList[ $art ]
+      requiredSemi
+    |
+      requiredSemi
+    )
+  ;
+
+extendWithOptElementsNoWith[ art ]
+  :
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    (
+      '{' { $art.elements = this.createDict(); }
+      elementDefOrExtend[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
+      optionalSemi
+    |
+      requiredSemi
+    )
+  ;
+
+// For `extend … with elements` or `extend entity … with`, `extend aspect … with`,
+// i.e. definitions in { … } are never enums
+elementDefOrExtend[ outer ] locals[ art = {} ]
+@after { /* #ATN 1 */ }  // if ($art) this.attachLocation( $art ); }
+  :
+    { $art.location = this.startLocation();; this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    // #ATN: element name for definition can be EXTEND
+    (
+      EXTEND
+      extendElement[ $art, $outer ]
+    |
+      elementDefInner[ $art, $outer, true ]
+    )
+  ;
+
+extendElement[ art, outer ]
+@after{ this.attachLocation( $art ); }
+  :
+    { this.setLocalToken( 'ELEMENT', 'ELEMENT', /^([:{@=}()]|WITH)$/i ); }
+    ( expected=ELEMENT { $art.expectedKind = 'element'; } )?
+    name=ident['Element']
+    { this.addDef( $art, $outer, 'elements', 'extend', $name.id ); }
+    extendWithOptElementsOrType[ $art, $art ]
+  ;
+
+annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
+@after { this.attachLocation( $art ); }
+  :
+    simplePath[ $name, 'Annotate' ]
+    ( ':' simplePath[ $elemName, 'Element'] )?
+    { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
+    ( WITH { this.noSemicolonHere(); } )?
+    { this.docComment( $art ); }
+    annotationAssignment_ll1[ $art ]*
+    (
+      '{' { $art.elements = this.createDict(); }
+      annotateElement[ $art ]*
+      '}' { this.finalizeDictOrArray( $art.elements ); }
+      { this.checkExtensionDict( $art.elements ); }
+      (
+        ACTIONS
+        '{' { $art.actions = this.createDict(); }
+        annotateAction[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.actions ); }
+      { this.checkExtensionDict( $art.actions ); }
       )?
       optionalSemi
     |
@@ -1008,458 +1134,44 @@ annotateParam [ outer ] locals [ art = {} ]
     annotationAssignment_ll1[ $art ]*
   ;
 
-// Element definition and its helpers ----------------------------------------
-
-enumSymbolDef[ outer ] locals[ art = {} ]
-@after { this.attachLocation( $art ); }
-  :
-    { $art.location = this.startLocation();; this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    name=ident['Enum']
-    { this.addDef( $art, $outer, 'enum', 'enum', $name.id );
-      this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    ( '='
-      { this.excludeExpected( ['Boolean', 'QuotedLiteral', "'#'", 'NULL'] ); }
-      (
-        val=literalValue
-        { $art.value = $val.val; }
-      |
-        ( plus='+' | min='-' ) num=Number
-        { $art.value = this.numberLiteral( $num, $plus||$min ); }
-      )
-      { this.docComment( $art ); }
-      annotationAssignment_ll1[ $art ]*
-    )?
-    requiredSemi
-  ;
+// Type expressions -------------------------------------------------------------
 
-defaultValue[ art ] locals[ elem, elements = {} ]
+includeRef[ art ] locals[ incl = {} ]
   :
-  // TODO: We may support structured default values here.
-  DEFAULT expr=expression { $art.default = $expr.expr; }
+    simplePath[ $incl, 'artref' ]
+    { if ($art.includes) $art.includes.push($incl); else $art.includes = [$incl]; }
   ;
 
-elementDefOrExtend[ outer ] locals[ art = {} ]
-@after { /* #ATN 1 */ }  // if ($art) this.attachLocation( $art ); }
+typeSpec[ art ]                 // for parameterDef
+@after{ /* #ATN 1 */ }
   :
-    { $art.location = this.startLocation();; this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    // #ATN: element name for definition can be EXTEND
-    (
-      EXTEND
-      extendElement[ $art, $outer ]
-    |
-      elementDefInner[ $art, $outer, true ]
+    typeStruct[ $art ]
+  |
+    ':'
+    // #ATN: typeSimple can start with ARRAY or TYPE
+    ( typeStruct[ $art ]
+      nullability[ $art ]?
+    | typeArray[ $art ] // nullability is set in typeArray
+    | typeTypeOf[ $art ]
+      nullability[ $art ]?
+      (
+        ENUM '{' { $art.enum = this.createDict(); }
+        enumSymbolDef[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.enum ); }
+      )?
+      // TODO: no LOCALIZED ?
+    | typeRefOptArgs[ $art ]
+      nullability[ $art ]?
+      (
+        ENUM '{' { $art.enum = this.createDict(); }
+        enumSymbolDef[ $art ]*
+        '}' { this.finalizeDictOrArray( $art.enum ); }
+      )?
     )
   ;
 
-elementDef[ outer ] locals[ $art = {} ]
-  :
-    { $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 = {} ]
-@after { /* #ATN 2 */ 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-field', $as ); }
-        )?
-      )
-    |
-      as='=' expression
-      { this.error( 'syntax-unsupported-field', $as ); }
-    )
-    requiredSemi
-  ;
-
-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 { $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
-      {
-        $art.masked = this.valueWithTokenLocation( true, $masked ) ;
-        this.message( 'syntax-unsupported-masked', $masked, { keyword: 'masked' } );
-      }
-    )?
-    // TODO: order?
-    ELEMENT?
-    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 ]
-        requiredSemi
-      | optionalSemi            // NOT and NULL are reserved...
-      )
-    |
-      ':'
-      // #ATN: referenced type name can be ASSOCIATION or ARRAY or TYPE or LOCALIZED
-      (
-        typeStruct[ $art ]
-        nullability[ $art ]?
-        requiredSemi
-      |
-        typeAssociationBase[ $art, true ]
-        // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
-        (
-          typeStruct[ $art.target, true ] optionalSemi
-        |
-          one=ONE
-          { this.setMaxCardinality( $art, $one, this.numberLiteral( $one, null, '1' ) ); }
-          typeCompoStruct[ $art.target ] optionalSemi
-        |
-          many=MANY
-          { this.setMaxCardinality( $art, $many, { literal: 'string', val: '*' } ); }
-          typeCompoStruct[ $art.target ] optionalSemi
-        |
-          // we do not support `Composition of many { e }` - ambiguity ad-hoc target versus foreign keys!
-          typeToMany[ $art ] typeAssociationElementCont[ $art ]
-        |
-          typeToOne[ $art ] typeAssociationElementCont[ $art ]
-        |
-          simplePath[ $art.target, 'artref' ] typeAssociationElementCont[ $art ]
-        )
-      |
-        (
-          array=ARRAY of=OF
-          { $art.items = { location: this.tokenLocation( $array, $of ) }; }
-        | many=MANY
-          { $art.items = { location: this.tokenLocation( $many ) };}
-        )
-        // #ATN: typeRefOptArgs can start with TYPE
-        ( typeStruct[ $art.items ]
-          nullability[ $art.items ]?
-        | typeTypeOf[ $art.items ]
-          nullability[ $art.items ]?
-          { this.docComment( $art ); }
-          annotationAssignment_ll1[ $art ]*
-        | 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 ); }
-            nullability[ $art.items ]?
-          )?
-        )
-        requiredSemi                     // also req after struct/enum
-      |
-        typeTypeOf[ $art ] elementProperties[ $art ]?
-        { 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( $art ); }
-        annotationAssignment_ll1[ $art ]*
-        ( elementProperties[ $art ]
-          { this.docComment( $art ); }
-          annotationAssignment_ll1[ $art ]*
-        )?
-        requiredSemi
-      |
-        typeRefOptArgs[ $art ]
-        { this.docComment( $art ); }
-        annotationAssignment_ll1[ $art ]*
-        (
-          ENUM '{' { $art.enum = this.createDict(); }
-          enumSymbolDef[ $art ]*
-          '}' { this.finalizeDictOrArray( $art.enum ); }
-          elementProperties[ $art ]?
-        |
-          elementProperties[ $art ]
-          { this.docComment( $art ); }
-          annotationAssignment_ll1[ $art ]*
-        )?
-        requiredSemi                     // also req after enum spec
-      )
-    |
-      // 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-field', $eq );
-        else if ($e.expr)
-          $art.value = $e.expr;
-      }
-      { this.docComment( $art ); }
-      annotationAssignment_ll1[ $art ]* // for enum symbol def via EXTEND
-      requiredSemi
-    )
-  ;
-
-extendElement[ art, outer ]
-@after{ /* #ATN 1 */ this.attachLocation( $art ); }
-  :
-    // #ATN: element name can be ELEMENT
-    ( expected=ELEMENT { $art.expectedKind = 'element'; } )?
-    name=ident['Element']
-    { this.addDef( $art, $outer, 'elements', 'extend', $name.id ); }
-    extendWithOptElementsOrType[ $art, $art ]
-  ;
-
-selectItemDef[ outer ] locals[ art ]
-@after{ if ($art) this.attachLocation( $art ); }
-  :
-    star='*'
-    { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
-  |
-    { $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 { $art.virtual = this.valueWithTokenLocation( true, $virtual ); } )?
-    ( key=KEY { $art.key = this.valueWithTokenLocation( true, $key ); } )?
-    selectItemDefBody[ $art, $outer ]
-  ;
-
-selectItemDefBody[ art, outer ]
-@after{ /* #ATN 2 */ }
-  :
-    { $outer.push( $art ); }
-    (
-      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
-      ( as=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 ); }
-      )
-      { if ($art.value && !$art.value.path) this.excludeExpected( ["'.'", "'{'"] );
-        else if ($art.name) this.excludeExpected( ["'.'"] );
-      }
-      (
-        { 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
-        (
-          selectItemInlineList[ $art, 'inline' ]
-          excludingClause[ $art ]?
-        |
-          star='*'
-          { $art.inline = [ this.valueWithTokenLocation( '*', $star ) ]; }
-        )
-      )?
-    |
-      selectItemInlineList[ $art, 'expand' ]
-      excludingClause[ $art ]?
-      AS n1=ident['Item'] { $art.name = $n1.id }
-    )
-    { this.docComment( $art ); }
-    annotationAssignment_fix[ $art ]*
-    ( ':'
-      // #ATN: typeRefOptArgs can start with TYPE, REDIRECTED
-      ( re=REDIRECTED to=TO
-        { $art.target = {}; }
-        simplePath[ $art.target, 'artref' ]
-        (
-          typeAssociationCont[ $art ]
-        |
-          { this.docComment( $art ); }
-          annotationAssignment_ll1[ $art ]*
-        )
-      | typeTypeOf[ $art ]
-        { 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!
-        ( typeToMany[ $art ] | typeToOne[ $art ] | simplePath[ $art.target, 'artref' ] )
-        typeAssociationCont[ $art ]?
-        { this.associationInSelectItem( $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] = this.createArray(); }
-    (
-      selectItemInlineDef[ $art[$clause] ]
-      ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
-        selectItemInlineDef[ $art[$clause] ]
-      )*
-    )?
-    '}' { this.finalizeDictOrArray( $art[$clause] ); }
-  ;
-
-selectItemInlineDef[ outer ] locals[ art ]
-@after{ if ($art) this.attachLocation( $art ); }
-  :
-    star='*'
-    { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
-  |
-    { $art = {};; this.docComment( $art ); }
-    annotationAssignment_atn[ $art ]*
-    selectItemDefBody[ $art, $outer ]
-  ;
-
-parameterListDef[ art ]
-  :
-    '(' { $art.params = this.createDict(); }
-    // also empty param list (we might do some hacking later to allow reserved words)
-    // see annotationAssignment_paren
-    (
-      parameterDef[ $art ]
-      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        parameterDef[ $art ]
-      )*
-    )?
-    ')' { this.finalizeDictOrArray( $art.params ); }
-  ;
-
-parameterDef[ outer ] locals[ art = {} ]
-@after { this.attachLocation( $art ); }
-  :
-    { this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-    name=ident['Param']
-    { this.addDef( $art, $outer, 'params', 'param', $name.id );
-      this.docComment( $art ); }
-    annotationAssignment_fix[ $art ]*
-    typeSpec[ $art ]
-    defaultValue[ $art ]?
-    { this.docComment( $art ); }
-    annotationAssignment_ll1[ $art ]*
-  ;
-
-nullability[ art ]
-  :
-    not=NOT n1=NULL
-    { $art.notNull = this.valueWithTokenLocation( true, $not, $n1 ); }
-  |
-    n2=NULL
-    { $art.notNull = this.valueWithTokenLocation( false, $n2 ); }
-  ;
-
-elementProperties[ elem ]
-  :
-    nullability[ $elem ]
-    defaultValue[ $elem ]?
-  |
-    defaultValue[ $elem ]
-    nullability[ $elem ]?
-  |
-    eq='='
-    { this.error( 'syntax-unsupported-field', $eq ); }
-    expression
-  ;
-
-// View definitions ----------------------------------------------------------
-
-viewDef[ art, outer ] locals[ name = {} ]
-@after { this.attachLocation( $art ); }
-  :
-    v=VIEW simplePath[ $name, 'Entity' ]
-    { $art['$'+'syntax'] = 'view';
-      this.addDef( $art, $outer, 'artifacts', 'entity', $name );
-      this.docComment( $art ); }
-    annotationAssignment_fix[ $art ]*
-    (
-      parameterListDef[ $art ]
-    |
-      // 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; }
-    // TODO check ANTLR: bad msg with 'view V as'<eof> but 'view V as FOO' is fine
-    requiredSemi
-  ;
-
-// Type references -----------------------------------------------------------
-
-includeRef[ art ] locals[ incl = {} ]
-  :
-    simplePath[ $incl, 'artref' ]
-    { if ($art.includes) $art.includes.push($incl); else $art.includes = [$incl]; }
-  ;
-
-typeSpec[ art ]                 // for params
-@after{ /* #ATN 1 */ }
-  :
-    typeStruct[ $art ]
-  |
-    ':'
-    // #ATN: typeSimple can start with ARRAY or TYPE
-    ( typeStruct[ $art ]
-      nullability[ $art ]?
-    | typeArray[ $art ] // nullability is set in typeArray
-    | typeTypeOf[ $art ]
-      nullability[ $art ]?
-      // TODO: no LOCALIZED ?
-    | typeRefOptArgs[ $art ]
-      nullability[ $art ]?
-      (
-        ENUM '{' { $art.enum = this.createDict(); }
-        enumSymbolDef[ $art ]*
-        '}' { this.finalizeDictOrArray( $art.enum ); }
-      )?
-    )
-  ;
-
-returnTypeSpec[ art ]
-@after{ /* #ATN 1 */ }
+returnTypeSpec[ art ]
+@after{ /* #ATN 1 */ }
   :
     ret=RETURNS { $art.returns = { location: this.tokenLocation( $ret ), kind: 'param' }; }
     // #ATN: typeSimple can start with ARRAY or TYPE
@@ -1468,6 +1180,11 @@ returnTypeSpec[ art ]
     | typeArray[ $art.returns ] // nullability is set in typeArray
     | typeTypeOf[ $art.returns ]
       nullability[ $art.returns ]?
+      (
+        ENUM '{' { $art.returns.enum = this.createDict(); }
+        enumSymbolDef[ $art.returns ]*
+        '}' { this.finalizeDictOrArray( $art.returns.enum ); }
+      )?
       // TODO: no LOCALIZED ?
     | typeRefOptArgs[ $art.returns ]
       nullability[ $art.returns ]?
@@ -1627,6 +1344,11 @@ typeArray[ art ]
       nullability[ $art.items ]?
     | typeTypeOf[ $art.items ]
       nullability[ $art.items ]?
+      (
+        ENUM '{' { $art.items.enum = this.createDict(); }
+        enumSymbolDef[ $art.items ]*
+        '}' { this.finalizeDictOrArray( $art.items.enum ); }
+      )?
     | typeRefOptArgs[ $art.items ]
       nullability[ $art.items ]?
       (
@@ -1742,235 +1464,499 @@ cardinality[ art ] locals[ card = {} ]
                               location: this.tokenLocation($trgMaxStar) }; }
       )
     )?
-    ']'
-  ;
-
-foreignKey[ outer ] locals[ art = {}, elem = {} ]
-@after { this.attachLocation($art); }
-  :
-    simplePath[ $elem, 'ref' ] { $art.targetElement = $elem; }
-    ( AS name=ident['Key'] )?
-    { this.addDef( $art, $outer, 'foreignKeys', 'key', ($ctx.name) ? $name.id : $elem.path ); }
+    ']'
+  ;
+
+nullability[ art ]
+  :
+    not=NOT n1=NULL
+    { $art.notNull = this.valueWithTokenLocation( true, $not, $n1 ); }
+  |
+    n2=NULL
+    { $art.notNull = this.valueWithTokenLocation( false, $n2 ); }
+  ;
+
+foreignKey[ outer ] locals[ art = {}, elem = {} ]
+@after { this.attachLocation($art); }
+  :
+    simplePath[ $elem, 'ref' ] { $art.targetElement = $elem; }
+    ( AS name=ident['Key'] )?
+    { this.addDef( $art, $outer, 'foreignKeys', 'key', ($ctx.name) ? $name.id : $elem.path ); }
+  ;
+
+typeTypeOf[ art ] locals[ _sync = 'nop' ]
+@after { this.attachLocation($art.type); }
+  :
+    TYPE OF
+    { $art.type = { scope: 'typeOf' }; }
+    simplePath[ $art.type, 'ref' ]
+    ( ':'
+      // If we have too much time, we could set the category of the simple path
+      // before to 'artref'
+      { $art.type.scope = $art.type.path.length; }
+      simplePath[ $art.type, 'ref']
+    )?
+  ;
+
+typeRefOptArgs[ art ]
+@init { $art.type = {}; }
+  :
+    simplePath[ $art.type, 'artref' ]
+    (
+      typeRefArgs[ $art ]
+    |
+      ':'
+      { $art.type.scope = $art.type.path.length; }
+      simplePath[ $art.type, 'ref']
+    )?
+  ;
+
+typeRefArgs[ art ]
+  :
+    paren='(' { $art['$'+'typeArgs'] = this.createArray(); }
+    (
+      // unnamed arguments
+      head=Number
+      { $art['$'+'typeArgs'].push( this.numberLiteral( $head ) ); }
+      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+        (
+          v=VARIABLE
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
+          }
+        |
+          f=FLOATING
+          { $art['$'+'typeArgs'].push(
+            { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
+          }
+        |
+          tail=Number
+          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
+        )
+      )*
+    |
+      // named arguments
+      typeNamedArg[ $art ]
+      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+        typeNamedArg[ $art ]
+      )*
+    )
+    ')'{ this.finalizeDictOrArray( $art['$'+'typeArgs']); }
+  ;
+
+typeNamedArgList[ art ]
+  :
+    paren='('
+    typeNamedArg[ $art ]
+    ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+      typeNamedArg[ $art ]
+    )*
+    ')'
+  ;
+
+typeNamedArg[ art ] locals[ arg = '' ]
+  :
+    name=ident['paramname']
+    ':'
+    { if ($name.id && this.checkTypeFacet( $art, $name.id ))
+        $arg = $name.id.id;
+    }
+    (
+      val=Number
+      { if ($arg && $art && $name.id) {
+          $art[$arg] = this.numberLiteral( $val );
+        }
+      }
+    |
+      v=VARIABLE
+      { if ($arg && $art && $name.id) {
+          $art[$arg] = { literal: 'string', val: 'variable', location: this.tokenLocation($v) };
+        }
+      }
+    |
+      f=FLOATING
+      { if ($arg && $art && $name.id) {
+          $art[$arg] = { literal: 'string', val: 'floating', location: this.tokenLocation($f) };
+        }
+      }
+    )
+  ;
+
+// Queries: the main query structure --------------------------------------------
+
+queryEOF returns [ query ]
+  :
+    q=queryExpression { $query = $q.query; } EOF
+  ;
+
+projectionSpec returns[ query ] locals[ src ]
+@after { this.attachLocation($query); }
+  :
+    proj=PROJECTION ON
+    // now a simplified `tableTerm`:
+    {
+      $src = { path: [], scope: 0 };
+      $query = { op: this.valueWithTokenLocation( 'SELECT', $proj ), from: $src, location: this.startLocation() };
+    }
+    fromPath[ $src, 'artref']
+    ( ':'
+      { $src.scope = $src.path.length; }
+      fromPath[ $src, 'ref']
+    )?
+    ( 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, 'columns' ]?
+    excludingClause[ $query ]?
+  ;
+
+projectionClauses[ query ]
+@after { this.attachLocation($query); }
+  :
+    ( WHERE cond=condition { $query.where = $cond.cond; } )?
+    (
+      GROUP BY
+      e1=expression { $query.groupBy = [ $e1.expr ]; }
+      ( ',' en=expression { $query.groupBy.push( $en.expr ); } )*
+    )?
+    ( HAVING having=condition { $query.having = $having.cond; } )?
+    ( ob=orderByClause[ $query ] { $query = $ob.query; } ) ?
+    ( lc=limitClause[ $query ]   { $query = $lc.query; } ) ?
+  ;
+
+queryExpression returns[ query ] // QLSubqueryComplex, SubqueryComplex
+@after{ this.attachLocation($query); }
+  :
+    qt1=queryTerm { $query = $qt1.query; }
+    (
+      ( op=UNION  q=( DISTINCT | ALL )?
+      | op=EXCEPT q=DISTINCT?
+      | op=MINUS  q=DISTINCT?
+      )
+      qt=queryTerm
+      { if ($qt.query) $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
+    )*
+    ( ob=orderByClause[ $query ] { if ($ob.query) $query = $ob.query; } ) ?
+    ( lc=limitClause[ $query ]   { if ($lc.query) $query = $lc.query; } ) ?
+  ;
+
+queryTerm returns[ query ]
+@after{ this.attachLocation($query); }
+  :
+    qt1=queryPrimary { $query = $qt1.query; }
+    (
+      intersect=INTERSECT quantifier=DISTINCT?
+      qt=queryPrimary
+      { $query = this.leftAssocBinaryOp( $query, $intersect, $quantifier, $qt.query );
+        $ctx.quantifier = null; }   // reset for loop
+    )*
+  ;
+
+queryPrimary returns[ query = {} ]
+@after { this.attachLocation($query); }
+  :
+    open='(' qe=queryExpression close=')'
+    { $query = this.surroundByParens( $qe.query, $open, $close ); }
+  |
+    select=SELECT
+    { $query = { op: this.valueWithTokenLocation( 'SELECT', $select ), location: this.startLocation() }; }
+    (
+      FROM querySource[ $query ]
+      (
+        mixin=MIXIN '{' { $query.mixin = this.createDict(); }
+        mixinElementDef[ $query ]*
+        '}' { this.finalizeDictOrArray( $query.mixin ); }
+        INTO
+      )?
+      ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
+      { $query.quantifier = this.valueWithTokenLocation( $ad.text.toLowerCase(), $ad ); }
+      )?
+      bracedSelectItemListDef[ $query, 'columns' ]?
+      excludingClause[ $query ]?
+    |
+      ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
+      { $query.quantifier = this.valueWithTokenLocation( $ad.text.toLowerCase(), $ad ); }
+      )?
+      { $query.columns = []; }  // set it early to avoid "wildcard" errors
+      selectItemDef[ $query.columns ]
+      ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
+        selectItemDef[ $query.columns ]
+      )*
+      FROM querySource[ $query ]
+    )
+    ( WHERE cond=condition { $query.where = $cond.cond; } )?
+    (
+      GROUP BY
+      e1=expression { $query.groupBy = [ $e1.expr ]; }
+      ( ',' en=expression { $query.groupBy.push( $en.expr ); } )*
+    )?
+    ( HAVING having=condition { $query.having = $having.cond; } )?
   ;
 
-typeTypeOf[ art ] locals[ _sync = 'nop' ]
-@after { this.attachLocation($art.type); }
+querySource[ query ]
+@after { this.attachLocation($query.from); }
   :
-    TYPE OF
-    { $art.type = { scope: 'typeOf' }; }
-    simplePath[ $art.type, 'ref' ]
-    ( ':'
-      // If we have too much time, we could set the category of the simple path
-      // before to 'artref'
-      { $art.type.scope = $art.type.path.length; }
-      simplePath[ $art.type, 'ref']
+    t1=tableExpression { $query.from = $t1.table; }
+    (
+      { const location = this.tokenLocation( this.getCurrentToken() );
+        $query.from = { op: { val: 'join', location },
+                        join: { val: 'cross', location },
+                        args: [$t1.table] }; }
+      ( ',' tn=tableExpression { if ($tn.table) $query.from.args.push( $tn.table ); } )+
     )?
   ;
 
-typeRefOptArgs[ art ]
-@init { $art.type = {}; }
+tableExpression returns[ table ] // TableOrJoin
+@after { this.attachLocation($table); }
   :
-    simplePath[ $art.type, 'artref' ]
+    qt=tableTerm { $table = $qt.table; }
     (
-      typeRefArgs[ $art ]
+      join=joinOp[ $table ] { $table = $join.table; }
+      te=tableExpression
+      { if (!$table) { $table = {}; } else if ($te.table) $table.args.push( $te.table ); }
+      ON cond=condition { $table.on = $cond.cond; }
     |
-      ':'
-      { $art.type.scope = $art.type.path.length; }
-      simplePath[ $art.type, 'ref']
-    )?
+      crj=CROSS jn=JOIN tt=tableTerm
+      { if (!$table) { $table = {}; } $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
+    )*
   ;
 
-typeRefArgs[ art ]
+tableTerm returns [ table ]
+@after{ /* #ATN 1 */ this.attachLocation($table); }
   :
-    paren='(' { $art['$'+'typeArgs'] = this.createArray(); }
+    { $table = { path: [], scope: 0 }; }
+    fromPath[ $table, 'artref']
+    ( ':'
+      { $table.scope = $table.path.length; }
+      fromPath[ $table, 'ref']
+    )?
+    ( AS n1=ident['FromAlias'] { $table.name = $n1.id }
+    | n2=identNoKeyword['FromAlias'] { $table.name = this.fragileAlias( $n2.id ); }
+      // if we would use rule `ident`, we would either had to make all JOIN
+      // kinds reserved or introduce ATN
+    )?
+    // ANTLR errors are better if we use ( A | B )? instead of ( A | B | ):
+    { if (!$table.name) this.classifyImplicitName( $table.scope ? 'FromAlias' : 'Without' ); }
+  |
+    open='('
+    // #ATN: The following alternative is not LL1, because both can start with
+    // left-paren, but queryExpression has SELECT after initial left-parens
     (
-      // unnamed arguments
-      head=Number
-      { $art['$'+'typeArgs'].push( this.numberLiteral( $head ) ); }
-      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        (
-          v=VARIABLE
-          { $art['$'+'typeArgs'].push(
-            { literal: 'string', val: 'variable', location: this.tokenLocation($v) } );
-          }
-        |
-          f=FLOATING
-          { $art['$'+'typeArgs'].push(
-            { literal: 'string', val: 'floating', location: this.tokenLocation($f) } );
-          }
-        |
-          tail=Number
-          { $art['$'+'typeArgs'].push( this.numberLiteral( $tail ) ); }
-        )
-      )*
+      qe=queryExpression close=')'
+      { $table = this.surroundByParens( $qe.query, $open, $close, true ); }
+      ( AS a1=ident['FromAlias'] { $table.name = $a1.id } // for defining table aliass
+      | a2=identNoKeyword['FromAlias'] { $table.name = this.fragileAlias( $a2.id, true ); }
+        // not using ident` to have a similar behavior to above
+      )
     |
-      // named arguments
-      typeNamedArg[ $art ]
-      ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-        typeNamedArg[ $art ]
-      )*
+      te=tableExpression close=')'
+      { $table = this.surroundByParens( $te.table, $open, $close ); }
     )
-    ')'{ this.finalizeDictOrArray( $art['$'+'typeArgs']); }
   ;
 
-typeNamedArgList[ art ]
+fromPath[ qp, idkind ]
+@after{ this.attachLocation($qp); }
   :
-    paren='('
-    typeNamedArg[ $art ]
-    ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-      typeNamedArg[ $art ]
+    id=ident[$idkind] { this.pushIdent( $qp.path, $id.id ); }
+    ( fromArguments[ $id.id ] cardinalityAndFilter[ $id.id ]?
+    | cardinalityAndFilter[ $id.id ]
+    )?
+    (
+      '.' id=ident[$idkind] { this.pushIdent( $qp.path, $id.id ); }
+      ( fromArguments[ $id.id ] cardinalityAndFilter[ $id.id ]?
+      | cardinalityAndFilter[ $id.id ]
+      )?
     )*
-    ')'
   ;
 
-typeNamedArg[ art ] locals[ arg = '' ]
+fromArguments[ pathStep ]
+@init{ if (!$pathStep) $pathStep = {}; } // grammar robustness, see test/negative/parser/NamedExpression.cds
   :
-    name=ident['paramname']
-    ':'
-    { if ($name.id && this.checkTypeFacet( $art, $name.id ))
-        $arg = $name.id.id;
-    }
-    (
-      val=Number
-      { if ($arg && $art && $name.id) {
-          $art[$arg] = this.numberLiteral( $val );
-        }
-      }
-    |
-      v=VARIABLE
-      { if ($arg && $art && $name.id) {
-          $art[$arg] = { literal: 'string', val: 'variable', location: this.tokenLocation($v) };
-        }
-      }
-    |
-      f=FLOATING
-      { if ($arg && $art && $name.id) {
-          $art[$arg] = { literal: 'string', val: 'floating', location: this.tokenLocation($f) };
-        }
-      }
-    )
+    '(' { $pathStep.args = this.createDict(); $pathStep['$'+'syntax'] = ':'; } // necessary?
+    name=ident['paramname'] ':'
+    namedExpression[ $pathStep, $name.id ]
+    ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
+      name=ident['paramname'] ':'
+      namedExpression[ $pathStep, $name.id ]
+    )*
+    ')' { this.finalizeDictOrArray( $pathStep.args ); }
   ;
 
+// Queries: columns and other clauses -------------------------------------------
 
-// Queries -------------------------------------------------------------------
-
-queryExpression returns[ query ] // QLSubqueryComplex, SubqueryComplex
-@after{ this.attachLocation($query); }
+excludingClause[ query ]
   :
-    qt1=queryTerm { $query = $qt1.query; }
-    (
-      ( op=UNION  q=( DISTINCT | ALL )?
-      | op=EXCEPT q=DISTINCT?
-      | op=MINUS  q=DISTINCT?
-      )
-      qt=queryTerm
-      { if ($qt.query) $query = this.leftAssocBinaryOp( $query, $op, $q, $qt.query );; $ctx.q = null; }
+    // syntax is less than ideal - EXCLUDING is only useful for `*` - with
+    // this syntax, people wonder what happens with explicit select items
+    EXCLUDING '{' { $query.excludingDict = this.createDict(); }
+    projectionExclusion[ $query ]
+    ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
+      projectionExclusion[ $query ]
     )*
-    ( ob=orderByClause[ $query ] { if ($ob.query) $query = $ob.query; } ) ?
-    ( lc=limitClause[ $query ]   { if ($lc.query) $query = $lc.query; } ) ?
-  ;
-
-orderByClause[ inQuery ] returns [ query ]
-  :
-    ORDER BY { $query = this.unaryOpForParens( $inQuery, '$'+'query' ); }
-    ob1=orderBySpec { $query.orderBy = [ $ob1.ob ]; }
-    ( ',' obn=orderBySpec  { $query.orderBy.push( $obn.ob ); } )*
+    '}' { this.finalizeDictOrArray( $query.excludingDict ); }
   ;
 
-// Generic function ORDER BY clause, e.g. `first_value(id order by name)`
-// lhsExpr is the left expression of the ORDER BY clause.
-functionOrderByClause[ lhsExpr ] returns [ expr ]
-@after { this.attachLocation( $expr ); }
+projectionExclusion[ outer ] locals[ art = {} ]
+@after { this.attachLocation($art); }
   :
-    o=ORDER b=BY { $expr = { op: this.valueWithTokenLocation( 'orderBy', $o, $b ) , args: [ $lhsExpr ] }}
-    ob1=orderBySpec { $expr.args.push( $ob1.ob ); }
-    ( ',' obn=orderBySpec { $expr.args.push( $obn.ob ); } )*
+    name=ident['ref']
+    { this.addDef( $art, $outer, 'excludingDict', '', $name.id ); }
   ;
 
-overOrderByClause returns [ expr ]
-@after { this.attachLocation( $expr ); }
+// 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); }
   :
-    o=ORDER b=BY { $expr = { op: this.valueWithTokenLocation( 'overOrderBy', $o, $b ) , args: [] }}
-    ob1=orderBySpec { $expr.args.push( $ob1.ob ); }
-    ( ',' obn=orderBySpec { $expr.args.push( $obn.ob ); } )*
+    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 ); }
+    )
+    requiredSemi
   ;
 
-partitionByClause returns [ expr ]
-@after { this.attachLocation( $expr ); }
+selectItemDef[ outer ] locals[ art ]
+@after{ if ($art) this.attachLocation( $art ); }
   :
-    p=PARTITION b=BY { $expr = { op: this.valueWithTokenLocation( 'partitionBy', $p, $b ) , args: [] }}
-    e1=expression { $expr.args.push( $e1.expr ); }
-    ( ',' en=expression { $expr.args.push( $en.expr ); } )*
+    star='*'
+    { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
+  |
+    { $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 { $art.virtual = this.valueWithTokenLocation( true, $virtual ); } )?
+    ( key=KEY { $art.key = this.valueWithTokenLocation( true, $key ); } )?
+    selectItemDefBody[ $art, $outer ]
   ;
 
-windowFrameClause returns [ wf ]
-@after { this.attachLocation( $wf ); }
+selectItemDefBody[ art, outer ] locals[ assoc ]
+@after{ /* #ATN 2 */ }
   :
-    r=ROWS { $wf = { op: this.valueWithTokenLocation( 'rows', $r ) , args: [] }}
-    wfe=windowFrameExtentSpec { $wf.args.push( $wfe.wfe ); }
+    { $outer.push( $art ); }
+    (
+      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
+      ( as=AS n1=ident['Item'] { $art.name = $n1.id }
+      | n2=ident['Item'] { $art.name = this.fragileAlias( $n2.id, true ); }
+      | { this.classifyImplicitName( 'Item', $e.expr ); }
+      )
+      { if ($art.value && !$art.value.path) this.excludeExpected( ["'.'", "'{'"] );
+        else if ($art.name) this.excludeExpected( ["'.'"] );
+      }
+      (
+        { 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
+        (
+          selectItemInlineList[ $art, 'inline' ]
+          excludingClause[ $art ]?
+        |
+          star='*'
+          { $art.inline = [ this.valueWithTokenLocation( '*', $star ) ]; }
+        )
+      )?
+    |
+      selectItemInlineList[ $art, 'expand' ]
+      excludingClause[ $art ]?
+      AS n1=ident['Item'] { $art.name = $n1.id }
+    )
+    { this.docComment( $art ); }
+    annotationAssignment_fix[ $art ]*
+    ( ':'
+      // #ATN: typeRefOptArgs can start with TYPE, REDIRECTED, ASSOCIATION
+      ( re=REDIRECTED to=TO
+        { $art.target = {}; }
+        simplePath[ $art.target, 'artref' ]
+        (
+          typeAssociationCont[ $art ]
+        |
+          { this.docComment( $art ); }
+          annotationAssignment_ll1[ $art ]*
+        )
+      | typeTypeOf[ $art ]
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
+      | l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
+        typeRefOptArgs[ $art ]
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
+      | typeRefOptArgs[ $art ]
+        { this.docComment( $art ); }
+        annotationAssignment_ll1[ $art ]*
+      |
+        { $assoc = this.associationInSelectItem( $art ); }
+        typeAssociationBase[ $assoc, false ]
+        // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
+        ( typeToMany[ $assoc ] | typeToOne[ $assoc ] | simplePath[ $assoc.target, 'artref' ] )
+        ON cond=condition
+        { $assoc.on=$cond.cond; }
+      )
+    )?
   ;
 
-windowFrameExtentSpec returns[ wfe ]
-@after { this.attachLocation( $wfe ); }
+bracedSelectItemListDef[ query ]
   :
-    { $wfe = {} }
-    windowFrameStartSpec [ $wfe ]
-  |
-    b=BETWEEN
-    { $wfe = { op: this.valueWithTokenLocation( 'frameBetween', $b ), args: [] } }
-    wfb1=windowFrameBoundSpec { $wfe.args.push( $wfb1.wfb ); }
-    AND
-    wfb2=windowFrameBoundSpec { $wfe.args.push( $wfb2.wfb ); }
+    '{' { $query.columns = this.createArray(); }
+    (
+      selectItemDef[ $query.columns ]
+      ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
+        selectItemDef[ $query.columns ]
+      )*
+    )?
+    '}' { this.finalizeDictOrArray( $query.columns ); }
   ;
 
-windowFrameBoundSpec returns [ wfb ]
-@after{ /* #ATN 1 */ }
+selectItemInlineList[ art, clause ]
   :
-    // #ATN:  Not ll1 because `UNBOUNDED` could also be part of the windowFrameStartSpec
-    //        `UNBOUNDED` would then be immediately followed by `PRECEDING`
-    u=UNBOUNDED f=FOLLOWING
-    { $wfb = { op: this.valueWithTokenLocation( 'unboundedFollowing', $u, $f ), args: []} }
-  |
-    // #ATN:  Not ll1 because `Number` could also be part of the windowFrameStartSpec
-    //        `Number` would then be immediately followed by `PRECEDING`
-    n=Number f=FOLLOWING
-    { $wfb = { op: this.valueWithTokenLocation( 'following', $n, $f ), args: [ this.numberLiteral( $n ) ]} }
-  |
-    { $wfb = {} }
-    windowFrameStartSpec [ $wfb ]
+    '{' { $art[$clause] = this.createArray(); }
+    (
+      selectItemInlineDef[ $art[$clause] ]
+      ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
+        selectItemInlineDef[ $art[$clause] ]
+      )*
+    )?
+    '}' { this.finalizeDictOrArray( $art[$clause] ); }
   ;
 
-windowFrameStartSpec [ wf ]
-@after { this.attachLocation( $wf ); }
+selectItemInlineDef[ outer ] locals[ art ]
+@after{ if ($art) this.attachLocation( $art ); }
   :
-    u=UNBOUNDED p=PRECEDING
-    {
-      $wf.op = this.valueWithTokenLocation( 'unboundedPreceding', $u, $p );
-      $wf.args = [];
-    }
-  |
-    n=Number p=PRECEDING
-    {
-      $wf.op = this.valueWithTokenLocation( 'preceding', $p );
-      $wf.args = [ this.numberLiteral( $n ) ];
-    }
+    star='*'
+    { $outer.push( this.valueWithTokenLocation( '*', $star ) ); }
   |
-    c=CURRENT r=ROW
-    {
-      $wf.op = this.valueWithTokenLocation( 'currentRow', $c, $r );
-      $wf.args = [];
-    }
+    { $art = {};; this.docComment( $art ); }
+    annotationAssignment_atn[ $art ]*
+    selectItemDefBody[ $art, $outer ]
   ;
 
-overClause returns [ over ]
-@after { this.attachLocation( $over ); }
+orderByClause[ inQuery ] returns [ query ]
   :
-    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 ); } )?
-    ')'
+    ORDER BY { $query = this.unaryOpForParens( $inQuery, '$'+'query' ); }
+    ob1=orderBySpec { $query.orderBy = [ $ob1.ob ]; }
+    ( ',' obn=orderBySpec  { $query.orderBy.push( $obn.ob ); } )*
   ;
 
 limitClause[ inQuery ] returns [ query ]
@@ -1994,87 +1980,6 @@ orderBySpec returns[ ob ]
     )?
   ;
 
-queryTerm returns[ query ]
-@after{ this.attachLocation($query); }
-  :
-    qt1=queryPrimary { $query = $qt1.query; }
-    (
-      intersect=INTERSECT quantifier=DISTINCT?
-      qt=queryPrimary
-      { $query = this.leftAssocBinaryOp( $query, $intersect, $quantifier, $qt.query );
-        $ctx.quantifier = null; }   // reset for loop
-    )*
-  ;
-
-queryPrimary returns[ query = {} ]
-@after { this.attachLocation($query); }
-  :
-    open='(' qe=queryExpression close=')'
-    { $query = this.surroundByParens( $qe.query, $open, $close ); }
-  |
-    select=SELECT
-    { $query = { op: this.valueWithTokenLocation( 'SELECT', $select ), location: this.startLocation() }; }
-    (
-      FROM querySource[ $query ]
-      (
-        mixin=MIXIN '{' { $query.mixin = this.createDict(); }
-        mixinElementDef[ $query ]*
-        '}' { this.finalizeDictOrArray( $query.mixin ); }
-        INTO
-      )?
-      ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
-      { $query.quantifier = this.valueWithTokenLocation( $ad.text.toLowerCase(), $ad ); }
-      )?
-      bracedSelectItemListDef[ $query, 'columns' ]?
-      excludingClause[ $query ]?
-    |
-      ( ad=( ALL | DISTINCT )     // TODO: or directly after SELECT ?
-      { $query.quantifier = this.valueWithTokenLocation( $ad.text.toLowerCase(), $ad ); }
-      )?
-      { $query.columns = []; }  // set it early to avoid "wildcard" errors
-      selectItemDef[ $query.columns ]
-      ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
-        selectItemDef[ $query.columns ]
-      )*
-      FROM querySource[ $query ]
-    )
-    ( WHERE cond=condition { $query.where = $cond.cond; } )?
-    (
-      GROUP BY
-      e1=expression { $query.groupBy = [ $e1.expr ]; }
-      ( ',' en=expression { $query.groupBy.push( $en.expr ); } )*
-    )?
-    ( HAVING having=condition { $query.having = $having.cond; } )?
-  ;
-
-querySource[ query ]
-@after { this.attachLocation($query.from); }
-  :
-    t1=tableExpression { $query.from = $t1.table; }
-    (
-      { const location = this.tokenLocation( this.getCurrentToken() );
-        $query.from = { op: { val: 'join', location },
-                        join: { val: 'cross', location },
-                        args: [$t1.table] }; }
-      ( ',' tn=tableExpression { if ($tn.table) $query.from.args.push( $tn.table ); } )+
-    )?
-  ;
-
-tableExpression returns[ table ] // TableOrJoin
-@after { this.attachLocation($table); }
-  :
-    qt=tableTerm { $table = $qt.table; }
-    (
-      join=joinOp[ $table ] { $table = $join.table; }
-      te=tableExpression
-      { if (!$table) { $table = {}; } else if ($te.table) $table.args.push( $te.table ); }
-      ON cond=condition { $table.on = $cond.cond; }
-    |
-      crj=CROSS jn=JOIN tt=tableTerm
-      { if (!$table) { $table = {}; } $table = this.leftAssocBinaryOp( $table, $jn, $crj, $tt.table, 'join' ); }
-    )*
-  ;
-
 joinOp[ left ] returns[ table ] locals [ join ]
   :
     ( op=JOIN { $join = 'inner'; }
@@ -2122,55 +2027,7 @@ joinCardinality returns [ joinCard ]
     )
   ;
 
-tableTerm returns [ table ]
-@after{ /* #ATN 1 */ this.attachLocation($table); }
-  :
-    { $table = { path: [], scope: 0 }; }
-    fromPath[ $table, 'artref']
-    ( ':'
-      { $table.scope = $table.path.length; }
-      fromPath[ $table, 'ref']
-    )?
-    ( AS n1=ident['FromAlias'] { $table.name = $n1.id }
-    | n2=identNoKeyword['FromAlias'] { $table.name = this.fragileAlias( $n2.id ); }
-      // if we would use rule `ident`, we would either had to make all JOIN
-      // kinds reserved or introduce ATN
-    )?
-    // ANTLR errors are better if we use ( A | B )? instead of ( A | B | ):
-    { if (!$table.name) this.classifyImplicitName( $table.scope ? 'FromAlias' : 'Without' ); }
-  |
-    open='('
-    // #ATN: The following alternative is not LL1, because both can start with
-    // left-paren, but queryExpression has SELECT after initial left-parens
-    (
-      qe=queryExpression close=')'
-      { $table = this.surroundByParens( $qe.query, $open, $close, true ); }
-      ( AS a1=ident['FromAlias'] { $table.name = $a1.id } // for defining table aliass
-      | a2=identNoKeyword['FromAlias'] { $table.name = this.fragileAlias( $a2.id, true ); }
-        // not using ident` to have a similar behavior to above
-      )
-    |
-      te=tableExpression close=')'
-      { $table = this.surroundByParens( $te.table, $open, $close ); }
-    )
-  ;
-
-fromPath[ qp, idkind ]
-@after{ this.attachLocation($qp); }
-  :
-    id=ident[$idkind] { this.pushIdent( $qp.path, $id.id ); }
-    ( fromArguments[ $id.id ] cardinalityAndFilter[ $id.id ]?
-    | cardinalityAndFilter[ $id.id ]
-    )?
-    (
-      '.' id=ident[$idkind] { this.pushIdent( $qp.path, $id.id ); }
-      ( fromArguments[ $id.id ] cardinalityAndFilter[ $id.id ]?
-      | cardinalityAndFilter[ $id.id ]
-      )?
-    )*
-  ;
-
-// Conditions and expressions ------------------------------------------------
+// Conditions and expressions ---------------------------------------------------
 
 // With "separate" `condition` and `expression` rules, we have long LL
 // ambiguities (not so with LALR used in Bison) with initial left parentheses:
@@ -2186,221 +2043,214 @@ fromPath[ qp, idkind ]
 // be then ensured by code (either in actions of the grammar or in a check
 // phase - to be discussed).
 //
+// We cannot generally allow `condition` where `expression` is written:
+//  - IN is also used in non-standard function `args` and as predicate:
+//  - AND is boolean operator and also used for BETWEEN…AND
+//
 // ANTLR4s left-recursion feature cannot be used as we will have rule
 // arguments.
 
-condition returns [ cond ] locals [ args = [], orl = [] ]
-@after{
-  $cond = ($args.length === 1)
-    ? this.attachLocation( $args[0] )
-    : this.attachLocation({ op: $orl[0], args: $args });
-}
+conditionEOF returns [ cond ]
+  :
+    c=condition { $cond = $c.cond; } EOF
+  ;
+
+condition returns [ cond ] locals[ args = [] ]
+@after{ $cond = this.argsExpression( $args ); }
   :
     c1=conditionAnd { $args.push($c1.cond); }
-    ( or=OR c2=conditionAnd { $args.push($c2.cond); $orl.push(this.valueWithTokenLocation( 'or', $or ))} )*
+    (
+      or=OR { this.pushXprToken( $args ); }
+      c2=conditionAnd { $args.push($c2.cond); }
+    )*
   ;
 
-conditionAnd returns [ cond ] locals [ args = [], andl = [] ]
-@after{
-  $cond = ($args.length === 1)
-    ? $args[0]
-    : this.attachLocation({ op: $andl[0], args: $args });
-}
+conditionAnd returns [ cond ] locals[ args = [] ]
+@after{ $cond = this.argsExpression( $args, null, 'and' ); } // 'and' used by A2J and checks
   :
     c1=conditionTerm { $args.push($c1.cond); }
-    ( and=AND c2=conditionTerm { $args.push($c2.cond); $andl.push(this.valueWithTokenLocation( 'and', $and )) } )*
+    (
+      and=AND { this.pushXprToken( $args ); }
+      c2=conditionTerm { $args.push($c2.cond); }
+    )*
   ;
 
 // Note: New operators need to be added to functionExpressionOperatorsRequireParentheses[] in toCdl.js.
-conditionTerm returns [ cond ]
-@after{
-  if ($cond) { this.attachLocation($cond); } else { $cond = $expr.expr; }
-}
+conditionTerm returns [ cond ] locals[ args = [] ]
+@after{ $cond = this.argsExpression( $args, null, '=' ); }// op: '=' used by A2J and checks
   :
-    nt=NOT ct=conditionTerm
-    { $cond = { op: this.valueWithTokenLocation( 'not', $nt ), args: [ $ct.cond ] }; }
+    nt=NOT { this.pushXprToken( $args ); }
+    ct=conditionTerm { $args.push( $ct.cond ); }
   |
-    ex=EXISTS
+    EXISTS { this.pushXprToken( $args ); }
     (
       open='(' qe=queryExpression close=')'
-      { $cond = { op: this.valueWithTokenLocation( 'exists', $ex ),
-                  args: [ this.surroundByParens( $qe.query, $open, $close, true ) ] }; }
+      { $args.push( this.surroundByParens( $qe.query, $open, $close, true ) ); }
     |
       qm=( HideAlternatives | '?' )
-      { $cond = { op: this.valueWithTokenLocation( 'exists', $ex ), args: [
-          { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' }
-        ] };
-        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
+      { $args.push( { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' } );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', code: '?' } );
       }
     |
-      ep=valuePath[ 'ref' ]
-      { $ep.qp['$'+'expected'] = 'exists';
-        $cond = { op: this.valueWithTokenLocation( 'exists', $ex ), args: [ $ep.qp ] };
-      }
+      ep=valuePath[ 'ref' ] { $args.push( $ep.qp ); }
+      { $ep.qp['$'+'expected'] = 'exists'; } // hm, really in parser? what about CSN input?
     )
   |
-    expr=expression             // see @after
+    expr=expression { $args.push( $expr.expr ); }
     (
-      rel=( '=' | '<>' | '>'  | '>=' | '<' | '<=' | '!=' )
-      { $cond = { op: this.valueWithTokenLocation( $rel.text, $rel ), args: [ $expr.expr ] }; }
-      ( asa=( ANY | SOME | ALL )
-        { $cond.quantifier = this.valueWithTokenLocation( $asa.text.toLowerCase(), $asa ); }
-      )?
-      e2=expression { $cond.args.push($e2.expr); }
+      ( '=' | '<>' | '>'  | '>=' | '<' | '<=' | '!=' ) { this.pushXprToken( $args ); }
+      ( ( ANY | SOME | ALL ) { this.pushXprToken( $args ); } )?
+      e2=expression { $args.push( $e2.expr ); }
     |
-      IS ( inn=NOT NULL | innu=NULL )
-      { $cond = { op: $inn ? this.valueWithTokenLocation( 'isNotNull', $inn ) : this.valueWithTokenLocation( 'isNull', $innu ), args: [ $expr.expr ] }; }
+      IS { this.pushXprToken( $args ); }
+      ( NOT { this.pushXprToken( $args ); } )?
+      NULL { this.pushXprToken( $args ); }
     |
-      { $cond = { args: [ $expr.expr ] }; }
-      NOT predicate[ $cond, true ]
-      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
+      NOT { this.pushXprToken( $args ); }
+      predicate[ $args ]
     |
-      { $cond = { args: [ $expr.expr ] }; }
-      predicate[ $cond, false ]
-      { if (!$cond.op) $cond = null; } // predicate failed to parse, avoid subseqential errors
+      predicate[ $args ]
     )?                          // optional: for conditions in parentheses
   ;
 
 // Note: New operators need to be added to functionExpressionOperatorsRequireParentheses[] in toCdl.js.
-predicate[ cond, negated ]
-// As an alternative, we could have a `negated` properties for the operations
-// `isNull`(!), `in`, `between` and `like` (or produce the same AST as for
-//    NOT (a BETWEEN b AND c)
+predicate[ args ]
   :
-    ino=IN e1=expression        // including ExpressionList
-    { $cond.op = this.valueWithTokenLocation( (negated) ? 'notIn' : 'in', $ino ); $cond.args.push( $e1.expr ); }
+    IN { this.pushXprToken( $args ); }
+    // TODO: do we really allow it not to start with `(`? - TODO: try with warning
+    e1=expression { $args.push( this.secureParens( $e1.expr ) ); } // including ExpressionList
   |
-    bw=BETWEEN e2=expression
-    { $cond.op = this.valueWithTokenLocation( (negated) ? 'notBetween' : 'between', $bw ); $cond.args.push( $e2.expr ); }
-    AND e3=expression { $cond.args.push( $e3.expr ); }
+    BETWEEN { this.pushXprToken( $args ); }
+    e2=expression { $args.push( $e2.expr ); }
+    AND { this.pushXprToken( $args ); }
+    e3=expression { $args.push( $e3.expr ); }
   |
-    lk=LIKE e4=expression
-    { $cond.op = this.valueWithTokenLocation( (negated) ? 'notLike' : 'like', $lk ); $cond.args.push( $e4.expr ); }
-    ( ESCAPE e5=expression { $cond.args.push( $e5.expr ); } )?
+    LIKE { this.pushXprToken( $args ); }
+    e4=expression { $args.push( $e4.expr ); }
+    ( ESCAPE { this.pushXprToken( $args ); }
+      e5=expression { $args.push( $e5.expr ); }
+    )?
   ;
 
-expression returns [ expr ]
-@after{ if ($expr) { this.attachLocation($expr); } else { $expr = this.attachLocation({});} }
+expression returns [ expr ] locals [ args = [] ]
+@after{ $expr = this.argsExpression( $args ); }
   :
-    e1=expressionSum { $expr = $e1.expr; }
+    e1=expressionSum { $args.push( $e1.expr ); }
     (
-      or='||' e2=expressionSum
-      {
-        $expr = {
-          op: this.valueWithTokenLocation( '||', $or ), args: [$expr, $e2.expr],
-          location: this.combinedLocation( $expr, $e2.expr ) };
-      }
+      '||' { this.pushXprToken( $args ); }
+      e2=expressionSum { $args.push( $e2.expr ); }
     )*
   ;
 
-expressionSum returns [ expr ]
-@after{ if ($expr) this.attachLocation($expr); }
+expressionSum returns [ expr ] locals [ args = [] ]
+@after{ $expr = this.argsExpression( $args ); }
   :
-    e1=expressionFactor { $expr = $e1.expr; }
+    e1=expressionFactor { $args.push( $e1.expr ); }
     (
-      op=( '+' | '-' ) e2=expressionFactor
-      {
-        $expr = {
-          op: this.valueWithTokenLocation( $op.text, $op ), args: [$expr, $e2.expr],
-          location: this.combinedLocation( $expr, $e2.expr ) };
-      }
+      ( '+' | '-' ) { this.pushXprToken( $args ); }
+      e2=expressionFactor { $args.push( $e2.expr ); }
     )*
   ;
 
-expressionFactor returns [ expr ]
-@after{ if ($expr) this.attachLocation($expr); }
+expressionFactor returns [ expr ] locals [ args = [] ]
+@after{ $expr = this.argsExpression( $args ); }
   :
-    e1=expressionTerm { $expr = $e1.expr; }
+    e1=expressionTerm { $args.push( $e1.expr ); }
     (
-      op=( '*' | '/' ) e2=expressionTerm
-      {
-        $expr = {
-          op: this.valueWithTokenLocation( $op.text, $op ), args: [$expr, $e2.expr],
-          location: this.combinedLocation( $expr, $e2.expr ) };
-      }
+      ( '*' | '/' ) { this.pushXprToken( $args ); }
+      e2=expressionTerm { $args.push( $e2.expr ); }
     )*
   ;
 
-expressionTerm returns [ expr ] locals [ op, args = [] ]
-@after{ /* #ATN 1 */ this.attachLocation($expr); }
+expressionTerm returns [ expr ] locals [ args = [] ]
+@after{ /* #ATN 1 */ $expr = this.argsExpression( $args ); }
   :
-    unary=( '+' | '-' ) e1=expressionTerm // prefix op or part of the number
-    { $expr = this.signedExpression( $unary, $e1.expr ); }
+    ( '+' | '-' )  { this.pushXprToken( $args ); }
+    e1=expressionTerm // prefix op or part of the number
+    { this.signedExpression( $args, $e1.expr ); }
   |
+    val=literalValue { $args.push( $val.val ); }
+  |
+    sf=specialFunction { $args.push( $sf.ret ); }
+  |
+    CASE { this.pushXprToken( $args ); }
     (
-      val=literalValue
-      { $expr = $val.val; }
-    |
-      sf=specialFunction
-      { $expr = $sf.ret; }
-    |
-      ca=CASE
-      { $expr = { op : this.valueWithTokenLocation( 'case', $ca ), args: [] }; }
-      (
-        e2=expression { $expr.args.push($e2.expr); }
-        ( ow=WHEN ew=expression THEN e3=expression
-          { $expr.args.push( this.createPrefixOp( $ow, [ $ew.expr, $e3.expr ] ) ); }
-        )+
-      |
-        ( ow=WHEN c=condition THEN e3=expression
-          { $expr.args.push( this.createPrefixOp( $ow, [ $c.cond, $e3.expr ] ) ); }
-        )+
-      )
-      ( el=ELSE e4=expression
-        { $expr.args.push( this.createPrefixOp( $el, [ $e4.expr ] ) ); }
-      )?
-      END
-    |
-      ne=NEW nqp=valuePath[ 'ref', null] // token rewrite for NEW
-      // please note: there will be no compiler-supported code completion after NEW
-      { $expr = { op: this.valueWithTokenLocation( 'new', $ne ), args: [] };
-        this.error( 'syntax-unsupported-new', $ne, { keyword: $ne.text }, '$(KEYWORD) is not supported' ); }
+      e2=expression { $args.push( $e2.expr ); }
+      ( WHEN { this.pushXprToken( $args ); }
+        ew=expression { $args.push( $ew.expr ); }
+        THEN { this.pushXprToken( $args ); }
+        e3=expression { $args.push( $e3.expr ); }
+      )+
     |
-      vp=valuePath[ 'ref', null ] { $expr = this.valuePathAst( $vp.qp ); }
-      { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
       (
-        over=overClause { $expr.suffix = [ $over.over ] }
-      )?
-    |
-      ':'
-      ( vp=valuePath[ 'paramref', this.startLocation() ]
-        { $expr = $vp.qp;; $expr.scope = 'param'; }
-      | pp=Number
-        { $expr = { param: this.numberLiteral( $pp ), scope: 'param' };
-          this.csnParseOnly( 'syntax-unsupported-param', [ $pp ], { '#': 'positional', name: ':' + $pp.text } );
-        }
-      )
+        WHEN { this.pushXprToken( $args ); }
+        c=condition { $args.push( $c.cond ); }
+        THEN { this.pushXprToken( $args ); }
+        e3=expression { $args.push( $e3.expr ); }
+      )+
+    )
+    (
+      ELSE { this.pushXprToken( $args ); }
+      e4=expression { $args.push( $e4.expr ); }
+    )?
+    END { this.pushXprToken( $args ); }
+  |
+    ne=NEW  { this.pushXprToken( $args ); } // token rewrite for NEW
+    // please note: there will be no compiler-supported code completion after NEW
+    { $expr = { op: this.valueWithTokenLocation( 'new', $ne ), args: [] };
+      this.error( 'syntax-unsupported-new', $ne, { keyword: $ne.text }, '$(KEYWORD) is not supported' ); }
+    nqp=valuePath[ 'ref', null ]
+  |
+    vp=valuePath[ 'ref', null ] { $args.push( this.valuePathAst( $vp.qp ) ); }
+    { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
+    (
+      { $args[0].suffix = []; }
+      OVER { this.pushXprToken( $args[0].suffix ); }
+      open='(' over=overClause close=')'
+      { $args[0].suffix.push( this.surroundByParens( $over.over, $open, $close ) ); }
+    )?
+  |
+    ':'
+    (
+      vp=valuePath[ 'paramref', this.startLocation() ]
+      {{ const par = $vp.qp;; par.scope = 'param';; $args.push( par ); }}
     |
-      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( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', name: '?' } );
+      pp=Number
+      { $args.push( { param: this.numberLiteral( $pp ), scope: 'param' } );
+        this.csnParseOnly( 'syntax-unsupported-param', [ $pp ], { '#': 'positional', code: ':' + $pp.text } );
       }
+    )
+  |
+    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)
+    { $args.push( { param: this.valueWithTokenLocation( '?', $qm ), scope: 'param' } );
+      this.csnParseOnly( 'syntax-unsupported-param', [ $qm ], { '#': 'dynamic', code: '?' } );
+    }
+  |
+    open='('
+    // #ATN: The following alternative is not LL1, because both can start with
+    // left-paren, but queryExpression has SELECT after initial left-parens
+    (
+      qe=queryExpression close=')'
+      { $args.push( this.surroundByParens( $qe.query, $open, $close, true ) ); }
     |
-      open='('
-      // #ATN: The following alternative is not LL1, because both can start with
-      // left-paren, but queryExpression has SELECT after initial left-parens
-      (
-        qe=queryExpression close=')'
-        { $expr = this.surroundByParens( $qe.query, $open, $close, true ); }
-      |
-        c1=condition { $expr = [ $c1.cond ]; }
-        ( ',' { if ($expr.length > 1 && this.isStraightBefore(')')) break; } // allow ',' before ')'
-          cn=expression { if ($cn.expr) $expr.push($cn.expr); }
-        )*
-        close=')'
-        {
-          if ($expr.length > 1)
-            $expr = { op: this.valueWithTokenLocation( ',', $open ), args: $expr };
-          else if ($expr[0]) // can be `null` if condition failed to parse
-            $expr = this.surroundByParens( $expr[0], $open, $close );
-        }
-      )
+      c1=condition { $args = [ $c1.cond ]; }
+      ( ',' { if ($args.length > 1 && this.isStraightBefore(')')) break; } // allow ',' before ')'
+        cn=expression { if ($cn.expr) $args.push($cn.expr); }
+      )*
+      close=')'
+      {
+        if ($args.length > 1)
+          $args = [ { op: this.valueWithTokenLocation( 'list', $open ), args: $args,
+                    location: this.tokenLocation( $open, $close ) } ];
+        else if ($args[0]) // can be `null` if condition failed to parse
+          $args = [ this.surroundByParens( $args[0], $open, $close ) ];
+      }
     )
   ;
 
-specialFunction returns [ ret = { } ] locals[ art = {} ]
+specialFunction returns [ ret = {} ] locals[ art = {} ]
   :
     ca=CAST '('                 // see createArray() in action
     {
@@ -2417,9 +2267,21 @@ specialFunction returns [ ret = { } ] locals[ art = {} ]
     ')' { this.finalizeDictOrArray( $ret.args ); }
   ;
 
-// query path includes aggregation:
-// ( COUNT | MIN | MAX | SUM | AVG | STDDEV | VAR )
-// '(' ( '*' | expression | ALL expression | DISTINCT expression_list ) ')'
+// Paths and functions: ---------------------------------------------------------
+
+simplePath[ art, category ] locals[ _sync = 'nop' ]
+@after { this.attachLocation($art); }
+// Due to error recovery, rule `ident` can return with value `null`.  Set the
+// path as broken in this case.
+  :
+    head=ident[ $category ]
+    { if (!$art.path) $art.path = []; this.pushIdent( $art.path, $head.id );
+      if ($category === 'artref') $art.scope = 0;
+    }
+    (
+      '.' tail=ident[ $category ] { this.pushIdent( $art.path, $tail.id ); }
+    )*
+  ;
 
 valuePath[ category, location = null ] returns[ qp = { path: [] } ] locals[ _sync = 'nop' ]
 @init { $qp.location = location || this.startLocation(); }
@@ -2439,19 +2301,6 @@ valuePath[ category, location = null ] returns[ qp = { path: [] } ] locals[ _syn
     )*
   ;
 
-fromArguments[ pathStep ]
-@init{ if (!$pathStep) $pathStep = {}; } // grammar robustness, see test/negative/parser/NamedExpression.cds
-  :
-    '(' { $pathStep.args = this.createDict(); $pathStep['$'+'syntax'] = ':'; } // necessary?
-    name=ident['paramname'] ':'
-    namedExpression[ $pathStep, $name.id ]
-    ( ',' { if (this.isStraightBefore(')')) break; } // allow ',' before ')'
-      name=ident['paramname'] ':'
-      namedExpression[ $pathStep, $name.id ]
-    )*
-    ')' { this.finalizeDictOrArray( $pathStep.args ); }
-  ;
-
 pathArguments[ pathStep, considerSpecial ]
 @init{
   if (!$pathStep) $pathStep = {}; // grammar robustness, see test/negative/parser/NamedExpression.cds
@@ -2491,11 +2340,9 @@ pathArguments[ pathStep, considerSpecial ]
         funcExpression[ $pathStep, $considerSpecial ]
       )*
       // Note: We can't move this into funcExpression, or we would increase the ATN count because of `,` amiguity.
-      ( ob=functionOrderByClause[ $pathStep.args[$pathStep.args.length - 1] ]
-        {
-          // Remove the last entry which was copied to $ob.expr and push $ob.expr.
-          $pathStep.args[$pathStep.args.length - 1] = $ob.expr;
-        }
+      ( ob=funcOrderByClause[ [ $pathStep.args[$pathStep.args.length - 1] ] ]
+        // Remove the last entry which was copied to $ob.expr and push $ob.expr:
+        { $pathStep.args[$pathStep.args.length - 1] = $ob.expr; }
       )?
     |
       { $pathStep.args = this.createArray(); }
@@ -2517,32 +2364,29 @@ namedExpression[ pathStep, id ]
     }
   ;
 
-funcExpression[ pathStep, considerSpecial ] locals[ args ]
+funcExpression[ pathStep, considerSpecial ] locals[ args = [] ]
 @init { this.prepareGenericKeywords( $considerSpecial ); }
+@after{ $pathStep.args.push( this.argsExpression( $args, true ) ); }
   :
     (
       expr=expression
-      { $pathStep.args.push( $expr.expr ); }
+      { $args.push( $expr.expr ); }
     |
       GenericExpr       // keyword as replacement for expression, like '*'
-      { $pathStep.args.push( this.xprToken() ); }
+      { this.pushXprToken( $args ); }
     |
       GenericIntro      // keyword as introduction of expression, like DISTINCT
-      { $pathStep.args.push( this.xprToken() ); }
-      expr=expression
-      { $args = this.setLastAsXpr( $pathStep.args );
-        $args.push( $expr.expr ); }
+      { this.pushXprToken( $args ); }
+      expr=expression { $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 )
+      ( HideAlternatives | '*' | ALL | DISTINCT ) { this.pushXprToken( $args ); }
       // now continue parsing like GenericExpr:
-      { $pathStep.args.push( this.xprToken() ); }
     )
     (
-      { if (!$args) $args = this.setLastAsXpr( $pathStep.args ); }
       (
         { this.prepareGenericKeywords( $considerSpecial, 'separator' ); }
         (
@@ -2556,26 +2400,108 @@ funcExpression[ pathStep, considerSpecial ] locals[ args ]
           { this.reportErrorForGenericKeyword(); }
           ( HideAlternatives | Identifier | FROM | IN | WITH | GROUP )
         )
-        { $args.push( this.xprToken() );
-          this.prepareGenericKeywords( $considerSpecial, 'expr' );
-        }
+        { this.pushXprToken( $args );
+          this.prepareGenericKeywords( $considerSpecial, 'expr' ); }
         (
-          expr=expression
-          { $args.push( $expr.expr ); }
+          expr=expression { $args.push( $expr.expr ); }
         |
-          GenericExpr
-          { $args.push( this.xprToken() ); }
+          GenericExpr { this.pushXprToken( $args ); }
         |
           { 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() ); }
+          ( HideAlternatives | ALL ) { this.pushXprToken( $args ); }
         )
       )+
     )?
   ;
 
+overClause returns[ over ] locals[ args = [] ]
+@after{ $over = this.argsExpression( $args ); }
+  :
+    // TODO: empty really allowed?
+    ( PARTITION { this.pushXprToken( $args ); } BY { this.pushXprToken( $args ); }
+      pb=partitionByClause { $args.push( $pb.expr ); }
+    )?
+    ( ORDER { this.pushXprToken( $args ); } BY { this.pushXprToken( $args ); }
+      ob=exprOrderByClause { $args.push( $ob.expr ); }
+    )?
+    ( ROWS { this.pushXprToken( $args ); }
+      wf=windowFrameClause { $args.push( $wf.wf ); }
+    )?
+  ;
+
+partitionByClause returns [ expr ] locals[ args = [] ]
+@after{ $expr = this.argsExpression( $args ); }
+  :
+    e1=expression { $args.push( $e1.expr ); }
+    ( ',' { this.pushXprToken( $args ); }
+      en=expression { $args.push( $en.expr ); }
+    )*
+  ;
+
+// ORDER BY clause in generic functions, e.g. `first_value(id order by name)`
+funcOrderByClause[ args ] returns[ expr ]
+@after{ $expr = this.argsExpression( args, true ); }
+  :
+    ORDER { this.pushXprToken( $args ); } BY { this.pushXprToken( $args ); }
+    ob=exprOrderByClause { $args.push( $ob.expr ); }
+  ;
+
+// ORDER BY clause in generic functions or OVER clause
+exprOrderByClause returns[ expr ] locals[ args = [] ]
+@after{ $expr = this.argsExpression( $args ); }
+  :
+    orderBySpecInExpr[ $args ]
+    ( ',' { this.pushXprToken( $args ); } orderBySpecInExpr[ $args ] )*
+  ;
+
+orderBySpecInExpr[ args ]
+  :
+    e=expression { $args.push( $e.expr ); }
+    ( ASC { this.pushXprToken( $args ); }
+    | DESC { this.pushXprToken( $args ); }
+    )?
+    ( NULLS { this.pushXprToken( $args ); }
+      ( FIRST | LAST ) { this.pushXprToken( $args ); }
+    )?
+  ;
+
+windowFrameClause returns[ wf ] locals[ args = [] ]
+@after{ $wf = this.argsExpression( $args ); }
+  :
+    (
+      windowFrameStartSpec[ $args ]
+    |
+      BETWEEN { this.pushXprToken( $args ); }
+      windowFrameBoundSpec[ $args ]
+      AND { this.pushXprToken( $args ); }
+      windowFrameBoundSpec[ $args ]
+    )
+  ;
+
+windowFrameBoundSpec[ args ]
+  :
+    UNBOUNDED { this.pushXprToken( $args ); }
+    ( FOLLOWING | PRECEDING ) { this.pushXprToken( $args ); }
+  |
+    n=Number { $args.push( this.numberLiteral( $n ) ); }
+    ( FOLLOWING | PRECEDING ) { this.pushXprToken( $args ); }
+  |
+    CURRENT { this.pushXprToken( $args ); } ROW { this.pushXprToken( $args ); }
+  ;
+
+windowFrameStartSpec[ args = [] ]
+  :
+    UNBOUNDED { this.pushXprToken( $args ); }
+    PRECEDING { this.pushXprToken( $args ); }
+  |
+    n=Number { $args.push( this.numberLiteral( $n ) ); }
+    PRECEDING { this.pushXprToken( $args ); }
+  |
+    CURRENT { this.pushXprToken( $args ); } ROW { this.pushXprToken( $args ); }
+  ;
+
 cardinalityAndFilter[ pathStep ] locals [ _sync = 'nop' ]
   :
     '['
@@ -2607,13 +2533,171 @@ optionalWhereForFilter
     // one of the expected ones.
     {
       var text = this.getCurrentToken().text.toUpperCase();
-      if (!['WHERE','GROUP','ORDER','LIMIT'].includes( text )) return;
+      if (!['WHERE','GROUP','ORDER','LIMIT'].includes( text )) return $ctx;
       // TODO: should we somehow add those keywords to $(EXPECTED)?
     }
     WHERE
   ;
 
-// Simple paths and values ---------------------------------------------------
+// Annotation assignments -------------------------------------------------------
+
+// We have three versions of the annotation assignment rules:
+//  - "fix": typically after a name if a ':' could follow
+//  - "ll1": typically before keyword+name, after a name if no ':' could follow
+//  - "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
+//   }
+
+annotationAssignment_fix[ art ] locals[ assignment ]
+// value outside @(...)
+@after {
+  if ($assignment) {
+    this.assignAnnotation( $art, $assignment );
+    this.docComment( $art );
+  }
+} :
+    '@'
+    (
+      annotationAssignment_paren[ $art ]
+    |
+      { $assignment = { name: {} }; }
+      annotationPath[ $assignment.name, 'anno' ]
+      annotationPathVariant[ $assignment.name ]?
+      { this.warnIfColonFollows( $assignment ); }
+    )
+  ;
+
+annotationAssignment_ll1[ art ] locals[ assignment ]
+@after {
+  if ($assignment) {
+    this.assignAnnotation( $art, $assignment );
+    this.docComment( $art );
+  }
+} :
+    '@'
+    (
+      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 ]
+      )?
+    )
+  ;
+
+// Has previously used ATN, now via local token rewrite
+annotationAssignment_atn[ art ] locals[ assignment ]
+@after {
+  if ($assignment) {
+    this.assignAnnotation( $art, $assignment );
+    this.docComment( $art );
+  }
+} :
+    '@'
+    (
+      annotationAssignment_paren[ $art ]
+    |
+      { $assignment = { name: {} }; }
+      annotationPath[ $assignment.name, 'anno' ]
+      // '#' is in the follow set of this rule, as it is used in rule "selectItemDef"
+      // before an "expression" which can start with a '#' for an enum value
+      // -> used to introduce variant name if and only if in same line as previous token
+      { this.setLocalToken( '#', 'HelperToken1', null, true ); }
+      (
+        HelperToken1 { this.meltKeywordToIdentifier(); }
+        variant=ident['variant'] { $assignment.name.variant = $variant.id; }
+      )?
+      // ':' is in the follow set of this rule, as it is used in rule "selectItemDef"
+      // before an "expression" which can start with a ':' for a parameter reference
+      // -> used to introduce assignment value if and only if in same line as previous token
+      { this.setLocalToken( ':', 'HelperToken2', null, true ); }
+      ( HelperToken2                        // ':'
+        { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
+        (
+          val=annoValueBase[ $assignment ]
+        |
+          at='@'? annotationPath[ $assignment, 'ref', $at ]
+          { this.setLocalToken( '#', 'HelperToken1', null, true ); } // see above
+          (
+            HelperToken1 { this.meltKeywordToIdentifier(); }
+            variant=ident['variant'] { $assignment.variant = $variant.id; }
+          )?
+        )
+      )?
+    )
+  ;
+
+annotationAssignment_paren[ art ]
+  :
+    '('
+    // allow completely useless `@()` with a warning, do not offer it for completion
+    {
+      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;
+      }
+    }
+    annotationAssignment_1[ $art ]
+    ( ','
+      {
+        this.meltKeywordToIdentifier();
+        if (this.isStraightBefore(')')) break; // allow ',' before ')'
+      }
+      annotationAssignment_1[ $art ]
+    )*
+    ')'
+  ;
+
+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 ]
+    )?
+  ;
+
+annotationPath[ art, category, headat = null ] locals[ _sync = 'nop' ]
+@after { this.attachLocation($art); }
+// Due to error recovery, rule `ident` can return with value `null`.  Set the
+// path as broken in this case.
+  :
+    head=ident[ $category ]
+    { $art.path = []; this.pushIdent( $art.path, $head.id, $headat );
+      if ($category === 'artref') $art.scope = 0;
+    }
+    (
+      '.' at='@'? tail=ident[ $category ]
+      { this.pushIdent( $art.path, $tail.id, $at );
+        // Otherwise, $at may continue to be set after one `.@anno` segment.
+        $ctx.at = null;
+      }
+    )*
+  ;
+
+annotationPathVariant[ art ] locals[ variant = {} ]
+@after { this.attachLocation($art); }
+  :
+    // TODO: warning for space after '#'
+    '#' { this.meltKeywordToIdentifier(); }
+    simplePath[ $variant, 'variant' ] { $art.variant = $variant; }
+  ;
 
 annoValue[ assignment ]
   :
@@ -2742,6 +2826,8 @@ annoSubValue returns[ val = {} ]
     ( annotationPathVariant[ $val ] )?
   ;
 
+// Literal values and identifiers -----------------------------------------------
+
 literalValue returns[ val ] locals[ tok ]
 @init{ $tok = this.getCurrentToken(); }
 @after { this.attachLocation($val); }
@@ -2765,47 +2851,7 @@ literalValue returns[ val ] locals[ tok ]
     { $val = this.quotedLiteral( $tok ); }
   ;
 
-simplePath[ art, category ] locals[ _sync = 'nop' ]
-@after { this.attachLocation($art); }
-// Due to error recovery, rule `ident` can return with value `null`.  Set the
-// path as broken in this case.
-  :
-    head=ident[ $category ]
-    { if (!$art.path) $art.path = []; this.pushIdent( $art.path, $head.id );
-      if ($category === 'artref') $art.scope = 0;
-    }
-    (
-      '.' tail=ident[ $category ] { this.pushIdent( $art.path, $tail.id ); }
-    )*
-  ;
-
-annotationPath[ art, category, headat = null ] locals[ _sync = 'nop' ]
-@after { this.attachLocation($art); }
-// Due to error recovery, rule `ident` can return with value `null`.  Set the
-// path as broken in this case.
-  :
-    head=ident[ $category ]
-    { $art.path = []; this.pushIdent( $art.path, $head.id, $headat );
-      if ($category === 'artref') $art.scope = 0;
-    }
-    (
-      '.' at='@'? tail=ident[ $category ]
-      { this.pushIdent( $art.path, $tail.id, $at );
-        // Otherwise, $at may continue to be set after one `.@anno` segment.
-        $ctx.at = null;
-      }
-    )*
-  ;
-
-annotationPathVariant[ art ] locals[ variant = {} ]
-@after { this.attachLocation($art); }
-  :
-    // TODO: warning for space after '#'
-    '#' { this.meltKeywordToIdentifier(); }
-    simplePath[ $variant, 'variant' ] { $art.variant = $variant; }
-  ;
-
-// Identifier and non-reserved keywords --------------------------------------
+// #IDENT - keep this comment here, used in scripts/linter/lintGrammar.js
 
 identNoKeyword[ category ] returns[ id ]    // for aliases without AS
 @after{ $id = this.identAst( $stop, $category ); }
@@ -2840,7 +2886,6 @@ ident[ category ] returns[ id ]
   | DEFINE
   | DEFINITIONS
   | DESC
-  | ELEMENT
   | ELEMENTS
   | ELSE
   | END
@@ -2870,7 +2915,6 @@ ident[ category ] returns[ id ]
   | LIMIT
   | LOCALIZED
   | MANY
-  | MASKED
   | MINUS
   | MIXIN
   | NAMESPACE
@@ -2901,7 +2945,7 @@ ident[ category ] returns[ id ]
   | VIEW
   ;
 
-//----------------------------------------------------------------------------
+// LEXER ------------------------------------------------------------------------
 
 WhiteSpace                      // like \s in JavaScript RegExp
   :                             // LineTerminator | [\t\f\v\u00A0\uFEFF] | Zs
@@ -2914,10 +2958,10 @@ Comment : '/*' .*? '*/' -> channel(HIDDEN);
 
 LineComment : '//' ~[\r\n\u2028\u2029]* -> channel(HIDDEN);
 
-// Values --------------------------------------------------------------------
+// Literal values ---------------------------------------------------------------
 
 // for syntactic code-completion: Combine all three string styles
-// Note: Use rule `string` instead as that also parses escape sequences!
+// Note: Use rule `string` instead as that also parses escape sequences! (TODO: ???)
 String : SingleLineString
        | MultiLineString
        | MutlLineStringBlock;
@@ -3037,7 +3081,7 @@ 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] ;
 DESC : [dD][eE][sS][cC] ;
-ELEMENT : [eE][lL][eE][mM][eE][nN][tT] ;
+// ELEMENT : [eE][lL][eE][mM][eE][nN][tT] ;
 ELEMENTS : [eE][lL][eE][mM][eE][nN][tT][sS] ;
 ELSE : [eE][lL][sS][eE] ;
 END : [eE][nN][dD] ;
@@ -3067,7 +3111,7 @@ LIKE : [lL][iI][kK][eE] ;
 LIMIT : [lL][iI][mM][iI][tT] ;
 LOCALIZED: [lL][oO][cC][aA][lL][iI][zZ][eE][dD];
 MANY : [mM][aA][nN][yY] ;
-MASKED : [mM][aA][sS][kK][eE][dD] ;
+// MASKED : [mM][aA][sS][kK][eE][dD] ;
 MINUS : [mM][iI][nN][uU][sS] ;
 MIXIN : [mM][iI][xX][iI][nN] ;
 NAMESPACE : [nN][aA][mM][eE][sS][pP][aA][cC][eE] ;