Remove eltype, matchingvalue, get_matching_type

Author: penelopeysm

src/abstract_varinfo.jl

@@ -611,29 +611,6 @@ julia> values_as(vi, Vector)
 """
 function values_as end
 
-"""
-    eltype(vi::AbstractVarInfo)
-
-Return the `eltype` of the values returned by `vi[:]`.
-
-!!! warning
-    This should generally not be called explicitly, as it's only used in
-    [`matchingvalue`](@ref) to determine the default type to use in place of
-    type-parameters passed to the model.
-
-    This method is considered legacy, and is likely to be deprecated in the future.
-"""
-function Base.eltype(vi::AbstractVarInfo)
-    T = Base.promote_op(getindex, typeof(vi), Colon)
-    if T === Union{}
-        # In this case `getindex(vi, :)` errors
-        # Let us throw a more descriptive error message
-        # Ref https://github.com/TuringLang/Turing.jl/issues/2151
-        return eltype(vi[:])
-    end
-    return eltype(T)
-end
-
 """
     has_varnamedvector(varinfo::VarInfo)
 

src/compiler.jl

@@ -707,53 +707,3 @@ function warn_empty(body)
     end
     return nothing
 end
-
-# TODO(mhauru) matchingvalue has methods that can accept both types and values. Why?
-# TODO(mhauru) This function needs a more comprehensive docstring.
-"""
-    matchingvalue(vi, value)
-
-Convert the `value` to the correct type for the `vi` object.
-"""
-function matchingvalue(vi, value)
-    T = typeof(value)
-    if hasmissing(T)
-        _value = convert(get_matching_type(vi, T), value)
-        # TODO(mhauru) Why do we make a deepcopy, even though in the !hasmissing branch we
-        # are happy to return `value` as-is?
-        if _value === value
-            return deepcopy(_value)
-        else
-            return _value
-        end
-    else
-        return value
-    end
-end
-
-function matchingvalue(vi, value::FloatOrArrayType)
-    return get_matching_type(vi, value)
-end
-function matchingvalue(vi, ::TypeWrap{T}) where {T}
-    return TypeWrap{get_matching_type(vi, T)}()
-end
-
-# TODO(mhauru) This function needs a more comprehensive docstring. What is it for?
-"""
-    get_matching_type(vi, ::TypeWrap{T}) where {T}
-
-Get the specialized version of type `T` for `vi`.
-"""
-get_matching_type(_, ::Type{T}) where {T} = T
-function get_matching_type(vi, ::Type{<:Union{Missing,AbstractFloat}})
-    return Union{Missing,float_type_with_fallback(eltype(vi))}
-end
-function get_matching_type(vi, ::Type{<:AbstractFloat})
-    return float_type_with_fallback(eltype(vi))
-end
-function get_matching_type(vi, ::Type{<:Array{T,N}}) where {T,N}
-    return Array{get_matching_type(vi, T),N}
-end
-function get_matching_type(vi, ::Type{<:Array{T}}) where {T}
-    return Array{get_matching_type(vi, T)}
-end

src/model.jl

@@ -933,9 +933,9 @@ Return the arguments and keyword arguments to be passed to the evaluator of the
 ) where {_F,argnames}
     unwrap_args = [
         if is_splat_symbol(var)
-            :($matchingvalue(varinfo, model.args.$var)...)
+            :(deepcopy(model.args.$var)...)
         else
-            :($matchingvalue(varinfo, model.args.$var))
+            :(deepcopy(model.args.$var))
         end for var in argnames
     ]
     return quote

src/simple_varinfo.jl

@@ -412,9 +412,6 @@ const SimpleOrThreadSafeSimple{T,V,C} = Union{
     SimpleVarInfo{T,V,C},ThreadSafeVarInfo{<:SimpleVarInfo{T,V,C}}
 }
 
-# Necessary for `matchingvalue` to work properly.
-Base.eltype(::SimpleOrThreadSafeSimple{<:Any,V}) where {V} = V
-
 # `subset`
 function subset(varinfo::SimpleVarInfo, vns::AbstractVector{<:VarName})
     return SimpleVarInfo(

test/compiler.jl

@@ -1,3 +1,8 @@
+module DynamicPPLCompilerTests
+
+using DynamicPPL, Distributions, Random, Test
+using LinearAlgebra: I
+
 macro custom(expr)
     (Meta.isexpr(expr, :call, 3) && expr.args[1] === :~) || error("incorrect macro usage")
     quote
@@ -794,3 +799,5 @@ module Issue537 end
         @test res == (a=1, b=1, c=2, d=2, t=DynamicPPL.TypeWrap{Int}())
     end
 end
+
+end # module DynamicPPLCompilerTests