@sap/cds-compiler 4.0.2 → 4.1.2

package/lib/compiler/classes.js

@@ -0,0 +1,62 @@
+// Base classes used as prototypes for XSN definitions, elements, etc.
+// The goal is to have named classes that can be seen in performance analyses, e.g.
+// by using the [DeOpt Explorer][1].
+// All classes should also be constructible using `{ __proto__: Class, …}`, i.e.
+// their constructors must not do anything besides assigning properties.
+//
+// Refer to these resources:
+// - <https://mathiasbynens.be/notes/shapes-ics>
+// - <https://v8.dev/blog/fast-properties>
+//
+// Before adding new properties, evaluate whether it has any performance
+// impact.  Too many properties that are rarely used could reduce performance,
+// but too few could lead to inconsistent object shapes for commonly
+// used properties.
+//
+// Use [DeOpt Explorer][1] to see the different object Maps by v8.
+//
+// [1]: https://devblogs.microsoft.com/typescript/introducing-deopt-explorer/
+
+'use strict';
+
+class XsnSource {
+  kind = 'source';
+  location;
+  usings = [];
+  dependencies = [];
+  artifacts = Object.create(null);
+  vocabularies = Object.create(null);
+  extensions = [];
+}
+
+class XsnArtifact {
+  location;
+  name;
+  kind;
+}
+
+class XsnName {
+  location;
+}
+
+class CsnLocation {
+  file;
+  line;
+  col;
+  endLine;
+  endCol;
+  constructor(file, line, col, endLine, endCol) {
+    this.file = file;
+    this.line = line;
+    this.col = col;
+    this.endLine = endLine;
+    this.endCol = endCol;
+  }
+}
+
+module.exports = {
+  XsnSource,
+  XsnArtifact,
+  XsnName,
+  CsnLocation,
+};

package/lib/compiler/cycle-detector.js

@@ -64,14 +64,14 @@ function detectCycles( definitions, reportCycle, cbScc ) {
       // console.log('PUSH: ', v.kind,v.name)
     }
     if (!v._deps)               // builtins, otherwise forgotten (TODO: assert in --test-mode)
-      setProp(v, '_deps', []);
+      setProp( v, '_deps', [] );
     // assert( v._scc.onStack );
 
     // Now consider successors of v (called w):
     while (v._scc.depIndex < v._deps.length) {
       const w = v._deps[v._scc.depIndex++].art;
       if (!w._scc) {            // node has not yet been visited
-        setProp(w, '_sccCaller', v);
+        setProp( w, '_sccCaller', v );
         // console.log('CALL: ', v._scc.depIndex )
         return w;               // recursive call with w in recursive algorithm
       }
@@ -112,7 +112,7 @@ function detectCycles( definitions, reportCycle, cbScc ) {
   function defaultCb( w, v, r ) {
     for (const dep of w._deps) {
       if (dep.art._scc.lowlink === w._scc.lowlink) // in same SCC
-        reportCycle( w, dep.art, dep.location );
+        reportCycle( w, dep.art, dep.location, dep.semanticLoc );
     }
     return r;
   }

package/lib/compiler/define.js

@@ -142,6 +142,7 @@ const { compareLayer } = require('./moduleLayers');
 const { initBuiltins, isInReservedNamespace } = require('./builtins');
 
 const $location = Symbol.for('cds.$location');
+const $inferred = Symbol.for('cds.$inferred');
 
 /**
  * Export function of this file.  Transform argument `sources` = dictionary of
@@ -172,6 +173,7 @@ function define( model ) {
     initArtifact,
     initMembers,
     checkDefinitions,           // TODO: remove
+    initSelectItems,
   } );
 
   let boundSelfParamType = true; // special `$self` for binding param must still be initialised
@@ -252,7 +254,7 @@ function define( model ) {
     }
     else if (src.definitions) {      // CSN input
       prefix = '';
-      dictForEach( shuffleDict( src.definitions ), v => addDefinition( v, src ) );
+      dictForEach( shuffleDict( src.definitions ), def => addDefinition( def, src, prefix ));
     }
     if (src.vocabularies) {
       if (!model.vocabularies)
@@ -264,7 +266,11 @@ function define( model ) {
     }
   }
 
-  function addDefinition( art, block ) {
+  function addDefinition( art, block, prefix ) {
+    if (!art.name.absolute) {
+      // TODO: art.name.absolute = art.name.id || …
+      art.name.absolute = (!art.name.path) ? art.name.id : prefix + pathName(art.name.path);
+    }
     const { absolute } = art.name;
     // TODO: check reserved, see checkName()/checkLocalizedObjects() of checks.js
     if (absolute === 'cds' || isInReservedNamespace(absolute)) {
@@ -373,8 +379,7 @@ function define( model ) {
   function addArtifact( art, block, prefix ) {
     if (art.kind === 'using')
       return;
-    art.name.absolute = prefix + pathName( art.name.path );
-    addDefinition( art, block );
+    addDefinition( art, block, prefix );
     if (art.artifacts) {
       const p = `${ art.name.absolute }.`;
       // path prefixes (usings) must be added before extensions in artifacts:
@@ -444,8 +449,10 @@ function define( model ) {
   function addVocabulary( vocab, block, prefix ) {
     setLink( vocab, '_block', block );
     const { name } = vocab;
-    if (!name.absolute)
-      name.absolute = prefix + pathName( name.path );
+    if (!name.absolute) {
+      // TODO: art.name.absolute = vocab.name.id || …
+      vocab.name.absolute = (!vocab.name.path) ? vocab.name.id : prefix + pathName(vocab.name.path);
+    }
     dictAdd( model.vocabularies, name.absolute, vocab );
   }
 
@@ -574,7 +581,7 @@ function define( model ) {
     if (!art.query)
       return;
     art.$queries = [];
-    setLink( art, '_from', [] ); // for sequence of resolve steps
+    setLink( art, '_from', [] ); // for sequence of resolve steps - TODO: remove
     if (!setLink( art, '_leadingQuery', initQueryExpression( art.query, art ) ) )
       return;                   // null or undefined in case of parse error
     // if (art._leadingQuery !== art.$queries [0]) throw Error('FOO');
@@ -880,9 +887,9 @@ function define( model ) {
     }
   }
 
-  function initSelectItems( parent, columns, user ) {
-    // TODO: forbid expand/inline with :param, global:true, in ref-where, outside queries (CSN), ...
-    let wildcard = null;
+  function initSelectItems( parent, columns, user, inExtension = false ) {
+    let wildcard = !!inExtension; // no `extend … with columns { * }`
+    // TODO: forbid expand/inline in ref-where, outside queries (CSN), ...
     let hasItems = false;
     for (const col of columns || parent.expand || parent.inline || []) {
       if (!col)                 // parse error
@@ -898,6 +905,11 @@ function define( model ) {
         if (!wildcard) {
           wildcard = col;
         }
+        else if (wildcard === true) { // in `extend … with columns {…}`
+          error( 'ext-unexpected-wildcard', [ col.location, parent ], { code: '*' },
+                 'Unexpected $(CODE) (wildcard) in an extension' );
+          col.val = null;       // do not consider it for expandWildcard()
+        }
         else {
           // a late syntax error (this code also runs with parse-cdl), i.e.
           // no semantic loc (wouldn't be available for expand/inline anyway)
@@ -917,7 +929,8 @@ function define( model ) {
       }
       // Either expression (value), expand or new association (target && type)
       else if (col.value || col.expand || (col.target && col.type)) {
-        setLink( col, '_block', parent._block );
+        if (!col._block)
+          setLink( col, '_block', parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
             warning( 'syntax-ignoring-anno', [ col.doc.location, col ],
@@ -932,23 +945,18 @@ function define( model ) {
           }
         }
         // TODO: allow sub queries? at least in top-level expand without parallel ref
-        if (columns)
+        if (columns && !inExtension) // not (yet) in `extend … with columns {…}`
           initExprForQuery( col.value, parent );
-        initSelectItems( col, null, user );
+        initSelectItems( col, null, user ); // TODO: use col as user (i.e. remove param)
       }
     }
 
-    if (hasItems && !wildcard && parent.excludingDict) {
-      // TODO: Better way to get source file?
-      let block = parent;
-      while (block._block)
-        block = block._block;
-
-      if (block.$frontend === 'cdl') {
-        warning('query-ignoring-exclude', [ parent.excludingDict[$location], user ],
-                { prop: '*' },
-                'Excluding elements without wildcard $(PROP) has no effect');
-      }
+    if (hasItems && !wildcard && parent.excludingDict && !options.$recompile) {
+      // TODO: the SQL backend should probably delete `excluding` when expanding `*`
+      // TODO: use `parent` for semantic location, use `-excluding`
+      warning( 'query-ignoring-exclude', [ parent.excludingDict[$location], user ],
+               { prop: '*' },
+               'Excluding elements without wildcard $(PROP) has no effect');
     }
   }
 
@@ -1016,13 +1024,13 @@ function define( model ) {
     const { targetAspect } = obj;
     if (targetAspect) {
       if (obj.foreignKeys) {
-        error( 'unexpected-keys-for-composition', [ obj.foreignKeys[$location], construct ],
+        error( 'type-unexpected-foreign-keys', [ obj.foreignKeys[$location], construct ],
                {},
                'A managed aspect composition can\'t have a foreign keys specification' );
         delete obj.foreignKeys; // continuation semantics: not specified
       }
       if (obj.on && !obj.target) {
-        error( 'unexpected-on-for-composition', [ obj.on.location, construct ],
+        error( 'type-unexpected-on-condition', [ obj.on.location, construct ],
                {},
                'A managed aspect composition can\'t have a specified ON-condition' );
         delete obj.on;          // continuation semantics: not specified
@@ -1056,30 +1064,33 @@ function define( model ) {
 
     function initElementsAsEnum() {
       // in extensions, extended enums are represented as elements
-      let firstEnum = null;
+      let hasElement = false;
       for (const n in obj.elements) {
         const e = obj.elements[n];
-        if (e.kind === 'element') {
-          // An "element" has `$syntax: 'enum'` if it could also be an enum
-          if (e.$syntax === 'enum') { // TODO: what about "just name"? (current forbidden)
-            e.kind = 'enum';
-            firstEnum = firstEnum || e;
-          }
-          else {
-            // We do not want to complain separately about all element properties:
-            error( 'ext-unexpected-element', [ e.location, construct ],
-                   { name: e.name.id, code: 'extend … with enum' },
-                   // eslint-disable-next-line max-len
-                   'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
-            return;
-          }
+        if (e.kind === 'extend')
+          continue;
+        const noVal = e.value?.val === undefined && e.value?.sym === undefined;
+        // TODO: forbid #symbol as enum value
+        if (e.$syntax === 'element' || // `extend … with elements` or `extend with { element … }`
+            noVal && e.$syntax !== 'enum' || // no value in CDL input
+            e.virtual || e.key || e.masked || e.type || e.elements || e.items || e.stored) {
+          // We do not want to complain separately about all element properties:
+          error( 'ext-unexpected-element', [ e.location, construct ],
+                 { name: e.name.id, code: 'extend … with enum' },
+                 // eslint-disable-next-line max-len
+                 'Unexpected elements like $(NAME) in an extension for an enum. Additionally, use $(CODE) when extending enums' );
+          // Don't emit 'ext-expecting-enum' if this error is emitted.
+          return;
         }
+        e.kind = 'enum';
+        if (noVal || e.$syntax !== 'enum')
+          hasElement = true;    // warning with CDL input or `name: {}` in CSN input
       }
-      if (firstEnum && block.$frontend !== 'json') {
-        // Don't emit this message if `ext-unexpected-element` was already emitted.
-        // This message is similar to the one above.  In v5/6, we could probably remove the warning
-        // and always emit the error.
-        warning( 'ext-expecting-enum', [ firstEnum.location, construct ],
+      if (hasElement) {
+        // This message is similar to the one above.  In v5/6, we could probably
+        // turn this warning into an error, remove `$syntax: 'element' (also in
+        // language.g4), and use the above `ext-unexpected-element` only for CSN input.
+        warning( 'ext-expecting-enum', [ obj.elements[$location], construct ],
                  { code: 'extend … with enum' }, 'Use $(CODE) when extending enums' );
       }
       forEachGeneric( { enum: obj.elements }, 'enum', init );
@@ -1231,7 +1242,7 @@ function define( model ) {
       if (!feature) {
         // Note: This error can't be triggered at the moment.  But as we likely want to
         //       allow extensions with params in the future, we keep the code.
-        error( 'unexpected-params', [ location, construct ], {},
+        error( 'def-unexpected-params', [ location, construct ], {},
                'Parameters only exist for entities, actions or functions' );
       }
       else {
@@ -1252,7 +1263,7 @@ function define( model ) {
       }
     }
     else if (prop === 'elements') {
-      error( 'unexpected-elements', [ location, construct ], {},
+      error( 'def-unexpected-elements', [ location, construct ], {},
              'Elements only exist in entities, types or typed constructs' );
     }
     else if (prop === 'columns') {
@@ -1270,14 +1281,16 @@ function define( model ) {
   function targetIsTargetAspect( elem ) {
     const { target } = elem;
     if (target.elements) {
-      // TODO: error if CSN has both target.elements and targetAspect.elements -> delete target
+      // TODO: error if CSN has both target.elements and targetAspect.elements
+      // -> delete target
       return true;
     }
     if (elem.targetAspect || options.parseCdl || !isDirectComposition( elem ))
       return false;
     const name = resolveUncheckedPath( target, 'target', elem );
     const aspect = name && model.definitions[name];
-    return aspect && (aspect.kind === 'aspect' || aspect.kind === 'type'); // type is sloppy
+    return (aspect?.kind === 'aspect' || aspect?.kind === 'type') && // type is sloppy
+      aspect.elements && !aspect.elements[$inferred];
   }
 }
 

package/lib/compiler/extend.js

@@ -23,10 +23,12 @@ const {
 } = require('./utils');
 const layers = require('./moduleLayers');
 const { CompilerAssertion } = require('../base/error');
+const { CsnLocation } = require('./classes');
 
 const $location = Symbol.for('cds.$location');
 
-const genLocation = { file: '' }; // attach stupid location - TODO: remove in v4
+// attach stupid location - TODO: remove in v5
+const genLocation = new CsnLocation( '' );
 
 // Array.prototype.spread = 42;   // prototype-polluted JS classes
 
@@ -41,6 +43,7 @@ function extend( model ) {
     resolveTypeArgumentsUnchecked,
     attachAndEmitValidNames,
     initMembers,
+    initSelectItems,
   } = model.$functions;
 
   Object.assign( model.$functions, {
@@ -383,12 +386,16 @@ function extend( model ) {
       const { query } = art;
       for (const col of ext.columns)
         col.$extended = true;
-      if (!query?.from?.path)
+
+      if (!query?.from?.path) {
         error( 'extend-columns', [ ext.columns[$location], ext ], { art } );
-      else if (!query.columns)
+        return;
+      }
+      if (!query.columns)
         query.columns = [ { location: query.from.location, val: '*' }, ...ext.columns ];
       else
         query.columns.push( ...ext.columns );
+      initSelectItems( query, ext.columns, query, true );
     }
     else if ([ 'length', 'precision', 'scale', 'srid' ].includes( prop )) {
       const typeExts = art.$typeExts || (art.$typeExts = {});
@@ -719,6 +726,11 @@ function extend( model ) {
           warning( 'anno-unexpected-params', [ location, ext._parent ], {},
                    'Parameters only exist for actions or functions' );
           break;
+        case 'actions':
+          // TODO: check if artifact can have actions, similar to `anno-unexpected-actions`
+          notFound( 'anno-undefined-action', ext.name.location, ext,
+                    { '#': 'action', art: parent, name } );
+          break;
         default:
           if (model.options.testMode)
             throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
@@ -887,8 +899,15 @@ function extend( model ) {
       model._entities.push( art ); // add structure with includes in dep order
       art.$entity = ++model.$entity;
     }
-    if (!noIncludes && art.includes)
-      applyIncludes( art, art );
+    if (art.includes) {
+      if (!noIncludes) {
+        applyIncludes( art, art );
+      }
+      else {
+        for (const ref of art.includes)
+          resolvePath( ref, 'include', art );
+      }
+    }
     // checkExtensionsKind( extensions, art );
     extendMembers( extensions, art, noIncludes === 'gen' );
     if (!noIncludes && art.includes) {
@@ -1055,7 +1074,6 @@ function extend( model ) {
   function canApplyIncludes( art, target, justResolveCyclic ) {
     if (!art.includes)
       return true;
-    const isView = !!target.query;
     for (const ref of art.includes) {
       const name = resolveUncheckedPath( ref, 'include', art );
       // console.log('CAI:',justResolveCyclic, name, ref.path, Object.keys(extensionsDict))
@@ -1071,7 +1089,6 @@ function extend( model ) {
       else if (ref._artifact) {
         delete ref._artifact;
       }
-      resolvePath( ref, isView ? 'viewInclude' : 'include', art );
     }
     return true;
   }
@@ -1096,20 +1113,18 @@ function extend( model ) {
       return;
     }
 
-    if (!art.query) {
-      if (!art._ancestors)
-        setLink( art, '_ancestors', [] ); // recursive array of includes
-      for (const ref of ext.includes) {
-        const template = ref._artifact;
-        // !template -> non-includable, e.g. scalar type, or cyclic
-        if (template) {
-          if (template._ancestors)
-            art._ancestors.push( ...template._ancestors );
-          art._ancestors.push( template );
-        }
+    if (!art._ancestors && !art.query)
+      setLink( art, '_ancestors', [] ); // recursive array of includes
+    for (const ref of ext.includes) {
+      const template = resolvePath( ref, 'include', art );
+      // !template -> non-includable, e.g. scalar type, or cyclic
+      if (template && !art.query) {
+        if (template._ancestors)
+          art._ancestors.push( ...template._ancestors );
+        art._ancestors.push( template );
       }
     }
-    if (!art.query)    // do not set art.elements and art.enums with query entity!
+    if (!art.query && art.elements) // do not set art.elements and art.enums with query entity!
       includeMembers( ext, art, 'elements' );
     includeMembers( ext, art, 'actions' );
   }
@@ -1128,12 +1143,15 @@ function extend( model ) {
     // Warning 'Overwrites definition from include "I" (at elem def)
     const parent = ext === art && art;
     const members = ext[prop];
-    ext[prop] = Object.create(null); // TODO: do not set actions property if there are none
+    if (members || art[prop])
+      ext[prop] = Object.create(null);
     let hasNewElement = false;
 
     for (const ref of ext.includes) {
       const template = ref._artifact; // already resolved
       if (template) {           // be robust
+        if (template[prop] && !ext[prop])
+          ext[prop] = Object.create(null);
         // eslint-disable-next-line no-loop-func
         forEachInOrder( template, prop, ( origin, name ) => {
           if (members && members[name]) {

package/lib/compiler/finalize-parse-cdl.js

@@ -101,7 +101,8 @@ function finalizeParseCdl( model ) {
     // Recursively go through all XSN properties.  There are a few that need to be
     // handled specifically.  Refer to the code below this loop for details.
     for (const prop in artifact) {
-      if (parseCdlSpeciallyHandledXsnProps.includes(prop) || parseCdlIgnoredXsnProps.includes(prop))
+      if (artifact[prop] === undefined || parseCdlSpeciallyHandledXsnProps.includes(prop) ||
+        parseCdlIgnoredXsnProps.includes(prop))
         continue;
 
       if (artifact[prop] && Object.getPrototypeOf(artifact[prop]) === null)

package/lib/compiler/generate.js

@@ -214,12 +214,6 @@ function generate( model ) {
       else if (isLocalized) {
         textElems.push( elem );
       }
-
-      if (isKey && isLocalized) { // key with localized is wrong - ignore localized
-        const errpos = elem.localized || elem.type || elem.name;
-        warning( 'def-ignoring-localized-key', [ errpos.location, elem ], { keyword: 'localized' },
-                 'Keyword $(KEYWORD) is ignored for primary keys' );
-      }
     }
     if (textElems.length <= keys)
       return false;
@@ -386,7 +380,6 @@ function generate( model ) {
 
     if (!fioriEnabled) {
       // To be compatible, we switch off draft without @fiori.draft.enabled
-      // TODO (next major version): remove?
       setAnnotation( art, '@odata.draft.enabled', art.location, false );
     }
     else {
@@ -446,7 +439,6 @@ function generate( model ) {
     if (!fioriEnabled) {
       locale.key = { val: true, location };
       // To be compatible, we switch off draft without @fiori.draft.enabled
-      // TODO (next major version): remove?
       setAnnotation( art, '@odata.draft.enabled', art.location, false );
     }
     else {

package/lib/compiler/index.js

@@ -38,6 +38,7 @@ const { cdsFs } = require('../utils/file');
 
 const fs = require('fs');
 const path = require('path');
+const { CsnLocation, XsnSource } = require('./classes');
 
 const extensionParsers = {
   csn: parseCsn.parse,
@@ -91,7 +92,8 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
   if (parser)
     return parser( source, filename, options, messageFunctions );
 
-  const model = { location: { file: filename } };
+  const model = new XsnSource();
+  model.location = new CsnLocation( filename );
   messageFunctions.error( 'file-unknown-ext', emptyWeakLocation(filename),
                           { file: ext, '#': !ext && 'none' }, {
                             std: 'Unknown file extension $(FILE)',
@@ -171,12 +173,12 @@ function compileX( filenames, dir = '', options = {}, fileCache = Object.create(
       return [];                 // no further dependency processing
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in sources:
-    sources[filename] = { location: { file: rel } };
+    sources[filename] = { location: new CsnLocation( rel ) };
 
     const source = await cdsFs( fileCache, options.traceFs ).readFileAsync( filename, 'utf8' );
     const ast = parseX( source, rel, options, model.$messageFunctions );
     sources[filename] = ast;
-    ast.location = { file: rel };
+    ast.location = new CsnLocation( rel );
     ast.dirname = path.dirname( filename );
     assertConsistency( ast, options );
 
@@ -290,7 +292,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
     }
     // no parallel readAndParse with same resolved filename should read the file,
     // also ensure deterministic sequence in a.sources:
-    a.sources[filename] = { location: { file: rel } };
+    a.sources[filename] = { location: new CsnLocation( rel ) };
 
     cdsFs( fileCache, options.traceFs ).readFileSync( filename, 'utf8', (err, source) => {
       if (err) {
@@ -300,7 +302,7 @@ function compileSyncX( filenames, dir = '', options = {}, fileCache = Object.cre
         try {
           const ast = parseX( source, rel, options, model.$messageFunctions );
           a.sources[filename] = ast;
-          ast.location = { file: rel };
+          ast.location = new CsnLocation( rel );
           ast.dirname = path.dirname( filename );
           assertConsistency( ast, options );
           cb( null, ast );
@@ -373,7 +375,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     if (typeof source === 'string') {
       const ast = parseX( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = { file: filename };
+      ast.location = new CsnLocation( filename );
       assertConsistency( ast, options );
     }
     else if (options.$xsnObjects) { // source is a XSN object with option $xsnObjects
@@ -382,7 +384,7 @@ function compileSourcesX( sourcesDict, options = {} ) {
     else {                      // source is a CSN object
       const ast = parseCsn.augment( source, filename, options, model.$messageFunctions );
       sources[filename] = ast;
-      ast.location = { file: filename };
+      ast.location = new CsnLocation( filename );
       assertConsistency( ast, options );
     }
 

package/lib/compiler/kick-start.js

@@ -125,6 +125,7 @@ function kickStart( model ) {
     if (elem.target && type && type[0] && type[0].id === 'cds.Composition') {
       // A target aspect would have already moved to property `targetAspect` in
       // define.js (hm... more something for kick-start.js...)
+      // TODO: for safety, just use resolveUncheckedPath()
       const target = resolvePath( elem.target, 'target', elem );
       if (target)
         model.$compositionTargets[target.name.absolute] = true;
@@ -134,6 +135,7 @@ function kickStart( model ) {
 
   // Resolve the using declarations in `using`.  Issue
   // error message if the referenced artifact does not exist.
+  // TODO: think of moving this to resolve.js
   function resolveUsings( src, topLevel ) {
     if (!src.usings)
       return;