add back depwarn option if invokelatest succeeded

Also remove `isdefined` shim, as that feels less logical to me with the
current implementation that uses invokelatest. If the implementation was
changed to use `invokenext`, I think it would make sense to add that back
and also to update `names` to return these also. But invoke next
(similar to backdated constants and #59735) prints an incorrect
suggestion of using invokelatest to get the same behavior. That message
is correct with this current commit state, but wrong relative to the
current implementations that use backdated.

Author: vtjnash

src/julia.h

@@ -792,7 +792,8 @@ enum jl_binding_flags {
     BINDING_FLAG_PUBLICP                              = 0x2,
     // Set if any methods defined in this module implicitly reference
     // this binding. If not, invalidation is optimized.
-    BINDING_FLAG_ANY_IMPLICIT_EDGES                   = 0x4
+    BINDING_FLAG_ANY_IMPLICIT_EDGES                   = 0x4,
+    BINDING_FLAG_DID_PRINT_INVOKELATEST_ADMONITION    = 0x8
 };
 
 typedef struct _jl_binding_t {

src/module.c

@@ -822,6 +822,22 @@ JL_DLLEXPORT jl_module_t *jl_get_module_of_binding(jl_module_t *m, jl_sym_t *var
     return b ? b->globalref->mod : m;
 }
 
+static NOINLINE void print_backdate_admonition(jl_binding_t *b) JL_NOTSAFEPOINT
+{
+    jl_safe_printf(
+        "WARNING: Detected access to binding `%s.%s` in a world prior to its definition world.\n"
+        "  Julia 1.12 has introduced more strict world age semantics for global bindings.\n"
+        "  !!! This code will error in future versions of Julia.\n"
+        "Hint: Add an appropriate `invokelatest` around the access to this binding.\n"
+        "To make this warning an error, and hence obtain a stack trace, use `julia --depwarn=error`.\n",
+        jl_symbol_name(b->globalref->mod->name), jl_symbol_name(b->globalref->name));
+}
+
+static inline void check_backdated_binding(jl_binding_t *b, enum jl_partition_kind kind) JL_NOTSAFEPOINT
+{
+    if (!(jl_atomic_fetch_or_relaxed(&b->flags, BINDING_FLAG_DID_PRINT_INVOKELATEST_ADMONITION) & BINDING_FLAG_DID_PRINT_INVOKELATEST_ADMONITION))
+        print_backdate_admonition(b);
+}
 
 JL_DLLEXPORT jl_value_t *jl_get_binding_value(jl_binding_t *b)
 {
@@ -833,18 +849,20 @@ JL_DLLEXPORT jl_value_t *jl_get_binding_value_in_world(jl_binding_t *b, size_t w
     jl_binding_partition_t *bpart = jl_get_binding_partition(b, world);
     jl_walk_binding_inplace(&b, &bpart, world);
     enum jl_partition_kind kind = jl_binding_kind(bpart);
-    if (kind == PARTITION_KIND_GUARD) {
-        // Retry lookup in current world counter for guard partitions (unless in pure callback)
-        if (!jl_current_task->ptls->in_pure_callback) {
+    if (jl_bkind_is_some_guard(kind)) {
+        // Retry lookup in current world counter for guard partitions (unless in pure callback or with deprecations disabled)
+        if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR && !jl_current_task->ptls->in_pure_callback) {
             size_t current_world = jl_atomic_load_acquire(&jl_world_counter);
-            if (current_world != world) {
-                return jl_get_binding_value_in_world(b, current_world);
+            if (current_world != world) { {
+                jl_value_t *futurevalue = jl_get_binding_value_in_world(b, current_world);
+                if (futurevalue)
+                    check_backdated_binding(b, kind);
+                return futurevalue;
+            }
             }
         }
         return NULL;
     }
-    if (jl_bkind_is_some_guard(kind))
-        return NULL;
     if (jl_bkind_is_some_constant(kind)) {
         return bpart->restriction;
     }
@@ -865,18 +883,19 @@ static jl_value_t *jl_get_binding_value_depwarn(jl_binding_t *b, size_t world)
         jl_walk_binding_inplace(&b, &bpart, world);
     }
     enum jl_partition_kind kind = jl_binding_kind(bpart);
-    if (kind == PARTITION_KIND_GUARD) {
-        // Retry lookup in current world counter for guard partitions (unless in pure callback)
-        if (!jl_current_task->ptls->in_pure_callback) {
+    if (jl_bkind_is_some_guard(kind)) {
+        // Retry lookup in current world counter for guard partitions (unless in pure callback or with deprecations disabled)
+        if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR && !jl_current_task->ptls->in_pure_callback) {
             size_t current_world = jl_atomic_load_acquire(&jl_world_counter);
             if (current_world != world) {
-                return jl_get_binding_value_depwarn(b, current_world);
+                jl_value_t *futurevalue = jl_get_binding_value_depwarn(b, current_world);
+                if (futurevalue)
+                    check_backdated_binding(b, kind);
+                return futurevalue;
             }
         }
         return NULL;
     }
-    if (jl_bkind_is_some_guard(kind))
-        return NULL;
     if (jl_bkind_is_some_constant(kind)) {
         return bpart->restriction;
     }
@@ -890,18 +909,19 @@ JL_DLLEXPORT jl_value_t *jl_get_binding_value_seqcst(jl_binding_t *b)
     jl_binding_partition_t *bpart = jl_get_binding_partition(b, world);
     jl_walk_binding_inplace(&b, &bpart, world);
     enum jl_partition_kind kind = jl_binding_kind(bpart);
-    if (kind == PARTITION_KIND_GUARD) {
-        // Retry lookup in current world counter for guard partitions (unless in pure callback)
-        if (!jl_current_task->ptls->in_pure_callback) {
+    if (jl_bkind_is_some_guard(kind)) {
+        // Retry lookup in current world counter for guard partitions (unless in pure callback or with deprecations disabled)
+        if (jl_options.depwarn != JL_OPTIONS_DEPWARN_ERROR && !jl_current_task->ptls->in_pure_callback) {
             size_t current_world = jl_atomic_load_acquire(&jl_world_counter);
             if (current_world != world) {
-                return jl_get_binding_value_in_world(b, current_world);
+                jl_value_t *futurevalue = jl_get_binding_value_in_world(b, current_world);
+                if (futurevalue)
+                    check_backdated_binding(b, kind);
+                return futurevalue;
             }
         }
         return NULL;
     }
-    if (jl_bkind_is_some_guard(kind))
-        return NULL;
     if (jl_bkind_is_some_constant(kind)) {
         return bpart->restriction;
     }
@@ -1438,31 +1458,7 @@ JL_DLLEXPORT int jl_boundp(jl_module_t *m, jl_sym_t *var, int allow_import) // u
         jl_walk_binding_inplace(&b, &bpart, jl_current_task->world_age);
     }
     enum jl_partition_kind kind = jl_binding_kind(bpart);
-    if (kind == PARTITION_KIND_GUARD) {
-        // Retry lookup in current world counter for guard partitions (unless in pure callback)
-        if (!jl_current_task->ptls->in_pure_callback) {
-            size_t current_world = jl_atomic_load_acquire(&jl_world_counter);
-            if (current_world != jl_current_task->world_age) {
-                jl_binding_partition_t *current_bpart = jl_get_binding_partition(b, current_world);
-                if (!current_bpart)
-                    return 0;
-                if (!allow_import) {
-                    if (!current_bpart || jl_bkind_is_some_import(jl_binding_kind(current_bpart)))
-                        return 0;
-                } else {
-                    jl_walk_binding_inplace(&b, &current_bpart, current_world);
-                }
-                enum jl_partition_kind current_kind = jl_binding_kind(current_bpart);
-                if (jl_bkind_is_some_guard(current_kind))
-                    return 0;
-                if (jl_bkind_is_defined_constant(current_kind)) {
-                    return 1;
-                }
-                return jl_atomic_load(&b->value) != NULL;
-            }
-        }
-        return 0;
-    }
+    // isdefined queries only check in the current world, and do not retry with invokelatest
     if (jl_bkind_is_some_guard(kind))
         return 0;
     if (jl_bkind_is_defined_constant(kind)) {

test/rebinding.jl

@@ -111,42 +111,70 @@ module Rebinding
     # Test world counter retry for newly defined bindings
     @testset "invokelatest for guard bindings" begin
         test_func_1 = (x) -> (@eval const new_binding_1 = $x; @isdefined(new_binding_1))
-        @test Base.invokelatest(test_func_1, 1)
+        @test !Base.invokelatest(test_func_1, 1)
         @test Base.invokelatest(test_func_1, 2)
         Base.delete_binding(Rebinding, :new_binding_1)
-        @test Base.invokelatest(test_func_1, 3)
+        @test !Base.invokelatest(test_func_1, 3)
 
         test_func_2 = (x) -> (@eval const new_binding_2 = $x; new_binding_2)
-        @test Base.invokelatest(test_func_2, 3) === 3
+        if Base.JLOptions().depwarn <= 1
+            @test 3 === @test_warn "Detected access to binding `Rebinding.new_binding_2`" Base.invokelatest(test_func_2, 3)
+        else
+            @test_throws UndefVarError Base.invokelatest(test_func_2, 3)
+        end
         @test Base.invokelatest(test_func_2, 4) === 3
         @test Base.invokelatest(test_func_2, 5) === 4
         Base.delete_binding(Rebinding, :new_binding_2)
-        @test Base.invokelatest(test_func_2, 6) === 6
+        if Base.JLOptions().depwarn <= 1
+            @test 6 === @test_warn "Detected access to binding `Rebinding.new_binding_2`" Base.invokelatest(test_func_2, 6)
+        else
+            @test_throws UndefVarError Base.invokelatest(test_func_2, 6)
+        end
 
         test_func_3 = (x) -> (@eval new_binding_3 = $x; @isdefined(new_binding_3))
-        @test Base.invokelatest(test_func_3, 5)
+        @test !Base.invokelatest(test_func_3, 5)
         @test Base.invokelatest(test_func_3, 6)
         Base.delete_binding(Rebinding, :new_binding_3)
-        @test Base.invokelatest(test_func_3, 7)
+        @test !Base.invokelatest(test_func_3, 7)
 
         test_func_4 = (x) -> (@eval new_binding_4 = $x; new_binding_4)
-        @test Base.invokelatest(test_func_4, 7) === 7
+        if Base.JLOptions().depwarn <= 1
+            @test 7 === @test_warn "Detected access to binding `Rebinding.new_binding_4`" Base.invokelatest(test_func_4, 7)
+        else
+            @test_throws UndefVarError Base.invokelatest(test_func_4, 7)
+        end
         @test Base.invokelatest(test_func_4, 8) === 8
         @test Base.invokelatest(test_func_4, 9) === 9
         Base.delete_binding(Rebinding, :new_binding_4)
-        @test Base.invokelatest(test_func_4, 10) === 10
+        if Base.JLOptions().depwarn <= 1
+            @test 10 === @test_warn "Detected access to binding `Rebinding.new_binding_4`" Base.invokelatest(test_func_4, 10)
+        else
+            @test_throws UndefVarError Base.invokelatest(test_func_4, 10)
+        end
 
         test_func_5 = (x) -> (@eval using Base: $x as new_import_1; @isdefined(new_import_1))
-        @test Base.invokelatest(test_func_5, :sin)
+        @test !Base.invokelatest(test_func_5, :sin)
         Base.delete_binding(Rebinding, :new_import_1)
-        @test Base.invokelatest(test_func_5, :cos)
+        @test !Base.invokelatest(test_func_5, :cos)
 
         test_func_6 = (x) -> (@eval using Base: $x as new_import_2; new_import_2)
-        @test Base.invokelatest(test_func_6, :sin) === Base.sin
+        if Base.JLOptions().depwarn <= 1
+            @test Base.sin === @test_warn "Detected access to binding `Rebinding.new_import_2`" Base.invokelatest(test_func_6, :sin)
+        else
+            @test_throws UndefVarError Base.invokelatest(test_func_6, :sin)
+        end
         Base.delete_binding(Rebinding, :new_import_2)
-        @test Base.invokelatest(test_func_6, :cos) === Base.cos
+        if Base.JLOptions().depwarn <= 1
+            @test Base.cos === @test_warn "Detected access to binding `Rebinding.new_import_2`" Base.invokelatest(test_func_6, :cos)
+        else
+            @test_throws UndefVarError Base.invokelatest(test_func_6, :cos)
+        end
         Base.delete_binding(Rebinding, :new_import_2)
-        @test Base.invokelatest(test_func_6, :tan) === Base.tan
+        if Base.JLOptions().depwarn <= 1
+            @test Base.tan === @test_warn "Detected access to binding `Rebinding.new_import_2`" Base.invokelatest(test_func_6, :tan)
+        else
+            @test_throws UndefVarError Base.invokelatest(test_func_6, :tan)
+        end
 
         @generated function test_generated_future(x)
             return future_generated_binding

test/worlds.jl

@@ -557,9 +557,8 @@ struct FooBackdated
 
     FooBackdated() = new(FooBackdated[])
 end
-# With world counter retry, `isdefinedglobal` will retry with current world counter
-# and successfully find the binding regardless of depwarn setting.
-@test Base.invoke_in_world(before_backdate_age, isdefinedglobal, @__MODULE__, :FooBackdated)
+@test isdefinedglobal(@__MODULE__, :FooBackdated)
+@test !Base.invoke_in_world(before_backdate_age, isdefinedglobal, @__MODULE__, :FooBackdated)
 
 # Test that ambiguous binding intersect the using'd binding's world ranges
 module AmbigWorldTest