TailCallAttribute does warn on non-tail-recursive async function with try-with or try-finally block

[jwosty]

I'm liking the new non-tail-recursion warning, however it looks like it's missing a case.

Repro steps

Compile this code with F# 8:

[<TailCall>]
let rec g x =
    try
        g (x + 1)
    with e ->
        raise (InvalidOperationException("Operation has failed", e))

[<TailCall>]
let rec gAsync x = async {
    try
        return! gAsync (x + 1)
    with e ->
        return raise (InvalidOperationException("Operation has failed", e))
}

Expected behavior

Both g and gAsync should produce Warning FS3569 : The member or function 'g' has the 'TailCallAttribute' attribute, but is not being used in a tail recursive way.

Actual behavior

Only g produces FS3569.

This is similarly missed for try-finally blocks

See also

• Tail recursion warning and attribute, analysis after optimization #15503

[jwosty]

Found some more odd edge cases which seem to confuse the compiler:

// correctly warns
[<TailCall>]
let rec f x =
    try
        f x
    with e ->
        ExceptionDispatchInfo.Throw(e)
        Unchecked.defaultof<_>
        
// should warn, but it doesn't
[<TailCall>]
let rec g x =
    try
        match x with
        | 0 -> x
        | _ -> g x
    with e ->
        ExceptionDispatchInfo.Throw(e)
        Unchecked.defaultof<_>

// correctly warns
[<TailCall>]
let rec h x =
    try
        match x with
        | 0 -> h x // only difference between g and h is this branch (!!)
        | _ -> h x
    with e ->
        ExceptionDispatchInfo.Throw(e)
        Unchecked.defaultof<_>

// should warn, but it doesn't
[<TailCall>]
let rec i x =
    try
        if (x = 0) then
            x
        else i x
    with e ->
        ExceptionDispatchInfo.Throw(e)
        Unchecked.defaultof<_>

// correctly doesn't warn
[<TailCall>]
let rec factorialWithAcc n accumulator = 
    match n with
    | 0u | 1u -> accumulator
    | _ -> factorialWithAcc (n - 1u) (n * accumulator)
    
// should warn, but it doesn't
[<TailCall>]
let rec factorialWithAccTryWith n accumulator =
    try
        match n with
        | 0u | 1u -> accumulator
        | _ -> factorialWithAccTryWith (n - 1u) (n * accumulator)
    with e ->
        ExceptionDispatchInfo.Throw(e)
        Unchecked.defaultof<_>

[dawedawe]

Thanks a lot @jwosty. I'll take a look at it.