Add _predeclare_call built-in

Author: topolarity

Compiler/src/typeinfer.jl

@@ -1324,21 +1324,32 @@ function collectinvokes!(workqueue::CompilationQueue, ci::CodeInfo, sptypes::Vec
         invokelatest_queue === nothing && continue
         if isexpr(stmt, :call)
             farg = stmt.args[1]
+
+            invokelatest_queue === nothing && continue
             !applicable(argextype, farg, ci, sptypes) && continue # TODO: Why is this failing during bootstrap
+
             ftyp = widenconst(argextype(farg, ci, sptypes))
 
             if ftyp === typeof(Core.finalizer) && length(stmt.args) == 3
-                finalizer = argextype(stmt.args[2], ci, sptypes)
-                obj = argextype(stmt.args[3], ci, sptypes)
-                atype = argtypes_to_type(Any[finalizer, obj])
+                finalizer_fn = argextype(stmt.args[2], ci, sptypes)
+                object = argextype(stmt.args[3], ci, sptypes)
+                atype = argtypes_to_type(Any[finalizer_fn, object])
+            elseif ftyp === typeof(Core._predeclare_call) && length(stmt.args) > 1
+                atype = argtypes_to_type(Any[
+                    argextype(stmt.args[i], ci, sptypes)
+                    for i in 2:length(stmt.args)
+                ])
+            else
+                # No dynamic dispatch to resolve / enqueue
+                continue
+            end
 
-                let workqueue = invokelatest_queue
-                    # make a best-effort attempt to enqueue the relevant code for the finalizer
-                    mi = compileable_specialization_for_call(workqueue.interp, atype)
-                    mi === nothing && continue
+            let workqueue = invokelatest_queue
+                # make a best-effort attempt to enqueue the relevant code for the finalizer
+                mi = compileable_specialization_for_call(workqueue.interp, atype)
+                mi === nothing && continue
 
-                    push!(workqueue, mi)
-                end
+                push!(workqueue, mi)
             end
         end
         # TODO: handle other StmtInfo like @cfunction and OpaqueClosure?

Compiler/src/verifytrim.jl

@@ -154,6 +154,7 @@ function may_dispatch(@nospecialize ftyp)
         return Core._apply isa ftyp ||
                Core._apply_iterate isa ftyp ||
                Core._call_in_world_total isa ftyp ||
+               Core._predeclare_call isa ftyp ||
                Core.invoke isa ftyp ||
                Core.invoke_in_world isa ftyp ||
                Core.invokelatest isa ftyp ||
@@ -233,6 +234,21 @@ function verify_codeinstance!(codeinst::CodeInstance, codeinfo::CodeInfo, inspec
 
                         error = "unresolved finalizer registered"
                     end
+                elseif Core._predeclare_call isa ftyp
+                    if length(stmt.args) > 1
+                        atype = argtypes_to_type(Any[
+                            argextype(stmt.args[i], codeinfo, sptypes)
+                            for i in 2:length(stmt.args)
+                        ])
+
+                        mi = compileable_specialization_for_call(interp, atype)
+                        if mi !== nothing
+                            ci = get(caches, mi, nothing)
+                            ci isa CodeInstance && continue
+                        end
+
+                        error = "unresolved pre-declared call"
+                    end
                 else
                     error = "unresolved call to builtin"
                 end

src/builtin_proto.h

@@ -27,6 +27,7 @@ DECLARE_BUILTIN(_call_in_world_total);
 DECLARE_BUILTIN(invokelatest);
 DECLARE_BUILTIN(_compute_sparams);
 DECLARE_BUILTIN(_expr);
+DECLARE_BUILTIN(_predeclare_call);
 DECLARE_BUILTIN(_svec_ref);
 DECLARE_BUILTIN(_typebody);
 DECLARE_BUILTIN(_typevar);

src/builtins.c

@@ -1624,6 +1624,17 @@ JL_CALLABLE(jl_f_invoke)
     return jl_gf_invoke(argtypes, args[0], &args[2], nargs - 1);
 }
 
+JL_CALLABLE(jl_f__predeclare_call)
+{
+    JL_NARGSV(_predeclare_call, 1);
+
+    // jl_datatype_t *tt = jl_inst_arg_tuple_type(args[0], &args[1], nargs, 1);
+    // JL_GC_PROMISE_ROOTED(tt); // it is a concrete type
+    // jl_compile_hint(tt)
+
+    return jl_nothing;
+}
+
 // Expr constructor for internal use ------------------------------------------
 
 jl_expr_t *jl_exprn(jl_sym_t *head, size_t n)
@@ -2510,6 +2521,7 @@ void jl_init_primitives(void) JL_GC_DISABLED
     add_builtin_func("invokelatest", jl_f_invokelatest);
     add_builtin_func("invoke_in_world", jl_f_invoke_in_world);
     add_builtin_func("_call_in_world_total", jl_f__call_in_world_total);
+    add_builtin_func("_predeclare_call", jl_f__predeclare_call);
     add_builtin_func("_typevar", jl_f__typevar);
     add_builtin_func("_structtype", jl_f__structtype);
     add_builtin_func("_abstracttype", jl_f__abstracttype);

src/staticdata.c

@@ -522,7 +522,7 @@ static htable_t bits_replace;
 // This is a manually constructed dual of the fvars array, which would be produced by codegen for Julia code, for C.
 static const jl_fptr_args_t id_to_fptrs[] = {
     &jl_f_throw, &jl_f_throw_methoderror, &jl_f_is, &jl_f_typeof, &jl_f_issubtype, &jl_f_isa,
-    &jl_f_typeassert, &jl_f__apply_iterate,
+    &jl_f_typeassert, &jl_f__apply_iterate, &jl_f__predeclare_call,
     &jl_f_invokelatest, &jl_f_invoke_in_world, &jl_f__call_in_world_total, &jl_f_isdefined, &jl_f_isdefinedglobal,
     &jl_f_tuple, &jl_f_svec, &jl_f_intrinsic_call,
     &jl_f_getfield, &jl_f_setfield, &jl_f_swapfield, &jl_f_modifyfield, &jl_f_setfieldonce,