Low-provenance conversion from Expr to SyntaxTree

README.md

@@ -28,8 +28,8 @@ This work is intended to
 
 Note this is a work in progress; many types of syntax are not yet handled.
 
-1. You need a 1.12-DEV build of Julia: At least 1.12.0-DEV.512. Commit `263928f9ad4` is currentl known to work. Note that JuliaLowering relies on Julia internals and may be broken on the latest Julia dev version from time to time. (In fact it is currently broken on the latest `1.12-DEV`.)
-2. Check out the main branch of [JuliaSyntax](https://github.com/JuliaLang/JuliaSyntax.jl)
+1. You need a 1.13.0-DEV build of Julia: At least 1.13.0-DEV.880. Commit `5ebc5b463ea` is currently known to work. Note that JuliaLowering relies on Julia internals and may be broken on the latest Julia dev version from time to time.
+2. Use commit `46723f0` of [JuliaSyntax](https://github.com/JuliaLang/JuliaSyntax.jl)
 3. Get the latest version of [JuliaSyntaxFormatter](https://github.com/c42f/JuliaSyntaxFormatter.jl)
 4. Run the demo `include("test/demo.jl")`
 

src/JuliaLowering.jl

@@ -13,7 +13,7 @@ using JuliaSyntax: highlight, Kind, @KSet_str
 using JuliaSyntax: is_leaf, children, numchildren, head, kind, flags, has_flags, numeric_flags
 using JuliaSyntax: filename, first_byte, last_byte, byte_range, sourcefile, source_location, span, sourcetext
 
-using JuliaSyntax: is_literal, is_number, is_operator, is_prec_assignment, is_prefix_call, is_infix_op_call, is_postfix_op_call, is_error, is_dotted
+using JuliaSyntax: is_literal, is_number, is_operator, is_prec_assignment, is_prefix_call, is_infix_op_call, is_postfix_op_call, is_error
 
 _include("kinds.jl")
 _register_kinds()
@@ -32,6 +32,7 @@ _include("runtime.jl")
 _include("syntax_macros.jl")
 
 _include("eval.jl")
+_include("compat.jl")
 
 function __init__()
     _register_kinds()

src/ast.jl

@@ -498,17 +498,20 @@ end
 # the middle of a pass.
 const CompileHints = Base.ImmutableDict{Symbol,Any}
 
-function setmeta(ex::SyntaxTree; kws...)
+function setmeta!(ex::SyntaxTree; kws...)
     @assert length(kws) == 1 # todo relax later ?
     key = first(keys(kws))
     value = first(values(kws))
     meta = begin
         m = get(ex, :meta, nothing)
         isnothing(m) ? CompileHints(key, value) : CompileHints(m, key, value)
     end
-    setattr(ex; meta=meta)
+    setattr!(ex; meta=meta)
+    ex
 end
 
+setmeta(ex::SyntaxTree; kws...) = setmeta!(copy_node(ex); kws...)
+
 function getmeta(ex::SyntaxTree, name::Symbol, default)
     meta = get(ex, :meta, nothing)
     isnothing(meta) ? default : get(meta, name, default)

src/closure_conversion.jl

@@ -147,6 +147,7 @@ function convert_global_assignment(ctx, ex, var, rhs0)
     end
     push!(stmts, @ast ctx ex [K"=" var rhs])
     @ast ctx ex [K"block"
+        [K"globaldecl" var]
         stmts...
         rhs1
     ]
@@ -337,19 +338,27 @@ function _convert_closures(ctx::ClosureConversionCtx, ex)
         elseif binfo.is_always_defined || is_self_captured(ctx, var)
             # Captured but unboxed vars are always defined
             @ast ctx ex true::K"Bool"
+        elseif binfo.kind == :global
+            # Normal isdefined won't work for globals (#56985)
+            @ast ctx ex [K"call"
+                "isdefinedglobal"::K"core"
+                ctx.mod::K"Value"
+                binfo.name::K"Symbol"
+                false::K"Bool"]
         else
             ex
         end
     elseif k == K"decl"
         @assert kind(ex[1]) == K"BindingId"
         binfo = lookup_binding(ctx, ex[1])
         if binfo.kind == :global
-            @ast ctx ex [K"call"
-                "set_binding_type!"::K"core"
-                binfo.mod::K"Value"
-                binfo.name::K"Symbol"
-                _convert_closures(ctx, ex[2])
-            ]
+            @ast ctx ex [K"block"
+                # flisp has this, but our K"assert" handling is in a previous pass
+                # [K"assert" "toplevel_only"::K"Symbol" [K"inert" ex]]
+                [K"globaldecl"
+                    ex[1]
+                    _convert_closures(ctx, ex[2])]
+                "nothing"::K"core"]
         else
             makeleaf(ctx, ex, K"TOMBSTONE")
         end
@@ -382,6 +391,7 @@ function _convert_closures(ctx::ClosureConversionCtx, ex)
                     type_for_closure(ctx, ex, name_str, field_syms, field_is_box)
                 if !ctx.is_toplevel_seq_point
                     push!(ctx.toplevel_stmts, closure_type_def)
+                    push!(ctx.toplevel_stmts, @ast ctx ex [K"latestworld_if_toplevel"])
                     closure_type_def = nothing
                 end
                 closure_info = ClosureInfo(closure_type_, field_syms, field_inds)
@@ -406,6 +416,7 @@ function _convert_closures(ctx::ClosureConversionCtx, ex)
                 end
                 @ast ctx ex [K"block"
                     closure_type_def
+                    [K"latestworld_if_toplevel"]
                     closure_type := if isempty(type_params)
                         closure_type_
                     else