#37552

pending completion

Build # #37552

Build Type

push

local

Committed by

web-flow

Commit Message

Abbreviate varinfo signature and re-order for consistency (#48860)

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

72746 of 83846 relevant lines covered (86.76%)

34617131.18 hits per line

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

60.8

/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("cmem.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, memcpy, memset, memmove, memcmp

# 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
    # Prevent spawned Julia process from getting stuck waiting on Tracy to connect.
    delete!(ENV, "JULIA_WAIT_FOR_TRACY")
    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	447✔
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))	49,326,781✔
32	getproperty(x::Type, f::Symbol) = (@inline; getfield(x, f))	9,462,287✔
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))	35,698,603,393✔
38	function setproperty!(x, f::Symbol, v)	99,260,120✔
39	ty = fieldtype(typeof(x), f)	99,259,781✔
40	val = v isa ty ? v : convert(ty, v)	102,853,774✔
41	return setfield!(x, f, val)	661,610,117✔
42	end
43
44	dotgetproperty(x, f) = getproperty(x, f)	1,055✔
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)	135✔
48	@inline	14✔
49	ty = Core.get_binding_type(x, f)	271✔
50	val = v isa ty ? v : convert(ty, v)	130✔
51	return setglobal!(x, f, val, order)	144✔
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))	38,614,463✔
59	function setproperty!(x, f::Symbol, v, order::Symbol)	2,218,912✔
60	@inline	2,218,912✔
61	ty = fieldtype(typeof(x), f)	2,218,912✔
62	val = v isa ty ? v : convert(ty, v)	2,218,912✔
63	return setfield!(x, f, val, order)	73,760,960✔
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)	104,561,611✔
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)	21,903,251✔
81	end
82
83	convert(::Type{Any}, Core.@nospecialize x) = x	263,226✔
84	convert(::Type{T}, x::T) where {T} = x	25,343✔
85	include("coreio.jl")
86
87	eval(x) = Core.eval(Base, x)	4✔
88	eval(m::Module, x) = Core.eval(m, x)	7✔
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, ())	172,843✔
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...)	35✔
129	@inline	35✔
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)	36✔
132	return invoke(Core.kwcall, T, kwargs, f, args...)	43✔
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,429✔
144	tt = rewrap_unionall(Tuple{Core.Typeof(f), (unwrap_unionall(t)::DataType).parameters...}, t)	34,431✔
145	return Core._hasmethod(tt)	34,429✔
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	26,920,016✔
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("cmem.jl")
167	include("refpointer.jl")
168
169	# now replace the Pair constructor (relevant for NamedTuples) with one that calls our Base.convert
170	delete_method(which(Pair{Any,Any}, (Any, Any)))
171	@eval function (P::Type{Pair{A, B}})(@nospecialize(a), @nospecialize(b)) where {A, B}	46,076✔
172	@inline	45,902✔
173	return $(Expr(:new, :P, :(a isa A ? a : convert(A, a)), :(b isa B ? b : convert(B, b))))	2,633,687✔
174	end
175
176	# The REPL stdlib hooks into Base using this Ref
177	const REPL_MODULE_REF = Ref{Module}()
178
179	include("checked.jl")
180	using .Checked
181	function cld end
182	function fld end
183
184	# Lazy strings
185	include("strings/lazy.jl")
186
187	# array structures
188	include("indices.jl")
189	include("array.jl")
190	include("abstractarray.jl")
191	include("subarray.jl")
192	include("views.jl")
193	include("baseext.jl")
194
195	include("ntuple.jl")
196
197	include("abstractdict.jl")
198	include("iddict.jl")
199	include("idset.jl")
200
201	include("iterators.jl")
202	using .Iterators: zip, enumerate, only
203	using .Iterators: Flatten, Filter, product # for generators
204	using .Iterators: Stateful # compat (was formerly used in reinterpretarray.jl)
205
206	include("namedtuple.jl")
207
208	# For OS specific stuff
209	# We need to strcat things here, before strings are really defined
210	function strcat(x::String, y::String)	×
211	out = ccall(:jl_alloc_string, Ref{String}, (Csize_t,), Core.sizeof(x) + Core.sizeof(y))	×
212	GC.@preserve x y out begin	×
213	out_ptr = unsafe_convert(Ptr{UInt8}, out)	×
214	unsafe_copyto!(out_ptr, unsafe_convert(Ptr{UInt8}, x), Core.sizeof(x))	×
215	unsafe_copyto!(out_ptr + Core.sizeof(x), unsafe_convert(Ptr{UInt8}, y), Core.sizeof(y))	×
216	end
217	return out	×
218	end
219	include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "build_h.jl")) # include($BUILDROOT/base/build_h.jl)
220	include(strcat((length(Core.ARGS)>=2 ? Core.ARGS[2] : ""), "version_git.jl")) # include($BUILDROOT/base/version_git.jl)
221
222	# numeric operations
223	include("hashing.jl")
224	include("rounding.jl")
225	using .Rounding
226	include("div.jl")
227	include("float.jl")
228	include("twiceprecision.jl")
229	include("complex.jl")
230	include("rational.jl")
231	include("multinverses.jl")
232	using .MultiplicativeInverses
233	include("abstractarraymath.jl")
234	include("arraymath.jl")
235	include("slicearray.jl")
236
237	# SIMD loops
238	sizeof(s::String) = Core.sizeof(s) # needed by gensym as called from simdloop	59,784,534✔
239	include("simdloop.jl")
240	using .SimdLoop
241
242	# map-reduce operators
243	include("reduce.jl")
244
245	## core structures
246	include("reshapedarray.jl")
247	include("reinterpretarray.jl")
248	include("bitarray.jl")
249	include("bitset.jl")
250
251	if !isdefined(Core, :Compiler)
252	include("docs/core.jl")
253	Core.atdoc!(CoreDocs.docm)
254	end
255
256	include("multimedia.jl")
257	using .Multimedia
258
259	# Some type
260	include("some.jl")
261
262	include("dict.jl")
263	include("abstractset.jl")
264	include("set.jl")
265
266	# Strings
267	include("char.jl")
268	include("strings/basic.jl")
269	include("strings/string.jl")
270	include("strings/substring.jl")
271
272	# Initialize DL_LOAD_PATH as early as possible. We are defining things here in
273	# a slightly more verbose fashion than usual, because we're running so early.
274	const DL_LOAD_PATH = String[]
275	let os = ccall(:jl_get_UNAME, Any, ())
276	if os === :Darwin \|\| os === :Apple
277	if Base.DARWIN_FRAMEWORK
278	push!(DL_LOAD_PATH, "@loader_path/Frameworks")
279	end
280	push!(DL_LOAD_PATH, "@loader_path")
281	end
282	end
283
284	include("osutils.jl")
285	include("c.jl")
286
287	# Core I/O
288	include("io.jl")
289	include("iobuffer.jl")
290
291	# strings & printing
292	include("intfuncs.jl")
293	include("strings/strings.jl")
294	include("regex.jl")
295	include("parse.jl")
296	include("shell.jl")
297	include("show.jl")
298	include("arrayshow.jl")
299	include("methodshow.jl")
300
301	# multidimensional arrays
302	include("cartesian.jl")
303	using .Cartesian
304	include("multidimensional.jl")
305
306	include("broadcast.jl")
307	using .Broadcast
308	using .Broadcast: broadcasted, broadcasted_kwsyntax, materialize, materialize!,
309	broadcast_preserving_zero_d, andand, oror
310
311	# missing values
312	include("missing.jl")
313
314	# version
315	include("version.jl")
316
317	# system & environment
318	include("sysinfo.jl")
319	include("libc.jl")
320	using .Libc: getpid, gethostname, time, memcpy, memset, memmove, memcmp
321
322	# These used to be in build_h.jl and are retained for backwards compatibility.
323	# NOTE: keep in sync with `libblastrampoline_jll.libblastrampoline`.
324	const libblas_name = "libblastrampoline" * (Sys.iswindows() ? "-5" : "")
325	const liblapack_name = libblas_name
326
327	# Logging
328	include("logging.jl")
329	using .CoreLogging
330
331	# Concurrency
332	include("linked_list.jl")
333	include("condition.jl")
334	include("threads.jl")
335	include("lock.jl")
336	include("channels.jl")
337	include("partr.jl")
338	include("task.jl")
339	include("threads_overloads.jl")
340	include("weakkeydict.jl")
341
342	include("env.jl")
343
344	# functions defined in Random
345	function rand end
346	function randn end
347
348	# I/O
349	include("libuv.jl")
350	include("asyncevent.jl")
351	include("iostream.jl")
352	include("stream.jl")
353	include("filesystem.jl")
354	using .Filesystem
355	include("cmd.jl")
356	include("process.jl")
357	include("ttyhascolor.jl")
358	include("secretbuffer.jl")
359
360	# core math functions
361	include("floatfuncs.jl")
362	include("math.jl")
363	using .Math
364	const (√)=sqrt
365	const (∛)=cbrt
366	const (∜)=fourthroot
367
368	# now switch to a simple, race-y TLS, relative include for the rest of Base
369	delete_method(which(include, (Module, String)))
370	let SOURCE_PATH = ""
371	global function include(mod::Module, path::String)	×
372	prev = SOURCE_PATH::String	×
373	path = normpath(joinpath(dirname(prev), path))	×
374	Core.println(path)	×
375	ccall(:jl_uv_flush, Nothing, (Ptr{Nothing},), Core.io_pointer(Core.stdout))	×
376	push!(_included_files, (mod, abspath(path)))	×
377	SOURCE_PATH = path	×
378	result = Core.include(mod, path)	×
379	SOURCE_PATH = prev	×
380	return result	×
381	end
382	end
383
384	# reduction along dims
385	include("reducedim.jl") # macros in this file rely on string.jl
386	include("accumulate.jl")
387
388	include("permuteddimsarray.jl")
389	using .PermutedDimsArrays
390
391	# basic data structures
392	include("ordering.jl")
393	using .Order
394
395	# Combinatorics
396	include("sort.jl")
397	using .Sort
398
399	# BinaryPlatforms, used by Artifacts. Needs `Sort`.
400	include("binaryplatforms.jl")
401
402	# Fast math
403	include("fastmath.jl")
404	using .FastMath
405
406	function deepcopy_internal end
407
408	# enums
409	include("Enums.jl")
410	using .Enums
411
412	# BigInts
413	include("gmp.jl")
414	using .GMP
415
416	# float printing: requires BigInt
417	include("ryu/Ryu.jl")
418	using .Ryu
419
420	# BigFloats
421	include("mpfr.jl")
422	using .MPFR
423
424	include("combinatorics.jl")
425
426	# irrational mathematical constants
427	include("irrationals.jl")
428	include("mathconstants.jl")
429	using .MathConstants: ℯ, π, pi
430
431	# metaprogramming
432	include("meta.jl")
433
434	# Stack frames and traces
435	include("stacktraces.jl")
436	using .StackTraces
437
438	# experimental API's
439	include("experimental.jl")
440
441	# utilities
442	include("deepcopy.jl")
443	include("download.jl")
444	include("summarysize.jl")
445	include("errorshow.jl")
446
447	include("initdefs.jl")
448
449	# worker threads
450	include("threadcall.jl")
451
452	# code loading
453	include("uuid.jl")
454	include("pkgid.jl")
455	include("toml_parser.jl")
456	include("linking.jl")
457	include("loading.jl")
458
459	# misc useful functions & macros
460	include("timing.jl")
461	include("util.jl")
462	include("client.jl")
463	include("asyncmap.jl")
464
465	# deprecated functions
466	include("deprecated.jl")
467	#
468	# Some additional basic documentation
469	include("docs/basedocs.jl")
470
471	# Documentation -- should always be included last in sysimg.
472	include("docs/Docs.jl")
473	using .Docs
474	if isdefined(Core, :Compiler) && is_primary_base_module
475	Docs.loaddocs(Core.Compiler.CoreDocs.DOCS)
476	end
477
478	# finally, now make `include` point to the full version
479	for m in methods(include)
480	delete_method(m)
481	end
482
483	# This method is here only to be overwritten during the test suite to test
484	# various sysimg related invalidation scenarios.
485	a_method_to_overwrite_in_test() = inferencebarrier(1)	1✔
486
487	# These functions are duplicated in client.jl/include(::String) for
488	# nicer stacktraces. Modifications here have to be backported there
489	include(mod::Module, _path::AbstractString) = _include(identity, mod, _path)	673✔
490	include(mapexpr::Function, mod::Module, _path::AbstractString) = _include(mapexpr, mod, _path)	2✔
491
492	end_base_include = time_ns()
493
494	const _sysimage_modules = PkgId[]
495	in_sysimage(pkgid::PkgId) = pkgid in _sysimage_modules	9,404✔
496
497	# Precompiles for Revise and other packages
498	# TODO: move these to contrib/generate_precompile.jl
499	# The problem is they don't work there
500	for match = _methods(+, (Int, Int), -1, get_world_counter())
501	m = match.method
502	delete!(push!(Set{Method}(), m), m)
503	copy(Core.Compiler.retrieve_code_info(Core.Compiler.specialize_method(match), typemax(UInt)))
504
505	empty!(Set())
506	push!(push!(Set{Union{GlobalRef,Symbol}}(), :two), GlobalRef(Base, :two))
507	(setindex!(Dict{String,Base.PkgId}(), Base.PkgId(Base), "file.jl"))["file.jl"]
508	(setindex!(Dict{Symbol,Vector{Int}}(), [1], :two))[:two]
509	(setindex!(Dict{Base.PkgId,String}(), "file.jl", Base.PkgId(Base)))[Base.PkgId(Base)]
510	(setindex!(Dict{Union{GlobalRef,Symbol}, Vector{Int}}(), [1], :two))[:two]
511	(setindex!(IdDict{Type, Union{Missing, Vector{Tuple{LineNumberNode, Expr}}}}(), missing, Int))[Int]
512	Dict{Symbol, Union{Nothing, Bool, Symbol}}(:one => false)[:one]
513	Dict(Base => [:(1+1)])[Base]
514	Dict(:one => [1])[:one]
515	Dict("abc" => Set())["abc"]
516	pushfirst!([], sum)
517	get(Base.pkgorigins, Base.PkgId(Base), nothing)
518	sort!([1,2,3])
519	unique!([1,2,3])
520	cumsum([1,2,3])
521	append!(Int[], BitSet())
522	isempty(BitSet())
523	delete!(BitSet([1,2]), 3)
524	deleteat!(Int32[1,2,3], [1,3])
525	deleteat!(Any[1,2,3], [1,3])
526	Core.svec(1, 2) == Core.svec(3, 4)
527	any(t->t[1].line > 1, [(LineNumberNode(2,:none), :(1+1))])	×
528
529	# Code loading uses this
530	sortperm(mtime.(readdir(".")), rev=true)
531	# JLLWrappers uses these
532	Dict{UUID,Set{String}}()[UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210")] = Set{String}()
533	get!(Set{String}, Dict{UUID,Set{String}}(), UUID("692b3bcd-3c85-4b1f-b108-f13ce0eb3210"))
534	eachindex(IndexLinear(), Expr[])
535	push!(Expr[], Expr(:return, false))
536	vcat(String[], String[])
537	k, v = (:hello => nothing)
538	precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int))
539	precompile(indexed_iterate, (Pair{Symbol, Union{Nothing, String}}, Int, Int))
540	# Preferences uses these
541	precompile(get_preferences, (UUID,))
542	precompile(record_compiletime_preference, (UUID, String))
543	get(Dict{String,Any}(), "missing", nothing)
544	delete!(Dict{String,Any}(), "missing")
545	for (k, v) in Dict{String,Any}()
546	println(k)
547	end
548
549	break # only actually need to do this once
550	end
551
552	if is_primary_base_module
553
554	# Profiling helper
555	# triggers printing the report and (optionally) saving a heap snapshot after a SIGINFO/SIGUSR1 profile request
556	# Needs to be in Base because Profile is no longer loaded on boot
557	const PROFILE_PRINT_COND = Ref{Base.AsyncCondition}()
558	function profile_printing_listener()	377✔
559	profile = nothing	×
560	try	377✔
561	while true	377✔
562	wait(PROFILE_PRINT_COND[])	377✔
563	profile = @something(profile, require(PkgId(UUID("9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"), "Profile")))	×
564
565	invokelatest(profile.peek_report[])	×
566	if Base.get_bool_env("JULIA_PROFILE_PEEK_HEAP_SNAPSHOT", false) === true	×
567	println(stderr, "Saving heap snapshot...")	×
568	fname = invokelatest(profile.take_heap_snapshot)	×
569	println(stderr, "Heap snapshot saved to `$(fname)`")	×
570	end
571	end	×
572	catch ex
573	if !isa(ex, InterruptException)	×
574	@error "Profile printing listener crashed" exception=ex,catch_backtrace()	×
575	end
576	end
577	end
578
579	function __init__()	487✔
580	# Base library init
581	reinit_stdio()	487✔
582	Multimedia.reinit_displays() # since Multimedia.displays uses stdout as fallback	487✔
583	# initialize loading
584	init_depot_path()	487✔
585	init_load_path()	487✔
586	init_active_project()	487✔
587	append!(empty!(_sysimage_modules), keys(loaded_modules))	487✔
588	if haskey(ENV, "JULIA_MAX_NUM_PRECOMPILE_FILES")	487✔
589	MAX_NUM_PRECOMPILE_FILES[] = parse(Int, ENV["JULIA_MAX_NUM_PRECOMPILE_FILES"])	×
590	end
591	# Profiling helper
592	@static if !Sys.iswindows()	×
593	# triggering a profile via signals is not implemented on windows
594	cond = Base.AsyncCondition()	487✔
595	Base.uv_unref(cond.handle)	487✔
596	PROFILE_PRINT_COND[] = cond	487✔
597	ccall(:jl_set_peek_cond, Cvoid, (Ptr{Cvoid},), PROFILE_PRINT_COND[].handle)	487✔
598	errormonitor(Threads.@spawn(profile_printing_listener()))	864✔
599	end
600	# Prevent spawned Julia process from getting stuck waiting on Tracy to connect.
601	delete!(ENV, "JULIA_WAIT_FOR_TRACY")	487✔
602	nothing	487✔
603	end
604
605	# enable threads support
606	@eval PCRE PCRE_COMPILE_LOCK = Threads.SpinLock()
607
608	end
609
610
611	end # baremodule Base

JuliaLang / julia / #37552

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