@sap/cds-compiler 3.6.2 → 3.8.0

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 ); }
@@ -1050,8 +1056,8 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
       ')' { this.finalizeDictOrArray( $art.params ); }
       { this.checkExtensionDict( $art.params ); }
       (
-        RETURNS { $art['$'+'syntax'] = 'returns'; }
-        '{' { $art.elements = this.createDict(); }
+        // TODO: set proper $art.returns
+        RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
         annotateElement[ $art ]*
         '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
@@ -1060,8 +1066,8 @@ annotateArtifact[ art, outer ] locals[ name = {}, elemName = {} ]
         requiredSemi
       )
     |
-      RETURNS { $art['$'+'syntax'] = 'returns'; }
-      '{' { $art.elements = this.createDict(); }
+      // TODO: set proper $art.returns
+      RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
@@ -1111,7 +1117,8 @@ annotateAction [ outer ] locals [ art = {} ]
       { this.checkExtensionDict( $art.params ); }
     )?
     (
-      RETURNS '{' { $art.elements = this.createDict(); }
+      // TODO: set proper $art.returns
+      RETURNS { $art.elements = this.createDict(); } { $art['$'+'syntax'] = 'returns'; } '{'
       annotateElement[ $art ]*
       '}' { this.finalizeDictOrArray( $art.elements ); }
       { this.checkExtensionDict( $art.elements ); }
@@ -1205,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
@@ -1213,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!
@@ -1225,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
@@ -1236,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 ); }
@@ -1257,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
@@ -1287,11 +1301,11 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
           (
             optionalSemi
           |
-            defaultValue[ $art ]
+            defaultAndNullablity[ $art ]
             requiredSemi
           )
         |
-          defaultValue[ $art ]?
+          defaultAndNullablity[ $art ]?
           requiredSemi
         )
       |
@@ -1301,7 +1315,10 @@ typeSpecSemi[ art ]      // with 'includes', for type and annotation defs
           includeRef[ $art ]
         )*
         typeStruct[ $art ]
-        optionalSemi
+        ( optionalSemi
+        | nullability[ $art ]
+          requiredSemi
+        )
       )
     )
   ;
@@ -1511,6 +1528,7 @@ typeRefOptArgs[ art ]
   ;
 
 typeRefArgs[ art ]
+@after { this.checkTypeArgs($art); }
   :
     paren='(' { $art['$'+'typeArgs'] = this.createArray(); }
     (
@@ -1746,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 ); }
@@ -2040,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); }
     (
@@ -2181,10 +2212,9 @@ expressionTerm returns [ expr ] locals [ args = [] ]
     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 ]
+    { $args.push( this.valuePathAst( $nqp.qp ) ); }
+    { this.fixNewKeywordPlacement( $args ); }
   |
     vp=valuePath[ 'ref', null ] { $args.push( this.valuePathAst( $vp.qp ) ); }
     { this.setLocalTokenIfBefore( 'OVER', 'OVER', /^\($/i ); }
@@ -2345,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 );
       }
     }
@@ -2752,6 +2782,13 @@ annoValueBase[ assignment ] locals [ seenEllipsis = false ]
   |
     ( plus='+' | min='-' ) num=Number
     {  Object.assign( $assignment, this.numberLiteral( $num, $plus||$min ) ); }
+  |
+    '('
+      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)*
+      { this.expressionAsAnnotationValue( $assignment, $ctx.cond ); }
+    ')'
   ;
 
 flattenedValue[ assignment ] locals[ val = { name: {} } ]
@@ -2807,6 +2844,11 @@ annoSubValue returns[ val = {} ]
   |
     at='@'? annotationPath[ $val, 'ref', $at ]
     ( annotationPathVariant[ $val ] )?
+  |
+    '('
+      cond=condition
+      { this.expressionAsAnnotationValue( $val, $ctx.cond ); }
+    ')'
   ;
 
 // Literal values and identifiers -----------------------------------------------

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.

package/lib/main.js

@@ -26,6 +26,7 @@ const compiler = lazyload('./compiler');
 const shared = lazyload('./compiler/shared');
 const define = lazyload('./compiler/define');
 const builtins = lazyload('./compiler/builtins');
+const base = lazyload('./compiler/base');
 const finalizeParseCdl = lazyload('./compiler/finalize-parse-cdl');
 
 // The compiler version (taken from package.json)
@@ -157,9 +158,10 @@ module.exports = {
   // INTERNAL functions for the cds-lsp package and friends - before you use
   // it, you MUST talk with us - there can be potential incompatibilities with
   // new releases (even having the same major version):
-  $lsp: { parse: (...args) => compiler.parseX(...args),
+  $lsp: {
+    parse: (...args) => compiler.parseX(...args),
     compile: (...args) => compiler.compileX(...args),
-    getArtifactName: a => a.name
+    getArtifactName: (...args) => base.getArtifactName(...args),
   },
 
   // CSN Model related functionality

package/lib/model/csnRefs.js

@@ -637,10 +637,18 @@ function csnRefs( csn, universalReady ) {
   /**
    * @param {CSN.Path} path
    * @param {CSN.Artifact} art
+   * @param {CSN.Artifact} parent
    * @param {string} [scope]
    * @param [extraInfo]
    */
   function resolvePath( path, art, parent, scope, extraInfo ) {
+    if (!art && path.length > 1) {
+      // TODO: For path.length===1, it may be that `art` is undefined, e.g. for CSN paths such
+      //       as `[…, 'on', 1]` where the path segment refers to `=`.
+      // TODO: Check the call-side.
+      const loc = locationString(parent?.$location);
+      throw new ModelError(`Path item 0='${ pathId(path[0]) }' refers to nothing; in ${ loc }; path=${ JSON.stringify(path) }`);
+    }
     const staticAssoc = extraInfo === 'static' && scope === 'global';
     /** @type {{idx, art?, env?}[]} */
     const links = path.map( (_v, idx) => ({ idx }) );
@@ -657,7 +665,7 @@ function csnRefs( csn, universalReady ) {
       if (!art) {
         const { env } = links[i - 1];
         const loc = env.name && env.name.$location || env.$location;
-        throw new ModelError( `Path item ${ i }=${ pathId( path[i] ) } on ${ locationString( loc ) } refers to nothing` );
+        throw new ModelError( `Path item ${ i }=${ pathId( path[i] ) } refers to nothing; in ${ locationString( loc ) }; path=${ JSON.stringify(path) }` );
       }
       links[i].art = art;
     }
@@ -706,8 +714,12 @@ function csnRefs( csn, universalReady ) {
         if (query !== main)
           cache.set( query, qcache );
 
-        if (fromSelect)
-          getCache( fromSelect, '$aliases' )[query.as] = qcache;
+        if (fromSelect) {
+          const $queryNumber = all.length + 1;
+          const alias = query.as || `$_select_${ $queryNumber }__`;
+          getCache(fromSelect, '$aliases')[alias] = qcache;
+        }
+
         const select = query.SELECT || query.projection;
         if (select) {
           cache.set( select, qcache ); // query and query.SELECT have the same cache qcache