[<TailCall>] attribute gives incorrect warning in many examples

[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.

[Bananas-Are-Yellow]

The following version does not produce warnings in either Debug or Release:

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 {
                match a < countA, b < countB with
                | true, true ->
                    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)

                | true, false ->
                    yield A itemsA[a]
                    yield! loop (a + 1) b

                | false, true ->
                    yield B itemsB[b]
                    yield! loop a (b + 1)

                | false, false -> ()
            }

        member _.Exec () = loop 0 0

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

So this is a workaround for this case for me. But I have other cases that give false warnings, which are a bit harder to reduce to something concise I can show here.

[T-Gro]

@dawedawe : Do you have an idea of what my going wrong here ?

[Bananas-Are-Yellow]

Here is another case. This is cut down from the actual code, so in this form it does nothing useful and is only a test case for the compiler.

module TailCall =
    type State =
        | Text
        | Backslash
        | Ampersand

    type Expand (chars: seq<char>) =
        let en = chars.GetEnumerator ()

        [<TailCall>]
        let rec loop _state =
            let gobble ch =
                seq {
                    match ch with
                    | '\\' -> yield! loop Backslash
                    | '&' -> yield! loop Ampersand
                    | _ ->
                        yield ch
                        yield! loop Text
                }

            seq {
                if en.MoveNext () then
                    yield! gobble en.Current
            }

In either a Debug or Release build, all 3 yield! loop calls in the gobble function produce the warning:

warning FS3569: The member or function 'loop' has the 'TailCallAttribute' attribute, but is not being used in a tail recursive way.

[Bananas-Are-Yellow]

This one is a bit more involved. As before, this is reduced from the actual code, but serves as a test case for the compiler.

type SimpleLazy<'t> (getValue: unit -> 't) =
    let mutable getValue = ValueSome getValue
    let mutable value = Unchecked.defaultof<'t>

    [<DebuggerBrowsable(DebuggerBrowsableState.Never)>]
    member _.Value =
        match getValue with
        | ValueNone -> value
        | ValueSome f ->
            value <- f ()
            getValue <- ValueNone
            value

    member _.IsValueCreated = getValue.IsNone

module TailCall =
    [<NoEquality; NoComparison>]
    type LazyList<'t> =
        | LazyCons of 't * SimpleLazy<LazyList<'t>>
        | LazyEmpty

    type Example<'t> (source: seq<'t>) =
        let en = source.GetEnumerator ()

        [<TailCall>]
        let rec loop () =
            if en.MoveNext () then
                LazyCons (en.Current, SimpleLazy loop) // warning FS3569 here
            else
                en.Dispose ()
                LazyEmpty

In this case, I get the warning at the line commented above, but only in a Release build.

[Bananas-Are-Yellow]

I assume [<TailCall>] works according to the RFC-1011 spec, which says:

All uses of an attributed function within its recursive scope would need to be in tail position. Thus passing the function as a higher-order argument would not be allowed. This can potentially limit the utility of such a function.

Is SimpleLazy loop an example of passing the function as a higher-order argument, even though SimpleLazy just stores the function for later use?

[majocha]

Is SimpleLazy loop an example of passing the function as a higher-order argument, even though SimpleLazy just stores the function for later use?

Well it is passed to the constructor. The function is not really recursive at all, as it is not calling itself.