irinterp: Allow for non-Const first argument (#48326)

The first argument isn't special here in any way. The original
code here just wanted to avoid calling is_all_const_arg with
the first argument included, because that condition was already
computed when determining `f`. This code pre-dated semi-concrete
eval and is now in the wrong place.

The changes on the inlining semi-concrete interpreted opaque closure is 
also added because now we allow irinterp on opaque closure inference.

Co-authored-by: Shuhei Kadowaki <aviatesk@gmail.com>

Author: Keno

base/compiler/abstractinterpretation.jl

@@ -843,8 +843,8 @@ function concrete_eval_eligible(interp::AbstractInterpreter,
         return nothing
     end
     isoverlayed(method_table(interp)) && !is_nonoverlayed(result.effects) && return nothing
-    if f !== nothing && result.edge !== nothing && is_foldable(result.effects)
-        if is_all_const_arg(arginfo, #=start=#2)
+    if result.edge !== nothing && is_foldable(result.effects)
+        if f !== nothing && is_all_const_arg(arginfo, #=start=#2)
             return true
         else
             return false

base/compiler/ssair/inlining.jl

@@ -1466,21 +1466,27 @@ function handle_const_prop_result!(cases::Vector{InliningCase},
     return true
 end
 
-function handle_semi_concrete_result!(cases::Vector{InliningCase}, result::SemiConcreteResult,
-    @nospecialize(info::CallInfo), flag::UInt8, state::InliningState;
-    allow_abstract::Bool)
+function semiconcrete_result_item(result::SemiConcreteResult,
+        @nospecialize(info::CallInfo), flag::UInt8, state::InliningState)
     mi = result.mi
-    spec_types = mi.specTypes
-    allow_abstract || isdispatchtuple(spec_types) || return false
-    validate_sparams(mi.sparam_vals) || return false
     if !state.params.inlining || is_stmt_noinline(flag)
         et = InliningEdgeTracker(state.et, nothing)
-        item = compileable_specialization(mi, result.effects, et, info;
+        return compileable_specialization(mi, result.effects, et, info;
             compilesig_invokes=state.params.compilesig_invokes)
-        item === nothing && return false
     else
-        item = InliningTodo(mi, result.ir, result.effects)
+        return InliningTodo(mi, result.ir, result.effects)
     end
+end
+
+function handle_semi_concrete_result!(cases::Vector{InliningCase}, result::SemiConcreteResult,
+        @nospecialize(info::CallInfo), flag::UInt8, state::InliningState;
+        allow_abstract::Bool)
+    mi = result.mi
+    spec_types = mi.specTypes
+    allow_abstract || isdispatchtuple(spec_types) || return false
+    validate_sparams(mi.sparam_vals) || return false
+    item = semiconcrete_result_item(result, info, flag, state)
+    item === nothing && return false
     push!(cases, InliningCase(spec_types, item))
     return true
 end
@@ -1538,7 +1544,14 @@ function handle_opaque_closure_call!(todo::Vector{Pair{Int,Any}},
     elseif isa(result, ConcreteResult)
         item = concrete_result_item(result, info, state)
     else
-        item = analyze_method!(info.match, sig.argtypes, info, flag, state; allow_typevars=false)
+        if isa(result, SemiConcreteResult)
+            result = inlining_policy(state.interp, result, info, flag, result.mi, sig.argtypes)
+        end
+        if isa(result, SemiConcreteResult)
+            item = semiconcrete_result_item(result, info, flag, state)
+        else
+            item = analyze_method!(info.match, sig.argtypes, info, flag, state; allow_typevars=false)
+        end
     end
     handle_single_case!(todo, ir, idx, stmt, item, state.params)
     return nothing