Merge branch 'master' into readeach_type_stability

Compiler/test/EAUtils.jl

@@ -4,8 +4,7 @@ export code_escapes, @code_escapes, __clear_cache!
 
 include("setup_Compiler.jl")
 
-using ..EscapeAnalysis
-const EA = EscapeAnalysis
+using .Compiler: EscapeAnalysis as EA
 
 # AbstractInterpreter
 # -------------------

base/float.jl

@@ -924,8 +924,8 @@ end
 """
     nextfloat(x::AbstractFloat)
 
-Return the smallest floating point number `y` of the same type as `x` such `x < y`. If no
-such `y` exists (e.g. if `x` is `Inf` or `NaN`), then return `x`.
+Return the smallest floating point number `y` of the same type as `x` such that `x < y`.
+If no such `y` exists (e.g. if `x` is `Inf` or `NaN`), then return `x`.
 
 See also: [`prevfloat`](@ref), [`eps`](@ref), [`issubnormal`](@ref).
 """
@@ -942,8 +942,8 @@ prevfloat(x::AbstractFloat, d::Integer) = nextfloat(x, -d)
 """
     prevfloat(x::AbstractFloat)
 
-Return the largest floating point number `y` of the same type as `x` such `y < x`. If no
-such `y` exists (e.g. if `x` is `-Inf` or `NaN`), then return `x`.
+Return the largest floating point number `y` of the same type as `x` such that `y < x`.
+If no such `y` exists (e.g. if `x` is `-Inf` or `NaN`), then return `x`.
 """
 prevfloat(x::AbstractFloat) = nextfloat(x,-1)
 

base/loading.jl

@@ -1433,6 +1433,7 @@ function run_module_init(mod::Module, i::Int=1)
 end
 
 function run_package_callbacks(modkey::PkgId)
+    @assert modkey != precompilation_target
     run_extension_callbacks(modkey)
     assert_havelock(require_lock)
     unlock(require_lock)
@@ -1562,7 +1563,7 @@ function _insert_extension_triggers(parent::PkgId, extensions::Dict{String, Any}
             uuid_trigger = UUID(totaldeps[trigger]::String)
             trigger_id = PkgId(uuid_trigger, trigger)
             push!(trigger_ids, trigger_id)
-            if !haskey(Base.loaded_modules, trigger_id) || haskey(package_locks, trigger_id)
+            if !haskey(Base.loaded_modules, trigger_id) || haskey(package_locks, trigger_id) || (trigger_id == precompilation_target)
                 trigger1 = get!(Vector{ExtensionId}, EXT_DORMITORY, trigger_id)
                 push!(trigger1, gid)
             else
@@ -1575,6 +1576,7 @@ end
 loading_extension::Bool = false
 loadable_extensions::Union{Nothing,Vector{PkgId}} = nothing
 precompiling_extension::Bool = false
+precompilation_target::Union{Nothing,PkgId} = nothing
 function run_extension_callbacks(extid::ExtensionId)
     assert_havelock(require_lock)
     succeeded = try
@@ -3081,6 +3083,7 @@ function create_expr_cache(pkg::PkgId, input::String, output::String, output_o::
         Base.track_nested_precomp($(_pkg_str(vcat(Base.precompilation_stack, pkg))))
         Base.loadable_extensions = $(_pkg_str(loadable_exts))
         Base.precompiling_extension = $(loading_extension)
+        Base.precompilation_target = $(_pkg_str(pkg))
         Base.include_package_for_output($(_pkg_str(pkg)), $(repr(abspath(input))), $(repr(depot_path)), $(repr(dl_load_path)),
             $(repr(load_path)), $(_pkg_str(concrete_deps)), $(repr(source_path(nothing))))
         """)

base/show.jl

@@ -443,7 +443,7 @@ function show_circular(io::IOContext, @nospecialize(x))
     for (k, v) in io.dict
         if k === :SHOWN_SET
             if v === x
-                print(io, "#= circular reference @-$d =#")
+                printstyled(io, "#= circular reference @-$d =#"; color = :yellow)
                 return true
             end
             d += 1

deps/checksums/LinearAlgebra-56d561c22e1ab8e0421160edbdd42f3f194ecfa8.tar.gz/md5

@@ -0,0 +1 @@
+00198e6d92d033fb33e75cf4eac34dca

deps/checksums/LinearAlgebra-56d561c22e1ab8e0421160edbdd42f3f194ecfa8.tar.gz/sha512

@@ -0,0 +1 @@
+ba4b390d99644c31d64594352da888e9ef18021cc9b7700c37a6cdb0c1ff2532eb208ecaccf93217e3183e1db8e6c089456fa5d93633b8ff037e8796199934e7

doc/src/devdocs/EscapeAnalysis.md

@@ -20,7 +20,8 @@ This escape analysis aims to:
 You can give a try to the escape analysis by loading the `EAUtils.jl` utility script that
 defines the convenience entries `code_escapes` and `@code_escapes` for testing and debugging purposes:
 ```@repl EAUtils
-using Base.Compiler: EscapeAnalysis # or `using Compiler: EscapeAnalysis` to use the stdlib version
+# InteractiveUtils.@activate Compiler # to use the stdlib version of the Compiler
+
 let JULIA_DIR = normpath(Sys.BINDIR, "..", "share", "julia")
     include(normpath(JULIA_DIR, "Compiler", "test", "EAUtils.jl"))
     using .EAUtils

julia.spdx.json

@@ -86,6 +86,18 @@
             "copyrightText": "Copyright (c) 2020 Stefan Karpinski <stefan@karpinski.org> and contributors",
             "summary": "ArgTools provides tools for creating consistent, flexible APIs that work with various kinds of function arguments."
         },
+        {
+            "name": "LinearAlgebra.jl",
+            "SPDXID": "SPDXRef-JuliaLinearAlgebra",
+            "downloadLocation": "git+https://github.com/JuliaLang/LinearAlgebra.jl.git",
+            "filesAnalyzed": false,
+            "homepage": "https://juliastats.org",
+            "sourceInfo": "The git hash of the version in use can be found in the file stdlib/LinearAlgebra.version",
+            "licenseConcluded": "MIT",
+            "licenseDeclared": "MIT",
+            "copyrightText": "Copyright (c) 2009-2024: Jeff Bezanson, Stefan Karpinski, Viral B. Shah, and other contributors: https://github.com/JuliaLang/julia/contributors",
+            "summary": "Development repository for the LinearAlgebra standard library (stdlib) that ships with Julia."
+        },
         {
             "name": "Tar.jl",
             "SPDXID": "SPDXRef-JuliaTar",

stdlib/.gitignore

@@ -29,6 +29,8 @@
 /StyledStrings
 /JuliaSyntaxHighlighting-*
 /JuliaSyntaxHighlighting
+/LinearAlgebra-*
+/LinearAlgebra
 /*_jll/StdlibArtifacts.toml
 /*/Manifest.toml
 /*.image

stdlib/LinearAlgebra.version

@@ -0,0 +1,4 @@
+LINEARALGEBRA_BRANCH = master
+LINEARALGEBRA_SHA1 = 56d561c22e1ab8e0421160edbdd42f3f194ecfa8
+LINEARALGEBRA_GIT_URL := https://github.com/JuliaLang/LinearAlgebra.jl.git
+LINEARALGEBRA_TAR_URL = https://api.github.com/repos/JuliaLang/LinearAlgebra.jl/tarball/$1