Deprecation warning: Wrapping Vararg directly in UnionAll is deprecated

[abpolym]

When running tests or precompiling packages that depend on ReactiveMP, I receive multiple deprecation warnings related to Vararg usage. This seems to be caused by function signatures that wrap Vararg directly in UnionAll, which is deprecated in Julia 1.11+.

Warning output:

WARNING: Wrapping `Vararg` directly in UnionAll is deprecated (wrap the tuple instead).
You may need to write `f(x::Vararg{T})` rather than `f(x::Vararg{<:T})` or 
`f(x::Vararg{T}) where T` instead of `f(x::Vararg{T} where T)`.

This warning appears several times during precompilation:

┌ ReactiveMP
│  WARNING: Wrapping `Vararg` directly in UnionAll is deprecated (wrap the tuple instead).
[repeated at least 20 times]
┌ ReactiveMP → ReactiveMPProjectionExt
│  WARNING: Wrapping `Vararg` directly in UnionAll is deprecated (wrap the tuple instead).

which also can be seen in any recent CI julia-runtest test output.

Fixing this should be easy so it is a good first issue.

[bvdmitri]

Yeah this is an old one, the problem is that I personally don't know where is it coming from exactly. But someone might figure it out by using the julia --depwarn=error option to force the error instead of a warning and analyzing the stack trace to figure out what is causing it

[abpolym]

The warning is also triggered during precompilation caused by precompilation of dependencies:

The possible culprits extensions are the culprits:

[extensions]
ReactiveMPOptimisersExt = "Optimisers"
ReactiveMPProjectionExt = "ExponentialFamilyProjection"
ReactiveMPRequiresExt = "Requires"

I have to trigger the precompilation again to determine which of the two are the

Besides ReactiveMP, the cause for the warning is also ReactiveMPProjectionExt = "ExponentialFamilyProjection".

We just have to switch out any instances

Vararg{T} where T   # ❌ deprecated
Vararg{<:T}         # ❌ deprecated

with

Tuple{Vararg{T}}    # ✅ correct form

[abpolym]

I remove the good first issue tag because it is not such an easy fix as it breaks a little bit of stuff. I can finish my local fix and request a PR tomorrow at the earliest.

[abpolym]

Most of the warning came from src/helpers/macrohelpers.jl:

function proxy_type(proxy, type::Expr)
    if @capture(type, Vararg{rest__})
        error("Vararg{T, N} is forbidden in @rule macro, use `ManyOf{N, T}` instead.")
    elseif @capture(type, ManyOf{N_, T_})
        return :(ReactiveMP.ManyOf{<:Tuple{Vararg{X, $N} where X <: $(proxy_type(proxy, T))}}) # causes vararg deprecation warnings
    else
        return :($(proxy){<:$(type)})
    end
end

which I now changed to

function proxy_type(proxy, type::Expr)
    if @capture(type, Vararg{rest__})
        error("Vararg{T, N} is forbidden in @rule macro, use `ManyOf{N, T}` instead.")
    elseif @capture(type, ManyOf{N_, T_})
        return :(ReactiveMP.ManyOf{<:NTuple{$N, $(proxy_type(proxy, T))}}) # this does now work in all cases? :)
    else
        return :($(proxy){<:$(type)})
    end
end

I tried out other solutions which did not work:

        return :(ReactiveMP.ManyOf{<:Tuple{Vararg{X, $N}}} where {X <: $(proxy_type(proxy, T))}) # causes interfaceindices errors

        return :(ReactiveMP.ManyOf{<:Tuple{Vararg{<:$(proxy_type(proxy, T)), $N}}}) # causes vararg deprecation warnings

One more warning came from src/nodes/interfaces.jl:

rule_method_error_type_nameof(::Type{T}) where {N, R, V <: NTuple{N, <:R}, T <: ManyOf{V}}           = string("ManyOf{", N, ", ", rule_method_error_type_nameof(dropproxytype(R)), "}")
rule_method_error_type_nameof(::Type{T}) where {N, V <: Tuple{Vararg{R, N} where R}, T <: ManyOf{V}} = string("ManyOf{", N, ", Union{", join(map(r -> rule_method_error_type_nameof(dropproxytype(r)), fieldtypes(V)), ","), "}}")

My solution might impact compilation/runtime speed as instead of two inline functions there is now one multi-line function with some if statements:

rule_method_error_type_nameof(::Type{T}) where {V, T <: ManyOf{V}} = begin
    # V is the tuple type carried in ManyOf{V}
    fts = fieldtypes(V)               # get the element type tuple, works for NTuple and Tuple
    N = length(fts)                   # number of elements

    if N == 0
        return "ManyOf{0, }"
    end

    # If all element types are the same, produce the compact NTuple-style message:
    if all(ft -> ft === fts[1], fts)
        elt = dropproxytype(fts[1])
        return string("ManyOf{", N, ", ", rule_method_error_type_nameof(elt), "}")
    end

    # Otherwise produce the Union of element type names:
    unions = join(map(r -> rule_method_error_type_nameof(dropproxytype(r)), fts), ",")
    return string("ManyOf{", N, ", Union{", unions, "}}")
end

@bvdmitri Maybe you can have a quick look at it in my PR?