remove isva field from OpaqueClosure (#44008)

Instead allow specifying an argument tuple type separately.

base/boot.jl

@@ -424,7 +424,7 @@ eval(Core, :(CodeInstance(mi::MethodInstance, @nospecialize(rettype), @nospecial
                     mi, rettype, inferred_const, inferred, const_flags, min_world, max_world, ipo_effects, effects, relocatability)))
 eval(Core, :(Const(@nospecialize(v)) = $(Expr(:new, :Const, :v))))
 eval(Core, :(PartialStruct(@nospecialize(typ), fields::Array{Any, 1}) = $(Expr(:new, :PartialStruct, :typ, :fields))))
-eval(Core, :(PartialOpaque(@nospecialize(typ), @nospecialize(env), isva::Bool, parent::MethodInstance, source::Method) = $(Expr(:new, :PartialOpaque, :typ, :env, :isva, :parent, :source))))
+eval(Core, :(PartialOpaque(@nospecialize(typ), @nospecialize(env), parent::MethodInstance, source::Method) = $(Expr(:new, :PartialOpaque, :typ, :env, :parent, :source))))
 eval(Core, :(InterConditional(slot::Int, @nospecialize(vtype), @nospecialize(elsetype)) = $(Expr(:new, :InterConditional, :slot, :vtype, :elsetype))))
 eval(Core, :(MethodMatch(@nospecialize(spec_types), sparams::SimpleVector, method::Method, fully_covers::Bool) =
     $(Expr(:new, :MethodMatch, :spec_types, :sparams, :method, :fully_covers))))

base/compiler/abstractinterpretation.jl

@@ -99,7 +99,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
                 end
                 this_argtypes = isa(matches, MethodMatches) ? argtypes : matches.applicable_argtypes[i]
                 this_arginfo = ArgInfo(fargs, this_argtypes)
-                const_result = abstract_call_method_with_const_args(interp, result, f, this_arginfo, match, sv, false)
+                const_result = abstract_call_method_with_const_args(interp, result, f, this_arginfo, match, sv)
                 effects = result.edge_effects
                 if const_result !== nothing
                     (;rt, effects, const_result) = const_result
@@ -138,7 +138,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             # this is in preparation for inlining, or improving the return result
             this_argtypes = isa(matches, MethodMatches) ? argtypes : matches.applicable_argtypes[i]
             this_arginfo = ArgInfo(fargs, this_argtypes)
-            const_result = abstract_call_method_with_const_args(interp, result, f, this_arginfo, match, sv, false)
+            const_result = abstract_call_method_with_const_args(interp, result, f, this_arginfo, match, sv)
             effects = result.edge_effects
             if const_result !== nothing
                 this_rt = const_result.rt
@@ -667,7 +667,7 @@ end
 
 function abstract_call_method_with_const_args(interp::AbstractInterpreter, result::MethodCallResult,
                                               @nospecialize(f), arginfo::ArgInfo, match::MethodMatch,
-                                              sv::InferenceState, va_override::Bool)
+                                              sv::InferenceState)
     if !const_prop_enabled(interp, sv, match)
         return nothing
     end
@@ -705,7 +705,7 @@ function abstract_call_method_with_const_args(interp::AbstractInterpreter, resul
                 return nothing
             end
         end
-        inf_result = InferenceResult(mi, (arginfo, sv), va_override)
+        inf_result = InferenceResult(mi, (arginfo, sv))
         if !any(inf_result.overridden_by_const)
             add_remark!(interp, sv, "[constprop] Could not handle constant info in matching_cache_argtypes")
             return nothing
@@ -1457,7 +1457,7 @@ function abstract_invoke(interp::AbstractInterpreter, (; fargs, argtypes)::ArgIn
     #     t, a = ti.parameters[i], argtypes′[i]
     #     argtypes′[i] = t ⊑ a ? t : a
     # end
-    const_result = abstract_call_method_with_const_args(interp, result, singleton_type(ft′), arginfo, match, sv, false)
+    const_result = abstract_call_method_with_const_args(interp, result, singleton_type(ft′), arginfo, match, sv)
     if const_result !== nothing
         (;rt, const_result) = const_result
     end
@@ -1603,7 +1603,7 @@ function abstract_call_opaque_closure(interp::AbstractInterpreter, closure::Part
     const_result = nothing
     if !result.edgecycle
         const_result = abstract_call_method_with_const_args(interp, result, nothing,
-            arginfo, match, sv, closure.isva)
+            arginfo, match, sv)
         if const_result !== nothing
             (;rt, const_result) = const_result
         end
@@ -1619,7 +1619,7 @@ function most_general_argtypes(closure::PartialOpaque)
     if !isa(argt, DataType) || argt.name !== typename(Tuple)
         argt = Tuple
     end
-    return most_general_argtypes(closure.source, argt, closure.isva, false)
+    return most_general_argtypes(closure.source, argt, false)
 end
 
 # call where the function is any lattice element
@@ -1843,14 +1843,14 @@ function abstract_eval_statement(interp::AbstractInterpreter, @nospecialize(e),
     elseif ehead === :new_opaque_closure
         tristate_merge!(sv, Effects()) # TODO
         t = Union{}
-        if length(e.args) >= 5
+        if length(e.args) >= 4
             ea = e.args
             argtypes = collect_argtypes(interp, ea, vtypes, sv)
             if argtypes === nothing
                 t = Bottom
             else
                 t = _opaque_closure_tfunc(argtypes[1], argtypes[2], argtypes[3],
-                    argtypes[4], argtypes[5], argtypes[6:end], sv.linfo)
+                    argtypes[4], argtypes[5:end], sv.linfo)
                 if isa(t, PartialOpaque)
                     # Infer this now so that the specialization is available to
                     # optimization.

base/compiler/inferenceresult.jl

@@ -21,11 +21,11 @@ end
 # to return a valid value for `cache_lookup(linfo, argtypes, cache).argtypes`,
 # so that we can construct cache-correct `InferenceResult`s in the first place.
 function matching_cache_argtypes(
-    linfo::MethodInstance, (arginfo, sv)#=::Tuple{ArgInfo,InferenceState}=#, va_override::Bool)
+    linfo::MethodInstance, (arginfo, sv)#=::Tuple{ArgInfo,InferenceState}=#)
     (; fargs, argtypes) = arginfo
     @assert isa(linfo.def, Method) # ensure the next line works
     nargs::Int = linfo.def.nargs
-    cache_argtypes, overridden_by_const = matching_cache_argtypes(linfo, nothing, va_override)
+    cache_argtypes, overridden_by_const = matching_cache_argtypes(linfo, nothing)
     given_argtypes = Vector{Any}(undef, length(argtypes))
     local condargs = nothing
     for i in 1:length(argtypes)
@@ -55,7 +55,7 @@ function matching_cache_argtypes(
         end
         given_argtypes[i] = widenconditional(argtype)
     end
-    isva = va_override || linfo.def.isva
+    isva = linfo.def.isva
     if isva || isvarargtype(given_argtypes[end])
         isva_given_argtypes = Vector{Any}(undef, nargs)
         for i = 1:(nargs - isva)
@@ -93,8 +93,9 @@ function matching_cache_argtypes(
 end
 
 function most_general_argtypes(method::Union{Method, Nothing}, @nospecialize(specTypes),
-    isva::Bool, withfirst::Bool = true)
+    withfirst::Bool = true)
     toplevel = method === nothing
+    isva = !toplevel && method.isva
     linfo_argtypes = Any[(unwrap_unionall(specTypes)::DataType).parameters...]
     nargs::Int = toplevel ? 0 : method.nargs
     if !withfirst
@@ -192,10 +193,9 @@ function elim_free_typevars(@nospecialize t)
     end
 end
 
-function matching_cache_argtypes(linfo::MethodInstance, ::Nothing, va_override::Bool)
+function matching_cache_argtypes(linfo::MethodInstance, ::Nothing)
     mthd = isa(linfo.def, Method) ? linfo.def::Method : nothing
-    cache_argtypes = most_general_argtypes(mthd, linfo.specTypes,
-        va_override || (isa(mthd, Method) ? mthd.isva : false))
+    cache_argtypes = most_general_argtypes(mthd, linfo.specTypes)
     return cache_argtypes, falses(length(cache_argtypes))
 end
 

base/compiler/optimize.jl

@@ -235,16 +235,15 @@ function stmt_effect_free(@nospecialize(stmt), @nospecialize(rt), src::Union{IRC
         elseif head === :foreigncall
             return foreigncall_effect_free(stmt, src)
         elseif head === :new_opaque_closure
-            length(args) < 5 && return false
+            length(args) < 4 && return false
             typ = argextype(args[1], src)
             typ, isexact = instanceof_tfunc(typ)
             isexact || return false
             typ ⊑ Tuple || return false
-            isva = argextype(args[2], src)
-            rt_lb = argextype(args[3], src)
-            rt_ub = argextype(args[4], src)
-            src = argextype(args[5], src)
-            if !(isva ⊑ Bool && rt_lb ⊑ Type && rt_ub ⊑ Type && src ⊑ Method)
+            rt_lb = argextype(args[2], src)
+            rt_ub = argextype(args[3], src)
+            src = argextype(args[4], src)
+            if !(rt_lb ⊑ Type && rt_ub ⊑ Type && src ⊑ Method)
                 return false
             end
             return true

base/compiler/ssair/inlining.jl

@@ -1056,10 +1056,10 @@ end
 
 function narrow_opaque_closure!(ir::IRCode, stmt::Expr, @nospecialize(info), state::InliningState)
     if isa(info, OpaqueClosureCreateInfo)
-        lbt = argextype(stmt.args[3], ir)
+        lbt = argextype(stmt.args[2], ir)
         lb, exact = instanceof_tfunc(lbt)
         exact || return
-        ubt = argextype(stmt.args[4], ir)
+        ubt = argextype(stmt.args[3], ir)
         ub, exact = instanceof_tfunc(ubt)
         exact || return
         # Narrow opaque closure type
@@ -1068,7 +1068,7 @@ function narrow_opaque_closure!(ir::IRCode, stmt::Expr, @nospecialize(info), sta
             # N.B.: Narrowing the ub requires a backdge on the mi whose type
             # information we're using, since a change in that function may
             # invalidate ub result.
-            stmt.args[4] = newT
+            stmt.args[3] = newT
         end
     end
 end

base/compiler/ssair/legacy.jl

@@ -3,7 +3,7 @@
 function inflate_ir(ci::CodeInfo, linfo::MethodInstance)
     sptypes = sptypes_from_meth_instance(linfo)
     if ci.inferred
-        argtypes, _ = matching_cache_argtypes(linfo, nothing, false)
+        argtypes, _ = matching_cache_argtypes(linfo, nothing)
     else
         argtypes = Any[ Any for i = 1:length(ci.slotflags) ]
     end

base/compiler/ssair/passes.jl

@@ -393,8 +393,8 @@ function lift_leaves(compact::IncrementalCompact,
                     ocleaf = simple_walk(compact, ocleaf)
                 end
                 ocdef, _ = walk_to_def(compact, ocleaf)
-                if isexpr(ocdef, :new_opaque_closure) && isa(field, Int) && 1 ≤ field ≤ length(ocdef.args)-5
-                    lift_arg!(compact, leaf, cache_key, ocdef, 5+field, lifted_leaves)
+                if isexpr(ocdef, :new_opaque_closure) && isa(field, Int) && 1 ≤ field ≤ length(ocdef.args)-4
+                    lift_arg!(compact, leaf, cache_key, ocdef, 4+field, lifted_leaves)
                     continue
                 end
                 return nothing

base/compiler/tfuncs.jl

@@ -1580,9 +1580,8 @@ function array_elmtype(@nospecialize ary)
     return Any
 end
 
-function _opaque_closure_tfunc(@nospecialize(arg), @nospecialize(isva),
-        @nospecialize(lb), @nospecialize(ub), @nospecialize(source), env::Vector{Any},
-        linfo::MethodInstance)
+function _opaque_closure_tfunc(@nospecialize(arg), @nospecialize(lb), @nospecialize(ub),
+        @nospecialize(source), env::Vector{Any}, linfo::MethodInstance)
 
     argt, argt_exact = instanceof_tfunc(arg)
     lbt, lb_exact = instanceof_tfunc(lb)
@@ -1596,9 +1595,8 @@ function _opaque_closure_tfunc(@nospecialize(arg), @nospecialize(isva),
     t = lbt == ubt ? t{ubt} : (t{T} where lbt <: T <: ubt)
 
     (isa(source, Const) && isa(source.val, Method)) || return t
-    (isa(isva, Const) && isa(isva.val, Bool)) || return t
 
-    return PartialOpaque(t, tuple_tfunc(env), isva.val, linfo, source.val)
+    return PartialOpaque(t, tuple_tfunc(env), linfo, source.val)
 end
 
 # whether getindex for the elements can potentially throw UndefRef

base/compiler/typelimits.jl

@@ -428,12 +428,11 @@ function tmerge(@nospecialize(typea), @nospecialize(typeb))
     end
     if isa(typea, PartialOpaque) && isa(typeb, PartialOpaque) && widenconst(typea) == widenconst(typeb)
         if !(typea.source === typeb.source &&
-             typea.isva === typeb.isva &&
              typea.parent === typeb.parent)
             return widenconst(typea)
         end
         return PartialOpaque(typea.typ, tmerge(typea.env, typeb.env),
-            typea.isva, typea.parent, typea.source)
+            typea.parent, typea.source)
     end
     # no special type-inference lattice, join the types
     typea, typeb = widenconst(typea), widenconst(typeb)

base/compiler/types.jl

@@ -126,9 +126,8 @@ mutable struct InferenceResult
     ipo_effects::Effects # if inference is finished
     effects::Effects # if optimization is finished
     function InferenceResult(linfo::MethodInstance,
-                             arginfo#=::Union{Nothing,Tuple{ArgInfo,InferenceState}}=# = nothing,
-                             va_override::Bool = false)
-        argtypes, overridden_by_const = matching_cache_argtypes(linfo, arginfo, va_override)
+                             arginfo#=::Union{Nothing,Tuple{ArgInfo,InferenceState}}=# = nothing)
+        argtypes, overridden_by_const = matching_cache_argtypes(linfo, arginfo)
         return new(linfo, argtypes, overridden_by_const, Any, nothing, WorldRange(), Effects(), Effects())
     end
 end

base/opaque_closure.jl

@@ -1,7 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
 """
-    @opaque (args...) -> body
+    @opaque ([type, ]args...) -> body
 
 Marks a given closure as "opaque". Opaque closures capture the
 world age of their creation (as opposed to their invocation).
@@ -10,9 +10,17 @@ list, but trades off against the ability to inline opaque
 closures at the call site, if their creation is not statically
 visible.
 
+An argument tuple type (`type`) may optionally be specified, to
+specify allowed argument types in a more flexible way. In particular,
+the argument type may be fixed length even if the function is variadic.
+
 !!! warning
     This interface is experimental and subject to change or removal without notice.
 """
 macro opaque(ex)
     esc(Expr(:opaque_closure, ex))
 end
+
+macro opaque(ty, ex)
+    esc(Expr(:opaque_closure, ty, ex))
+end