@sap/cds-compiler 4.9.4 → 5.0.6

package/lib/checks/enricher.js

@@ -49,7 +49,6 @@ function enrichCsn( csn, options ) {
     dictionary( csn, 'definitions', csn.definitions );
   return { csn, cleanup };
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function standard( parent, prop, node ) {
     if (!node || typeof node !== 'object' || !{}.propertyIsEnumerable.call( parent, prop ))
       return;
@@ -69,7 +68,7 @@ function enrichCsn( csn, options ) {
     }
     csnPath.pop();
   }
-  // eslint-disable-next-line jsdoc/require-jsdoc
+
   function dictionary( node, prop, dict ) {
     setProp(node, '$path', [ ...csnPath ]);
     cleanupCallbacks.push(() => delete node.$path);
@@ -115,7 +114,6 @@ function enrichCsn( csn, options ) {
     }
   }
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function columns( parent, prop, node ) {
     // Establish the link relationships
     parent[prop].forEach((column) => {
@@ -130,7 +128,6 @@ function enrichCsn( csn, options ) {
     standard(parent, prop, node);
   }
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function simpleRef( node, prop, ref ) {
     setProp(node, '$path', [ ...csnPath ]);
     cleanupCallbacks.push(() => delete node.$path);
@@ -158,7 +155,6 @@ function enrichCsn( csn, options ) {
     }
   }
 
-  // eslint-disable-next-line jsdoc/require-jsdoc
   function pathRef( node, prop, path ) {
     const {
       links, art, scope, $env,

package/lib/checks/structuredAnnoExpressions.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const { isBuiltinType } = require('../base/builtins');
+const { transformExpression, applyTransformationsOnNonDictionary } = require('../model/csnUtils');
+/**
+ *
+ * @param {object} member
+ */
+function checkAnnotationExpression( member, _memberName, _prop, path ) {
+  Object.keys(member).filter(pn => pn[0] === '@').forEach((anno) => {
+    applyTransformationsOnNonDictionary(member, anno, {
+      xpr: (parent, prop, _xpr, xprPath) => {
+        transformExpression(parent, prop, {
+          ref: (elemref, __prop, ref, refPath) => {
+            const { art, scope } = this.csnUtils.inspectRef(refPath);
+            if (scope !== '$magic' && art) {
+              const ft = this.csnUtils.getFinalTypeInfo(art.type);
+              if (!isBuiltinType(ft?.type))
+                this.error('odata-anno-xpr-ref', refPath, { anno, elemref, '#': 'flatten_builtin_type' });
+            }
+          },
+        }, xprPath);
+      },
+    }, {}, path);
+  });
+}
+
+module.exports = {
+  checkAnnotationExpression,
+};

package/lib/checks/validator.js

@@ -15,6 +15,7 @@ const navigationIntoMany = require('./manyNavigations');
 const checkUsedTypesForAnonymousAspectComposition = require('./managedInType');
 const validateHasPersistedElements = require('./hasPersistedElements');
 const checkForHanaTypes = require('./checkForTypes');
+const { checkAnnotationExpression } = require('./structuredAnnoExpressions');
 const checkForParams = require('./parameters');
 // forOdata
 const { validateDefaultValues } = require('./defaultValues');
@@ -210,6 +211,13 @@ function forRelationalDB( csn, that ) {
                         duplicate messages due to the forEachMemberRecursively.
                         TODO: check if this recursion can be factored out of the validator */
                        forEachMember(artifact, checkUsedTypesForAnonymousAspectComposition.bind(that));
+                     },
+                     (artifact, artifactName) => {
+                       if (that.options.transformation === 'effective') {
+                         forEachMemberRecursively(artifact, checkAnnotationExpression.bind(that), [ 'definitions', artifactName ], false, {
+                           skipArtifact: a => a.returns || (a.params && !a.query),
+                         });
+                       }
                      }
                    ),
                    forRelationalDBQueryValidators.concat(commonQueryValidators),

package/lib/compiler/assert-consistency.js

@@ -208,6 +208,7 @@ function assertConsistency( model, stage ) {
             'elements', '$autoElement', '$uncheckedElements', '_origin', '_extensions',
             '$requireElementAccess', '_effectiveType', '$effectiveSeqNo', '_deps',
             '$calcDepElement', '$filtered', '$enclosed', '_parent',
+            'deprecated', '$onlyInExprCtx',
           ],
           schema: {
             kind: { test: isString, enum: [ 'builtin' ] },
@@ -215,6 +216,8 @@ function assertConsistency( model, stage ) {
             $autoElement: { test: isString },
             $uncheckedElements: { test: isBoolean },
             $requireElementAccess: { test: isBoolean },
+            deprecated: { test: isBoolean },
+            $onlyInExprCtx: { test: TODO },
             // missing location for normal "elements"
             elements: { test: TODO },
           },
@@ -703,7 +706,7 @@ function assertConsistency( model, stage ) {
         'localized', // e.g. compiler-generated elements for localized: `text` assoc, etc.
         'localized-entity', // `.texts` entity
         'localized-origin', // `.texts` entity
-        'nav', // only used for MASKED, TODO(v5): Remove
+        'nav', // only used for MASKED, TODO(v6): Remove
         'none', // only used in ensureColumnName(): Used in object representing empty alias
         'query', // inferred query properties, e.g. `key`
         'rewrite', // on-conditions or FKeys are rewritten

package/lib/compiler/base.js

@@ -48,7 +48,7 @@ const kindProperties = {
     normalized: 'action',
     dict: 'actions',
   }, // no extend params, only annotate
-  key: { normalized: 'element' },
+  key: { normalized: 'element', dict: 'elements' }, // dict for annotate
   param: { elements: () => false, enum: () => false, dict: 'params' },
   source: { artifacts: true },  // TODO -> $source
   using: {},

package/lib/compiler/builtins.js

@@ -178,14 +178,15 @@ const magicVariables = {
     // Allow shortcut in CDL: `$user` becomes `$user.id` in CSN.
     $autoElement: 'id',
   },
-  $at: {
+  $at: { // $at is considered deprecated since cds-compiler v5
     elements: {
       from: {}, to: {},
     },
     // Require that elements are accessed, i.e. no $at, only $at.<element>.
     $requireElementAccess: true,
+    deprecated: true, // $at is deprecated; use $valid
   },
-  $valid: { // dito
+  $valid: {
     elements: {
       from: {}, to: {},
     },
@@ -200,6 +201,15 @@ const magicVariables = {
     $uncheckedElements: true,
     $requireElementAccess: true,
   },
+  $draft: {
+    elements: {
+      IsActiveEntity: {},
+    },
+    // Require that elements are accessed, i.e. no $draft, only $draft.<element>.
+    $requireElementAccess: true,
+    // See reference semantics in shared.js
+    $onlyInExprCtx: [ 'annotation', 'annoRewrite' ],
+  },
 };
 
 // see lib/render/renderUtil.js for DB-specific magic vars, specified in CAP CDS  via function
@@ -437,6 +447,10 @@ function initBuiltins( model ) {
         art.$uncheckedElements = magic.$uncheckedElements;
       if (magic.$requireElementAccess)
         art.$requireElementAccess = magic.$requireElementAccess;
+      if (magic.deprecated)
+        art.deprecated = magic.deprecated;
+      if (magic.$onlyInExprCtx)
+        art.$onlyInExprCtx = magic.$onlyInExprCtx;
 
       createMagicElements( art, magic.elements );
       if (options.variableReplacements?.[id])
@@ -461,6 +475,8 @@ function initBuiltins( model ) {
       // Propagate this property so that it is available for sub-elements.
       if (art.$uncheckedElements)
         magic.$uncheckedElements = art.$uncheckedElements;
+      if (art.$onlyInExprCtx)
+        magic.$onlyInExprCtx = art.$onlyInExprCtx;
       setProp( magic, '_parent', art );
       // setProp( magic, '_effectiveType', magic );
       if (elements[id] && typeof elements[id] === 'object')

package/lib/compiler/checks.js

@@ -54,9 +54,6 @@ function check( model ) {
   function checkEvent( def ) {
     // Ensure that events are structured. Up to compiler v4, we allowed non-structured events,
     // because when we introduced them, it was not fully specified what they are.
-    // TODO(v5):
-    //  - Make this a (configurable) error; move to acceptTypeOrElement
-    //  - require type/elements to be set in parser
     if (def.kind === 'event' && !def._effectiveType?.elements && !def._effectiveType?.projection)
       message( 'def-expected-structured', [ (def.type || def.name).location, def ] );
   }
@@ -862,8 +859,8 @@ function check( model ) {
       // Tree-ish expression from the compiler (not augmented)
       // eslint-disable-next-line max-len
       return (isAssociationOperand( xpr.args[0] ) && isDollarSelfOrProjectionOperand( xpr.args[2] ) ||
-      // eslint-disable-next-line max-len
-             isAssociationOperand( xpr.args[2] ) && isDollarSelfOrProjectionOperand( xpr.args[0] ));
+              // eslint-disable-next-line max-len
+              isAssociationOperand( xpr.args[2] ) && isDollarSelfOrProjectionOperand( xpr.args[0] ));
     }
 
     // Nothing else qualifies

package/lib/compiler/define.js

@@ -364,7 +364,7 @@ function define( model ) {
   // must be called after addUsing().
   function addNamespace( namespace, src ) {
     // create using for own namespace:
-    // TODO: should we really do that in v5? See also initNamespaceAndUsing().
+    // TODO: should we really do that (in v6)?  See also initNamespaceAndUsing().
     const last = namespace.path[namespace.path.length - 1];
     const { id } = last;
     if (src.artifacts[id] || last.id.includes( '.' ))
@@ -507,9 +507,10 @@ function define( model ) {
   // TODO: message ids
   function checkRedefinition( art ) {
     if (!art.$duplicates || !art.name.id ||
-        art.$errorReported === 'syntax-duplicate-extend' ||
-        art.$errorReported === 'syntax-duplicate-annotate')
+        art.$errorReported === 'syntax-duplicate-extend')
       return;
+    if (art.kind === 'annotate' || art.kind === 'extend')
+      return; // extensions are merged into a super-annotate; $duplicates are only kept for LSP
     if (art._main) {
       error( 'duplicate-definition', [ art.name.location, art ], {
         name: art.name.id,
@@ -637,7 +638,6 @@ function define( model ) {
   }
 
   function initDollarParameters( art ) {
-    // TODO: remove $parameters in v5?
     // TODO: use setMemberParent() ?
     const parameters = {
       name: { id: '$parameters' },
@@ -939,14 +939,14 @@ function define( model ) {
           setLink( col, '_block', parent._block );
         if (col.inline) { // `@anno elem.{ * }` does not work
           if (col.doc) {
-            message( 'syntax-ignoring-anno', [ col.doc.location, col ],
+            message( 'syntax-unexpected-anno', [ col.doc.location, col ],
                      { '#': 'doc', code: '.{ ‹inline› }' } );
           }
           // col.$annotations no available for CSN input, have to search.
           // Message about first annotation should be enough to avoid spam.
           const firstAnno = Object.keys( col ).find( key => key.startsWith( '@' ) );
           if (firstAnno) {
-            message( 'syntax-ignoring-anno', [ col[firstAnno].name.location, col ],
+            message( 'syntax-unexpected-anno', [ col[firstAnno].name.location, col ],
                      { code: '.{ ‹inline› }' } );
           }
         }
@@ -1083,7 +1083,7 @@ function define( model ) {
           hasElement = true;    // warning with CDL input or `name: {}` in CSN input
       }
       if (hasElement) {
-        // This message is similar to the one above.  In v5/6, we could probably
+        // This message is similar to the one above.  In v6, 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 ],

package/lib/compiler/extend.js

@@ -8,8 +8,8 @@ const {
   forEachInOrder,
   forEachDefinition,
   forEachMember,
+  forEachGeneric,
   isDeprecatedEnabled,
-  isBetaEnabled,
 } = require('../base/model');
 const { dictAdd, pushToDict } = require('../base/dictionaries');
 const { kindProperties, dictKinds } = require('./base');
@@ -30,7 +30,7 @@ const { Location } = require('../base/location');
 
 const $location = Symbol.for( 'cds.$location' );
 
-// attach stupid location - TODO: remove in v5
+// attach stupid location - TODO: remove in v6
 const genLocation = new Location( '' );
 
 const draftElements = [
@@ -59,6 +59,7 @@ function extend( model ) {
     resolvePath,
     resolveUncheckedPath,
     resolveTypeArgumentsUnchecked,
+    resolveDefinitionName,
     attachAndEmitValidNames,
     initMembers,
     initSelectItems,
@@ -72,7 +73,6 @@ function extend( model ) {
   } );
 
   const includesNonShadowedFirst = isDeprecatedEnabled( model.options, 'includesNonShadowedFirst' );
-  const isV5preview = isBetaEnabled( model.options, 'v5preview' );
 
   sortModelSources();
   const extensionsDict = Object.create( null ); // TODO TMP
@@ -161,6 +161,7 @@ function extend( model ) {
     moveReturnsExtensions( art, extensionsMap );
 
     if (art.returns) {
+      ensureArtifactNotProcessed( art.returns );
       pushToDict( art.returns, '_extensions', ...extensionsMap.elements || [] );
       pushToDict( art.returns, '_extensions', ...extensionsMap.enum || [] );
       if (art.kind !== 'annotate') {
@@ -171,16 +172,35 @@ function extend( model ) {
     }
     const sub = art.items || art.targetAspect?.elements && art.targetAspect;
     if (sub) {
+      ensureArtifactNotProcessed( sub );
       pushToDict( sub, '_extensions', ...extensionsMap.elements || [] );
       pushToDict( sub, '_extensions', ...extensionsMap.enum || [] );
     }
     else {
-      moveDictExtensions( art, extensionsMap,
-                          (art.enum && art.kind !== 'annotate' ? 'enum' : 'elements'), 'elements' );
+      let elementsProp = 'elements';
+      if (art.kind !== 'annotate')
+        elementsProp = art.enum && 'enum' || art.foreignKeys && 'foreignKeys' || 'elements';
+      moveDictExtensions( art, extensionsMap, elementsProp, 'elements' );
       moveDictExtensions( art, extensionsMap, 'enum' );
     }
   }
 
+  /**
+   * Applying extensions is handled in extendArtifactAfter(). And only afterward,
+   * an effective sequence number is set.  Meaning that if a sub-artifact already
+   * has a sequence number, then extensions would be lost.
+   */
+  function ensureArtifactNotProcessed( art ) {
+    if (!model.options.testMode)
+      return;
+
+    if (art.$effectiveSeqNo !== 0 && art.$effectiveSeqNo !== undefined) {
+      // if the artifact already has a sequence number, then
+      // extendArtifactAfter() was already called -> annotations would be lost.
+      throw new CompilerAssertion('artifact already processed; extensions would be lost');
+    }
+  }
+
   /**
    * Create super annotate statements for remaining extensions
    */
@@ -196,15 +216,25 @@ function extend( model ) {
   }
 
   // TODO: delete again - if not, what about extensions in contexts/services?
+  //       Check test.lsp-api.js! Links in extensions are needed.
   function setArtifactLinkForExtensions( source ) {
     if (!source.extensions)
       return;
-    for (const ext of source.extensions ) {
+    for (const ext of source.extensions) {
+      if (!ext.name?.id)
+        continue;
+
       const { name } = ext;
-      if (name?.id && name._artifact === undefined) {
+      const { path } = name;
+      if (name._artifact === undefined) {
         const refCtx = (name.id.startsWith( 'localized.' )) ? '_extensions' : ext.kind;
         resolvePath( name, refCtx, ext ); // for LSP
       }
+      else if (model.options.lspMode && path?.[0]._artifact === undefined) {
+        // we don't use resolvePath(…,'extend'), as that would add a dependency
+        resolveDefinitionName( ext );
+        setArtifactLink( path[path.length - 1], name._artifact );
+      }
     }
   }
 
@@ -224,7 +254,7 @@ function extend( model ) {
             code: 'extend … with definitions',
             keyword: 'extend service',
           };
-          // TODO(v5): Discuss: make this an error?
+          // TODO(v6): Discuss: make this an error?
           warning( 'ext-invalid-kind', [ loc, ext ], msgArgs, {
             std: 'Artifact $(ART) is not of kind $(KIND), use $(CODE) instead',
             annotate: 'There is no artifact $(ART), use $(CODE) instead',
@@ -393,6 +423,9 @@ function extend( model ) {
       for (const col of ext.columns)
         col.$extended = true;
 
+      if (art.kind === 'annotate' && art.$inferred === '')
+        return; // internal super-annotate for unknown artifacts
+
       if (!query?.from?.path) {
         const variant = (query?.from || query)?.op?.val || 'std';
         error( 'extend-columns', [ ext.columns[$location], ext ], { '#': variant, art } );
@@ -490,7 +523,7 @@ function extend( model ) {
     if ('val' in upToSpec) {
       if (previousItem.val === upToSpec.val) // enum, struct and ref have no val
         return true;
-      // TODO v5: delete the speciao UP TO comparison?
+      // TODO v6: delete the special UP TO comparison?
       const upToVal = upToSpec.val;
       const prevVal = previousItem.val;
       // eslint-disable-next-line eqeqeq
@@ -540,7 +573,7 @@ function extend( model ) {
   // - 'ext-unexpected-type-argument' (TODO) if the artifact does not have the prop
   // - 'ext-invalid-type-argument' if the value is wrong for extend (no overwrite)
   //
-  // TODO v5: do not allow `extend … with (precision: …)` alone if original def also has `scale`
+  // TODO v6: do not allow `extend … with (precision: …)` alone if original def also has `scale`
   function applyTypeExtensions( art, ext, prop, scaleDiff ) {
     // console.log('ATE:',art?.[prop],ext?.[prop],scaleDiff)
     if (!ext?.[prop])
@@ -617,17 +650,17 @@ function extend( model ) {
     const artDict = art[artProp] || annotateFor( art, extProp ); // no auto-correction in annotate
 
     for (const ext of extensions) {
-      const extDict = ext[extProp];
       let dictCheck = (art.kind !== 'annotate'); // no check in super annotate statement
-      for (const name in extDict) {
-        const elemExt = extDict[name];
+      forEachGeneric(ext, extProp, (elemExt, name) => {
         if (elemExt.kind !== 'annotate' && elemExt.kind !== 'extend') // TODO: specified elems
-          continue;             // definitions inside extend, already handled
+          return;             // definitions inside extend, already handled
         dictCheck = dictCheck && checkRemainingMemberExtensions( art, elemExt, artProp, name );
         const elem = artDict[name] || annotateFor( art, extProp, name );
         setLink( elemExt.name, '_artifact', (elem.kind !== 'annotate' ? elem : null ) );
-        pushToDict( elem, '_extensions', elemExt );
-      }
+        ensureArtifactNotProcessed( elem );
+        if (elem.$duplicates !== true)
+          pushToDict( elem, '_extensions', elemExt );
+      });
     }
   }
 
@@ -778,6 +811,10 @@ function extend( model ) {
                     { '#': (inReturns ? 'enum-returns' : 'enum'), art, name },
                     parent.enum );
           break;
+        case 'foreignKeys':
+          notFound( 'ext-undefined-key', ext.name.location, ext,
+                    { name }, parent.foreignKeys );
+          break;
         case 'params':
           notFound( 'ext-undefined-param', ext.name.location, ext,
                     { '#': 'param', art: parent, name },
@@ -791,7 +828,8 @@ function extend( model ) {
                     parent.actions );
           break;
         default:
-          // assert
+          if (model.options.testMode)
+            throw new CompilerAssertion(`Missing case for prop: ${ prop }`);
       }
     }
     return true;
@@ -832,8 +870,9 @@ function extend( model ) {
   }
 
   function checkRemainingMainExtensions( art, ext, localized ) {
+    const isExtend = ext.kind === 'extend';
     if (localized) {
-      if (isV5preview && ext.kind === 'extend') {
+      if (isExtend) {
         // In v5, reject any `extend` on localized.
         error( 'ref-undefined-art', [ ext.location || ext.name.location, ext ],
                { '#': 'localized', keyword: 'annotate' } );
@@ -847,22 +886,21 @@ function extend( model ) {
     if (art?.builtin) {
       info( 'anno-builtin', [ ext.name.location, ext ], {} ); // TODO: better location?
     }
-    else if (art?.kind === 'namespace') {
+    else if (isExtend && art?.kind === 'namespace') {
+      // `annotate` on namespaces already handled before
       const hasAnnotations = Object.keys(ext).find(a => a.charAt(0) === '@');
       const firstAnno = ext[hasAnnotations];
       // In v5, extending namespaces is only allowed for `extend with definitions`.
       // Neither annotations nor other extensions are allowed.
       // Non-artifact extensions are reported in resolvePath() already (for v5).
-      if ((hasAnnotations || !ext.artifacts) ) {
-        if (isV5preview) {
-          error( 'ref-undefined-art', [ (firstAnno?.name || ext.name).location, ext ], {
-            '#': 'namespace', art: ext,
-          } );
-        }
-        else {
-          info( 'anno-namespace', [ (firstAnno?.name || ext.name).location, ext ], {},
-                'Namespaces can\'t be annotated nor extended' );
-        }
+      // Because "namespaces" are the same as "unknown" artifacts in CSN, we don't report
+      // an error for `annotate`s.
+      // FIXME: The compiler generates empty `annotate` statements for
+      //        `extend ns with definitions {…}`. That's why we check the frontend.
+      if (hasAnnotations || (!ext.artifacts && ext._block.$frontend !== 'json')) {
+        error( 'ref-undefined-art', [ (firstAnno?.name || ext.name).location, ext ], {
+          '#': 'namespace', art: ext,
+        } );
       }
     }
   }
@@ -1101,7 +1139,6 @@ function extend( model ) {
                  { art: artName },
                  {
                    std: 'Unknown $(ART) - nothing to extend',
-                   // eslint-disable-next-line max-len
                    element: 'Artifact $(ART) has no element or enum $(MEMBER) - nothing to extend',
                    action: 'Artifact $(ART) has no action $(MEMBER) - nothing to extend',
                  } );
@@ -1232,7 +1269,7 @@ function extend( model ) {
           if (!parent) // not yet set for EXTEND foo WITH bar => linkToOrigin() did not add it
             dictAdd( ext[prop], name, elem );
           elem.$inferred = 'include';
-          if (origin.masked)    // TODO(v5): remove 'masked'
+          if (origin.masked)    // TODO(v6): remove 'masked'
             elem.masked = Object.assign( { $inferred: 'include' }, origin.masked );
           if (origin.key)
             elem.key = Object.assign( { $inferred: 'include' }, origin.key );
@@ -1269,8 +1306,6 @@ function extend( model ) {
   /**
    * Report duplicates in parent[prop] that happen due to multiple includes having the
    * same member.  Covers `entity G : E, G {};` but not `entity G : E {};  extend G with F;`.
-   *
-   * TODO(v5): Make this a hard error; see checkRedefinition(); maybe combine both;
    */
   function checkRedefinitionThroughIncludes( parent, prop ) {
     if (!parent[prop])

package/lib/compiler/generate.js

@@ -656,7 +656,7 @@ function generate( model ) {
 
     if (elem.type && !isDirectComposition( elem )) {
       // Only issue warning for direct usages, not for projections, includes, etc.
-      // TODO: Make it configurable error; v5: error
+      // TODO: Make it configurable error; v6: error
       // TODO: move to resolve.js where we test the targetAspect,
       warning( 'type-expecting-composition', [ elem.type.location, elem ],
                { newcode: 'Composition of', code: 'Association to' },

package/lib/compiler/index.js

@@ -83,11 +83,7 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
   if (!messageFunctions)
     messageFunctions = createMessageFunctions( options, 'parse' );
   const ext = path.extname( filename ).slice(1).toLowerCase();
-  // eslint-disable-next-line no-nested-ternary
-  const parser = options.fallbackParser === 'auto!'
-    ? (source?.startsWith( '{' ) ? parseCsn.parse : parseLanguage)
-    : (extensionParsers[ext] || extensionParsers[options.fallbackParser] ||
-       source.startsWith( '{' ) && parseCsn.parse);
+  const parser = parserForFile( source, ext, options );
   if (parser)
     return parser( source, filename, options, messageFunctions );
 
@@ -101,6 +97,27 @@ function parseX( source, filename, options = {}, messageFunctions = null ) {
   return model;
 }
 
+/**
+ * Get the correct parser for the given source / file extension.
+ * Respects the set fallback parser.
+ *
+ * @param {string} source
+ * @param {string} ext
+ * @param {object} options
+ */
+function parserForFile( source, ext, options ) {
+  // 'auto!' ignores the file's extension
+  if (options.fallbackParser === 'auto!')
+    return (source?.startsWith( '{' ) ? parseCsn.parse : parseLanguage);
+
+  if (options.fallbackParser === 'csn!')
+    return parseCsn.parse;
+
+  return extensionParsers[ext] ||
+    extensionParsers[options.fallbackParser] ||
+    (source.startsWith( '{' ) && parseCsn.parse);
+}
+
 // Main function: Compile the sources from the files given by the array of
 // `filenames`.  As usual with the `fs` library, relative file names are
 // relative to the working directory `process.cwd()`.  With argument `dir`, the
@@ -530,7 +547,7 @@ function processFilenamesSync( filenames, dir ) {
       // already handles non-existent files.
       name = fs.realpathSync.native( name );
     }
-    catch (e) {
+    catch {
       // Ignore the not-found (ENOENT) error
     }
     filenameMap[originalName] = name;