Post-merge cleanup of FunctionSpec type change (#323)

vchuravy · web-flow · commit f2d67b29b63c · 2022-05-10T11:02:04.000+02:00
diff --git a/src/irgen.jl b/src/irgen.jl
@@ -389,7 +389,7 @@ end
 function lower_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.Function)
     ctx = context(mod)
     ft = eltype(llvmtype(f))
-    @compiler_assert return_type(ft) == LLVM.VoidType(ctx) job
+    @compiler_assert LLVM.return_type(ft) == LLVM.VoidType(ctx) job
 
     # find the byval parameters
     byval = BitVector(undef, length(parameters(ft)))
@@ -407,7 +407,7 @@ function lower_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.
         has_kernel_state = kernel_state_type(job) !== Nothing
         orig_ft = if has_kernel_state
             # the kernel state has been added here already, so strip the first parameter
-            LLVM.FunctionType(return_type(ft), parameters(ft)[2:end]; vararg=isvararg(ft))
+            LLVM.FunctionType(LLVM.return_type(ft), parameters(ft)[2:end]; vararg=isvararg(ft))
         else
             ft
         end
@@ -462,7 +462,7 @@ function lower_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.
             push!(new_types, param)
         end
     end
-    new_ft = LLVM.FunctionType(return_type(ft), new_types)
+    new_ft = LLVM.FunctionType(LLVM.return_type(ft), new_types)
     new_f = LLVM.Function(mod, "", new_ft)
     linkage!(new_f, linkage(f))
     for (arg, new_arg) in zip(parameters(f), parameters(new_f))
@@ -595,7 +595,7 @@ function add_kernel_state!(@nospecialize(job::CompilerJob), mod::LLVM.Module,
 
         # create a new function
         new_param_types = [T_state, parameters(ft)...]
-        new_ft = LLVM.FunctionType(return_type(ft), new_param_types)
+        new_ft = LLVM.FunctionType(LLVM.return_type(ft), new_param_types)
         new_f = LLVM.Function(mod, fn, new_ft)
         LLVM.name!(parameters(new_f)[1], "state")
         linkage!(new_f, linkage(f))
@@ -627,7 +627,7 @@ function add_kernel_state!(@nospecialize(job::CompilerJob), mod::LLVM.Module,
                     #      is all this even sound?
                     typ = llvmtype(val)::LLVM.PointerType
                     ft = eltype(typ)::LLVM.FunctionType
-                    new_ft = LLVM.FunctionType(return_type(ft), [T_state, parameters(ft)...])
+                    new_ft = LLVM.FunctionType(LLVM.return_type(ft), [T_state, parameters(ft)...])
                     return const_bitcast(workmap[target], LLVM.PointerType(new_ft, addrspace(typ)))
                 end
             elseif opcode(val) == LLVM.API.LLVMPtrToInt
diff --git a/src/optim.jl b/src/optim.jl
@@ -302,7 +302,7 @@ function cpu_features!(mod::LLVM.Module)
             # warn?
             false
         end
-        has_fma = ConstantInt(return_type(ft), has_fma)
+        has_fma = ConstantInt(LLVM.return_type(ft), has_fma)
 
         # substitute all uses of the intrinsic with a constant
         materialized = LLVM.Value[]
@@ -342,7 +342,7 @@ function lower_gc_frame!(fun::LLVM.Function)
     if haskey(functions(mod), "julia.gc_alloc_obj")
         alloc_obj = functions(mod)["julia.gc_alloc_obj"]
         alloc_obj_ft = eltype(llvmtype(alloc_obj))
-        T_prjlvalue = return_type(alloc_obj_ft)
+        T_prjlvalue = LLVM.return_type(alloc_obj_ft)
         T_pjlvalue = convert(LLVMType, Any; ctx, allow_boxed=true)
 
         for use in uses(alloc_obj)
diff --git a/src/ptx.jl b/src/ptx.jl
@@ -337,7 +337,7 @@ function hide_unreachable!(fun::LLVM.Function)
                     # couldn't find any other successor. this happens with functions
                     # that only contain a single block, or when the block is dead.
                     ft = eltype(llvmtype(fun))
-                    if return_type(ft) == LLVM.VoidType(ctx)
+                    if LLVM.return_type(ft) == LLVM.VoidType(ctx)
                         # even though returning can lead to invalid control flow,
                         # it mostly happens with functions that just throw,
                         # and leaving the unreachable there would make the optimizer
@@ -411,7 +411,7 @@ function nvvm_reflect!(fun::LLVM.Function)
     haskey(LLVM.functions(mod), NVVM_REFLECT_FUNCTION) || return false
     reflect_function = LLVM.functions(mod)[NVVM_REFLECT_FUNCTION]
     isdeclaration(reflect_function) || error("_reflect function should not have a body")
-    reflect_typ = return_type(eltype(llvmtype(reflect_function)))
+    reflect_typ = LLVM.return_type(eltype(llvmtype(reflect_function)))
     isa(reflect_typ, LLVM.IntegerType) || error("_reflect's return type should be integer")
 
     to_remove = []
diff --git a/src/reflection.jl b/src/reflection.jl
@@ -39,51 +39,58 @@ function highlight(io::IO, code, lexer)
     return
 end
 
+#
+# Compat shims
+# 
+
+include("reflection_compat.jl")
 
 #
 # code_* replacements
 #
 
-code_lowered(@nospecialize(job::CompilerJob); kwargs...) =
-    InteractiveUtils.code_lowered(job.source.f, job.source.tt; kwargs...)
-
 @inline function typed_signature(@nospecialize(job::CompilerJob))
     u = Base.unwrap_unionall(job.source.tt)
     return Base.rewrap_unionall(Tuple{job.source.f, u.parameters...}, job.source.tt)
 end
 
+code_lowered(@nospecialize(job::CompilerJob); kwargs...) =
+    code_lowered_by_type(typed_signature(job); kwargs...)
+
 function code_typed(@nospecialize(job::CompilerJob); interactive::Bool=false, kwargs...)
     # TODO: use the compiler driver to get the Julia method instance (we might rewrite it)
+    tt = typed_signature(job)
     if interactive
         # call Cthulhu without introducing a dependency on Cthulhu
         mod = get(Base.loaded_modules, Cthulhu, nothing)
         mod===nothing && error("Interactive code reflection requires Cthulhu; please install and load this package first.")
         interp = get_interpreter(job)
         descend_code_typed = getfield(mod, :descend_code_typed)
-        descend_code_typed(job.source.f, job.source.tt; interp, kwargs...)
+        descend_code_typed(tt; interp, kwargs...)
     elseif VERSION >= v"1.7-"
         interp = get_interpreter(job)
-        Base.code_typed_by_type(typed_signature(job); interp, kwargs...)
+        Base.code_typed_by_type(tt; interp, kwargs...)
     else
-        Base.code_typed_by_type(typed_signature(job); kwargs...)
+        Base.code_typed_by_type(tt; kwargs...)
     end
 end
 
 function code_warntype(io::IO, @nospecialize(job::CompilerJob); interactive::Bool=false, kwargs...)
     # TODO: use the compiler driver to get the Julia method instance (we might rewrite it)
+    tt = typed_signature(job)
     if interactive
         @assert io == stdout
         # call Cthulhu without introducing a dependency on Cthulhu
         mod = get(Base.loaded_modules, Cthulhu, nothing)
         mod===nothing && error("Interactive code reflection requires Cthulhu; please install and load this package first.")
         interp = get_interpreter(job)
         descend_code_warntype = getfield(mod, :descend_code_warntype)
-        descend_code_warntype(job.source.f, job.source.tt; interp, kwargs...)
+        descend_code_warntype(tt; interp, kwargs...)
     elseif VERSION >= v"1.7-"
         interp = get_interpreter(job)
-        InteractiveUtils.code_warntype(io, job.source.f, job.source.tt; interp, kwargs...)
+        code_warntype_by_type(io, tt; interp, kwargs...)
     else
-        InteractiveUtils.code_warntype(io, job.source.f, job.source.tt; kwargs...)
+        code_warntype_by_type(io, tt; kwargs...)
     end
 end
 code_warntype(@nospecialize(job::CompilerJob); kwargs...) = code_warntype(stdout, job; kwargs...)
diff --git a/src/reflection_compat.jl b/src/reflection_compat.jl
@@ -0,0 +1,120 @@
+# The content of this file should be upstreamed to Julia proper
+
+function method_instances(@nospecialize(tt::Type), world::UInt=Base.get_world_counter())
+    return map(Core.Compiler.specialize_method, method_matches(tt; world))
+end
+
+if VERSION >= v"1.7-"
+    const hasgenerator = Base.hasgenerator
+else
+    const hasgenerator = Base.isgenerated
+end
+
+function code_lowered_by_type(@nospecialize(tt); generated::Bool=true, debuginfo::Symbol=:default)
+
+    debuginfo = Base.IRShow.debuginfo(debuginfo)
+    if debuginfo !== :source && debuginfo !== :none
+        throw(ArgumentError("'debuginfo' must be either :source or :none"))
+    end
+    return map(method_instances(tt)) do m
+        if generated && hasgenerator(m)
+            if Base.may_invoke_generator(m)
+                return ccall(:jl_code_for_staged, Any, (Any,), m)::CodeInfo
+            else
+                error("Could not expand generator for `@generated` method ", m, ". ",
+                      "This can happen if the provided argument types (", t, ") are ",
+                      "not leaf types, but the `generated` argument is `true`.")
+            end
+        end
+        code = Base.uncompressed_ir(m.def::Method)
+        debuginfo === :none && Base.remove_linenums!(code)
+        return code
+    end
+end
+
+function code_warntype_by_type(io::IO, @nospecialize(tt);
+                       debuginfo::Symbol=:default, optimize::Bool=false, kwargs...)
+    debuginfo = Base.IRShow.debuginfo(debuginfo)
+    lineprinter = Base.IRShow.__debuginfo[debuginfo]
+    for (src, rettype) in Base.code_typed_by_type(tt; optimize, kwargs...)
+        if !(src isa Core.CodeInfo)
+            println(io, src)
+            println(io, "  failed to infer")
+            continue
+        end
+        lambda_io::IOContext = io
+        p = src.parent
+        nargs::Int = 0
+        if p isa Core.MethodInstance
+            println(io, p)
+            print(io, "  from ")
+            println(io, p.def)
+            p.def isa Method && (nargs = p.def.nargs)
+            if !isempty(p.sparam_vals)
+                println(io, "Static Parameters")
+                sig = p.def.sig
+                warn_color = Base.warn_color() # more mild user notification
+                for i = 1:length(p.sparam_vals)
+                    sig = sig::UnionAll
+                    name = sig.var.name
+                    val = p.sparam_vals[i]
+                    print_highlighted(io::IO, v::String, color::Symbol) =
+                        if highlighting[:warntype]
+                            Base.printstyled(io, v; color)
+                        else
+                            Base.print(io, v)
+                        end
+                    if val isa TypeVar
+                        if val.lb === Union{}
+                            print(io, "  ", name, " <: ")
+                            print_highlighted(io, "$(val.ub)", warn_color)
+                        elseif val.ub === Any
+                            print(io, "  ", sig.var.name, " >: ")
+                            print_highlighted(io, "$(val.lb)", warn_color)
+                        else
+                            print(io, "  ")
+                            print_highlighted(io, "$(val.lb)", warn_color)
+                            print(io, " <: ", sig.var.name, " <: ")
+                            print_highlighted(io, "$(val.ub)", warn_color)
+                        end
+                    elseif val isa typeof(Vararg)
+                        print(io, "  ", name, "::")
+                        print_highlighted(io, "Int", warn_color)
+                    else
+                        print(io, "  ", sig.var.name, " = ")
+                        print_highlighted(io, "$(val)", :cyan) # show the "good" type
+                    end
+                    println(io)
+                    sig = sig.body
+                end
+            end
+        end
+        if src.slotnames !== nothing
+            slotnames = Base.sourceinfo_slotnames(src)
+            lambda_io = IOContext(lambda_io, :SOURCE_SLOTNAMES => slotnames)
+            slottypes = src.slottypes
+            nargs > 0 && println(io, "Arguments")
+            for i = 1:length(slotnames)
+                if i == nargs + 1
+                    println(io, "Locals")
+                end
+                print(io, "  ", slotnames[i])
+                if isa(slottypes, Vector{Any})
+                    InteractiveUtils.warntype_type_printer(io, slottypes[i], true)
+                end
+                println(io)
+            end
+        end
+        print(io, "Body")
+        InteractiveUtils.warntype_type_printer(io, rettype, true)
+        println(io)
+@static if VERSION < v"1.7.0"
+        Base.IRShow.show_ir(lambda_io, src, lineprinter(src), InteractiveUtils.warntype_type_printer)
+else
+        irshow_config = Base.IRShow.IRShowConfig(lineprinter(src), InteractiveUtils.warntype_type_printer)
+        Base.IRShow.show_ir(lambda_io, src, irshow_config)
+end
+        println(io)
+    end
+    nothing
+end
diff --git a/src/rtlib.jl b/src/rtlib.jl
@@ -81,8 +81,8 @@ function emit_function!(mod, @nospecialize(job::CompilerJob), f, method; ctx::Co
                             optimize=false, libraries=false, ctx)
     ft = eltype(llvmtype(meta.entry))
     expected_ft = convert(LLVM.FunctionType, method; ctx=context(new_mod))
-    if return_type(ft) != return_type(expected_ft)
-        error("Invalid return type for runtime function '$(method.name)': expected $(return_type(expected_ft)), got $(return_type(ft))")
+    if LLVM.return_type(ft) != LLVM.return_type(expected_ft)
+        error("Invalid return type for runtime function '$(method.name)': expected $(LLVM.return_type(expected_ft)), got $(LLVM.return_type(ft))")
     end
 
     # recent Julia versions include prototypes for all runtime functions, even if unused
diff --git a/src/spirv.jl b/src/spirv.jl
@@ -219,7 +219,7 @@ end
 function wrap_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.Function)
     ctx = context(mod)
     ft = eltype(llvmtype(f)::LLVM.PointerType)::LLVM.FunctionType
-    @compiler_assert return_type(ft) == LLVM.VoidType(ctx) job
+    @compiler_assert LLVM.return_type(ft) == LLVM.VoidType(ctx) job
 
     # find the byval parameters
     byval = BitVector(undef, length(parameters(ft)))
@@ -235,7 +235,7 @@ function wrap_byval(@nospecialize(job::CompilerJob), mod::LLVM.Module, f::LLVM.F
         has_kernel_state = kernel_state_type(job) !== Nothing
         orig_ft = if has_kernel_state
             # the kernel state has been added here already, so strip the first parameter
-            LLVM.FunctionType(return_type(ft), parameters(ft)[2:end]; vararg=isvararg(ft))
+            LLVM.FunctionType(LLVM.return_type(ft), parameters(ft)[2:end]; vararg=isvararg(ft))
         else
             ft
         end
diff --git a/src/validation.jl b/src/validation.jl
@@ -2,35 +2,38 @@
 
 export InvalidIRError
 
-function get_method_matches(@nospecialize(job::CompilerJob))
-    tt = typed_signature(job)
-
+function method_matches(@nospecialize(tt::Type{<:Tuple}); world=Base.get_world_counter())
     ms = Core.MethodMatch[]
-    for m in Base._methods_by_ftype(tt, -1, job.source.world)::Vector
+    for m in Base._methods_by_ftype(tt, -1, world)::Vector
         m = m::Core.MethodMatch
         push!(ms, m)
     end
 
     return ms
 end
 
+function return_type(m::Core.MethodMatch;
+                     interp = Core.Compiler.NativeInterpreter(world))
+    ty = Core.Compiler.typeinf_type(interp, m.method, m.spec_types, m.sparams)
+    return something(ty, Any)
+end
+
 
 function check_method(@nospecialize(job::CompilerJob))
     isa(job.source.f, Core.Builtin) && throw(KernelError(job, "function is not a generic function"))
 
     # get the method
-    ms = get_method_matches(job)
+    world = job.source.world
+    ms = method_matches(typed_signature(job); world)
     isempty(ms)   && throw(KernelError(job, "no method found"))
     length(ms)!=1 && throw(KernelError(job, "no unique matching method"))
 
     # kernels can't return values
     if job.source.kernel
         cache = ci_cache(job)
         mt = method_table(job)
-        interp = GPUInterpreter(cache, mt, job.source.world)
-        m = only(ms)
-        ty = Core.Compiler.typeinf_type(interp, m.method, m.spec_types, m.sparams)
-        rt = something(ty, Any)
+        interp = GPUInterpreter(cache, mt, world)
+        rt = return_type(only(ms); interp)
 
         if rt != Nothing
             throw(KernelError(job, "kernel returns a value of type `$rt`",
diff --git a/test/Project.toml b/test/Project.toml
@@ -1,6 +1,8 @@
 [deps]
+Cthulhu = "f68482b8-f384-11e8-15f7-abe071a5a75f"
 InteractiveUtils = "b77e0a4c-d291-57a0-90e8-8db25a27a240"
 LLVM = "929cbde3-209d-540e-8aea-75f648917ca0"
+REPL = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb"
 SPIRV_LLVM_Translator_unified_jll = "85f0d8ed-5b39-5caa-b1ae-7472de402361"
 SPIRV_Tools_jll = "6ac6d60f-d740-5983-97d7-a4482c0689f4"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
diff --git a/test/native.jl b/test/native.jl
