[<TailCall>] attribute gives incorrect warning with simple sequence expression

[Bananas-Are-Yellow]

This code compiles fine:

    [<TailCall>]
    let rec fib a b = seq {
        yield a
        yield! fib b (a + b)
    }

    let fibonacci = fib 0 1

But the following minor change produces the message: The member or function 'fib' has the 'TailCallAttribute' attribute, but is not being used in a tail recursive way.

    [<TailCall>]
    let rec fib a b = seq {
        yield a
        if true then
            yield! fib b (a + b)
    }

    let fibonacci = fib 0 1

Related information

Provide any related information (optional):

• Pop!_OS 22.04
• VS Code: 1.102.2
• TargetFramework: net9.0

[Bananas-Are-Yellow]

FSharp.Core (9.0.300)

[Bananas-Are-Yellow]

This issue might be related to #16477, which is fixed and closed.

As with #16477, if I reverse the if test, I don't get the warning. So, the following code gives the warning:

    [<TailCall>]
    let rec fib a b = seq {
        yield a
        if true then
            yield! fib b (a + b)
    }

But this code does not give the warning.

    [<TailCall>]
    let rec fib a b = seq {
        yield a
        if false then () else
            yield! fib b (a + b)
    }

Also, as with #16477, this example only happens with a Debug build.

However, my actual code is slightly more complicated and still gives warnings in a Release build. The code compares two sorted arrays using a compare function.

Because I can't apply the [<TailCall>] attribute to a nested function (attributes on nested functions are not supported), I have the recursive function inside a separate type.

type Diff<'a,'b> =
    | A of 'a
    | B of 'b
    | AB of 'a * 'b

module SortedArray =
    type private CompareWith<'a,'b> (compare, itemsA: array<'a>, itemsB: array<'b>) =
        let countA = Array.length itemsA
        let countB = Array.length itemsB

        [<TailCall>]
        let rec loop a b =
            seq {
                if a < countA && b < countB then
                    let itemA = itemsA[a]
                    let itemB = itemsB[b]

                    let test = compare itemA itemB
                    if test < 0 then
                        yield A itemA
                        yield! loop (a + 1) b
                    elif test > 0 then
                        yield B itemB
                        yield! loop a (b + 1)
                    else
                        yield AB (itemA, itemB)
                        yield! loop (a + 1) (b + 1) // no warning for this one

                elif a < countA then
                    yield A itemsA[a]
                    yield! loop (a + 1) b

                elif b < countB then
                    yield B itemsB[b]
                    yield! loop a (b + 1)
            }

        member _.Exec () = loop 0 0

    let compareWith compare itemsA itemsB = CompareWith(compare, itemsA, itemsB).Exec()

When I compile, I get warnings for 4 of the yield! loop calls, but not for the one in the else branch. I get these warnings for both Debug and Release.

[Bananas-Are-Yellow]

If I change each of those yield! loop calls into if false then () else yield! loop, the warnings are not shown with a Debug build, but they still appear with a Release build.