Merge pull request #489 from ReactiveBayes/fix-invalidations

Fix invalidations from SnoopCompile

Author: bvdmitri

src/helpers/algebra/companion_matrix.jl

@@ -20,9 +20,8 @@ struct CompanionMatrix{R <: Real, T <: AbstractVector{R}} <: AbstractMatrix{R}
     θ::T
 end
 
-Base.eltype(::CompanionMatrix{R}) where {R} = R
-Base.size(cmatrix::CompanionMatrix)         = (length(cmatrix.θ), length(cmatrix.θ))
-Base.length(cmatrix::CompanionMatrix)       = prod(size(cmatrix))
+Base.size(cmatrix::CompanionMatrix) = (length(cmatrix.θ), length(cmatrix.θ))
+Base.length(cmatrix::CompanionMatrix) = prod(size(cmatrix))
 
 Base.getindex(cmatrix::CompanionMatrix, i::Int) = getindex(cmatrix, map(r -> r + 1, reverse(divrem(i - 1, first(size(cmatrix)))))...)
 
@@ -40,9 +39,8 @@ struct CompanionMatrixTransposed{R <: Real, T <: AbstractVector{R}} <: AbstractM
     θ::T
 end
 
-Base.eltype(::CompanionMatrixTransposed{R}) where {R} = R
-Base.size(cmatrix::CompanionMatrixTransposed)         = (length(cmatrix.θ), length(cmatrix.θ))
-Base.length(cmatrix::CompanionMatrixTransposed)       = prod(size(cmatrix))
+Base.size(cmatrix::CompanionMatrixTransposed) = (length(cmatrix.θ), length(cmatrix.θ))
+Base.length(cmatrix::CompanionMatrixTransposed) = prod(size(cmatrix))
 
 Base.getindex(cmatrix::CompanionMatrixTransposed, i::Int) = getindex(cmatrix, map(r -> r + 1, reverse(divrem(i - 1, first(size(cmatrix)))))...)
 

src/helpers/algebra/permutation_matrix.jl

@@ -39,8 +39,6 @@ function PermutationMatrix(dim::T; switch_first::Bool = true) where {T <: Intege
     return PermutationMatrix(ind)
 end
 
-# extensions of base functionality
-Base.eltype(::PermutationMatrix{T}) where {T} = T
 function Base.size(mat::PermutationMatrix)
     nr_elements = length(mat.ind)
     return (nr_elements, nr_elements)

src/helpers/algebra/standard_basis_vector.jl

@@ -28,9 +28,6 @@ function StandardBasisVector(length::Int, index::Int, scale::T = one(Int)) where
     return StandardBasisVector{T}(length, index, scale)
 end
 
-Base.eltype(::StandardBasisVector{T}) where {T}       = T
-Base.eltype(::Type{StandardBasisVector{T}}) where {T} = T
-
 # extensions of base functionality
 Base.size(e::StandardBasisVector)    = (length(e),)
 Base.size(e::StandardBasisVector, d) = d::Integer == 1 ? length(e) : 1

src/helpers/helpers.jl

@@ -64,9 +64,8 @@ Base.IteratorSize(::Type{<:SkipIndexIterator})   = HasLength()
 Base.IteratorEltype(::Type{<:SkipIndexIterator}) = HasEltype()
 Base.IndexStyle(::Type{<:SkipIndexIterator})     = IndexLinear()
 
-Base.eltype(::Type{<:SkipIndexIterator{T}}) where {T} = T
-Base.length(iter::SkipIndexIterator)                  = length(iter.iterator) - 1
-Base.size(iter::SkipIndexIterator)                    = (length(iter),)
+Base.length(iter::SkipIndexIterator) = length(iter.iterator) - 1
+Base.size(iter::SkipIndexIterator)   = (length(iter),)
 
 Base.@propagate_inbounds Base.getindex(iter::SkipIndexIterator, i::Int)               = i < skip(iter) ? iter.iterator[i] : iter.iterator[i + 1]
 Base.@propagate_inbounds Base.getindex(iter::SkipIndexIterator, i::CartesianIndex{1}) = Base.getindex(iter, first(i.I))

src/marginal.jl

@@ -133,10 +133,13 @@ MacroHelpers.@proxy_methods Marginal getdata [
     Base.precision,
     Base.length,
     Base.ndims,
-    Base.size,
-    Base.eltype
+    Base.size
 ]
 
+# Eltype is special here, because it should be only defined on types
+# Otherwise it causes invalidations and slower compile times
+Base.eltype(::Type{<:Marginal{D}}) where {D} = Base.eltype(D)
+
 Distributions.mean(fn::Function, marginal::Marginal) = mean(fn, getdata(marginal))
 
 """

src/message.jl

@@ -187,10 +187,13 @@ MacroHelpers.@proxy_methods Message getdata [
     Base.precision,
     Base.length,
     Base.ndims,
-    Base.size,
-    Base.eltype
+    Base.size
 ]
 
+# Eltype is special here, because it should be only defined on types
+# Otherwise it causes invalidations and slower compile times
+Base.eltype(::Type{<:Message{D}}) where {D} = Base.eltype(D)
+
 Distributions.mean(fn::Function, message::Message) = mean(fn, getdata(message))
 
 ## Deferred Message

src/nodes/predefined/autoregressive.jl

@@ -127,9 +127,6 @@ end
 Base.size(precision::ARPrecisionMatrix) = (precision.order, precision.order)
 Base.getindex(precision::ARPrecisionMatrix, i::Int, j::Int) = (i === 1 && j === 1) ? precision.γ : ((i === j) ? convert(eltype(precision), huge) : zero(eltype(precision)))
 
-Base.eltype(::Type{<:ARPrecisionMatrix{T}}) where {T} = T
-Base.eltype(::ARPrecisionMatrix{T}) where {T}         = T
-
 Base.convert(::Type{AbstractArray{T}}, matrix::ARPrecisionMatrix{R}) where {T, R} = ARPrecisionMatrix(matrix.order, convert(T, matrix.γ))
 Base.convert(::Type{AbstractArray{T}}, matrix::ARPrecisionMatrix{T}) where {T} = matrix
 
@@ -164,9 +161,6 @@ end
 Base.size(transition::ARTransitionMatrix) = (transition.order, transition.order)
 Base.getindex(transition::ARTransitionMatrix, i::Int, j::Int) = (i === 1 && j === 1) ? transition.inv_γ : zero(eltype(transition))
 
-Base.eltype(::Type{<:ARTransitionMatrix{T}}) where {T} = T
-Base.eltype(::ARTransitionMatrix{T}) where {T}         = T
-
 Base.convert(::Type{AbstractArray{T}}, matrix::ARTransitionMatrix{R}) where {T, R} = ARTransitionMatrix{T}(matrix.order, convert(T, matrix.inv_γ))
 Base.convert(::Type{AbstractArray{T}}, matrix::ARTransitionMatrix{T}) where {T} = matrix
 

src/nodes/predefined/gcv.jl

@@ -14,7 +14,6 @@ ExponentialLinearQuadratic(approximation, a::Real, b::Real, c::Real, d::Real)
 ExponentialLinearQuadratic(approximation, a::Integer, b::Integer, c::Integer, d::Integer) = ExponentialLinearQuadratic(approximation, float(a), float(b), float(c), float(d))
 
 Base.eltype(::Type{<:ExponentialLinearQuadratic{A, T}}) where {A, T} = T
-Base.eltype(::ExponentialLinearQuadratic{A, T}) where {A, T}         = T
 
 Base.precision(dist::ExponentialLinearQuadratic) = mean_invcov(dist)[2]
 

src/pipeline/logger.jl

@@ -17,12 +17,14 @@ LoggerPipelineStage()               = LoggerPipelineStage(Core.stdout, "Log")
 LoggerPipelineStage(output::IO)     = LoggerPipelineStage(output, "Log")
 LoggerPipelineStage(prefix::String) = LoggerPipelineStage(Core.stdout, prefix)
 
-Base.println(stage::LoggerPipelineStage, something) = Base.println(stage, stage.output, append_prefix(stage, something))
+logger_pipeline_stage_println(logger::LoggerPipelineStage, something::Any) = logger_pipeline_stage_println(
+    logger, logger.output, logger_pipeline_stage_append_prefix(logger, something)
+)
 
-Base.println(stage::LoggerPipelineStage, output::Core.CoreSTDOUT, something) = Core.println(output, something)
-Base.println(stage::LoggerPipelineStage, output, something) = println(output, something)
+logger_pipeline_stage_println(logger::LoggerPipelineStage, output::Core.CoreSTDOUT, something) = Core.println(output, something)
+logger_pipeline_stage_println(logger::LoggerPipelineStage, output, something) = println(output, something)
 
-append_prefix(stage::LoggerPipelineStage, something) = string("[", stage.prefix, "]", something)
+logger_pipeline_stage_append_prefix(logger::LoggerPipelineStage, something) = lazy"[$(logger.prefix)]$something"
 
-apply_pipeline_stage(stage::LoggerPipelineStage, factornode, tag::Val{T}, stream) where {T}             = stream |> tap((v) -> println(stage, "[$(functionalform(factornode))][$(T)]: $v"))
-apply_pipeline_stage(stage::LoggerPipelineStage, factornode, tag::Tuple{Val{T}, Int}, stream) where {T} = stream |> tap((v) -> println(stage, "[$(functionalform(factornode))][$(T):$(tag[2])]: $v"))
+apply_pipeline_stage(logger::LoggerPipelineStage, factornode, tag::Val{T}, stream) where {T}             = stream |> tap((v) -> logger_pipeline_stage_println(logger, lazy"[$(functionalform(factornode))][$(T)]: $v"))
+apply_pipeline_stage(logger::LoggerPipelineStage, factornode, tag::Tuple{Val{T}, Int}, stream) where {T} = stream |> tap((v) -> logger_pipeline_stage_println(logger, lazy"[$(functionalform(factornode))][$(T):$(tag[2])]: $v"))

src/rule.jl

@@ -853,7 +853,7 @@ Base.copy(entry::TestRuleEntryInputSpecification) = TestRuleEntryInputSpecificat
 Base.values(entry::TestRuleEntryInputSpecification) = Base.Generator((arg) -> arg.second, entry.arguments)
 
 # Convert the `TestRuleEntryInputSpecification` back into the `Expr` form, e.g `(m_x = ..., q_y = ..., meta = ...)`
-function Base.convert(::Type{Expr}, test_entry::TestRuleEntryInputSpecification)
+function rule_macro_convert_to_expr(test_entry::TestRuleEntryInputSpecification)
     tuple = Expr(:tuple)
     tuple.args = map((arg) -> Expr(:(=), arg.first, arg.second), test_entry.arguments)
     if !isnothing(test_entry.meta)
@@ -889,8 +889,8 @@ struct TestRuleEntry
 end
 
 # Convert the `TestRuleEntry` back into the `Expr` form, e.g `(input = ..., output = ...)`
-function Base.convert(::Type{Expr}, test_entry::TestRuleEntry)
-    return Expr(:tuple, Expr(:(=), :input, convert(Expr, test_entry.input)), Expr(:(=), :output, test_entry.output))
+function rule_macro_convert_to_expr(test_entry::TestRuleEntry)
+    return Expr(:tuple, Expr(:(=), :input, rule_macro_convert_to_expr(test_entry.input)), Expr(:(=), :output, test_entry.output))
 end
 
 # This function takes a `test` parameter which is expected to be an expression of single test entry.
@@ -937,8 +937,8 @@ end
 
 function test_rules_generate_testset(test_entry::TestRuleEntry, invoke_test_fn, call_macro_fn, rule_specification, configuration)
     # `nothing` here is a `LineNumberNode`, macrocall expects a `line` number, but we do not have it here
-    actual_inputs = convert(Expr, test_entry.input)
-    actual_output = Expr(:macrocall, call_macro_fn, nothing, rule_specification, convert(Expr, actual_inputs))
+    actual_inputs = rule_macro_convert_to_expr(test_entry.input)
+    actual_output = Expr(:macrocall, call_macro_fn, nothing, rule_specification, actual_inputs)
     expected_output = test_entry.output
     rule_spec_str = "$rule_specification"
     rule_inputs_str = "$actual_inputs"