Enforce display of deprecation warnings

Project.toml

@@ -1,6 +1,6 @@
 name = "Distributions"
 uuid = "31c24e10-a181-5473-b8eb-7969acd0382f"
-version = "0.25.123"
+version = "0.25.124"
 authors = ["JuliaStats"]
 
 [deps]

src/Distributions.jl

@@ -122,7 +122,6 @@ export
     Lindley,
     LKJ,
     LKJCholesky,
-    LocationScale,
     Logistic,
     LogLogistic,
     LogNormal,
@@ -154,7 +153,6 @@ export
     Pareto,
     PGeneralizedGaussian,
     SkewedExponentialPower,
-    Product, # deprecated
     Poisson,
     PoissonBinomial,
     QQPair,
@@ -169,7 +167,6 @@ export
     TDist,
     TriangularDist,
     Triweight,
-    Truncated,
     Uniform,
     UnivariateGMM,
     VonMises,

src/deprecates.jl

@@ -1,24 +1,28 @@
 #### Deprecate on 0.6 (to be removed on 0.7)
 
-@Base.deprecate expected_logdet meanlogdet
+export expected_logdet
+@noinline function expected_logdet(d::Wishart)
+    Base.depwarn("`expected_logdet(d::Wishart)` is deprecated, use `meanlogdet(d)` instead.", :expected_logdet; force = true)
+    return meanlogdet(d)
+end
 
-function probs(d::DiscreteUnivariateDistribution)
-    Base.depwarn("probs(d::$(typeof(d))) is deprecated. Please use pdf(d) instead.", :probs)
+@noinline function probs(d::DiscreteUnivariateDistribution)
+    Base.depwarn("`probs(d::DiscreteUnivariateDistribution)` is deprecated, use `pdf(d)` instead.", :probs; force = true)
     return pdf(d)
 end
 
-function Binomial(n::Real, p::Real)
-    Base.depwarn("Binomial(n::Real, p) is deprecated. Please use Binomial(n::Integer, p) instead.", :Binomial)
+@noinline function Binomial(n::Real, p::Real)
+    Base.depwarn("`Binomial(n::Real, p::Real)` is deprecated, use `Binomial(Int(n), p)` instead.", :Binomial; force = true)
     Binomial(Int(n), p)
 end
 
-function Binomial(n::Real)
-    Base.depwarn("Binomial(n::Real) is deprecated. Please use Binomial(n::Integer) instead.", :Binomial)
+@noinline function Binomial(n::Real)
+    Base.depwarn("`Binomial(n::Real)` is deprecated, use `Binomial(Int(n))` instead.", :Binomial; force = true)
     Binomial(Int(n))
 end
 
-function BetaBinomial(n::Real, α::Real, β::Real)
-    Base.depwarn("BetaBinomial(n::Real, α, β) is deprecated. Please use BetaBinomial(n::Integer, α, β) instead.", :BetaBinomial)
+@noinline function BetaBinomial(n::Real, α::Real, β::Real)
+    Base.depwarn("`BetaBinomial(n::Real, α::Real, β::Real)` is deprecated, use `BetaBinomial(Int(n), α, β)` instead.", :BetaBinomial; force = true)
     BetaBinomial(Int(n), α, β)
 end
 
@@ -34,23 +38,54 @@ for fun in [:pdf, :logpdf,
     fun! = Symbol(fun, '!')
 
     @eval begin
-        @deprecate ($_fun!)(r::AbstractArray{<:Real}, d::UnivariateDistribution, X::AbstractArray{<:Real}) r .= Base.Fix1($fun, d).(X) false
-        @deprecate ($fun!)(r::AbstractArray{<:Real}, d::UnivariateDistribution, X::AbstractArray{<:Real}) r .= Base.Fix1($fun, d).(X) false
-        @deprecate ($fun)(d::UnivariateDistribution, X::AbstractArray{<:Real}) map(Base.Fix1($fun, d), X)
+        export $(fun!)
+        @noinline function ($_fun!)(r::AbstractArray{<:Real}, d::UnivariateDistribution, X::AbstractArray{<:Real})
+            Base.depwarn("`$(string(_fun!))(r::AbstractArray{<:Real}, d::UnivariateDistribution, X::AbstractArray{<:Real})` is deprecated, use `r .= $(string(fun)).(d, X)` instead.", $(QuoteNode(_fun!)); force = true)
+            r .= $(fun).(d, X)
+        end
+        @noinline function ($fun!)(r::AbstractArray{<:Real}, d::UnivariateDistribution, X::AbstractArray{<:Real})
+            Base.depwarn("`$(string(fun!))(r::AbstractArray{<:Real}, d::UnivariateDistribution, X::AbstractArray{<:Real})` is deprecated, use `r .= $(string(fun)).(d, X)` instead.", $(QuoteNode(fun!)); force = true)
+            r .= $(fun).(d, X)
+        end
+        @noinline function ($fun)(d::UnivariateDistribution, X::AbstractArray{<:Real})
+            Base.depwarn("`$(string(fun))(d::UnivariateDistribution, X::AbstractArray{<:Real})` is deprecated, use `$(string(fun)).(d, X)` instead.", $(QuoteNode(fun)); force = true)
+            $(fun).(d, X)
+        end
     end
 end
 
-@deprecate pdf(d::DiscreteUnivariateDistribution) map(Base.Fix1(pdf, d), support(d))
+@noinline function pdf(d::DiscreteUnivariateDistribution)
+    Base.depwarn("`pdf(d::DiscreteUnivariateDistribution)` is deprecated, please use `pdf.(d, support(d))` instead.", :pdf; force = true)
+    pdf.(d, support(d))
+end
 
 # Wishart constructors
-@deprecate Wishart(df::Real, S::AbstractPDMat, warn::Bool) Wishart(df, S)
-@deprecate Wishart(df::Real, S::Matrix, warn::Bool) Wishart(df, S)
-@deprecate Wishart(df::Real, S::Cholesky, warn::Bool) Wishart(df, S)
+@noinline function Wishart(df::Real, S::AbstractPDMat, ::Bool)
+    Base.depwarn("`Wishart(df::Real, S::AbstractPDMat, warn::Bool)` is deprecated, use `Wishart(df, S)` instead.", :Wishart; force = true)
+    Wishart(df, S)
+end
+@noinline function Wishart(df::Real, S::Matrix, ::Bool)
+    Base.depwarn("`Wishart(df::Real, S::Matrix, warn::Bool)` is deprecated, use `Wishart(df, S)` instead.", :Wishart; force = true)
+    Wishart(df, S)
+end
+@noinline function Wishart(df::Real, S::Cholesky, ::Bool)
+    Base.depwarn("`Wishart(df::Real, S::Cholesky, warn::Bool)` is deprecated, use `Wishart(df, S)` instead.", :Wishart; force = true)
+    Wishart(df, S)
+end
 
 # Deprecate 3 arguments expectation and once with function in second place
-@deprecate expectation(distr::DiscreteUnivariateDistribution, g::Function, epsilon::Real) expectation(g, distr; epsilon=epsilon) false
-@deprecate expectation(distr::ContinuousUnivariateDistribution, g::Function, epsilon::Real) expectation(g, distr) false
-@deprecate expectation(distr::Union{UnivariateDistribution,MultivariateDistribution}, g::Function; kwargs...) expectation(g, distr; kwargs...) false
+@noinline function expectation(distr::DiscreteUnivariateDistribution, g::Function, epsilon::Real)
+    Base.depwarn("`expectation(d::DiscreteUnivariateDistribution, g::Function, epsilon::Real)` is deprecated, use `expectation(g, d; epsilon)` instead.", :expectation; force = true)
+    expectation(g, distr; epsilon=epsilon)
+end
+@noinline function expectation(distr::ContinuousUnivariateDistribution, g::Function, ::Real)
+    Base.depwarn("`expectation(d::ContinuousUnivariateDistribution, g::Function, epsilon::Real)` is deprecated, use `expectation(g, d)` instead.", :expectation; force = true)
+    expectation(g, distr)
+end
+@noinline function expectation(distr::Union{UnivariateDistribution,MultivariateDistribution}, g::Function; kwargs...)
+    Base.depwarn("`expectation(d::ContinuousUnivariateDistribution, g::Function; kwargs...)` is deprecated, use `expectation(g, d; kwargs...)` instead.", :expectation; force = true)
+    expectation(g, distr; kwargs...)
+end
 
 # Deprecate `MatrixReshaped`
 # This is very similar to `Base.@deprecate_binding MatrixReshaped{...} ReshapedDistribution{...}`
@@ -64,10 +99,94 @@ Base.deprecate(@__MODULE__, :MatrixReshaped)
 # In Julia >= 1.6, instead of a new alias we could have defined a method for (ReshapedDistribution{2,S,D} where {S<:ValueSupport,D<:MultivariateDistribution{S}})
 const _MatrixReshaped{S<:ValueSupport,D<:MultivariateDistribution{S}} = ReshapedDistribution{2,S,D}
 function _MatrixReshaped(d::MultivariateDistribution, n::Integer, p::Integer=n)
-    Base.depwarn("`MatrixReshaped(d, n, p)` is deprecated, use `reshape(d, (n, p))` instead.", :MatrixReshaped)
+    Base.depwarn("`MatrixReshaped(d::MultivariateDistribution, n::Integer, p::Integer=n)` is deprecated, use `reshape(d, (n, p))` instead.", :MatrixReshaped; force = true)
     return reshape(d, (n, p))
 end
 
+export dim
 for D in (:InverseWishart, :LKJ, :MatrixBeta, :MatrixFDist, :Wishart)
-    @eval @deprecate dim(d::$D) size(d, 1)
+    @eval begin
+        @noinline function dim(d::$D)
+            Base.depwarn("`dim(d::$($D))` is deprecated, use `size(d, 1)` instead.", :dim; force = true)
+            size(d, 1)
+        end
+    end
+end
+
+# deprecated 12 September 2016
+export circvar
+@noinline function circvar(d)
+    Base.depwarn("`circvar(d)` is deprecated, use `var(d)` instead.", :circvar; force = true)
+    var(d)
+end
+
+# deprecated constructors with standard deviations
+@noinline function MvNormal(μ::AbstractVector{<:Real}, σ::AbstractVector{<:Real})
+    Base.depwarn("`MvNormal(μ::AbstractVector{<:Real}, σ::AbstractVector{<:Real})` is deprecated, use `MvNormal(μ, LinearAlgebra.Diagonal(map(abs2, σ)))` instead.", :MvNormal; force = true)
+    MvNormal(μ, Diagonal(map(abs2, σ)))
+end
+@noinline function MvNormal(μ::AbstractVector{<:Real}, σ::Real)
+    Base.depwarn("`MvNormal(μ::AbstractVector{<:Real}, σ::Real)` is deprecated, use `MvNormal(μ, σ^2 * LinearAlgebra.I)` instead.", :MvNormal; force = true)
+    MvNormal(μ, σ^2 * I)
 end
+@noinline function MvNormal(σ::AbstractVector{<:Real})
+    Base.depwarn("`MvNormal(σ::AbstractVector{<:Real})` is deprecated, use `MvNormal(LinearAlgebra.Diagonal(map(abs2, σ)))` instead.", :MvNormal; force = true)
+    MvNormal(Diagonal(map(abs2, σ)))
+end
+@noinline function MvNormal(d::Int, σ::Real)
+    Base.depwarn("`MvNormal(d::Int, σ::Real)` is deprecated, use `MvNormal(LinearAlgebra.Diagonal(FillArrays.Fill(σ^2, d)))` instead.", :MvNormal; force = true)
+    MvNormal(Diagonal(Fill(σ^2, d)))
+end
+
+# Deprecated constructors
+@noinline function MvNormalCanon(h::AbstractVector{<:Real}, prec::AbstractVector{<:Real})
+    Base.depwarn("`MvNormalCanon(h::AbstractVector{<:Real}, prec::AbstractVector{<:Real})` is deprecated, use `MvNormalCanon(h, LinearAlgebra.Diagonal(prec))` instead.", :MvNormalCanon; force = true)
+    MvNormalCanon(h, Diagonal(prec))
+end
+@noinline function MvNormalCanon(h::AbstractVector{<:Real}, prec::Real)
+    Base.depwarn("`MvNormalCanon(h::AbstractVector{<:Real}, prec::Real)` is deprecated, use `MvNormalCanon(h, prec * LinearAlgebra.I)` instead.", :MvNormalCanon; force = true)
+    MvNormalCanon(h, prec * I)
+end
+@noinline function MvNormalCanon(prec::AbstractVector)
+    Base.depwarn("`MvNormalCanon(prec::AbstractVector)` is deprecated, use `MvNormalCanon(LinearAlgebra.Diagonal(prec))` instead.", :MvNormalCanon; force = true)
+    MvNormalCanon(Diagonal(prec))
+end
+@noinline function MvNormalCanon(d::Int, prec::Real)
+    Base.depwarn("`MvNormalCanon(d::Int, prec::Real)` is deprecated, use `MvNormalCanon(LinearAlgebra.Diagonal(FillArrays.Fill(prec, d)))` instead.", :MvNormalCanon; force = true)
+    MvNormalCanon(Diagonal(Fill(prec, d)))
+end
+
+### Constructors of `Truncated` are deprecated - users should call `truncated`
+export Truncated
+@noinline function Truncated(d::UnivariateDistribution, l::Real, u::Real)
+    Base.depwarn("`Truncated(d::UnivariateDistribution, l::Real, u::Real)` is deprecated, use `truncated(d, l, u)` instead.", :Truncated; force = true)
+    truncated(d, l, u)
+end
+@noinline function Truncated(d::UnivariateDistribution, l::T, u::T, lcdf::T, ucdf::T, tp::T, logtp::T) where {T <: Real} 
+    Base.depwarn("`Truncated(d::UnivariateDistribution, l::T, u::T, lcdf::T, ucdf::T, tp::T, logtp::T) where {T <: Real}` is deprecated, use `Truncated(d, l, u, log(lcdf), lcdf, ucdf, tp, logtp)` instead.", :Truncated; force = true)
+    Truncated(d, l, u, log(lcdf), lcdf, ucdf, tp, logtp)
+end
+
+export Product
+function Product(v::V) where {S<:ValueSupport,T<:UnivariateDistribution{S},V<:AbstractVector{T}}
+    Base.depwarn(
+        "`Product(v::AbstractVector{<:UnivariateDistribution})` is deprecated, use `product_distribution(v)`",
+        :Product;
+        force = true,
+    )
+    return Product{S, T, V}(v)
+end
+
+export LocationScale
+const LocationScale{T,S,D} = AffineDistribution{T,S,D}
+function LocationScale(μ::Real, σ::Real, ρ::UnivariateDistribution; check_args::Bool=true)
+    Base.depwarn(
+        "`LocationScale(μ::Real, σ::Real, ρ::UnivariateDistribution; check_args::Bool=true)` is deprecated, use `μ + σ * d` instead.",
+        :LocationScale;
+        force = true,
+    )
+    # preparation for future PR where I remove σ > 0 check
+    @check_args LocationScale (σ, σ > zero(σ))
+    return AffineDistribution(μ, σ, ρ; check_args=false)
+end
+

src/multivariate/mvnormal.jl

@@ -213,12 +213,6 @@ Construct a multivariate normal distribution with zero mean and covariance matri
 """
 MvNormal(Σ::AbstractMatrix{<:Real}) = MvNormal(Zeros{eltype(Σ)}(size(Σ, 1)), Σ)
 
-# deprecated constructors with standard deviations
-Base.@deprecate MvNormal(μ::AbstractVector{<:Real}, σ::AbstractVector{<:Real}) MvNormal(μ, LinearAlgebra.Diagonal(map(abs2, σ)))
-Base.@deprecate MvNormal(μ::AbstractVector{<:Real}, σ::Real) MvNormal(μ, σ^2 * I)
-Base.@deprecate MvNormal(σ::AbstractVector{<:Real}) MvNormal(LinearAlgebra.Diagonal(map(abs2, σ)))
-Base.@deprecate MvNormal(d::Int, σ::Real) MvNormal(LinearAlgebra.Diagonal(FillArrays.Fill(σ^2, d)))
-
 Base.eltype(::Type{<:MvNormal{T}}) where {T} = T
 
 ### Conversion

src/multivariate/mvnormalcanon.jl

@@ -110,12 +110,6 @@ precision matrix `J`.
 """
 MvNormalCanon(J::AbstractMatrix{<:Real}) = MvNormalCanon(Zeros{eltype(J)}(size(J, 1)), J)
 
-# Deprecated constructors
-Base.@deprecate MvNormalCanon(h::AbstractVector{<:Real}, prec::AbstractVector{<:Real}) MvNormalCanon(h, LinearAlgebra.Diagonal(prec))
-Base.@deprecate MvNormalCanon(h::AbstractVector{<:Real}, prec::Real) MvNormalCanon(h, prec * I)
-Base.@deprecate MvNormalCanon(prec::AbstractVector) MvNormalCanon(LinearAlgebra.Diagonal(prec))
-Base.@deprecate MvNormalCanon(d::Int, prec::Real) MvNormalCanon(LinearAlgebra.Diagonal(FillArrays.Fill(prec, d)))
-
 ### Show
 
 distrname(d::IsoNormalCanon) = "IsoNormalCanon"

src/multivariate/product.jl

@@ -26,14 +26,6 @@ struct Product{
     end
 end
 
-function Product(v::V) where {S<:ValueSupport,T<:UnivariateDistribution{S},V<:AbstractVector{T}}
-    Base.depwarn(
-        "`Product(v)` is deprecated, please use `product_distribution(v)`",
-        :Product,
-    )
-    return Product{S, T, V}(v)
-end
-
 length(d::Product) = length(d.v)
 function Base.eltype(::Type{<:Product{S,T}}) where {S<:ValueSupport,
                                                     T<:UnivariateDistribution{S}}

src/truncate.jl

@@ -105,10 +105,6 @@ end
 const LeftTruncated{D<:UnivariateDistribution,S<:ValueSupport,T<:Real} = Truncated{D,S,T,T,Nothing}
 const RightTruncated{D<:UnivariateDistribution,S<:ValueSupport,T<:Real} = Truncated{D,S,T,Nothing,T}
 
-### Constructors of `Truncated` are deprecated - users should call `truncated`
-@deprecate Truncated(d::UnivariateDistribution, l::Real, u::Real) truncated(d, l, u)
-@deprecate Truncated(d::UnivariateDistribution, l::T, u::T, lcdf::T, ucdf::T, tp::T, logtp::T) where {T <: Real} Truncated(d, l, u, log(lcdf), lcdf, ucdf, tp, logtp)
-
 function truncated(d::Truncated, l::T, u::T) where {T<:Real}
     return truncated(
         d.untruncated,

src/univariate/continuous/vonmises.jl

@@ -56,8 +56,6 @@ mean(d::VonMises) = d.μ
 median(d::VonMises) = d.μ
 mode(d::VonMises) = d.μ
 var(d::VonMises) = 1 - besselix(1, d.κ) / d.I0κx
-# deprecated 12 September 2016
-@deprecate circvar(d) var(d)
 entropy(d::VonMises) = log(twoπ * d.I0κx) + d.κ * (1 - besselix(1, d.κ) / d.I0κx)
 
 cf(d::VonMises, t::Real) = (besselix(abs(t), d.κ) / d.I0κx) * cis(t * d.μ)

src/univariate/locationscale.jl

@@ -61,14 +61,6 @@ function AffineDistribution(μ::Real, σ::Real, ρ::UnivariateDistribution; chec
 end
 
 # aliases
-const LocationScale{T,S,D} = AffineDistribution{T,S,D}
-function LocationScale(μ::Real, σ::Real, ρ::UnivariateDistribution; check_args::Bool=true)
-    Base.depwarn("`LocationScale` is deprecated. Use `+` and `*` instead", :LocationScale)
-    # preparation for future PR where I remove σ > 0 check
-    @check_args LocationScale (σ, σ > zero(σ))
-    return AffineDistribution(μ, σ, ρ; check_args=false)
-end
-
 const ContinuousAffineDistribution{T<:Real,D<:ContinuousUnivariateDistribution} = AffineDistribution{T,Continuous,D}
 const DiscreteAffineDistribution{T<:Real,D<:DiscreteUnivariateDistribution} = AffineDistribution{T,Discrete,D}