Expose function to check if precompile guaranteed to fail (similar to hasmethod)

base/loading.jl

@@ -2048,7 +2048,6 @@ function _require_from_serialized(uuidkey::PkgId, path::String, ocachepath::Unio
 end
 
 
-
 # relative-path load
 
 """
@@ -3208,6 +3207,27 @@ macro __DIR__()
     return isempty(_dirname) ? pwd() : abspath(_dirname)
 end
 
+# TODO: mark `public`?
+# TODO: name? isprecompilable? has_precompilable_specialization? has_precompilable_method?
+# TODO: put here next to `precompile` or in `reflection.jl` next to `hasmethod`?
+"""
+    precompilable(f, argtypes::Tuple{Vararg{Any}})::Bool
+
+Check if we can find a method instance for the given function `f` for the argument tuple
+(of types) `argtypes` that we can try to compile, but do not compile it.
+
+If `false`, then `precompile(f, argtypes)` would return `false`.
+If `true`, then `precompile(f, argtypes)` would try to compile a method specialization (but
+may still return `false` if it does not succeed).
+"""
+function precompilable(@nospecialize(f), @nospecialize(argtypes::Tuple))
+    precompile(Tuple{Core.Typeof(f), argtypes...})
+end
+
+function precompilable(@nospecialize(argt::Type))
+    return ccall(:jl_has_compile_hint_specialization, Int32, (Any,), argt) != 0
+end
+
 """
     precompile(f, argtypes::Tuple{Vararg{Any}})
 

src/gf.c

@@ -2942,6 +2942,19 @@ JL_DLLEXPORT int jl_compile_hint(jl_tupletype_t *types)
     return 1;
 }
 
+// true if jl_get_compile_hint_specialization can find a method instance for us to try
+// to compile
+JL_DLLEXPORT int jl_has_compile_hint_specialization(jl_tupletype_t *types)
+{
+    size_t world = jl_atomic_load_acquire(&jl_world_counter);
+    size_t min_valid = 0;
+    size_t max_valid = ~(size_t)0;
+    jl_method_instance_t *mi = jl_get_compile_hint_specialization(types, world, &min_valid, &max_valid, 1);
+    if (mi == NULL)
+        return 0;
+    return 1;
+}
+
 // add type of `f` to front of argument tuple type
 jl_value_t *jl_argtype_with_function(jl_value_t *f, jl_value_t *types0)
 {

test/reflection.jl

@@ -1057,3 +1057,17 @@ end
 @test !Base.ismutationfree(Vector{UInt64})
 
 @test Base.ismutationfree(Type{Union{}})
+
+module PrecompilableTest
+    foo(v::AbstractVector) = first(v) +1
+end
+@testset "precompilable" begin
+    @test !Base.precompilable(PrecompilableTest.foo, (AbstractVector,))
+    @test !Base.precompilable(PrecompilableTest.foo, (AbstractVector{Int},))
+    @test !Base.precompilable(PrecompilableTest.foo, (Vector,))
+    @test Base.precompilable(PrecompilableTest.foo, (Vector{Int},))
+    @test hasmethod(PrecompilableTest.foo, (AbstractVector,))
+    @test hasmethod(PrecompilableTest.foo, (AbstractVector{Int},))
+    @test hasmethod(PrecompilableTest.foo, (Vector,))
+    @test hasmethod(PrecompilableTest.foo, (Vector{Int},))
+end