@sap/cds-compiler 3.7.2 → 3.8.2

package/lib/language/language.g4

@@ -581,17 +581,17 @@ elementDefInner[ art, outer, mightBeEnum ]
 @after{ this.attachLocation( $art ); }
   :
     // VIRTUAL is keyword, except if before the following tokens texts:
-    { this.setLocalToken( 'VIRTUAL', 'VIRTUAL', /^[:{@=}]$/ ); }
+    { this.setLocalToken( 'VIRTUAL', 'VIRTUAL', /^[;:{@=}]$/ ); }
     ( virtual=VIRTUAL { $art.virtual = this.valueWithTokenLocation( true, $virtual ); } )?
     ( key=KEY { $art.key = this.valueWithTokenLocation( true, $key ); } )?
-    { this.setLocalToken( 'MASKED', 'MASKED', /^[:{@=}]$/ ); }
+    { this.setLocalToken( 'MASKED', 'MASKED', /^[;:{@=}]$/ ); }
     ( masked=MASKED
       {
         $art.masked = this.valueWithTokenLocation( true, $masked ) ;
         this.message( 'syntax-unsupported-masked', $masked, { keyword: 'masked' } );
       }
     )?
-    { this.setLocalToken( 'ELEMENT', 'ELEMENT', /^[:{@=}]$/ ); }
+    { this.setLocalToken( 'ELEMENT', 'ELEMENT', /^[;:{@=}]$/ ); }
     ( ELEMENT { $mightBeEnum = false; } )? // auto-recognizable at other places
     name=ident['Element']
     { this.addDef( $art, $outer, 'elements', 'element', $name.id );
@@ -610,13 +610,15 @@ elementDefInner[ art, outer, mightBeEnum ]
       '=' e=expression       // SQL has syntax variant using AS - we DO NOT
       { $art.value = $e.expr;
         // this.setIntroLocation( eq );  -- future
-        if ($mightBeEnum && ($e.expr.val !== undefined || $e.expr.sym !== undefined) &&
+        if ($mightBeEnum && ($e.expr?.val !== undefined || $e.expr?.sym !== undefined) &&
             !$virtual && !$key && !$masked && !$art.elements && !$art.type)
           $art['$'+'syntax'] = 'enum';
       }
       { this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]* // for enum symbol def via EXTEND
       requiredSemi
+    |
+      requiredSemi
     )
   ;
 
@@ -716,14 +718,19 @@ elementType[ art ]     // TODO: split this monster rule
   ;
 
 elementProperties[ elem ]
+  :
+    defaultAndNullablity[ $elem ]
+  |
+    '=' e=expression { $elem.value = $e.expr; }
+  ;
+
+defaultAndNullablity[ elem ]
   :
     defaultValue[ $elem ]
     nullability[ $elem ]?       // placement accoring to SQL spec
   |
     nullability[ $elem ]
     defaultValue[ $elem ]?
-  |
-    '=' e=expression { $elem.value = $e.expr; }
   ;
 
 defaultValue[ art ] locals[ elem, elements = {} ]
@@ -761,13 +768,13 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       |
         requiredSemi
       |
-        ELEMENTS '{' { $art.elements = this.createDict(); }
+        ELEMENTS { $art.elements = this.createDict(); } '{'
         elementDefOrExtend[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
         { this.checkExtensionDict( $art.elements ); }
         optionalSemi
       |
-        ENUM '{' { $art.enum = this.createDict(); }
+        ENUM { $art.enum = this.createDict(); } '{'
         enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.enum ); }
         optionalSemi
@@ -782,24 +789,22 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         includeRef[ $art ] ( ',' includeRef[ $art ] )*
         requiredSemi
       |
-        DEFINITIONS
-        '{' { $art.artifacts = this.createDict(); }
+        DEFINITIONS { $art.artifacts = this.createDict(); } '{'
         artifactDefOrExtend[ $art, 'definitions' ]*
         '}' { this.finalizeDictOrArray( $art.artifacts ); }
         optionalSemi
       |
-        COLUMNS
-        '{' { $art.columns = []; }
+        COLUMNS { $art.columns = this.createArray(); } '{'
         (
           selectItemDef[ $art.columns ]
           ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
             selectItemDef[ $art.columns ]
           )*
         )?
-        '}'
+        '}' { this.finalizeDictOrArray( $art.columns ); }
         optionalSemi
       |
-        ACTIONS '{' { $art.actions = this.createDict(); }
+        ACTIONS { $art.actions = this.createDict(); } '{'
         actionFunctionDef[ $art ]* // TODO: no EXTEND in actions? (ok, would just allow annos)
         '}' { this.finalizeDictOrArray( $art.actions ); }
         optionalSemi
@@ -811,7 +816,7 @@ extendArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
 extendService[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    SERVICE { $art.expectedKind = 'service'; }
+    SERVICE { $art.expectedKind = this.valueWithTokenLocation(); }
     simplePath[ $name, 'Service' ]
     { $art.name = $name; this.addItem( $art, $outer, 'extensions', 'extend' ); }
     ( WITH { this.noSemicolonHere(); } )?
@@ -821,7 +826,7 @@ extendService[ art, outer ] locals[ name = {} ]
 extendContext[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    CONTEXT { $art.expectedKind = 'context'; }
+    CONTEXT { $art.expectedKind = this.valueWithTokenLocation(); }
     simplePath[ $name, 'Context' ]
     { $art.name = $name; this.addItem( $art, $outer, 'extensions', 'extend' ); }
     ( WITH { this.noSemicolonHere(); } )?
@@ -831,8 +836,9 @@ extendContext[ art, outer ] locals[ name = {} ]
 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;
+    (ASPECT | ENTITY) { $art.expectedKind = this.valueWithTokenLocation(); }
+    simplePath[ $name, 'Extend' ]
+    { $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
     (
@@ -858,13 +864,13 @@ extendForEntity[ art ]
     elementDefOrExtend[ $art ]*
     '}' { this.finalizeDictOrArray( $art.elements ); }
     (
-      ACTIONS '{' { $art.actions = this.createDict(); }
+      ACTIONS { $art.actions = this.createDict(); } '{'
       actionFunctionDef[ $art ]*
       '}' { this.finalizeDictOrArray( $art.actions ); }
     )?
     optionalSemi
   |
-    ACTIONS '{' { $art.actions = this.createDict(); }
+    ACTIONS { $art.actions = this.createDict(); } '{'
     actionFunctionDef[ $art ]*
     '}' { this.finalizeDictOrArray( $art.actions ); }
     optionalSemi
@@ -875,30 +881,31 @@ extendForEntity[ art ]
 extendProjection[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    expected=PROJECTION simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'entity'; $art.name = $name;
+    PROJECTION { $art.expectedKind = this.valueWithTokenLocation( 'entity' ); }
+    simplePath[ $name, 'Extend' ]
+    { $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
     ( WITH { this.noSemicolonHere(); } )?
     { this.docComment( $art ); }
     annotationAssignment_ll1[ $art ]*
     (
-      '{' { $art.columns = []; }
+      '{' { $art.columns = this.createArray(); }
       (
         selectItemDef[ $art.columns ]
         ( ',' { if (this.isStraightBefore("}")) break; } // allow ',' before '}'
           selectItemDef[ $art.columns ]
         )*
       )?
-      '}'
+      '}' { this.finalizeDictOrArray( $art.columns ); }
       (
-        ACTIONS '{' { $art.actions = this.createDict(); }
+        ACTIONS { $art.actions = this.createDict(); } '{'
         actionFunctionDef[ $art ]*
         '}' { this.finalizeDictOrArray( $art.actions ); }
       )?
       optionalSemi
     |
-      ACTIONS '{' { $art.actions = this.createDict(); }
+      ACTIONS { $art.actions = this.createDict(); } '{'
       actionFunctionDef[ $art ]*
       '}' { this.finalizeDictOrArray( $art.actions ); }
       optionalSemi
@@ -910,8 +917,9 @@ extendProjection[ art, outer ] locals[ name = {} ]
 extendType[ art, outer ] locals[ name = {} ]
 @after { this.attachLocation( $art ); }
   :
-    TYPE simplePath[ $name, 'Extend' ]
-    { $art.expectedKind = 'type'; $art.name = $name;
+    TYPE { $art.expectedKind = this.valueWithTokenLocation(); }
+    simplePath[ $name, 'Extend' ]
+    { $art.name = $name;
       this.addItem( $art, $outer, 'extensions', 'extend' );
     }
     // extendWithOptElementsOrType + includeRef:
@@ -952,13 +960,13 @@ extendWithOptElementsOrType[ art ]
       { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
-      ELEMENTS '{' { $art.elements = this.createDict(); }
+      ELEMENTS { $art.elements = this.createDict(); } '{'
       elementDefOrExtend[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
       optionalSemi
     |
-      ENUM '{' { $art.enum = this.createDict(); }
+      ENUM { $art.enum = this.createDict(); } '{'
       enumSymbolDef[ $art ]*  // TODO: no EXTEND in enum? (ok, would just allow annos)
       '}' { this.finalizeDictOrArray( $art.enum ); }
       optionalSemi
@@ -1006,7 +1014,7 @@ extendElement[ art, outer ]
 @after{ this.attachLocation( $art ); }
   :
     { this.setLocalToken( 'ELEMENT', 'ELEMENT', /^([:{@=}()]|WITH)$/i ); }
-    ( expected=ELEMENT { $art.expectedKind = 'element'; } )?
+    ( ELEMENT { $art.expectedKind = this.valueWithTokenLocation(); } )?
     name=ident['Element']
     { this.addDef( $art, $outer, 'elements', 'extend', $name.id ); }
     extendWithOptElementsOrType[ $art, $art ]
@@ -1016,7 +1024,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
 @after { this.attachLocation( $art ); }
   :
     simplePath[ $name, 'Annotate' ]
-    ( ':' simplePath[ $elemName, 'Element'] )?
+    ( ':' simplePath[ $elemName, 'Element'] )? // TODO: do like for extendArtifact !
     { this.addExtension( $art, $outer, 'annotate', $name, $elemName.path ); }
     ( WITH { this.noSemicolonHere(); } )?
     { this.docComment( $art ); }
@@ -1027,16 +1035,14 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
       (
-        ACTIONS
-        '{' { $art.actions = this.createDict(); }
+        ACTIONS { $art.actions = this.createDict(); } '{'
         annotateAction[ $art ]*
         '}' { this.finalizeDictOrArray( $art.actions ); }
       { this.checkExtensionDict( $art.actions ); }
       )?
       optionalSemi
     |
-      ACTIONS
-      '{' { $art.actions = this.createDict(); }
+      ACTIONS { $art.actions = this.createDict(); } '{'
       annotateAction[ $art ]*
       '}' { this.finalizeDictOrArray( $art.actions ); }
       { this.checkExtensionDict( $art.actions ); }
@@ -1051,8 +1057,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       { this.checkExtensionDict( $art.params ); }
       (
         // TODO: set proper $art.returns
-        RETURNS { $art['$'+'syntax'] = 'returns'; }
-        '{' { $art.elements = this.createDict(); }
+        RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
         annotateElement[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
@@ -1062,8 +1067,7 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       )
     |
       // TODO: set proper $art.returns
-      RETURNS { $art['$'+'syntax'] = 'returns'; }
-      '{' { $art.elements = this.createDict(); }
+      RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
@@ -1114,8 +1118,7 @@ annotateAction [ outer ] locals [ art = {} ]
     )?
     (
       // TODO: set proper $art.returns
-      RETURNS { $art['$'+'syntax'] = 'returns'; }
-      '{' { $art.elements = this.createDict(); }
+      RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
@@ -1209,7 +1212,10 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
 @after{ /* #ATN 3 */ }
   :
     typeStruct[ $art ]
-    optionalSemi
+    ( nullability[ $art ]
+      requiredSemi
+    | optionalSemi
+    )
   |
     ':'
     // #ATN: typeRefOptArgs can start with ARRAY or MANY or ASSOCIATION or TYPE or LOCALIZED
@@ -1217,7 +1223,10 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
     { this.setLocalToken( 'MANY', 'HelperToken1', /^[^\{]/ ); }
     (
       typeStruct[ $art ]
-      optionalSemi
+      ( nullability[ $art ]
+        requiredSemi
+      | optionalSemi
+      )
     |
       typeAssociationBase[ $art, false ]
       // #ATN: path could start with MANY or ONE - make sure a token follows in same rule!
@@ -1229,7 +1238,7 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
       { $art.items = { location: this.tokenLocation( $many ) };}
       typeStruct[ $art.items ]
       nullability[ $art.items ]?
-      optionalSemi
+      optionalSemi // TODO(v4): Should be requiredSemi with nullability
     |
       (
         array=ARRAY of=OF
@@ -1240,7 +1249,7 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
       // #ATN: typeRefOptArgs can start with TYPE
       ( typeStruct[ $art.items ]
         nullability[ $art.items ]?
-        optionalSemi
+        optionalSemi // TODO(v4): Should be requiredSemi with nullability
       | ( typeTypeOf[ $art.items ] | typeRefOptArgs[ $art.items ] )
         nullability[ $art.items ]?
         { this.docComment( $art ); }
@@ -1261,13 +1270,14 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
       )
     |
       typeTypeOf[ $art ]
-      defaultValue[ $art ]?
+      defaultAndNullablity[ $art ]?
       { this.docComment( $art ); }
-      annotationAssignment_ll1[ $art ]* requiredSemi
+      annotationAssignment_ll1[ $art ]*
+      requiredSemi
     |
       l=LOCALIZED { $art.localized = this.valueWithTokenLocation( true, $l ); }
       typeRefOptArgs[ $art ]
-      defaultValue[ $art ]?
+      defaultAndNullablity[ $art ]?
       { this.docComment( $art ); }
       annotationAssignment_ll1[ $art ]*
       requiredSemi
@@ -1291,11 +1301,11 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
           (
             optionalSemi
           |
-            defaultValue[ $art ]
+            defaultAndNullablity[ $art ]
             requiredSemi
           )
         |
-          defaultValue[ $art ]?
+          defaultAndNullablity[ $art ]?
           requiredSemi
         )
       |
@@ -1305,7 +1315,10 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
           includeRef[ $art ]
         )*
         typeStruct[ $art ]
-        optionalSemi
+        ( optionalSemi
+        | nullability[ $art ]
+          requiredSemi
+        )
       )
     )
   ;
@@ -1751,7 +1764,7 @@ tableTerm returns [ table ]
       ( 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 ); }
@@ -2045,8 +2058,21 @@ conditionEOF returns [ cond ]
     c=condition { $cond = $c.cond; } EOF
   ;
 
-condition returns [ cond ] locals[ args = [] ]
-@after{ $cond = this.argsExpression( $args, true ); }
+condition returns [ cond ] locals [ args = [], orl = [] ]
+@after{ $cond = this.argsExpression( $args, $ctx.e2 ? '?:' : true ); }
+  :
+    c1=conditionOr { $args.push($c1.cond); }
+    (
+      // '?' is not mentioned in code completion, see errorStrategy.js#intervalSetToArray
+      q='?' { this.pushXprToken( $args ); }
+      e2=expression { $args.push($e2.expr); }
+      colon=':' { this.pushXprToken( $args ); }
+      e3=expression { $args.push($e3.expr); }
+    )?
+  ;
+
+conditionOr returns [ cond ] locals [ args = [], orl = [] ]
+@after{ $cond = this.argsExpression( $args, 'or' ); }
   :
     c1=conditionAnd { $args.push($c1.cond); }
     (
@@ -2349,7 +2375,7 @@ namedExpression[ pathStep, id ]
   :
     elem=expression
     { if ($pathStep && $id) {
-      this.addDef( ($ctx.elem) ? $elem.expr : { location: $id.location },
+      this.addDef( ($ctx.elem && $elem.expr) ? $elem.expr : { location: $id.location },
                    $pathStep, 'args', 0, $id );
       }
     }
@@ -2557,7 +2583,7 @@ annotationAssignment_fix[ art ] locals[ assignment ]
     |
       { $assignment = { name: {} }; }
       annotationPath[ $assignment.name, 'anno' ]
-      annotationPathVariant[ $assignment.name ]?
+      ( '#' annotationPathVariant[ $assignment.name ] )?
       { this.warnIfColonFollows( $assignment ); }
     )
   ;
@@ -2575,7 +2601,7 @@ annotationAssignment_ll1[ art ] locals[ assignment ]
     |
       { $assignment = { name: {} }; }
       annotationPath[ $assignment.name, 'anno' ]
-      annotationPathVariant[ $assignment.name ]?
+      ( '#' annotationPathVariant[ $assignment.name ] )?
       (
         ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
         val=annoValue[ $assignment ]
@@ -2601,11 +2627,7 @@ annotationAssignment_atn[ art ] locals[ assignment ]
       // 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 ); }
-      (
-        hash=HelperToken1
-        { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
-        variant=ident['variant'] { $assignment.name.variant = $variant.id; }
-      )?
+      ( hash=HelperToken1 annotationPathVariant[ $assignment.name ] )?
       // ':' 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
@@ -2617,11 +2639,7 @@ annotationAssignment_atn[ art ] locals[ assignment ]
         |
           atv='@'? annotationPath[ $assignment, 'ref', $atv ]
           { this.setLocalToken( '#', 'HelperToken1', null, true ); } // see above
-          (
-            hash=HelperToken1
-            { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
-            variant=ident['variant'] { $assignment.variant = $variant.id; }
-          )?
+          ( hash=HelperToken1 annotationPathVariant[ $assignment ] )?
         )
       )?
     )
@@ -2632,11 +2650,11 @@ annotationAssignment_paren[ art ]
     '('
     // allow completely useless `@()`; no warning anymore - who cares?
     {
-      this.meltKeywordToIdentifier();
       if (this.isStraightBefore(')')) {
         this.matchWildcard();   // we know it is the ')' - we do not reach the final match
         return $ctx;
       }
+      this.meltKeywordToIdentifier();
     }
     annotationAssignment_1[ $art ]
     ( ','
@@ -2653,7 +2671,7 @@ annotationAssignment_1[ art ] locals[ assignment = { name: {} } ]
 @after { this.assignAnnotation( $art, $assignment ); }
   :
     annotationPath[ $assignment.name, 'anno' ]
-    annotationPathVariant[ $assignment.name ]?
+    ( '#' annotationPathVariant[ $assignment.name ] )?
     (
       ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
       val=annoValue[ $assignment ]
@@ -2678,11 +2696,11 @@ annotationPath[ art, category, headat = null ] locals[ _sync = 'nop' ]
     )*
   ;
 
+// Before calling this rule, match '#'
 annotationPathVariant[ art ] locals[ variant = {} ]
 @after { this.attachLocation($art); }
   :
-    // TODO: warning for space after '#'
-    hash='#' { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
+    { this.reportUnexpectedSpace();; this.meltKeywordToIdentifier(); }
     simplePath[ $variant, 'variant' ] { $art.variant = $variant; }
   ;
 
@@ -2693,7 +2711,7 @@ annoValue[ assignment ]
     // no docComment() here
     // this alternative is done with token rewrite in rule "annotationAssignment_atn"
     at='@'? annotationPath[ $assignment, 'ref', $at ]
-    annotationPathVariant[ $assignment ]?
+    ( '#' annotationPathVariant[ $assignment ] )?
   ;
 
 annoValueBase[ assignment ] locals [ seenEllipsis = false ]
@@ -2713,6 +2731,7 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
   |
     '['                 // no need for createArray() here, $assignment.location is set
     { $assignment.val = []; $assignment.literal = 'array'; }
+    { this.meltKeywordToIdentifier(true); }
     (
       (
         head=annoSubValue  { $assignment.val.push( $head.val ); }
@@ -2727,6 +2746,7 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
       )
       (
         ',' { if (this.isStraightBefore(']')) break; } // allow ',' before ']'
+        { this.meltKeywordToIdentifier(true); }
         (
           tail=annoSubValue { $assignment.val.push( $tail.val ); }
         |
@@ -2761,19 +2781,14 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
       cond=condition // 'condition' is also used in 'expression' inside '()'.
       // TODO: (1,2,3) not supported, yet, only ((1,2,3)); we could support it via:
       // (',' condition)*
-      { $assignment.value = $cond.cond;
-        if (!this.isBetaEnabled(this.options, 'annotationExpressions')) {
-          this.error( 'syntax-unsupported-expression', [ $cond.cond.location ], {},
-                      'Expressions in annotation values are not supported' );
-        }
-      }
+      { this.expressionAsAnnotationValue( $assignment, $ctx.cond ); }
     ')'
   ;
 
 flattenedValue[ assignment ] locals[ val = { name: {} } ]
   :
     at='@'? annotationPath[ $val.name, 'name', $at ]
-    ( annotationPathVariant[ $val.name ] )?
+    ( '#' annotationPathVariant[ $val.name ] )?
     (
       ':' { this.meltKeywordToIdentifier(true); } // allow path as anno value start with reserved
       annoValue[ $val ]
@@ -2784,7 +2799,8 @@ flattenedValue[ assignment ] locals[ val = { name: {} } ]
 namedValue[ struct ] locals[ val = { name: {} } ]
   :
     at='@'? annotationPath[ $val.name, 'name', $at ]
-    ( ':' sub=annoSubValue { Object.assign( $val, $sub.val ); } )?
+    ( ':' { this.meltKeywordToIdentifier(true); }
+      sub=annoSubValue { Object.assign( $val, $sub.val ); } )?
     {
       if (!$val.location) $val.location = $val.name.location;
       this.addDef( $val, $struct, 'struct', null, $val.name ); // TODO: re-check name
@@ -2809,8 +2825,10 @@ annoSubValue returns[ val = {} ]
   |
     '['                 // no need for createArray() here, $val.location is set
     { $val.val = []; $val.literal = 'array'; }
+    { this.meltKeywordToIdentifier(true); }
     ( head=annoSubValue { $val.val.push( $head.val ); }
       ( ',' { if (this.isStraightBefore(']')) break; } // allow ',' before ']'
+        { this.meltKeywordToIdentifier(true); }
         tail=annoSubValue { $val.val.push( $tail.val ); }
       )*
     )?
@@ -2822,7 +2840,12 @@ annoSubValue returns[ val = {} ]
     { Object.assign( $val, this.numberLiteral( $num, $plus||$min ) ); }
   |
     at='@'? annotationPath[ $val, 'ref', $at ]
-    ( annotationPathVariant[ $val ] )?
+    ( '#' annotationPathVariant[ $val ] )?
+  |
+    '('
+      cond=condition
+      { this.expressionAsAnnotationValue( $val, $ctx.cond ); }
+    ')'
   ;
 
 // Literal values and identifiers -----------------------------------------------
@@ -2831,7 +2854,7 @@ literalValue returns[ val ] locals[ tok ]
 @init{ $tok = this.getCurrentToken(); }
 @after { this.attachLocation($val); }
   :
-    hash='#' { this.meltKeywordToIdentifier();; this.reportUnexpectedSpace( $hash ); }
+    hash='#' { this.reportUnexpectedSpace( $hash );; this.meltKeywordToIdentifier(); }
     name=ident['enumref']   // TODO v4: remove from this rule (not in enum!)
     { $val = { literal: 'enum', sym: $name.id } }
   |

package/lib/language/textUtils.js

@@ -37,8 +37,21 @@ function isWhitespaceCharacterNoNewline( char ) {
   return whitespaceRegEx.test(char);
 }
 
+/**
+ * Normalized CDL newlines to LF (\n).  CDL newlines also contain PS and other
+ * characters, see cdlNewLineRegEx.
+ *
+ * @param {string} str
+ * @return {string}
+ */
+function normalizeNewLine( str ) {
+  // Note: cdlNewLineRegEx does not have `g` flag and we can't use replaceAll in Node 14.
+  return str.replace(new RegExp(cdlNewLineRegEx, 'ug'), '\n');
+}
+
 module.exports = {
   isWhitespaceOrNewLineOnly,
   isWhitespaceCharacterNoNewline,
   cdlNewLineRegEx,
+  normalizeNewLine,
 };

package/lib/main.d.ts

@@ -818,6 +818,23 @@ declare namespace compiler {
        * @param dialect
        */
       function delimitedId(name: string, dialect: string) : string;
+
+      /**
+       * Return all non-lossy changes in artifacts between two given models.
+       * Note: Only supports changes in artifacts compiled/rendered as db-CSN/SQL.
+       *
+       * ATTENTION: This function may change without prior notice!
+       *            It is still considered work-in-progress!
+       *
+       * @beta
+       *
+       * @param csn          A client/inferred CSN model representing the desired "after-image"
+       * @param options      SQL specific options
+       * @param beforeImage  A db-transformed CSN representing the "before-image", or null in case no such image
+       *                     is known, i.e. for the very first migration step.
+       * @returns See {@link SqlMigrationResult} for details.
+       */
+      function migration(csn: CSN, options: SqlOptions, beforeImage: CSN): SqlMigrationResult;
     }
 
     /**
@@ -884,10 +901,10 @@ declare namespace compiler {
        * Return all changes in artifacts between two given models.
        * Note: Only supports changes in entities (not views etc.) compiled/rendered as HANA-CSN/SQL.
        *
-       * @param csn          A clean input CSN representing the desired "after-image"
+       * @param csn          A client/inferred CSN model representing the desired "after-image"
        * @param options      Options
-       * @param beforeImage  A HANA-transformed CSN representing the "before-image", or null in case no such image
-       *                                  is known, i.e. for the very first migration step
+       * @param beforeImage  A SAP HANA-transformed CSN representing the "before-image", or null in case
+       *                     no such image is known, i.e. for the very first migration step.
        * @returns See {@link HdiMigrationResult} for details.
        */
       function migration(csn: CSN, options: HdiOptions, beforeImage: CSN): HdiMigrationResult;
@@ -942,6 +959,29 @@ declare namespace compiler {
     }>,
   }
 
+  /**
+   * Result type of {@link to.sql.migration}.
+   *
+   * ATTENTION: This structure may change without prior notice!
+   *            It is still considered work-in-progress!
+   *
+   * @beta
+   */
+  export type SqlMigrationResult = {
+    /**
+     * The desired after-image in db-transformed CSN format
+     */
+    afterImage: CSN
+    /**
+     * An array of SQL statements to drop views/tables.
+     */
+    drops: string[],
+    /**
+     * An array of SQL statements to ALTER/CREATE tables/views.
+     */
+    createsAndAlters: string[],
+  }
+
   /**
    * Return the resulting database name for (absolute) 'artifactName', depending on the current naming
    * mode.