Fix implementation for OpaqueClosure

Author: serenity4

stdlib/InteractiveUtils/src/macros.jl

@@ -107,7 +107,7 @@ function construct_callable(@nospecialize(func::Type))
     # for callables such as `(::Returns{Int})(args...)` where using `Returns{Int}`
     # would give us code for the constructor, not for the callable object.
     throw(ArgumentError("If a function type is explicitly provided, it must be a singleton whose only instance is the callable object.
-                         To alleviate this restriction, the reflection macro may use `use_signature_tuple = true` from `gen_call_with_extracted_types`."))
+                         To alleviate this restriction, the reflection macro may set `use_signature_tuple = true` if using `gen_call_with_extracted_types`."))
 end
 
 function separate_kwargs(exs::Vector{Any})
@@ -196,9 +196,21 @@ function merge_namedtuple_types(nt::Type{<:NamedTuple}, nts::Type{<:NamedTuple}.
 end
 
 function gen_call(fcn, args, where_params, kws; use_signature_tuple::Bool)
-    use_signature_tuple && return :($fcn($(esc(typesof_expr(args, where_params))); $(kws...)))
     f, args... = args
-    return :($fcn($(esc(extract_farg(f))), $(esc(typesof_expr(args, where_params))); $(kws...)))
+    args = collect(Any, args)
+    !use_signature_tuple && return :($fcn($(esc(extract_farg(f))), $(esc(typesof_expr(args, where_params))); $(kws...)))
+    # We use a signature tuple only if we are sure we won't get an opaque closure as first argument.
+    # If we do get one, we have to use the 2-argument form.
+    with_signature_tuple = :($fcn($(esc(typesof_expr(Any[f, args...], where_params))); $(kws...)))
+    isexpr(f, :(::)) && return with_signature_tuple # we have a type, not a value, so not an OpaqueClosure
+    return quote
+        f = $(esc(f))
+        if isa(f, Core.OpaqueClosure)
+            $fcn(f, $(esc(typesof_expr(args, where_params))); $(kws...))
+        else
+            $with_signature_tuple
+        end
+    end
 end
 
 is_code_macro(fcn) = startswith(string(fcn), "code_")

stdlib/InteractiveUtils/test/runtests.jl

@@ -398,6 +398,23 @@ end
         @test (@code_typed (::Base.Fix2{typeof(+), Float64})(3))[2] == Float64
         @test (@code_typed optimize=false (::Returns{Float64})(::Int64; name::String))[2] == Float64
     end
+
+    @testset "Opaque closures" begin
+        opaque_f(@nospecialize(x::Type), @nospecialize(y::Type)) = sizeof(x) == sizeof(y)
+        src, _ = only(code_typed(opaque_f, (Type, Type)))
+        src.slottypes[1] = Tuple{}
+
+        # from CodeInfo
+        oc = Core.OpaqueClosure(src; sig = Tuple{Type, Type}, rettype = Bool, nargs = 2)
+
+        # from optimized IR
+        ir = Core.Compiler.inflate_ir(src)
+        oc = Core.OpaqueClosure(ir)
+        ret = @code_typed oc(Int64, Float64)
+        @test [ret] == code_typed(oc)
+        _, rt = ret
+        @test rt === Bool
+    end
 end
 
 module MacroTest