insufficient constant propagation for unit exponentiation with floating-point exponent

[DylanMMarques]

Hello, I found a use case where uconvertrp becomes type instable:

using Unitful, Unitful.DefaultSymbols
function tmp(a, b)
           uconvertp(NoUnits, a * (b ^ (3/2)))
end

julia> @code_warntype tmp(10u"dB/cm^(3/2)", 10cm)
MethodInstance for tmp(::Quantity{Gain{Unitful.LogInfo{:Decibel, 10, 10}, :?, Int64}, 𝐋^-3/2, Unitful.FreeUnits{(cm^-3/2,), 𝐋^-3/2, nothing}}, ::Quantity{Int64, 𝐋, Un
itful.FreeUnits{(cm,), 𝐋, nothing}})
  from tmp(a, b) @ Main REPL[61]:1
Arguments
  #self#::Core.Const(Main.tmp)
  a::Quantity{Gain{Unitful.LogInfo{:Decibel, 10, 10}, :?, Int64}, 𝐋^-3/2, Unitful.FreeUnits{(cm^-3/2,), 𝐋^-3/2, nothing}}
  b::Quantity{Int64, 𝐋, Unitful.FreeUnits{(cm,), 𝐋, nothing}}
Body::Any
1 ─ %1 = Main.uconvertp::Core.Const(Unitful.uconvertp)
│   %2 = Main.NoUnits::Core.Const()
│   %3 = Main.:*::Core.Const(*)
│   %4 = Main.:^::Core.Const(^)
│   %5 = (3 / 2)::Core.Const(1.5)
│   %6 = (%4)(b, %5)::Any
│   %7 = (%3)(a, %6)::Any
│   %8 = (%1)(%2, %7)::Any
└──      return %8

Thanks

[sostock]

This has nothing to do with uconvertrp, the b^(3/2) is the problem (since unit exponentiation is type-unstable):

julia> tmp(b) = b ^ (3/2)
tmp (generic function with 2 methods)

julia> @code_warntype tmp(10cm)
MethodInstance for tmp(::Quantity{Int64, 𝐋, Unitful.FreeUnits{(cm,), 𝐋, nothing}})
  from tmp(b) @ Main REPL[8]:1
Arguments
  #self#::Core.Const(Main.tmp)
  b::Quantity{Int64, 𝐋, Unitful.FreeUnits{(cm,), 𝐋, nothing}}
Body::Any
1 ─ %1 = Main.:^::Core.Const(^)
│   %2 = (3 / 2)::Core.Const(1.5)
│   %3 = (%1)(b, %2)::Any
└──      return %3

A workaround is to use sqrt(b)^3 instead of b^(3/2):

julia> function tmp(a, b)
                  uconvertp(NoUnits, a * (sqrt(b) ^ 3))
       end
tmp (generic function with 2 methods)

julia> @code_warntype tmp(10u"dB/cm^(3/2)", 10cm)
MethodInstance for tmp(::Quantity{Gain{Unitful.LogInfo{:Decibel, 10, 10}, :?, Int64}, 𝐋^-3/2, Unitful.FreeUnits{(cm^-3/2,), 𝐋^-3/2, nothing}}, ::Quantity{Int64, 𝐋, Unitful.FreeUnits{(cm,), 𝐋, nothing}})
  from tmp(a, b) @ Main REPL[19]:1
Arguments
  #self#::Core.Const(Main.tmp)
  a::Quantity{Gain{Unitful.LogInfo{:Decibel, 10, 10}, :?, Int64}, 𝐋^-3/2, Unitful.FreeUnits{(cm^-3/2,), 𝐋^-3/2, nothing}}
  b::Quantity{Int64, 𝐋, Unitful.FreeUnits{(cm,), 𝐋, nothing}}
Body::Float64
1 ─ %1  = Main.uconvertp::Core.Const(Unitful.uconvertp)
│   %2  = Main.NoUnits::Core.Const()
│   %3  = Main.:*::Core.Const(*)
│   %4  = Main.:^::Core.Const(^)
│   %5  = Main.sqrt(b)::Quantity{Float64, 𝐋^1/2, Unitful.FreeUnits{(cm^1/2,), 𝐋^1/2, nothing}}
│   %6  = Core.apply_type(Base.Val, 3)::Core.Const(Val{3})
│   %7  = (%6)()::Core.Const(Val{3}())
│   %8  = Base.literal_pow(%4, %5, %7)::Quantity{Float64, 𝐋^3/2, Unitful.FreeUnits{(cm^3/2,), 𝐋^3/2, nothing}}
│   %9  = (%3)(a, %8)::Gain{Unitful.LogInfo{:Decibel, 10, 10}, :?, Float64}
│   %10 = (%1)(%2, %9)::Float64
└──       return %10

[sostock]

Actually, replacing 3/2 by 3//2 is already enough to infer the unit. The problem with 3/2 is that unit exponents are stored as Rationals, and converting floating-point numbers to rationals cannot be constant-folded:

julia> Base.infer_effects(Rational{Int}, (Float64,))
(!c,!e,!n,!t,!s,!m,!u,!o,!r)