Fix world-age issue with three-argument convfact (JuliaPhysics#791)

* Make convfact(T, s, t) not generated

* Only convert convfact to built-in float types

* Add test

* Rename floattype → convfact_floattype

Author: sostock

src/conversion.jl

@@ -50,10 +50,10 @@ convfact(s::Units{S}, t::Units{S}) where {S} = 1
     convfact(T::Type, s::Units, t::Units)
 Returns the appropriate conversion factor from unit `t` to unit `s` for the number type `T`.
 """
-@generated function convfact(::Type{T}, s::Units, t::Units) where T
-    cf = convfact(s(), t())
+function convfact(::Type{T}, s::Units, t::Units) where T
+    cf = convfact(s, t)
     if cf isa AbstractFloat
-        F = floattype(T)
+        F = convfact_floattype(T)
         # Since conversion factors only have Float64 precision,
         # there is no point in converting to BigFloat
         convert(F == BigFloat ? Float64 : F, cf)
@@ -62,17 +62,20 @@ Returns the appropriate conversion factor from unit `t` to unit `s` for the numb
     end
 end
 
-function floattype(::Type{T}) where T
+function convfact_floattype(::Type{T}) where T
     # Use try-catch instead of hasmethod because a
     # fallback method might exist but throw an error
     try
-        F = float(real(T))
-        F <: AbstractFloat ? F : Float64
+        _convfact_floattype(float(real(T)))
     catch
         Float64
     end
 end
 
+_convfact_floattype(::Type) = Float64
+_convfact_floattype(::Type{Float16}) = Float16
+_convfact_floattype(::Type{Float32}) = Float32
+
 """
     uconvert(a::Units, x::Quantity{T,D,U}) where {T,D,U}
 Convert a [`Unitful.Quantity`](@ref) to different units. The conversion will

test/runtests.jl

@@ -128,6 +128,14 @@ Base.:*(x::ErrReal, y::Float64) = x.num * y
 Base.real(x::ErrReal) = error("real not defined")
 Base.float(x::ErrReal) = error("float not defined")
 
+# A number type for which `real` and `float` do not return a built-in type
+struct MyFloat64 <: AbstractFloat
+    num::Float64
+end
+Base.:*(x::MyFloat64, y::Float64) = x.num * y
+# Base.real(x::MyFloat) = x
+# Base.float(x::MyFloat) = x
+
 @testset "Conversion" begin
     @testset "> Unitless ↔ unitful conversion" begin
         @test_throws DimensionError convert(typeof(3m), 1)
@@ -286,6 +294,7 @@ Base.float(x::ErrReal) = error("float not defined")
             @test Unitful.numtype(uconvert(°, (Float16(2)π + im) * rad)) === ComplexF16
             @test uconvert(rad, NonReal(360)°) == uconvert(rad, 360°)
             @test uconvert(rad, ErrReal(360)°) == uconvert(rad, 360°)
+            @test uconvert(rad, MyFloat64(360)°) == uconvert(rad, 360°)
             # Floating point overflow/underflow in uconvert can happen if the
             # conversion factor is large, because uconvert does not cancel
             # common basefactors (or just for really large exponents and/or