remove jl_function_t typealias (#59216)

This has been an alias for a long time now, remove it since it is just
confusing/misleading to be different from jl_value_t.

Author: vtjnash

doc/src/devdocs/ast.md

@@ -658,10 +658,10 @@ for important details on how to modify these fields safely.
     The ABI to use when calling `fptr`. Some significant ones include:
 
       * 0 - Not compiled yet
-      * 1 - `JL_CALLABLE` `jl_value_t *(*)(jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)`
+      * 1 - `JL_CALLABLE` `jl_value_t *(*)(jl_value_t *f, jl_value_t *args[nargs], uint32_t nargs)`
       * 2 - Constant (value stored in `rettype_const`)
-      * 3 - With Static-parameters forwarded `jl_value_t *(*)(jl_svec_t *sparams, jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)`
-      * 4 - Run in interpreter `jl_value_t *(*)(jl_method_instance_t *meth, jl_function_t *f, jl_value_t *args[nargs], uint32_t nargs)`
+      * 3 - With Static-parameters forwarded `jl_value_t *(*)(jl_svec_t *sparams, jl_value_t *f, jl_value_t *args[nargs], uint32_t nargs)`
+      * 4 - Run in interpreter `jl_value_t *(*)(jl_method_instance_t *meth, jl_value_t *f, jl_value_t *args[nargs], uint32_t nargs)`
 
   * `min_world` / `max_world`
 

doc/src/devdocs/debuggingtips.md

@@ -177,7 +177,7 @@ $2 = void
 
 The most recent `jl_apply` is at frame #3, so we can go back there and look at the AST for the
 function `julia_convert_16886`. This is the uniqued name for some method of `convert`. `f` in
-this frame is a `jl_function_t*`, so we can look at the type signature, if any, from the `specTypes`
+this frame is a `jl_value_t*`, so we can look at the type signature, if any, from the `specTypes`
 field:
 
 ```

doc/src/devdocs/functions.md

@@ -38,7 +38,7 @@ This entry point for the same functionality accepts the function separately, so
 does not contain the function:
 
 ```c
-jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs);
+jl_value_t *jl_call(jl_value_t *f, jl_value_t **args, int32_t nargs);
 ```
 
 ## Adding methods

doc/src/devdocs/object.md

@@ -155,7 +155,7 @@ jl_sym_t *jl_symbol(const char *str);
 Functions and MethodInstance:
 
 ```c
-jl_function_t *jl_new_generic_function(jl_sym_t *name);
+jl_value_t *jl_new_generic_function(jl_sym_t *name);
 jl_method_instance_t *jl_new_method_instance(jl_value_t *ast, jl_tuple_t *sparams);
 ```
 

doc/src/manual/embedding.md

@@ -228,7 +228,7 @@ passing arguments computed in C to Julia. For this you will need to invoke Julia
 using `jl_call`:
 
 ```c
-jl_function_t *func = jl_get_function(jl_base_module, "sqrt");
+jl_value_t *func = jl_get_function(jl_base_module, "sqrt");
 jl_value_t *argument = jl_box_float64(2.0);
 jl_value_t *ret = jl_call1(func, argument);
 ```
@@ -240,7 +240,7 @@ the function is called using `jl_call1`. `jl_call0`, `jl_call2`, and `jl_call3`
 exist, to conveniently handle different numbers of arguments. To pass more arguments, use `jl_call`:
 
 ```
-jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, int32_t nargs)
+jl_value_t *jl_call(jl_value_t *f, jl_value_t **args, int32_t nargs)
 ```
 
 Its second argument `args` is an array of `jl_value_t*` arguments and `nargs` is the number of
@@ -319,7 +319,7 @@ jl_value_t *ret1 = jl_eval_string("sqrt(2.0)");
 JL_GC_PUSH1(&ret1);
 jl_value_t *ret2 = 0;
 {
-    jl_function_t *func = jl_get_function(jl_base_module, "exp");
+    jl_value_t *func = jl_get_function(jl_base_module, "exp");
     ret2 = jl_call1(func, ret1);
     JL_GC_PUSH1(&ret2);
     // Do something with ret2.
@@ -350,7 +350,7 @@ properly with mutable types.
 ```c
 // This functions shall be executed only once, during the initialization.
 jl_value_t* refs = jl_eval_string("refs = IdDict()");
-jl_function_t* setindex = jl_get_function(jl_base_module, "setindex!");
+jl_value_t* setindex = jl_get_function(jl_base_module, "setindex!");
 
 ...
 
@@ -374,7 +374,7 @@ container is created by `jl_call*`, then you will need to reload the pointer to
 ```c
 // This functions shall be executed only once, during the initialization.
 jl_value_t* refs = jl_eval_string("refs = IdDict()");
-jl_function_t* setindex = jl_get_function(jl_base_module, "setindex!");
+jl_value_t* setindex = jl_get_function(jl_base_module, "setindex!");
 jl_datatype_t* reft = (jl_datatype_t*)jl_eval_string("Base.RefValue{Any}");
 
 ...
@@ -401,7 +401,7 @@ The GC can be allowed to deallocate a variable by removing the reference to it f
 the function `delete!`, provided that no other reference to the variable is kept anywhere:
 
 ```c
-jl_function_t* delete = jl_get_function(jl_base_module, "delete!");
+jl_value_t* delete = jl_get_function(jl_base_module, "delete!");
 jl_call2(delete, refs, rvar);
 ```
 
@@ -505,7 +505,7 @@ for (size_t i = 0; i < jl_array_nrows(x); i++)
 Now let us call a Julia function that performs an in-place operation on `x`:
 
 ```c
-jl_function_t *func = jl_get_function(jl_base_module, "reverse!");
+jl_value_t *func = jl_get_function(jl_base_module, "reverse!");
 jl_call1(func, (jl_value_t*)x);
 ```
 
@@ -517,7 +517,7 @@ If a Julia function returns an array, the return value of `jl_eval_string` and `
 cast to a `jl_array_t*`:
 
 ```c
-jl_function_t *func  = jl_get_function(jl_base_module, "reverse");
+jl_value_t *func  = jl_get_function(jl_base_module, "reverse");
 jl_array_t *y = (jl_array_t*)jl_call1(func, (jl_value_t*)x);
 ```
 
@@ -664,7 +664,7 @@ double c_func(int i)
     printf("[C %08x] i = %d\n", pthread_self(), i);
 
     // Call the Julia sqrt() function to compute the square root of i, and return it
-    jl_function_t *sqrt = jl_get_function(jl_base_module, "sqrt");
+    jl_value_t *sqrt = jl_get_function(jl_base_module, "sqrt");
     jl_value_t* arg = jl_box_int32(i);
     double ret = jl_unbox_float64(jl_call1(sqrt, arg));
 

src/builtins.c

@@ -663,8 +663,8 @@ static jl_value_t *jl_arrayref(jl_array_t *a, size_t i)
 JL_CALLABLE(jl_f__apply_iterate)
 {
     JL_NARGSV(_apply_iterate, 2);
-    jl_function_t *iterate = args[0];
-    jl_function_t *f = args[1];
+    jl_value_t *iterate = args[0];
+    jl_value_t *f = args[1];
     assert(iterate);
     args += 1;
     nargs -= 1;

src/gc-common.c

@@ -460,7 +460,7 @@ JL_DLLEXPORT void jl_gc_add_quiescent(jl_ptls_t ptls, void **v, void *f) JL_NOTS
     jl_gc_add_finalizer_(ptls, (void*)(((uintptr_t)v) | 3), f);
 }
 
-JL_DLLEXPORT void jl_gc_add_finalizer_th(jl_ptls_t ptls, jl_value_t *v, jl_function_t *f) JL_NOTSAFEPOINT
+JL_DLLEXPORT void jl_gc_add_finalizer_th(jl_ptls_t ptls, jl_value_t *v, jl_value_t *f) JL_NOTSAFEPOINT
 {
     if (__unlikely(jl_typetagis(f, jl_voidpointer_type))) {
         jl_gc_add_ptr_finalizer(ptls, v, jl_unbox_voidpointer(f));
@@ -470,7 +470,7 @@ JL_DLLEXPORT void jl_gc_add_finalizer_th(jl_ptls_t ptls, jl_value_t *v, jl_funct
     }
 }
 
-JL_DLLEXPORT void jl_gc_add_finalizer(jl_value_t *v, jl_function_t *f)
+JL_DLLEXPORT void jl_gc_add_finalizer(jl_value_t *v, jl_value_t *f)
 {
     jl_ptls_t ptls = jl_current_task->ptls;
     jl_gc_add_finalizer_th(ptls, v, f);

src/gc-common.h

@@ -195,7 +195,7 @@ extern arraylist_t to_finalize;
 void schedule_finalization(void *o, void *f) JL_NOTSAFEPOINT;
 void run_finalizer(jl_task_t *ct, void *o, void *ff);
 void run_finalizers(jl_task_t *ct, int finalizers_thread);
-JL_DLLEXPORT void jl_gc_add_finalizer_th(jl_ptls_t ptls, jl_value_t *v, jl_function_t *f) JL_NOTSAFEPOINT;
+JL_DLLEXPORT void jl_gc_add_finalizer_th(jl_ptls_t ptls, jl_value_t *v, jl_value_t *f) JL_NOTSAFEPOINT;
 JL_DLLEXPORT void jl_finalize_th(jl_task_t *ct, jl_value_t *o);
 
 

src/gf.c

@@ -939,12 +939,12 @@ int jl_foreach_reachable_mtable(int (*visit)(jl_methtable_t *mt, void *env), jl_
     return 1;
 }
 
-jl_function_t *jl_typeinf_func JL_GLOBALLY_ROOTED = NULL;
+jl_value_t *jl_typeinf_func JL_GLOBALLY_ROOTED = NULL;
 JL_DLLEXPORT size_t jl_typeinf_world = 1;
 
 JL_DLLEXPORT void jl_set_typeinf_func(jl_value_t *f)
 {
-    jl_typeinf_func = (jl_function_t*)f;
+    jl_typeinf_func = (jl_value_t*)f;
     jl_typeinf_world = jl_get_tls_world_age();
 }
 
@@ -4342,7 +4342,7 @@ jl_sym_t *jl_gf_supertype_name(jl_sym_t *name)
 }
 
 // Return value is rooted globally
-jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_t *module, jl_datatype_t *st, size_t new_world)
+jl_value_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_t *module, jl_datatype_t *st, size_t new_world)
 {
     // type name is function name prefixed with #
     jl_sym_t *tname = jl_gf_supertype_name(name);
@@ -4358,10 +4358,10 @@ jl_function_t *jl_new_generic_function_with_supertype(jl_sym_t *name, jl_module_
     ftype->instance = f;
     jl_gc_wb(ftype, f);
     JL_GC_POP();
-    return (jl_function_t*)f;
+    return (jl_value_t*)f;
 }
 
-jl_function_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module, size_t new_world)
+jl_value_t *jl_new_generic_function(jl_sym_t *name, jl_module_t *module, size_t new_world)
 {
     return jl_new_generic_function_with_supertype(name, module, jl_function_type, new_world);
 }

src/jitlayers.h

@@ -317,7 +317,7 @@ enum CompilationPolicy {
     Extern = 1,
 };
 
-Function *jl_cfunction_object(jl_function_t *f, jl_value_t *rt, jl_tupletype_t *argt,
+Function *jl_cfunction_object(jl_value_t *f, jl_value_t *rt, jl_tupletype_t *argt,
     jl_codegen_params_t &params);
 
 extern "C" JL_DLLEXPORT_CODEGEN