Julia: Keyword arguments in code_typed/lowered/llvm/native

[quinnj]

I can't seem to find any documentation, discussion, etc. on this and didn't get any hits on the julia-users post. Is this possible? Can/should it be added? Is it just missing documentation?

[JeffBezanson]

This will be handled by #2758

[quinnj]

Sounds great!

[quinnj]

If/when keyword arguments are next worked on, it would be great to think through cases like this as well as #23548 (i.e. precompiling methods w/ keyword arguments). Not supporting functions w/ keyword arguments in these reflection apis and precompile really make them 2nd-class citizens, in addition to the known performance cost.

[ChrisRackauckas]

Now that keyword arguments have been changed, is what @code_warntype shows changed at all?

[quinnj]

This issue is pretty stale at this point; I think improvements to inlining have mostly fixed this since you usually see the inlined "original" method body in @code_warntype. If the invoked keyword args are too complex, you can still use knowledge about keyword methods are lowered/called to still get to the original method body for inspection (clarified in https://github.com/JuliaLang/julia/pull/28358).

[kcajf]

julia> versioninfo()
Julia Version 1.2.0
Commit c6da87ff4b (2019-08-20 00:03 UTC)
Platform Info:
  OS: Linux (x86_64-pc-linux-gnu)
  CPU: Intel(R) Xeon(R) CPU E5-2683 v4 @ 2.10GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-6.0.1 (ORCJIT, broadwell)

# Using kwargs:

julia> function foo(;x::Int64)
           x + rand(1:10)
       end
foo (generic function with 1 method)

julia> @code_warntype foo(x=4)
Variables
  #unused#::Core.Compiler.Const(getfield(Main, Symbol("#kw##foo"))(), false)
  @_2::NamedTuple{(:x,),Tuple{Int64}}
  @_3::Core.Compiler.Const(foo, false)
  x::Int64
  @_5::Int64

Body::Int64
1 ─ %1  = Base.haskey(@_2, :x)::Core.Compiler.Const(true, false)
│         %1
│   %3  = Base.getindex(@_2, :x)::Int64
│   %4  = (%3 isa Main.Int64)::Core.Compiler.Const(true, false)
│         %4
└──       goto #3
2 ─       Core.Compiler.Const(:(%new(Core.TypeError, Symbol("keyword argument"), :x, Main.Int64, %3)), false)
└──       Core.Compiler.Const(:(Core.throw(%7)), false)
3 ┄       (@_5 = %3)
└──       goto #5
4 ─       Core.Compiler.Const(:(Core.UndefKeywordError(:x)), false)
└──       Core.Compiler.Const(:(@_5 = Core.throw(%11)), false)
5 ┄       (x = @_5)
│   %14 = (:x,)::Core.Compiler.Const((:x,), false)
│   %15 = Core.apply_type(Core.NamedTuple, %14)::Core.Compiler.Const(NamedTuple{(:x,),T} where T<:Tuple, false)
│   %16 = Base.structdiff(@_2, %15)::Core.Compiler.Const(NamedTuple(), false)
│   %17 = Base.pairs(%16)::Core.Compiler.Const(Base.Iterators.Pairs{Union{},Union{},Tuple{},NamedTuple{(),Tuple{}}}(), false)
│   %18 = Base.isempty(%17)::Core.Compiler.Const(true, false)
│         %18
└──       goto #7
6 ─       Core.Compiler.Const(:(Base.kwerr(@_2, @_3)), false)
7 ┄ %22 = Main.:(#foo#17)(x, @_3)::Int64
└──       return %22

# Non-kwargs

julia> function bar(x::Int64)
           x + rand(1:10)
       end
bar (generic function with 1 method)

# much nicer output: we actually see the logic!
julia> @code_warntype bar(4)
Variables
  #self#::Core.Compiler.Const(bar, false)
  x::Int64

Body::Int64
1 ─ %1 = (1:10)::Core.Compiler.Const(1:10, false)
│   %2 = Main.rand(%1)::Int64
│   %3 = (x + %2)::Int64

On julia 1.2, I find this to still be an issue even for a very small function that should be "inlined" into the kwargs call. Makes it tricky to debug type instabilities, and is particularly confusing for first-time users.