Emit latestworld world age increments

For method defs, `latestworld` is produced in desugaring rather than closure
conversion for now (our closure conversion doesn't seem to cover the same
cases as lisp lowering yet).

Covers JuliaLang/julia#56523, JuliaLang/julia#56509, JuliaLang/julia#57299.

Also includes changes from JuliaLang/julia#57102 (bpart: Start enforcing minimum
world age for const bparts) and JuliaLang/julia#57150 (bpart: Start enforcing
min_world for global variable definitions) since the lowering changes from those
appear to be amendments to the changes above.

Author: mlechu

src/closure_conversion.jl

@@ -354,7 +354,6 @@ function _convert_closures(ctx::ClosureConversionCtx, ex)
                 K"globaldecl"
                 ex[1]
                 _convert_closures(ctx, ex[2])
-                # TODO (null)?
             ]
         else
             makeleaf(ctx, ex, K"TOMBSTONE")

src/desugaring.jl

@@ -1188,6 +1188,7 @@ function expand_unionall_def(ctx, srcref, lhs, rhs, is_const=true)
             K"block"
             [K"=" rr [K"where" rhs lhs[2:end]...]]
             [is_const ? K"const" : K"assign_const_if_global" name rr]
+            [K"latestworld_if_toplevel"]
             rr
         ]
     )
@@ -1246,7 +1247,7 @@ function expand_assignment(ctx, ex, is_const=false)
                 K"block"
                 sink_assignment(ctx, ex, rr, expand_forms_2(ctx, rhs))
                 [K"const" lhs rr]
-                # todo latestworld
+                [K"latestworld"]
                 [K"removable" rr]
             ]
         else
@@ -1863,6 +1864,17 @@ function expand_call(ctx, ex)
             expand_forms_2(ctx, farg)
             expand_forms_2(ctx, _wrap_unsplatted_args(ctx, ex, args))...
         ]
+    elseif kind(farg) == K"Identifier" && farg.name_val == "include"
+        # world age special case
+        r = ssavar(ctx, ex)
+        @ast ctx ex [K"block"
+            [K"=" r [K"call"
+                expand_forms_2(ctx, farg)
+                expand_forms_2(ctx, args)...
+            ]]
+            [K"latestworld_if_toplevel"]
+            r
+        ]
     else
         @ast ctx ex [K"call"
             expand_forms_2(ctx, farg)
@@ -2332,6 +2344,7 @@ function method_def_expr(ctx, srcref, callex_srcref, method_table,
                 ret_var  # might be `nothing` and hence removed
             ]
         ]
+        [K"latestworld"]
         [K"removable" method_metadata]
     ]
 end
@@ -2464,6 +2477,7 @@ function expand_function_generator(ctx, srcref, callex_srcref, func_name, func_n
             [K"method_defs"
                 gen_name
                 [K"block"
+                    [K"latestworld_if_toplevel"]
                     method_def_expr(ctx, srcref, callex_srcref, nothing, SyntaxList(ctx),
                                     gen_arg_names, gen_arg_types, gen_body, nothing)
                 ]
@@ -3102,6 +3116,7 @@ function expand_function_def(ctx, ex, docs, rewrite_call=identity, rewrite_body=
         end
         gen_func_method_defs
         kw_func_method_defs
+        [K"latestworld_if_toplevel"]
         [K"scope_block"(scope_type=:hard)
             [K"method_defs"
                 isnothing(bare_func_name) ? "nothing"::K"core" : bare_func_name
@@ -3415,6 +3430,7 @@ function expand_abstract_or_primitive_type(ctx, ex)
             nothing_(ctx, ex)
             [K"const" name newtype_var]
         ]
+        [K"latestworld"]
         nothing_(ctx, ex)
     ]
 end
@@ -3965,6 +3981,7 @@ function expand_struct_def(ctx, ex, docs)
                     [K"globalref" struct_name]
                     struct_name
                  ]
+                [K"latestworld"]
                 # Default constructors
                 if isempty(inner_defs)
                     default_inner_constructors(ctx, ex, global_struct_name,

src/eval.jl

@@ -302,6 +302,7 @@ function to_lowered_expr(mod, ex, ssa_offset=0)
                k == K"const"     ? :const      :
                k == K"leave"     ? :leave      :
                k == K"isdefined" ? :isdefined  :
+               k == K"latestworld"       ? :latestworld       :
                k == K"globaldecl"        ? :globaldecl        :
                k == K"pop_exception"     ? :pop_exception     :
                k == K"captured_local"    ? :captured_local    :

src/kinds.jl

@@ -109,6 +109,8 @@ function _register_kinds()
             # A local variable captured into a global method. Contains the
             # `index` of the associated `Box` in the rewrite list.
             "captured_local"
+            # Causes the linearization pass to conditionally emit a world age increment
+            "latestworld_if_toplevel"
         "END_LOWERING_KINDS"
 
         # The following kinds are emitted by lowering and used in Julia's untyped IR
@@ -142,6 +144,8 @@ function _register_kinds()
             "new_opaque_closure"
             # Wrapper for the lambda of around opaque closure methods
             "opaque_closure_method"
+            # World age increment
+            "latestworld"
         "END_IR_KINDS"
     ])
 end

src/linear_ir.jl

@@ -94,6 +94,14 @@ function current_lambda_bindings(ctx::LinearIRContext)
     ctx.lambda_bindings
 end
 
+function at_top_level(ctx)
+    # TODO: How do we determine if we're at the top level here?  Lisp does
+    # this by checking that the current lambda takes no arguments (any
+    # user-defined lambda will take at least one, the closure #self#) That
+    # doesn't seem to work the same here, and even if it does, it's a bit janky.
+    isempty(ctx.lambda_bindings.bindings)
+end
+
 function is_valid_body_ir_argument(ctx, ex)
     if is_valid_ir_argument(ctx, ex)
         true
@@ -651,11 +659,7 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
     elseif k == K"=" || k == K"const"
         if k == K"const"
             check_no_local_bindings(ctx, ex[1], "unsupported `const` declaration on local variable")
-            # if !at_top_level(ctx)
-            #     TODO: How do we determine this?
-            #     Lisp does this by checking that the current lambda takes no arguments
-            #     throw(LoweringError(ex, "`global const` declaration not allowed inside function"))
-            # end
+            # other errors (probably this one too) should be handled in previous passes
         end
         lhs = ex[1]
         if kind(lhs) == K"Placeholder"
@@ -827,11 +831,18 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
         end
     elseif k == K"gc_preserve_begin"
         makenode(ctx, ex, k, compile_args(ctx, children(ex)))
-    elseif k == K"gc_preserve_end" || k == K"global"
+    elseif k == K"gc_preserve_end"
+        if needs_value
+            throw(LoweringError(ex, "misplaced kind $k in value position"))
+        end
+        emit(ctx, ex)
+        nothing
+    elseif  k == K"global"
         if needs_value
             throw(LoweringError(ex, "misplaced kind $k in value position"))
         end
         emit(ctx, ex)
+        at_top_level(ctx) && emit(makenode(ctx, ex, K"latestworld"))
         nothing
     elseif k == K"meta"
         emit(ctx, ex)
@@ -889,6 +900,11 @@ function compile(ctx::LinearIRContext, ex, needs_value, in_tail_pos)
             emit(ctx, @ast ctx ex [K"=" rr ex[2]])
             emit(ctx, @ast ctx ex [K"globaldecl" ex[1] rr])
         end
+        emit(ctx, makenode(ctx, ex, K"latestworld"))
+    elseif k == K"latestworld"
+        emit(ctx, makeleaf(ctx, ex, K"latestworld"))
+    elseif k == K"latestworld_if_toplevel"
+        at_top_level(ctx) && emit(ctx, makeleaf(ctx, ex, K"latestworld"))
     else
         throw(LoweringError(ex, "Invalid syntax; $(repr(k))"))
     end