#37527

pending completion

Build # #37527

Build Type

push

local

Committed by

web-flow

Commit Message

make `IRShow.method_name` inferrable (#49607)

Run Details

18 of 18 new or added lines in 3 files covered. (100.0%)

68710 of 81829 relevant lines covered (83.97%)

33068903.12 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

62.1

/base/Base.jl

# This file is a part of Julia. License is MIT: https://julialang.org/license

baremodule Base

using Core.Intrinsics, Core.IR

# to start, we're going to use a very simple definition of `include`
# that doesn't require any function (except what we can get from the `Core` top-module)
const _included_files = Array{Tuple{Module,String},1}()
function include(mod::Module, path::String)
    ccall(:jl_array_grow_end, Cvoid, (Any, UInt), _included_files, UInt(1))
    Core.arrayset(true, _included_files, (mod, ccall(:jl_prepend_cwd, Any, (Any,), path)), arraylen(_included_files))
    Core.println(path)
    ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))
    Core.include(mod, path)
end
include(path::String) = include(Base, path)

# from now on, this is now a top-module for resolving syntax
const is_primary_base_module = ccall(:jl_module_parent, Ref{Module}, (Any,), Base) === Core.Main
ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Base, is_primary_base_module)

# The @inline/@noinline macros that can be applied to a function declaration are not available
# until after array.jl, and so we will mark them within a function body instead.
macro inline()   Expr(:meta, :inline)   end
macro noinline() Expr(:meta, :noinline) end

# Try to help prevent users from shooting them-selves in the foot
# with ambiguities by defining a few common and critical operations
# (and these don't need the extra convert code)
getproperty(x::Module, f::Symbol) = (@inline; getglobal(x, f))
getproperty(x::Type, f::Symbol) = (@inline; getfield(x, f))
setproperty!(x::Type, f::Symbol, v) = error("setfield! fields of Types should not be changed")
getproperty(x::Tuple, f::Int) = (@inline; getfield(x, f))
setproperty!(x::Tuple, f::Int, v) = setfield!(x, f, v) # to get a decent error

getproperty(x, f::Symbol) = (@inline; getfield(x, f))
function setproperty!(x, f::Symbol, v)
    ty = fieldtype(typeof(x), f)
    val = v isa ty ? v : convert(ty, v)
    return setfield!(x, f, val)
end

dotgetproperty(x, f) = getproperty(x, f)

getproperty(x::Module, f::Symbol, order::Symbol) = (@inline; getglobal(x, f, order))
function setproperty!(x::Module, f::Symbol, v, order::Symbol=:monotonic)
    @inline
    ty = Core.get_binding_type(x, f)
    val = v isa ty ? v : convert(ty, v)
    return setglobal!(x, f, val, order)
end
getproperty(x::Type, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))
setproperty!(x::Type, f::Symbol, v, order::Symbol) = error("setfield! fields of Types should not be changed")
getproperty(x::Tuple, f::Int, order::Symbol) = (@inline; getfield(x, f, order))
setproperty!(x::Tuple, f::Int, v, order::Symbol) = setfield!(x, f, v, order) # to get a decent error

getproperty(x, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))
function setproperty!(x, f::Symbol, v, order::Symbol)
    @inline
    ty = fieldtype(typeof(x), f)
    val = v isa ty ? v : convert(ty, v)
    return setfield!(x, f, val, order)
end

function swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)
    @inline
    ty = fieldtype(typeof(x), f)
    val = v isa ty ? v : convert(ty, v)
    return Core.swapfield!(x, f, val, order)
end
function modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)
    @inline
    return Core.modifyfield!(x, f, op, v, order)
end
function replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)
    @inline
    ty = fieldtype(typeof(x), f)
    val = desired isa ty ? desired : convert(ty, desired)
    return Core.replacefield!(x, f, expected, val, success_order, fail_order)
end

convert(::Type{Any}, Core.@nospecialize x) = x
convert(::Type{T}, x::T) where {T} = x
include("coreio.jl")

eval(x) = Core.eval(Base, x)
eval(m::Module, x) = Core.eval(m, x)

# init core docsystem
import Core: @doc, @__doc__, WrappedException, @int128_str, @uint128_str, @big_str, @cmd
if isdefined(Core, :Compiler)
    import Core.Compiler.CoreDocs
    Core.atdoc!(CoreDocs.docm)
end

include("exports.jl")

if false
    # simple print definitions for debugging. enable these if something
    # goes wrong during bootstrap before printing code is available.
    # otherwise, they just just eventually get (noisily) overwritten later
    global show, print, println
    show(io::IO, x) = Core.show(io, x)
    print(io::IO, a...) = Core.print(io, a...)
    println(io::IO, x...) = Core.println(io, x...)
end

"""
    time_ns() -> UInt64

Get the time in nanoseconds. The time corresponding to 0 is undefined, and wraps every 5.8 years.
"""
time_ns() = ccall(:jl_hrtime, UInt64, ())

start_base_include = time_ns()

## Load essential files and libraries
include("essentials.jl")
include("ctypes.jl")
include("gcutils.jl")
include("generator.jl")
include("reflection.jl")
include("options.jl")

# define invoke(f, T, args...; kwargs...), without kwargs wrapping
# to forward to invoke
function Core.kwcall(kwargs::NamedTuple, ::typeof(invoke), f, T, args...)
    @inline
    # prepend kwargs and f to the invoked from the user
    T = rewrap_unionall(Tuple{Core.Typeof(kwargs), Core.Typeof(f), (unwrap_unionall(T)::DataType).parameters...}, T)
    return invoke(Core.kwcall, T, kwargs, f, args...)
end
# invoke does not have its own call cache, but kwcall for invoke does
setfield!(typeof(invoke).name.mt, :max_args, 3, :monotonic) # invoke, f, T, args...

# define applicable(f, T, args...; kwargs...), without kwargs wrapping
# to forward to applicable
function Core.kwcall(kwargs::NamedTuple, ::typeof(applicable), @nospecialize(args...))
    @inline
    return applicable(Core.kwcall, kwargs, args...)
end
function Core._hasmethod(@nospecialize(f), @nospecialize(t)) # this function has a special tfunc (TODO: make this a Builtin instead like applicable)
    tt = rewrap_unionall(Tuple{Core.Typeof(f), (unwrap_unionall(t)::DataType).parameters...}, t)
    return Core._hasmethod(tt)
end


# core operations & types
include("promotion.jl")
include("tuple.jl")
include("expr.jl")
include("pair.jl")
include("traits.jl")
include("range.jl")
include("error.jl")

# core numeric operations & types
==(x, y) = x === y
include("bool.jl")
include("number.jl")
include("int.jl")
include("operators.jl")
include("pointer.jl")
include("refvalue.jl")
include("refpointer.jl")

# now replace the Pair constructor (relevant for NamedTuples) with one that calls our Base.convert
delete_method(which(Pair{Any,Any}, (Any, Any)))
@eval function (P::Type{Pair{A, B}})(@nospecialize(a), @nospecialize(b)) where {A, B}
    @inline
    return $(Expr(:new, :P, :(a isa A ? a : convert(A, a)), :(b isa B ? b : convert(B, b))))
end

# The REPL stdlib hooks into Base using this Ref
const REPL_MODULE_REF = Ref{Module}()

include("checked.jl")
using .Checked
function cld end
function fld end

# Lazy strings
include("strings/lazy.jl")

# array structures
include("indices.jl")
include("array.jl")
include("abstractarray.jl")
include("subarray.jl")
include("views.jl")
include("baseext.jl")

include("ntuple.jl")

include("abstractdict.jl")
include("iddict.jl")
include("idset.jl")

include("iterators.jl")
using .Iterators: zip, enumerate, only
using .Iterators: Flatten, Filter, product  # for generators
using .Iterators: Stateful    # compat (was formerly used in reinterpretarray.jl)

include("namedtuple.jl")

# For OS specific stuff
# We need to strcat things here, before strings are really defined
function strcat(x::String, y::String)
    out = ccall(:jl_alloc_string, Ref{String}, (Csize_t,), Core.sizeof(x) + Core.sizeof(y))
    GC.@preserve x y out begin
        out_ptr = unsafe_convert(Ptr{UInt8}, out)
        unsafe_copyto!(out_ptr, unsafe_convert(Ptr{UInt8}, x), Core.sizeof(x))
        unsafe_copyto!(out_ptr + Core.sizeof(x), unsafe_convert(Ptr{UInt8}, y), Core.sizeof(y))
    end
    return out
end
include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "build_h.jl"))     # include($BUILDROOT/base/build_h.jl)
include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "version_git.jl")) # include($BUILDROOT/base/version_git.jl)

# numeric operations
include("hashing.jl")
include("rounding.jl")
using .Rounding
include("div.jl")
include("float.jl")
include("twiceprecision.jl")
include("complex.jl")
include("rational.jl")
include("multinverses.jl")
using .MultiplicativeInverses
include("abstractarraymath.jl")
include("arraymath.jl")
include("slicearray.jl")

# SIMD loops
sizeof(s::String) = Core.sizeof(s)  # needed by gensym as called from simdloop
include("simdloop.jl")
using .SimdLoop

# map-reduce operators
include("reduce.jl")

## core structures
include("reshapedarray.jl")
include("reinterpretarray.jl")
include("bitarray.jl")
include("bitset.jl")

if !isdefined(Core, :Compiler)
    include("docs/core.jl")
    Core.atdoc!(CoreDocs.docm)
end

include("multimedia.jl")
using .Multimedia

# Some type
include("some.jl")

include("dict.jl")
include("abstractset.jl")
include("set.jl")

# Strings
include("char.jl")
include("strings/basic.jl")
include("strings/string.jl")
include("strings/substring.jl")

# Initialize DL_LOAD_PATH as early as possible.  We are defining things here in
# a slightly more verbose fashion than usual, because we're running so early.
const DL_LOAD_PATH = String[]
let os = ccall(:jl_get_UNAME, Any, ())
    if os === :Darwin || os === :Apple
        if Base.DARWIN_FRAMEWORK
            push!(DL_LOAD_PATH, "@loader_path/Frameworks")
        end
        push!(DL_LOAD_PATH, "@loader_path")
    end
end

include("osutils.jl")
include("c.jl")

# Core I/O
include("io.jl")
include("iobuffer.jl")

# strings & printing
include("intfuncs.jl")
include("strings/strings.jl")
include("regex.jl")
include("parse.jl")
include("shell.jl")
include("show.jl")
include("arrayshow.jl")
include("methodshow.jl")

# multidimensional arrays
include("cartesian.jl")
using .Cartesian
include("multidimensional.jl")

include("broadcast.jl")
using .Broadcast
using .Broadcast: broadcasted, broadcasted_kwsyntax, materialize, materialize!,
                  broadcast_preserving_zero_d, andand, oror

# missing values
include("missing.jl")

# version
include("version.jl")

# system & environment
include("sysinfo.jl")
include("libc.jl")
using .Libc: getpid, gethostname, time

# These used to be in build_h.jl and are retained for backwards compatibility.
# NOTE: keep in sync with `libblastrampoline_jll.libblastrampoline`.
const libblas_name = "libblastrampoline" * (Sys.iswindows() ? "-5" : "")
const liblapack_name = libblas_name

# Logging
include("logging.jl")
using .CoreLogging

# Concurrency
include("linked_list.jl")
include("condition.jl")
include("threads.jl")
include("lock.jl")
include("channels.jl")
include("partr.jl")
include("task.jl")
include("threads_overloads.jl")
include("weakkeydict.jl")

include("env.jl")

# functions defined in Random
function rand end
function randn end

# I/O
include("libuv.jl")
include("asyncevent.jl")
include("iostream.jl")
include("stream.jl")
include("filesystem.jl")
using .Filesystem
include("cmd.jl")
include("process.jl")
include("ttyhascolor.jl")
include("secretbuffer.jl")

# core math functions
include("floatfuncs.jl")
include("math.jl")
using .Math
const (√)=sqrt
const (∛)=cbrt
const (∜)=fourthroot

# now switch to a simple, race-y TLS, relative include for the rest of Base
delete_method(which(include, (Module, String)))
let SOURCE_PATH = ""
    global function include(mod::Module, path::String)
        prev = SOURCE_PATH::String
        path = normpath(joinpath(dirname(prev), path))
        Core.println(path)
        ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))
        push!(_included_files, (mod, abspath(path)))
        SOURCE_PATH = path
        result = Core.include(mod, path)
        SOURCE_PATH = prev
        return result
    end
end

# reduction along dims
include("reducedim.jl")  # macros in this file rely on string.jl
include("accumulate.jl")

include("permuteddimsarray.jl")
using .PermutedDimsArrays

# basic data structures
include("ordering.jl")
using .Order

# Combinatorics
include("sort.jl")
using .Sort

# BinaryPlatforms, used by Artifacts.  Needs `Sort`.
include("binaryplatforms.jl")

# Fast math
include("fastmath.jl")
using .FastMath

function deepcopy_internal end

# enums
include("Enums.jl")
using .Enums

# BigInts
include("gmp.jl")
using .GMP

# float printing: requires BigInt
include("ryu/Ryu.jl")
using .Ryu

# BigFloats
include("mpfr.jl")
using .MPFR

include("combinatorics.jl")

# irrational mathematical constants
include("irrationals.jl")
include("mathconstants.jl")
using .MathConstants: ℯ, π, pi

# metaprogramming
include("meta.jl")

# Stack frames and traces
include("stacktraces.jl")
using .StackTraces

# experimental API's
include("experimental.jl")

# utilities
include("deepcopy.jl")
include("download.jl")
include("summarysize.jl")
include("errorshow.jl")

include("initdefs.jl")

# worker threads
include("threadcall.jl")

# code loading
include("uuid.jl")
include("pkgid.jl")
include("toml_parser.jl")
include("linking.jl")
include("loading.jl")

# misc useful functions & macros
include("timing.jl")
include("util.jl")
include("client.jl")
include("asyncmap.jl")

# deprecated functions
include("deprecated.jl")
#
# Some additional basic documentation
include("docs/basedocs.jl")

# Documentation -- should always be included last in sysimg.
include("docs/Docs.jl")
using .Docs
if isdefined(Core, :Compiler) && is_primary_base_module
    Docs.loaddocs(Core.Compiler.CoreDocs.DOCS)
end

# finally, now make `include` point to the full version
for m in methods(include)
    delete_method(m)
end

# This method is here only to be overwritten during the test suite to test
# various sysimg related invalidation scenarios.
a_method_to_overwrite_in_test() = inferencebarrier(1)

# These functions are duplicated in client.jl/include(::String) for
# nicer stacktraces. Modifications here have to be backported there
include(mod::Module, _path::AbstractString) = _include(identity, mod, _path)
include(mapexpr::Function, mod::Module, _path::AbstractString) = _include(mapexpr, mod, _path)

end_base_include = time_ns()

const _sysimage_modules = PkgId[]
in_sysimage(pkgid::PkgId) = pkgid in _sysimage_modules

# Precompiles for Revise and other packages
# TODO: move these to contrib/generate_precompile.jl
# The problem is they don't work there
for match = _methods(+, (Int, Int), -1, get_world_counter())
    m = match.method
    delete!(push!(Set{Method}(), m), m)
    copy(Core.Compiler.retrieve_code_info(Core.Compiler.specialize_method(match), typemax(UInt)))

    empty!(Set())
    push!(push!(Set{Union{GlobalRef,Symbol}}(), :two), GlobalRef(Base, :two))
    (setindex!(Dict{String,Base.PkgId}(), Base.PkgId(Base), "file.jl"))["file.jl"]
    (setindex!(Dict{Symbol,Vector{Int}}(), [1], :two))[:two]
    (setindex!(Dict{Base.PkgId,String}(), "file.jl", Base.PkgId(Base)))[Base.PkgId(Base)]
    (setindex!(Dict{Union{GlobalRef,Symbol}, Vector{Int}}(), [1], :two))[:two]
    (setindex!(IdDict{Type, Union{Missing, Vector{Tuple{LineNumberNode, Expr}}}}(), missing, Int))[Int]
    Dict{Symbol, Union{Nothing, Bool, Symbol}}(:one => false)[:one]
    Dict(Base => [:(1+1)])[Base]
    Dict(:one => [1])[:one]
    Dict("abc" => Set())["abc"]
    pushfirst!([], sum)
    get(Base.pkgorigins, Base.PkgId(Base), nothing)
    sort!([1,2,3])
    unique!([1,2,3])
    cumsum([1,2,3])
    append!(Int[], BitSet())
    isempty(BitSet())
    delete!(BitSet([1,2]), 3)
    deleteat!(Int32[1,2,3], [1,3])
    deleteat!(Any[1,2,3], [1,3])
    Core.svec(1, 2) == Core.svec(3, 4)
    any(t->t[1].line > 1, [(LineNumberNode(2,:none), :(1+1))])

    # Code loading uses this
    sortperm(mtime.(readdir(".")), rev=true)
    # JLLWrappers uses these
    Dict{UUID,Set{String}}()[UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210")] = Set{String}()
    get!(Set{String}, Dict{UUID,Set{String}}(), UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210"))
    eachindex(IndexLinear(), Expr[])
    push!(Expr[], Expr(:return, false))
    vcat(String[], String[])
    k, v = (:hello => nothing)
    precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int))
    precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int, Int))
    # Preferences uses these
    precompile(get_preferences, (UUID,))
    precompile(record_compiletime_preference, (UUID, String))
    get(Dict{String,Any}(), "missing", nothing)
    delete!(Dict{String,Any}(), "missing")
    for (k, v) in Dict{String,Any}()
        println(k)
    end

    break   # only actually need to do this once
end

if is_primary_base_module

# Profiling helper
# triggers printing the report and (optionally) saving a heap snapshot after a SIGINFO/SIGUSR1 profile request
# Needs to be in Base because Profile is no longer loaded on boot
const PROFILE_PRINT_COND = Ref{Base.AsyncCondition}()
function profile_printing_listener()
    profile = nothing
    try
        while true
            wait(PROFILE_PRINT_COND[])
            profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))

            invokelatest(profile.peek_report[])
            if Base.get_bool_env("JULIA_PROFILE_PEEK_HEAP_SNAPSHOT", false) === true
                println(stderr, "Saving heap snapshot...")
                fname = invokelatest(profile.take_heap_snapshot)
                println(stderr, "Heap snapshot saved to `$(fname)`")
            end
        end
    catch ex
        if !isa(ex, InterruptException)
            @error "Profile printing listener crashed" exception=ex,catch_backtrace()
        end
    end
end

function __init__()
    # Base library init
    reinit_stdio()
    Multimedia.reinit_displays() # since Multimedia.displays uses stdout as fallback
    # initialize loading
    init_depot_path()
    init_load_path()
    init_active_project()
    append!(empty!(_sysimage_modules), keys(loaded_modules))
    if haskey(ENV, "JULIA_MAX_NUM_PRECOMPILE_FILES")
        MAX_NUM_PRECOMPILE_FILES[] = parse(Int, ENV["JULIA_MAX_NUM_PRECOMPILE_FILES"])
    end
    # Profiling helper
    @static if !Sys.iswindows()
        # triggering a profile via signals is not implemented on windows
        cond = Base.AsyncCondition()
        Base.uv_unref(cond.handle)
        PROFILE_PRINT_COND[] = cond
        ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), PROFILE_PRINT_COND[].handle)
        errormonitor(Threads.@spawn(profile_printing_listener()))
    end
    nothing
end

# enable threads support
@eval PCRE PCRE_COMPILE_LOCK = Threads.SpinLock()

end


end # baremodule Base

1	# This file is a part of Julia. License is MIT: https://julialang.org/license
2
3	baremodule Base
4
5	using Core.Intrinsics, Core.IR
6
7	# to start, we're going to use a very simple definition of `include`
8	# that doesn't require any function (except what we can get from the `Core` top-module)
9	const _included_files = Array{Tuple{Module,String},1}()
10	function include(mod::Module, path::String)	×
11	ccall(:jl_array_grow_end, Cvoid, (Any, UInt), _included_files, UInt(1))	×
12	Core.arrayset(true, _included_files, (mod, ccall(:jl_prepend_cwd, Any, (Any,), path)), arraylen(_included_files))	×
13	Core.println(path)	×
14	ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))	×
15	Core.include(mod, path)	×
16	end
17	include(path::String) = include(Base, path)	×
18
19	# from now on, this is now a top-module for resolving syntax
20	const is_primary_base_module = ccall(:jl_module_parent, Ref{Module}, (Any,), Base) === Core.Main
21	ccall(:jl_set_istopmod, Cvoid, (Any, Bool), Base, is_primary_base_module)
22
23	# The @inline/@noinline macros that can be applied to a function declaration are not available
24	# until after array.jl, and so we will mark them within a function body instead.
25	macro inline() Expr(:meta, :inline) end	288✔
26	macro noinline() Expr(:meta, :noinline) end	7✔
27
28	# Try to help prevent users from shooting them-selves in the foot
29	# with ambiguities by defining a few common and critical operations
30	# (and these don't need the extra convert code)
31	getproperty(x::Module, f::Symbol) = (@inline; getglobal(x, f))	42,070,184✔
32	getproperty(x::Type, f::Symbol) = (@inline; getfield(x, f))	8,736,812✔
33	setproperty!(x::Type, f::Symbol, v) = error("setfield! fields of Types should not be changed")	×
34	getproperty(x::Tuple, f::Int) = (@inline; getfield(x, f))	4✔
35	setproperty!(x::Tuple, f::Int, v) = setfield!(x, f, v) # to get a decent error	1✔
36
37	getproperty(x, f::Symbol) = (@inline; getfield(x, f))	34,975,034,295✔
38	function setproperty!(x, f::Symbol, v)	95,739,188✔
39	ty = fieldtype(typeof(x), f)	95,738,682✔
40	val = v isa ty ? v : convert(ty, v)	100,312,494✔
41	return setfield!(x, f, val)	588,895,313✔
42	end
43
44	dotgetproperty(x, f) = getproperty(x, f)	1,030✔
45
46	getproperty(x::Module, f::Symbol, order::Symbol) = (@inline; getglobal(x, f, order))	×
47	function setproperty!(x::Module, f::Symbol, v, order::Symbol=:monotonic)	10✔
48	@inline	10✔
49	ty = Core.get_binding_type(x, f)	22✔
50	val = v isa ty ? v : convert(ty, v)	7✔
51	return setglobal!(x, f, val, order)	18✔
52	end
53	getproperty(x::Type, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))	×
54	setproperty!(x::Type, f::Symbol, v, order::Symbol) = error("setfield! fields of Types should not be changed")	×
55	getproperty(x::Tuple, f::Int, order::Symbol) = (@inline; getfield(x, f, order))	×
56	setproperty!(x::Tuple, f::Int, v, order::Symbol) = setfield!(x, f, v, order) # to get a decent error	×
57
58	getproperty(x, f::Symbol, order::Symbol) = (@inline; getfield(x, f, order))	18,270,166✔
59	function setproperty!(x, f::Symbol, v, order::Symbol)	2,220,146✔
60	@inline	2,220,146✔
61	ty = fieldtype(typeof(x), f)	2,220,146✔
62	val = v isa ty ? v : convert(ty, v)	2,220,145✔
63	return setfield!(x, f, val, order)	31,705,360✔
64	end
65
66	function swapproperty!(x, f::Symbol, v, order::Symbol=:not_atomic)	27✔
67	@inline	27✔
68	ty = fieldtype(typeof(x), f)	27✔
69	val = v isa ty ? v : convert(ty, v)	27✔
70	return Core.swapfield!(x, f, val, order)	66,523,122✔
71	end
72	function modifyproperty!(x, f::Symbol, op, v, order::Symbol=:not_atomic)	10✔
73	@inline	10✔
74	return Core.modifyfield!(x, f, op, v, order)	10✔
75	end
76	function replaceproperty!(x, f::Symbol, expected, desired, success_order::Symbol=:not_atomic, fail_order::Symbol=success_order)	100,079✔
77	@inline	100,079✔
78	ty = fieldtype(typeof(x), f)	100,079✔
79	val = desired isa ty ? desired : convert(ty, desired)	200,132✔
80	return Core.replacefield!(x, f, expected, val, success_order, fail_order)	9,092,041✔
81	end
82
83	convert(::Type{Any}, Core.@nospecialize x) = x	262,969✔
84	convert(::Type{T}, x::T) where {T} = x	485,767✔
85	include("coreio.jl")
86
87	eval(x) = Core.eval(Base, x)	×
88	eval(m::Module, x) = Core.eval(m, x)	1✔
89
90	# init core docsystem
91	import Core: @doc, @__doc__, WrappedException, @int128_str, @uint128_str, @big_str, @cmd
92	if isdefined(Core, :Compiler)
93	import Core.Compiler.CoreDocs
94	Core.atdoc!(CoreDocs.docm)
95	end
96
97	include("exports.jl")
98
99	if false
100	# simple print definitions for debugging. enable these if something
101	# goes wrong during bootstrap before printing code is available.
102	# otherwise, they just just eventually get (noisily) overwritten later
103	global show, print, println
104	show(io::IO, x) = Core.show(io, x)	×
105	print(io::IO, a...) = Core.print(io, a...)	×
106	println(io::IO, x...) = Core.println(io, x...)	×
107	end
108
109	"""
110	time_ns() -> UInt64
111
112	Get the time in nanoseconds. The time corresponding to 0 is undefined, and wraps every 5.8 years.
113	"""
114	time_ns() = ccall(:jl_hrtime, UInt64, ())	42,373,572✔
115
116	start_base_include = time_ns()
117
118	## Load essential files and libraries
119	include("essentials.jl")
120	include("ctypes.jl")
121	include("gcutils.jl")
122	include("generator.jl")
123	include("reflection.jl")
124	include("options.jl")
125
126	# define invoke(f, T, args...; kwargs...), without kwargs wrapping
127	# to forward to invoke
128	function Core.kwcall(kwargs::NamedTuple, ::typeof(invoke), f, T, args...)	33✔
129	@inline	33✔
130	# prepend kwargs and f to the invoked from the user
131	T = rewrap_unionall(Tuple{Core.Typeof(kwargs), Core.Typeof(f), (unwrap_unionall(T)::DataType).parameters...}, T)	34✔
132	return invoke(Core.kwcall, T, kwargs, f, args...)	41✔
133	end
134	# invoke does not have its own call cache, but kwcall for invoke does
135	setfield!(typeof(invoke).name.mt, :max_args, 3, :monotonic) # invoke, f, T, args...
136
137	# define applicable(f, T, args...; kwargs...), without kwargs wrapping
138	# to forward to applicable
139	function Core.kwcall(kwargs::NamedTuple, ::typeof(applicable), @nospecialize(args...))	×
140	@inline	×
141	return applicable(Core.kwcall, kwargs, args...)	×
142	end
143	function Core._hasmethod(@nospecialize(f), @nospecialize(t)) # this function has a special tfunc (TODO: make this a Builtin instead like applicable)	34,509✔
144	tt = rewrap_unionall(Tuple{Core.Typeof(f), (unwrap_unionall(t)::DataType).parameters...}, t)	34,503✔
145	return Core._hasmethod(tt)	34,501✔
146	end
147
148
149	# core operations & types
150	include("promotion.jl")
151	include("tuple.jl")
152	include("expr.jl")
153	include("pair.jl")
154	include("traits.jl")
155	include("range.jl")
156	include("error.jl")
157
158	# core numeric operations & types
159	==(x, y) = x === y	27,740,140✔
160	include("bool.jl")
161	include("number.jl")
162	include("int.jl")
163	include("operators.jl")
164	include("pointer.jl")
165	include("refvalue.jl")
166	include("refpointer.jl")
167
168	# now replace the Pair constructor (relevant for NamedTuples) with one that calls our Base.convert
169	delete_method(which(Pair{Any,Any}, (Any, Any)))
170	@eval function (P::Type{Pair{A, B}})(@nospecialize(a), @nospecialize(b)) where {A, B}	53,129✔
171	@inline	52,968✔
172	return $(Expr(:new, :P, :(a isa A ? a : convert(A, a)), :(b isa B ? b : convert(B, b))))	2,595,140✔
173	end
174
175	# The REPL stdlib hooks into Base using this Ref
176	const REPL_MODULE_REF = Ref{Module}()
177
178	include("checked.jl")
179	using .Checked
180	function cld end
181	function fld end
182
183	# Lazy strings
184	include("strings/lazy.jl")
185
186	# array structures
187	include("indices.jl")
188	include("array.jl")
189	include("abstractarray.jl")
190	include("subarray.jl")
191	include("views.jl")
192	include("baseext.jl")
193
194	include("ntuple.jl")
195
196	include("abstractdict.jl")
197	include("iddict.jl")
198	include("idset.jl")
199
200	include("iterators.jl")
201	using .Iterators: zip, enumerate, only
202	using .Iterators: Flatten, Filter, product # for generators
203	using .Iterators: Stateful # compat (was formerly used in reinterpretarray.jl)
204
205	include("namedtuple.jl")
206
207	# For OS specific stuff
208	# We need to strcat things here, before strings are really defined
209	function strcat(x::String, y::String)	×
210	out = ccall(:jl_alloc_string, Ref{String}, (Csize_t,), Core.sizeof(x) + Core.sizeof(y))	×
211	GC.@preserve x y out begin	×
212	out_ptr = unsafe_convert(Ptr{UInt8}, out)	×
213	unsafe_copyto!(out_ptr, unsafe_convert(Ptr{UInt8}, x), Core.sizeof(x))	×
214	unsafe_copyto!(out_ptr + Core.sizeof(x), unsafe_convert(Ptr{UInt8}, y), Core.sizeof(y))	×
215	end
216	return out	×
217	end
218	include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "build_h.jl")) # include($BUILDROOT/base/build_h.jl)
219	include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "version_git.jl")) # include($BUILDROOT/base/version_git.jl)
220
221	# numeric operations
222	include("hashing.jl")
223	include("rounding.jl")
224	using .Rounding
225	include("div.jl")
226	include("float.jl")
227	include("twiceprecision.jl")
228	include("complex.jl")
229	include("rational.jl")
230	include("multinverses.jl")
231	using .MultiplicativeInverses
232	include("abstractarraymath.jl")
233	include("arraymath.jl")
234	include("slicearray.jl")
235
236	# SIMD loops
237	sizeof(s::String) = Core.sizeof(s) # needed by gensym as called from simdloop	55,685,618✔
238	include("simdloop.jl")
239	using .SimdLoop
240
241	# map-reduce operators
242	include("reduce.jl")
243
244	## core structures
245	include("reshapedarray.jl")
246	include("reinterpretarray.jl")
247	include("bitarray.jl")
248	include("bitset.jl")
249
250	if !isdefined(Core, :Compiler)
251	include("docs/core.jl")
252	Core.atdoc!(CoreDocs.docm)
253	end
254
255	include("multimedia.jl")
256	using .Multimedia
257
258	# Some type
259	include("some.jl")
260
261	include("dict.jl")
262	include("abstractset.jl")
263	include("set.jl")
264
265	# Strings
266	include("char.jl")
267	include("strings/basic.jl")
268	include("strings/string.jl")
269	include("strings/substring.jl")
270
271	# Initialize DL_LOAD_PATH as early as possible. We are defining things here in
272	# a slightly more verbose fashion than usual, because we're running so early.
273	const DL_LOAD_PATH = String[]
274	let os = ccall(:jl_get_UNAME, Any, ())
275	if os === :Darwin \|\| os === :Apple
276	if Base.DARWIN_FRAMEWORK
277	push!(DL_LOAD_PATH, "@loader_path/Frameworks")
278	end
279	push!(DL_LOAD_PATH, "@loader_path")
280	end
281	end
282
283	include("osutils.jl")
284	include("c.jl")
285
286	# Core I/O
287	include("io.jl")
288	include("iobuffer.jl")
289
290	# strings & printing
291	include("intfuncs.jl")
292	include("strings/strings.jl")
293	include("regex.jl")
294	include("parse.jl")
295	include("shell.jl")
296	include("show.jl")
297	include("arrayshow.jl")
298	include("methodshow.jl")
299
300	# multidimensional arrays
301	include("cartesian.jl")
302	using .Cartesian
303	include("multidimensional.jl")
304
305	include("broadcast.jl")
306	using .Broadcast
307	using .Broadcast: broadcasted, broadcasted_kwsyntax, materialize, materialize!,
308	broadcast_preserving_zero_d, andand, oror
309
310	# missing values
311	include("missing.jl")
312
313	# version
314	include("version.jl")
315
316	# system & environment
317	include("sysinfo.jl")
318	include("libc.jl")
319	using .Libc: getpid, gethostname, time
320
321	# These used to be in build_h.jl and are retained for backwards compatibility.
322	# NOTE: keep in sync with `libblastrampoline_jll.libblastrampoline`.
323	const libblas_name = "libblastrampoline" * (Sys.iswindows() ? "-5" : "")
324	const liblapack_name = libblas_name
325
326	# Logging
327	include("logging.jl")
328	using .CoreLogging
329
330	# Concurrency
331	include("linked_list.jl")
332	include("condition.jl")
333	include("threads.jl")
334	include("lock.jl")
335	include("channels.jl")
336	include("partr.jl")
337	include("task.jl")
338	include("threads_overloads.jl")
339	include("weakkeydict.jl")
340
341	include("env.jl")
342
343	# functions defined in Random
344	function rand end
345	function randn end
346
347	# I/O
348	include("libuv.jl")
349	include("asyncevent.jl")
350	include("iostream.jl")
351	include("stream.jl")
352	include("filesystem.jl")
353	using .Filesystem
354	include("cmd.jl")
355	include("process.jl")
356	include("ttyhascolor.jl")
357	include("secretbuffer.jl")
358
359	# core math functions
360	include("floatfuncs.jl")
361	include("math.jl")
362	using .Math
363	const (√)=sqrt
364	const (∛)=cbrt
365	const (∜)=fourthroot
366
367	# now switch to a simple, race-y TLS, relative include for the rest of Base
368	delete_method(which(include, (Module, String)))
369	let SOURCE_PATH = ""
370	global function include(mod::Module, path::String)	×
371	prev = SOURCE_PATH::String	×
372	path = normpath(joinpath(dirname(prev), path))	×
373	Core.println(path)	×
374	ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))	×
375	push!(_included_files, (mod, abspath(path)))	×
376	SOURCE_PATH = path	×
377	result = Core.include(mod, path)	×
378	SOURCE_PATH = prev	×
379	return result	×
380	end
381	end
382
383	# reduction along dims
384	include("reducedim.jl") # macros in this file rely on string.jl
385	include("accumulate.jl")
386
387	include("permuteddimsarray.jl")
388	using .PermutedDimsArrays
389
390	# basic data structures
391	include("ordering.jl")
392	using .Order
393
394	# Combinatorics
395	include("sort.jl")
396	using .Sort
397
398	# BinaryPlatforms, used by Artifacts. Needs `Sort`.
399	include("binaryplatforms.jl")
400
401	# Fast math
402	include("fastmath.jl")
403	using .FastMath
404
405	function deepcopy_internal end
406
407	# enums
408	include("Enums.jl")
409	using .Enums
410
411	# BigInts
412	include("gmp.jl")
413	using .GMP
414
415	# float printing: requires BigInt
416	include("ryu/Ryu.jl")
417	using .Ryu
418
419	# BigFloats
420	include("mpfr.jl")
421	using .MPFR
422
423	include("combinatorics.jl")
424
425	# irrational mathematical constants
426	include("irrationals.jl")
427	include("mathconstants.jl")
428	using .MathConstants: ℯ, π, pi
429
430	# metaprogramming
431	include("meta.jl")
432
433	# Stack frames and traces
434	include("stacktraces.jl")
435	using .StackTraces
436
437	# experimental API's
438	include("experimental.jl")
439
440	# utilities
441	include("deepcopy.jl")
442	include("download.jl")
443	include("summarysize.jl")
444	include("errorshow.jl")
445
446	include("initdefs.jl")
447
448	# worker threads
449	include("threadcall.jl")
450
451	# code loading
452	include("uuid.jl")
453	include("pkgid.jl")
454	include("toml_parser.jl")
455	include("linking.jl")
456	include("loading.jl")
457
458	# misc useful functions & macros
459	include("timing.jl")
460	include("util.jl")
461	include("client.jl")
462	include("asyncmap.jl")
463
464	# deprecated functions
465	include("deprecated.jl")
466	#
467	# Some additional basic documentation
468	include("docs/basedocs.jl")
469
470	# Documentation -- should always be included last in sysimg.
471	include("docs/Docs.jl")
472	using .Docs
473	if isdefined(Core, :Compiler) && is_primary_base_module
474	Docs.loaddocs(Core.Compiler.CoreDocs.DOCS)
475	end
476
477	# finally, now make `include` point to the full version
478	for m in methods(include)
479	delete_method(m)
480	end
481
482	# This method is here only to be overwritten during the test suite to test
483	# various sysimg related invalidation scenarios.
484	a_method_to_overwrite_in_test() = inferencebarrier(1)	1✔
485
486	# These functions are duplicated in client.jl/include(::String) for
487	# nicer stacktraces. Modifications here have to be backported there
488	include(mod::Module, _path::AbstractString) = _include(identity, mod, _path)	640✔
489	include(mapexpr::Function, mod::Module, _path::AbstractString) = _include(mapexpr, mod, _path)	2✔
490
491	end_base_include = time_ns()
492
493	const _sysimage_modules = PkgId[]
494	in_sysimage(pkgid::PkgId) = pkgid in _sysimage_modules	9,590✔
495
496	# Precompiles for Revise and other packages
497	# TODO: move these to contrib/generate_precompile.jl
498	# The problem is they don't work there
499	for match = _methods(+, (Int, Int), -1, get_world_counter())
500	m = match.method
501	delete!(push!(Set{Method}(), m), m)
502	copy(Core.Compiler.retrieve_code_info(Core.Compiler.specialize_method(match), typemax(UInt)))
503
504	empty!(Set())
505	push!(push!(Set{Union{GlobalRef,Symbol}}(), :two), GlobalRef(Base, :two))
506	(setindex!(Dict{String,Base.PkgId}(), Base.PkgId(Base), "file.jl"))["file.jl"]
507	(setindex!(Dict{Symbol,Vector{Int}}(), [1], :two))[:two]
508	(setindex!(Dict{Base.PkgId,String}(), "file.jl", Base.PkgId(Base)))[Base.PkgId(Base)]
509	(setindex!(Dict{Union{GlobalRef,Symbol}, Vector{Int}}(), [1], :two))[:two]
510	(setindex!(IdDict{Type, Union{Missing, Vector{Tuple{LineNumberNode, Expr}}}}(), missing, Int))[Int]
511	Dict{Symbol, Union{Nothing, Bool, Symbol}}(:one => false)[:one]
512	Dict(Base => [:(1+1)])[Base]
513	Dict(:one => [1])[:one]
514	Dict("abc" => Set())["abc"]
515	pushfirst!([], sum)
516	get(Base.pkgorigins, Base.PkgId(Base), nothing)
517	sort!([1,2,3])
518	unique!([1,2,3])
519	cumsum([1,2,3])
520	append!(Int[], BitSet())
521	isempty(BitSet())
522	delete!(BitSet([1,2]), 3)
523	deleteat!(Int32[1,2,3], [1,3])
524	deleteat!(Any[1,2,3], [1,3])
525	Core.svec(1, 2) == Core.svec(3, 4)
526	any(t->t[1].line > 1, [(LineNumberNode(2,:none), :(1+1))])	×
527
528	# Code loading uses this
529	sortperm(mtime.(readdir(".")), rev=true)
530	# JLLWrappers uses these
531	Dict{UUID,Set{String}}()[UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210")] = Set{String}()
532	get!(Set{String}, Dict{UUID,Set{String}}(), UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210"))
533	eachindex(IndexLinear(), Expr[])
534	push!(Expr[], Expr(:return, false))
535	vcat(String[], String[])
536	k, v = (:hello => nothing)
537	precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int))
538	precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int, Int))
539	# Preferences uses these
540	precompile(get_preferences, (UUID,))
541	precompile(record_compiletime_preference, (UUID, String))
542	get(Dict{String,Any}(), "missing", nothing)
543	delete!(Dict{String,Any}(), "missing")
544	for (k, v) in Dict{String,Any}()
545	println(k)
546	end
547
548	break # only actually need to do this once
549	end
550
551	if is_primary_base_module
552
553	# Profiling helper
554	# triggers printing the report and (optionally) saving a heap snapshot after a SIGINFO/SIGUSR1 profile request
555	# Needs to be in Base because Profile is no longer loaded on boot
556	const PROFILE_PRINT_COND = Ref{Base.AsyncCondition}()
557	function profile_printing_listener()	345✔
558	profile = nothing	×
559	try	345✔
560	while true	347✔
561	wait(PROFILE_PRINT_COND[])	347✔
562	profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))	×
563
564	invokelatest(profile.peek_report[])	2✔
565	if Base.get_bool_env("JULIA_PROFILE_PEEK_HEAP_SNAPSHOT", false) === true	2✔
566	println(stderr, "Saving heap snapshot...")	×
567	fname = invokelatest(profile.take_heap_snapshot)	×
568	println(stderr, "Heap snapshot saved to `$(fname)`")	×
569	end
570	end	2✔
571	catch ex
572	if !isa(ex, InterruptException)	×
573	@error "Profile printing listener crashed" exception=ex,catch_backtrace()	×
574	end
575	end
576	end
577
578	function __init__()	449✔
579	# Base library init
580	reinit_stdio()	449✔
581	Multimedia.reinit_displays() # since Multimedia.displays uses stdout as fallback	449✔
582	# initialize loading
583	init_depot_path()	449✔
584	init_load_path()	449✔
585	init_active_project()	449✔
586	append!(empty!(_sysimage_modules), keys(loaded_modules))	449✔
587	if haskey(ENV, "JULIA_MAX_NUM_PRECOMPILE_FILES")	449✔
588	MAX_NUM_PRECOMPILE_FILES[] = parse(Int, ENV["JULIA_MAX_NUM_PRECOMPILE_FILES"])	×
589	end
590	# Profiling helper
591	@static if !Sys.iswindows()	×
592	# triggering a profile via signals is not implemented on windows
593	cond = Base.AsyncCondition()	449✔
594	Base.uv_unref(cond.handle)	449✔
595	PROFILE_PRINT_COND[] = cond	449✔
596	ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), PROFILE_PRINT_COND[].handle)	449✔
597	errormonitor(Threads.@spawn(profile_printing_listener()))	449✔
598	end
599	nothing	449✔
600	end
601
602	# enable threads support
603	@eval PCRE PCRE_COMPILE_LOCK = Threads.SpinLock()
604
605	end
606
607
608	end # baremodule Base

JuliaLang / julia / #37527

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous