Improve inference of tail-like functions (#29264)

Previously these sorts of function would block constant propagation.
Hopfully #28955 will just fix this, but until then, add a surgical
fix and a test.

base/compiler/abstractinterpretation.jl

@@ -194,14 +194,21 @@ function abstract_call_method_with_const_args(@nospecialize(f), argtypes::Vector
         atypes = get_argtypes(inf_result)
         if method.isva
             vargs = argtypes[(nargs + 1):end]
+            all_vargs_const = true
             for i in 1:length(vargs)
                 a = maybe_widen_conditional(vargs[i])
+                all_vargs_const &= a isa Const
                 if i > length(inf_result.vargs)
                     push!(inf_result.vargs, a)
                 elseif a isa Const
                     inf_result.vargs[i] = a
                 end
             end
+            # If all vargs are const, the result may be a constant
+            # tuple. If so, we should make sure to treat it as such
+            if all_vargs_const
+                atypes[nargs + 1] = builtin_tfunction(tuple, inf_result.vargs, sv)
+            end
         end
         for i in 1:nargs
             a = maybe_widen_conditional(argtypes[i])

test/compiler/compiler.jl

@@ -2089,3 +2089,14 @@ f30394(foo::T1, ::Type{T2}) where {T2, T1 <: T2} = foo
 f30394(foo, T2) = f30394(foo.foo_inner, T2)
 
 @test Base.return_types(f30394, (Foo30394_2, Type{Base30394})) == Any[Base30394]
+
+# test that this doesn't cause an internal error
+get_order_kwargs()
+end
+
+# Test that tail-like functions don't block constant propagation
+my_tail_const_prop(i, tail...) = tail
+function foo_tail_const_prop()
+    Val{my_tail_const_prop(1,2,3,4)}()
+end
+@test (@inferred foo_tail_const_prop()) == Val{(2,3,4)}()