What happens to exceptions thrown inside a catch filter (when clause) in C#? Can they be traced?

Question

I was reading up on filter expressions using catch(..) when (..) in C# and I couldn't find any mention of what happens if an exception is thrown while evaluating the expression. I tried going through the docs and spec but either I couldn't find them or they are not mentioned. So, I made up a tiny program to check what happens when I throw from when(..). I put it up on https://dotnetfiddle.net/R7oJNp

try {
    Console.WriteLine("Test(): Inside Test()");
    throw new Exception("thrown from Test()");
} catch (Exception) when (AlwaysThrow()) {
    Console.WriteLine("Test(): caught exception in Test()");
} catch (Exception e) {
    Console.WriteLine("Test(): totally skipped last catch clause, any inner exception: " + (e.InnerException?.Message ?? "nothing"));
    throw;
}

What I'm noticing is that the entire catch(..) when (..) block is skipped if an exception is thrown inside when(..). It skips to the next matching catch block and upon inspecting the exception object caught, there's no trace of the exception that originated from when(..).

I wanted to know if this is the expected behavior and if there's a reference to the docs/spec regarding what's supposed to happen in this scenario. It seems odd to skip the entire block and throw away the exception because that'd make it very hard to debug.

**Edit: ** Okay, this is the behavior according to .NET docs but is there any way to trace these? I'm onboard with the idea that exceptions must not happen and filters should be simple enough but we make mistakes. Also, isn't this behavior supposed to be mentioned in C# spec?

Answer 1

VB.Net has supported this long before C# so you may be searching too narrowly:

If an exception occurs during execution of the user-filtered expression, that exception is discarded and the filter expression is considered to have evaluated to false.

https://learn.microsoft.com/en-us/dotnet/standard/exceptions/using-user-filtered-exception-handlers