@eval Core.Module() begin

if Threads.maxthreadid() != 1

@warn "Running this file with multiple Julia threads may lead to a build error" Threads.maxthreadid()

if Base.isempty(Base.ARGS) || Base.ARGS[1] !== "0"

Sys.__init_build()

if !isdefined(Base, :uv_eventloop)

Base.reinit_stdio()

using Base.Meta

const PARALLEL_PRECOMPILATION = true

const debug_output = devnull # or stdout

const fancyprint = (stdout isa Base.TTY) && Base.get_bool_env("CI", false) !== true

CTRL_C = '\x03'

CTRL_R = '\x12'

UP_ARROW = "\e[A"

DOWN_ARROW = "\e[B"

hardcoded_precompile_statements = """

for T in (Float16, Float32, Float64), IO in (IOBuffer, IOContext{IOBuffer}, Base.TTY, IOContext{Base.TTY})

global hardcoded_precompile_statements

hardcoded_precompile_statements *= "precompile(Tuple{typeof(show), $IO, $T})\n"

precompile_script = """

julia_exepath() = joinpath(Sys.BINDIR, Base.julia_exename())

Artifacts = get(Base.loaded_modules,

Base.PkgId(Base.UUID("56f22d72-fd6d-98f1-02f0-08ddc0907c33"), "Artifacts"),

nothing)

if Artifacts !== nothing

precompile_script *= """

FileWatching = get(Base.loaded_modules,

Base.PkgId(Base.UUID("7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee"), "FileWatching"),

nothing)

if FileWatching !== nothing

hardcoded_precompile_statements *= """

Libdl = get(Base.loaded_modules,

Base.PkgId(Base.UUID("8f399da3-3557-5675-b5ff-fb832c97cbdb"), "Libdl"),

nothing)

if Libdl !== nothing

hardcoded_precompile_statements *= """

global print_state

print_lk = ReentrantLock()

status = Dict{String, String}(

"step1" => "W",

"step3" => "W",

"clock" => "◐",

)

function print_status(key::String)

txt = status[key]

if startswith(txt, "W") # Waiting

printstyled("? ", color=Base.warn_color()); print(txt[2:end])

elseif startswith(txt, "R") # Running

print(status["clock"], " ", txt[2:end])

elseif startswith(txt, "F") # Finished

printstyled("✓ ", color=:green); print(txt[2:end])

else

print(txt)

end

end

function print_state(args::Pair{String,String}...)

lock(print_lk) do

isempty(args) || push!(status, args...)

print("\r└ Collect (Basic: ")

print_status("step1")

print(") => Execute ")

print_status("step3")

end

end

ansi_enablecursor = "\e[?25h"

ansi_disablecursor = "\e[?25l"

blackhole = Sys.isunix() ? "/dev/null" : "nul"

procenv = Dict{String,Any}(

"JULIA_HISTORY" => blackhole,

"JULIA_LOAD_PATH" => "@$(Sys.iswindows() ? ";" : ":")@stdlib",

"JULIA_DEPOT_PATH" => Sys.iswindows() ? ";" : ":",

"TERM" => "",

# "JULIA_DEBUG" => "precompilation",

"JULIA_FALLBACK_REPL" => "true")

generate_precompile_statements() = try # Make sure `ansi_enablecursor` is printed

start_time = time_ns()

sysimg = Base.unsafe_string(Base.JLOptions().image_file)

# Extract the precompile statements from the precompile file

statements_step1 = Channel{String}(Inf)

# From hardcoded statements

for statement in split(hardcoded_precompile_statements::String, '\n')

push!(statements_step1, statement)

end

println("Collecting and executing precompile statements")

fancyprint && print(ansi_disablecursor)

print_state()

clock = @async begin

t = Timer(0; interval=1/10)

anim_chars = ["◐","◓","◑","◒"]

current = 1

if fancyprint

while isopen(statements_step1) || !isempty(statements_step1)

print_state("clock" => anim_chars[current])

wait(t)

current = current == 4 ? 1 : current + 1

end

end

close(t)

end

# Collect statements from running the script

step1 = @async mktempdir() do prec_path

print_state("step1" => "R")

# Also precompile a package here

pkgname = "__PackagePrecompilationStatementModule"

pkguuid = "824efdaf-a0e9-431c-8ee7-3d356b2531c2"

pkgpath = joinpath(prec_path, pkgname)

mkpath(joinpath(pkgpath, "src"))

write(joinpath(pkgpath, "src", "$pkgname.jl"),

"""

""")

write(joinpath(pkgpath, "Project.toml"),

"""

""")

touch(joinpath(pkgpath, "Manifest.toml"))

tmp_prec = tempname(prec_path)

tmp_proc = tempname(prec_path)

s = """

p = run(pipeline(addenv(`$(julia_exepath()) -O0 --trace-compile=$tmp_proc --sysimage $sysimg

--cpu-target=native --startup-file=no --color=yes --project=$(pkgpath)`, procenv),

stdin=IOBuffer(s), stderr=debug_output, stdout=debug_output))

n_step1 = 0

for f in (tmp_prec, tmp_proc)

isfile(f) || continue

for statement in split(read(f, String), '\n')

push!(statements_step1, statement)

n_step1 += 1

end

end

close(statements_step1)

print_state("step1" => "F$n_step1")

return :ok

end

PARALLEL_PRECOMPILATION ? bind(statements_step1, step1) : wait(step1)

# Create a staging area where all the loaded packages are available

PrecompileStagingArea = Module()

for (_pkgid, _mod) in Base.loaded_modules

if !(_pkgid.name in ("Main", "Core", "Base"))

eval(PrecompileStagingArea, :(const $(Symbol(_mod)) = $_mod))

end

end

n_succeeded = 0

# Make statements unique

statements = Set{String}()

# Execute the precompile statements

for statement in statements_step1

# Main should be completely clean

occursin("Main.", statement) && continue

Base.in!(statement, statements) && continue

# println(statement)

try

ps = Meta.parse(statement)

if !isexpr(ps, :call)

# these are typically comments

@debug "skipping statement because it does not parse as an expression" statement

delete!(statements, statement)

continue

end

popfirst!(ps.args) # precompile(...)

ps.head = :tuple

# println(ps)

ps = Core.eval(PrecompileStagingArea, ps)

if precompile(ps...)

n_succeeded += 1

else

@warn "Failed to precompile expression" form=statement _module=nothing _file=nothing _line=0

end

failed = length(statements) - n_succeeded

yield() # Make clock spinning

print_state("step3" => string("R$n_succeeded", failed > 0 ? " ($failed failed)" : ""))

catch ex

# See #28808

@warn "Failed to precompile expression" form=statement exception=(ex,catch_backtrace()) _module=nothing _file=nothing _line=0

end

end

wait(clock) # Stop asynchronous printing

failed = length(statements) - n_succeeded

print_state("step3" => string("F$n_succeeded", failed > 0 ? " ($failed failed)" : ""))

println()

# Seems like a reasonable number right now, adjust as needed

# comment out if debugging script

have_repl = false

n_succeeded > (have_repl ? 650 : 90) || @warn "Only $n_succeeded precompile statements"

fetch(step1) == :ok || throw("Step 1 of collecting precompiles failed.")

tot_time = time_ns() - start_time

println("Precompilation complete. Summary:")

print("Total ─────── "); Base.time_print(stdout, tot_time); println()

fancyprint && print(ansi_enablecursor)

GC.gc(true); GC.gc(false); # reduce memory footprint

generate_precompile_statements()

let stdout = Ref{IO}(stdout)

Base.PROGRAM_FILE = ""

Sys.BINDIR = ""

Sys.STDLIB = ""

empty!(Base.ARGS)

empty!(Core.ARGS)

empty!(Base.TOML_CACHE.d)

Base.TOML.reinit!(Base.TOML_CACHE.p, "")

println("Outputting sysimage file...")

Base.stdout = Core.stdout

Base.stderr = Core.stderr

# Print report after sysimage has been saved so all time spent can be captured

pre_output_time = time_ns()

Base.postoutput() do

output_time = time_ns() - pre_output_time

let stdout = stdout[]

print(stdout, "Output ────── "); Base.time_print(stdout, output_time); println(stdout)

end

stdout[] = Core.stdout

end

end # if

end # @eval