Utilities for compiling a JuliaSyntax sysimage

Author: c42f

README.md

@@ -103,6 +103,22 @@ julia> parseall(Expr, "(x + y)*z")
 :($(Expr(:toplevel, :((x + y) * z))))
 ```
 
+# Using JuliaSyntax as the default parser
+
+To use JuliaSyntax as the default Julia parser to `include()` files,
+parse code with `Meta.parse()`, etc, call
+
+```
+julia> JuliaSyntax.enable_in_core!()
+```
+
+This causes some startup latency, so to reduce that you can create a custom
+system image by running the code in `./sysimage/compile.jl` as a Julia script
+(or directly using the shell, on unix). Then use `julia -J $resulting_sysimage`.
+
+Using a custom sysimage has the advantage that package precompilation will also
+go through the JuliaSyntax parser.
+
 # Parser implementation
 
 Our goal is to losslessly represent the source text with a tree; this may be

src/hooks.jl

@@ -67,12 +67,8 @@ flisp parser for all parsing work.
 That is, JuliaSyntax will be used for `include()` `Meta.parse()`, the REPL, etc.
 """
 function enable_in_core!(enable=true)
-    if enable
-        # TODO: Use invoke_in_world to freeze the world age at the time this was enabled.
-        Base.eval(Core, :(_parse = $core_parser_hook))
-    else
-        Base.eval(Core, :(_parse = Core.Compiler.fl_parse))
-    end
+    parser = enable ? core_parser_hook : Core.Compiler.fl_parse
+    Base.eval(Core, :(_parse = $parser))
     nothing
 end
 

sysimage/JuliaSyntaxCore/Project.toml

@@ -0,0 +1,10 @@
+name = "JuliaSyntaxCore"
+uuid = "05e5f68f-ccd0-4d84-a81a-f557a333a331"
+authors = ["Chris Foster <[email protected]> and contributors"]
+version = "0.1.0"
+
+[compat]
+julia = "1.6"
+
+[deps]
+JuliaSyntax = "70703baa-626e-46a2-a12c-08ffd08c73b4"

sysimage/JuliaSyntaxCore/src/JuliaSyntaxCore.jl

@@ -0,0 +1,26 @@
+module JuliaSyntaxCore
+
+# A tiny module to hold initialization code for JuliaSyntax.jl integration with
+# the runtime.
+
+using JuliaSyntax
+
+import Base: JLOptions
+
+function __init__()
+    # HACK! Fool the runtime into allowing us to set Core._parse, even during
+    # incremental compilation. (Ideally we'd just arrange for Core._parse to be
+    # set to the JuliaSyntax parser. But how do we signal that to the dumping
+    # code outside of the initial creation of Core?)
+    i = findfirst(==(:incremental), fieldnames(JLOptions))
+    ptr = convert(Ptr{fieldtype(JLOptions, i)},
+                  cglobal(:jl_options, JLOptions) + fieldoffset(JLOptions, i))
+    incremental = unsafe_load(ptr)
+    incremental == 0 || unsafe_store!(ptr, 0)
+
+    JuliaSyntax.enable_in_core!()
+
+    incremental == 0 || unsafe_store!(ptr, incremental)
+end
+
+end

sysimage/compile.jl

@@ -0,0 +1,34 @@
+#!/bin/bash
+#=
+[[ $1 == +* ]] && juliaup_arg=$1 && shift # release channel for juliaup
+exec julia ${juliaup_arg} --startup-file=no -e 'include(popfirst!(ARGS))' "$0" "$@"
+=#
+
+imgs_base_path = joinpath(first(DEPOT_PATH), "sysimages", "v$VERSION")
+mkpath(imgs_base_path)
+
+using Libdl
+
+cd(@__DIR__)
+
+using Pkg
+Pkg.activate(".")
+Pkg.develop("JuliaSyntax")
+Pkg.develop(path="./JuliaSyntaxCore")
+
+image_path = joinpath(imgs_base_path, "juliasyntax_sysimage."*Libdl.dlext)
+
+using PackageCompiler
+PackageCompiler.create_sysimage(
+    ["JuliaSyntaxCore"],
+    project=".",
+    sysimage_path=image_path,
+    precompile_execution_file="precompile_exec.jl",
+    incremental=true,
+)
+
+@info """## System image compiled!
+
+      Use it with `julia -J "$image_path"`
+      """
+

sysimage/precompile_exec.jl

@@ -0,0 +1,5 @@
+import JuliaSyntax
+Base.include(@__MODULE__(), joinpath(pkgdir(JuliaSyntax), "test", "test_utils.jl"))
+Base.include(@__MODULE__(), joinpath(pkgdir(JuliaSyntax), "test", "parser.jl"))
+JuliaSyntax.enable_in_core!()
+@info "Some parsing" Meta.parse("x+y+z-w .+ [a b c]")