`@which` and `@code_warntype` don't show `^Val{p}` lowering

[rdeits]

Cross-posting from discourse: https://discourse.julialang.org/t/incorrect-results-from-which-and-code-warntype-for-literal-powers/2630

I'm trying to use the new literal exponent behavior introduced in #20530 and #20889. I think I'm correctly overloading literal_pow, but various macros like @which, @code_warntype and others all seem to be showing me the wrong behavior.

julia> versioninfo()
Julia Version 0.6.0-pre.alpha.136
Commit 6eeabd8 (2017-03-13 00:18 UTC)
Platform Info:
  OS: macOS (x86_64-apple-darwin13.4.0)
  CPU: Intel(R) Core(TM) i7-2860QM CPU @ 2.50GHz
  WORD_SIZE: 64
  BLAS: libopenblas (USE64BITINT DYNAMIC_ARCH NO_AFFINITY Sandybridge)
  LAPACK: libopenblas64_
  LIBM: libopenlibm
  LLVM: libLLVM-3.9.1 (ORCJIT, sandybridge)

julia> immutable MyType
           x::Int
       end

julia> import Base: literal_pow

julia> literal_pow(^, m::MyType, ::Type{Val{p}}) where p = m.x + p
literal_pow (generic function with 6 methods)

julia> m = MyType(1)
MyType(1)

julia> m^2
3

That's all good so far. But none of the introspection macros seem to work for m^2:

julia> @which m^2
^(x, p::Integer) in Base at intfuncs.jl:196

julia> @code_warntype m^2
Variables:
  #self#::Base.#^
  x::MyType
  p::Int64

Body:
  begin
      return $(Expr(:invoke, MethodInstance for power_by_squaring(::MyType, ::Int64), :(Base.power_by_squaring), :(x), :(p)))
  end::Any

julia> @code_lowered m^2
CodeInfo(:(begin
        nothing
        return (Base.power_by_squaring)(x, p)
    end))

julia> using Base.Test

julia> @inferred m^2
ERROR: MethodError: no method matching *(::MyType, ::MyType)
Closest candidates are:
  *(::Any, ::Any, ::Any, ::Any...) at operators.jl:424
Stacktrace:
 [1] power_by_squaring(::MyType, ::Int64) at ./intfuncs.jl:166
 [2] ^(::MyType, ::Int64) at ./intfuncs.jl:196

are the special lowering rules not being applied inside these macros?

[TotalVerb]

Duplicate (mostly) of #20620. Maybe we can leave this open as a reminder in case literal power and dot operator end up being treated separately.

[rdeits]

Ah, I see, thanks. So is the workaround to use eval with expand like this?

julia> eval(:(@which $(expand(:(m^2)))))
literal_pow(^, m::MyType, ::Type{Val{p}}) where p in Main at REPL[3]:1

julia> eval(:(@code_warntype $(expand(:(m^2)))))
Variables:
  #self#::Base.#literal_pow
  ^::Base.#^
  m::MyType
  #unused#::Any

Body:
  begin
      return (Base.add_int)((Core.getfield)(m::MyType, :x)::Int64, $(Expr(:static_parameter, 1)))::Int64
  end::Int64

[TotalVerb]

Yes, or the alternative but equivalent syntax

julia> @eval @which $(expand(:(1^2)))
literal_pow(::Base.#^, x::Union{Complex{#s37} where #s37<:Union{Float32, Float64, Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8}, Float32, Float64, Int16, Int32, Int64, Int8, Rational{#s23} where #s23<:Union{Float32, Float64, Int16, Int32, Int64, Int8, UInt16, UInt32, UInt64, UInt8}, UInt16, UInt32, UInt64, UInt8}, ::Type{Val{2}}) in Base at intfuncs.jl:218

[thofma]

Would be nice if this is fixed in 0.7. The new literal power stuff breaks existing code and it is quite difficuelt to find out how to fix it. Overload literal_pow?

[fredrikekre]

Do you have an example of code that is broken by this?

[thofma]

For my type, in ^(x::mytype, ::Int) I throw a domain error for negative exponents. On 0.7 it gives me (as expected)

julia> a = -1;

julia> x^a
ERROR: DomainError with nothing:

Stacktrace:
 [1] ^(::Nemo.nmod_poly, ::Int64) at /home/thofmann/.julia/v0.7/Nemo/src/flint/nmod_poly.jl:295
 [2] top-level scope

But for literals it gives me:

julia> x^-1
ERROR: MethodError: no method matching inv(::Nemo.nmod_poly)
Closest candidates are:
  inv(::Complex{Float64}) at complex.jl:391
  inv(::Nemo.Generic.perm) at /home/thofmann/.julia/v0.7/Nemo/src/generic/PermGroups.jl:243
  inv(::Nemo.nmod) at /home/thofmann/.julia/v0.7/Nemo/src/flint/nmod.jl:256
  ...
Stacktrace:
 [1] @generated body at ./none:0 [inlined]
 [2] literal_pow(::typeof(^), ::Nemo.nmod_poly, ::Val{-1}) at ./<missing>:0
 [3] top-level scope

I cannot define inv, because the elements are not invertible. Also why should I need to define inv if I want to have literal powers? I already defined powering for exponents of type Int.

This is very intransparent for custom types.

[fredrikekre]

That would be #24240 then, I suppose that inv transformation should only be done on types that are defined in base.

[stevengj]

You don't need to define inv if you don't have an inverse. It will just throw a MethodError instead of a DomainError for negative literal powers.

(If it's crucial that you throw a DomainError, you could define an inv method that throws a DomainError, which is not so unreasonable: if you want a DomainError for x^-1, why wouldn't you want a DomainError for inv(x) too?)

[thofma]

See #24699