Since the values stored in the parent corresponding to the structural
zeros of a tridiagonal matrix aren't well-defined, using it in `ldiv!`
is a footgun that may lead to heisenbugs (one seen in
https://buildkite.com/julialang/julia-master/builds/31285#018c7cc7-6c77-41ac-a01b-1c7d14cb1b15).
This PR changes it to using the tridiagonal matrix directly in `ldiv!`,
which should lead to predictable results, and be bug-free. The failing
tests for #52571 pass locally with this change.

(cherry picked from commit ef549ae)

Make these consistent with what's shown by `julia --help`.

Fixes JuliaLang/www.julialang.org#1997.

(cherry picked from commit e7e8b89)

Fixes #52404
@nilshg I opted to make it one line as it fits.
```
julia> versioninfo()
Julia Version 1.11.0-DEV.1011
Commit bb7091c* (2023-12-04 14:58 UTC)
Platform Info:
  OS: macOS (arm64-apple-darwin23.0.0)
  CPU: 10 × Apple M2 Pro
  WORD_SIZE: 64
  LLVM: libLLVM-15.0.7 (ORCJIT, apple-m1)
  Threads: 1 default, 0 interactive, 1 GC (on 6 virtual cores)
Environment:
  JULIA_EDITOR = code
```

(cherry picked from commit e96c13a)

Fix #52613 by making the TypeVar special case in inference check for
vararg first. There's nothing the special case can really do with vararg
anyway, so fall back to the ordinary abstract call handling.

Fixes #52686
Fixes timholy/Revise.jl#770

---------

Co-authored-by: Jameson Nash <vtjnash@gmail.com>
Co-authored-by: Kristoffer Carlsson <kcarlsson89@gmail.com>
Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>

…) (#52774)

Fixes another variant of #52531.

Issues like #52531 were more broadly fixed by #52856. This commit
partially reverts #52596, while leaving the added tests.

The fallback code that was written for #41099 is causing unintended
issues with some inlined stack frames (one previous #51405, new #52709),
since the main piece, linetable storage and lookup, was removed in
#50546. Probably better to strip it all back to how it was previously,
until it can all be revisited more fully.

Should be backported to 1.10.

…52836)

Investigating into #52763, I've found that `AbstractInterpreters` which
enables the `aggressive_constprop` option, such as `REPLInterpreter`,
might perform const-prop' even if the result of a non-const call is
`LimitedAccuracy`. This can lead to an unintended infinite loop with a
custom aggressive const-prop' implementation.

This commit restricts const-prop' for such cases where the non-const
call result is limited to avoid the issue. This fix is conservative, but
given that accurate inference is mostly impossible when there are
unresolvable cycles (which is indicated by limited result), aggressive
const-prop' isn't necessary for such cases, and I don't anticipate this
leading to any obvious regression.

fix #52763

…ead289a (#52886)

Stdlib: Downloads
URL: https://github.com/JuliaLang/Downloads.jl.git
Stdlib branch: release-1.10
Julia branch: backports-release-1.10
Old commit: f97c72f
New commit: ead289a
Julia version: 1.10.0
Downloads version: 1.6.0(It's okay that it doesn't match)
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
JuliaLang/Downloads.jl@f97c72f...ead289a

```
$ git log --oneline f97c72f..ead289a
ead289a Close Multi timers atexit. Add 1.6 CI (#234)
8a614d5 Skip flakey "concurrent requests" tests on windows (#228)
246504e add a small precompile workload (#226)
3ed0f08 Document how to bypass the 20-second timeout (#222)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>

I think when we backed off the new heuristics for 1.10 this got missed
in the meanwhile.
Should fix #52923

…2228)

…00df7 (#53008)

…5539d (#53028)

Stdlib: Pkg
URL: https://github.com/JuliaLang/Pkg.jl.git
Stdlib branch: release-1.10
Julia branch: backports-release-1.10
Old commit: 11cf00df7
New commit: 70525539d
Julia version: 1.10.0
Pkg version: 1.10.0
Bump invoked by: @IanButterworth
Powered by:
[BumpStdlibs.jl](https://github.com/JuliaLang/BumpStdlibs.jl)

Diff:
JuliaLang/Pkg.jl@11cf00d...7052553

```
$ git log --oneline 11cf00df7..70525539d
70525539d Merge pull request #3770 from JuliaLang/backports-release-1.10
729ebe1e3 Avoid deleting existing artifacts when ignoring hashes. (#3768)
```

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>

(cherry picked from commit fb76136)

…an environment higher in the load path (#52637)

I noticed this when seeing some weird precompile issues when I had
SparseArrays devved in my main environment but it was with the standard
stdlib format in the current environment:

```
(NearestNeighbors) pkg> st -m
Project NearestNeighbors v0.4.15
Status `~/JuliaPkgs/NearestNeighbors.jl/Manifest.toml`
...
  [2f01184e] SparseArrays v1.10.0
...
```

But even so, `locate_package` claims that the path to SparseArrays is
the one in the main environment:

```
julia> pkg = Base.PkgId(Base.UUID("2f01184e-e22b-5df5-ae63-d93ebab69eaf"), "SparseArrays")
SparseArrays [2f01184e-e22b-5df5-ae63-d93ebab69eaf]

julia> Base.locate_package(pkg)
"/home/kc/JuliaPkgs/SparseArrays.jl/src/SparseArrays.jl"
```

This correctly fixes it so that packages without a `git-tree-sha1` (and
without a `path`) are resolved to the stdlib path.

(cherry picked from commit c9bc2ff)

Handle any sort of cycle encountered in the datatype super fields by
always deferring that field until later and setting a deferred mechanism
for updating the field only after the supertype is ready.

Fix #52660

(cherry picked from commit c94b1a3)

…dows env variables (#52758)

Should fix #52711.

My analysis of the invalidation is as follows:

We added code to cache the conversion to `cwstring` in env handling on
Windows (#51371):

```julia
const env_dict = IdDict{String, Vector{UInt16}}()

function memoized_env_lookup(str::AbstractString)
    ...
    env_dict[str] = cwstring(str)
    ...
end

function access_env(onError::Function, str::AbstractString)
    var = memoized_env_lookup(str)
    ...
end
```

Since `IdDict` has `@nospecialize` on `setindex!` we compile this
method:

```julia
setindex!(::IdDict{String, Vector{UInt16}}, ::Any, ::Any)
```

which has an edge to:

```julia
convert(Type{Vector{Int64}}, Any})
```

But then StaticArrays comes along and adds a method

```julia
convert(::Type{Array{T, N}}, ::StaticArray)
```

which invalidates the `setindex!` (due to the edge to `convert`) which
invalidates the whole env handling on Windows which causes 4k other
methods downstream to be invalidated, in particular, the artifact string
macro which causes a significant delay in the next jll package you load
after loading StaticArrays.

There should be no performance penalty to this since strings already
does a hash for their `objectid`.

(cherry picked from commit b7c24ed)

This is #48814 times 23. It solves most of but not all of #50035.

(cherry picked from commit a327a95)

…alse-sharing (#52994)

For some reason this only shows up in the `many_refs.jl` benchmark,
since it's the only one that hammers the work-stealing queue (we also
didn't test this benchmark on a large number of GC threads in our
[previous
analysis](#48600 (comment))).

- master:
```
bench = "many_refs.jl"
(gcthreads, threads) = (1, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       4268 │    3243 │      3048 │        194 │         1126 │                15 │      868 │         76 │
│  median │       4270 │    3246 │      3051 │        195 │         1128 │                17 │      868 │         76 │
│ maximum │       4278 │    3247 │      3052 │        195 │         1128 │                18 │      868 │         76 │
│   stdev │          5 │       2 │         2 │          0 │            1 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (2, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2728 │    1692 │      1551 │        141 │          598 │                23 │      868 │         62 │
│  median │       2732 │    1709 │      1567 │        141 │          603 │                23 │      868 │         62 │
│ maximum │       2744 │    1712 │      1571 │        143 │          607 │                24 │      868 │         63 │
│   stdev │          6 │       9 │         9 │          1 │            4 │                 0 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (4, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2105 │    1082 │       987 │         95 │          405 │                23 │      875 │         51 │
│  median │       2115 │    1089 │       994 │         95 │          409 │                23 │      875 │         52 │
│ maximum │       2127 │    1100 │      1003 │         97 │          417 │                25 │      875 │         52 │
│   stdev │          8 │       8 │         7 │          1 │            5 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (8, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       3861 │    2755 │      2676 │         79 │         1301 │                22 │      878 │         68 │
│  median │       3864 │    2835 │      2756 │         80 │         1342 │                25 │      879 │         73 │
│ maximum │       4032 │    2877 │      2797 │         80 │         1378 │                26 │      880 │         74 │
│   stdev │         73 │      45 │        45 │          1 │           28 │                 2 │        1 │          2 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (16, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       7455 │    6425 │      6344 │         80 │         3262 │                24 │      882 │         86 │
│  median │       7703 │    6682 │      6602 │         81 │         3313 │                25 │      884 │         87 │
│ maximum │       7826 │    6806 │      6725 │         81 │         3422 │                27 │      887 │         87 │
│   stdev │        152 │     153 │       153 │          0 │           68 │                 1 │        2 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```

- PR:
```
bench = "many_refs.jl"
(gcthreads, threads) = (1, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       4264 │    3240 │      3048 │        192 │         1127 │                15 │      868 │         76 │
│  median │       4271 │    3244 │      3052 │        192 │         1129 │                17 │      868 │         76 │
│ maximum │       4514 │    3481 │      3289 │        193 │         1247 │                18 │      868 │         77 │
│   stdev │        109 │     106 │       106 │          0 │           53 │                 1 │        0 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (2, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2712 │    1680 │      1541 │        138 │          591 │                22 │      868 │         62 │
│  median │       2713 │    1691 │      1552 │        140 │          594 │                24 │      868 │         62 │
│ maximum │       2732 │    1710 │      1569 │        141 │          606 │                25 │      868 │         63 │
│   stdev │         11 │      12 │        12 │          1 │            6 │                 1 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (4, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2090 │    1057 │       962 │         95 │          398 │                22 │      874 │         50 │
│  median │       2103 │    1070 │       974 │         95 │          401 │                24 │      874 │         51 │
│ maximum │       2140 │    1074 │       978 │         96 │          402 │                25 │      875 │         51 │
│   stdev │         19 │       6 │         6 │          0 │            1 │                 1 │        1 │          1 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (8, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2236 │    1208 │      1129 │         79 │          528 │                23 │      880 │         54 │
│  median │       2238 │    1214 │      1135 │         79 │          533 │                23 │      880 │         54 │
│ maximum │       2246 │    1218 │      1138 │         80 │          534 │                35 │      880 │         54 │
│   stdev │          4 │       4 │         4 │          0 │            3 │                 5 │        0 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
(gcthreads, threads) = (16, 1)
┌─────────┬────────────┬─────────┬───────────┬────────────┬──────────────┬───────────────────┬──────────┬────────────┐
│         │ total time │ gc time │ mark time │ sweep time │ max GC pause │ time to safepoint │ max heap │ percent gc │
│         │         ms │      ms │        ms │         ms │           ms │                us │       MB │          % │
├─────────┼────────────┼─────────┼───────────┼────────────┼──────────────┼───────────────────┼──────────┼────────────┤
│ minimum │       2326 │    1297 │      1216 │         80 │          595 │                24 │      884 │         56 │
│  median │       2348 │    1325 │      1245 │         80 │          620 │                25 │      885 │         56 │
│ maximum │       2370 │    1341 │      1262 │         81 │          631 │                26 │      887 │         57 │
│   stdev │         17 │      19 │        19 │          0 │           14 │                 1 │        1 │          0 │
└─────────┴────────────┴─────────┴───────────┴────────────┴──────────────┴───────────────────┴──────────┴────────────┘
```

(cherry picked from commit 9f36490)

The type-assertion helps convey the information that
`iterate(tail(s)...)` would never return `nothing`, which makes JET
happy.
On master
```julia
julia> L = Base.LogicalIndex([true])
1-element Base.LogicalIndex{Int64, Vector{Bool}}:
 1

julia> @report_call iterate(L)
═════ 2 possible errors found ═════
┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}) @ Base ./multidimensional.jl:778
│┌ iterate(L::Base.LogicalIndex{Int64, Vector{Bool}}, s::Tuple{Int64, LinearIndices{1, Tuple{Base.OneTo{Int64}}}}) @ Base ./multidimensional.jl:789
││┌ indexed_iterate(I::Nothing, i::Int64) @ Base ./tuple.jl:94
│││ no matching method found `iterate(::Nothing)`: x = iterate(I::Nothing)
││└────────────────────
││┌ indexed_iterate(I::Nothing, i::Int64, state::Int64) @ Base ./tuple.jl:99
│││ no matching method found `iterate(::Nothing, ::Int64)`: x = iterate(I::Nothing, state::Int64)
```
This PR
```julia
julia> @report_call iterate(L)
No errors detected
```

Close JuliaArrays/StaticArrays.jl#1225

(cherry picked from commit 32ad80b)

When splitting a Markdown list item into multiple lines, the following
lines must be indented or else a new paragraph starts.

(cherry picked from commit 35c0498)

We had some common code in `Ryu.append_c_digits` that can be combined
with Base logic for the same thing. But it turns out all of this
duplicated code in Ryu seems to just make it run slightly slower in most
cases. The old version had many more branches to check, even though
often numbers are small, so only the last check is meaningful. But the
assumption that it would be faster even if all of them were used also
seems to not hold up in practice. Particularly for a function like
`append_nine_digits` which unrolls completely, but the complicated
version has slightly more data dependencies because of they way it is
written.

Similarly, we replace `unsafe_copy` with `@inbounds[]`, since this is
better for the optimizer, which doesn't need to treat this operation as
an unknown reference escape.

Lastly, we use the append_nine_digits trick from Ryu to make printing of
arbitrary big numbers much faster.

```
julia> @Btime string(typemax(Int128))
  402.345 ns (2 allocations: 120 bytes) # before
  151.139 ns (2 allocations: 120 bytes) # after
```

(cherry picked from commit e9d9314)

Fixes #52749.

(cherry picked from commit 5643c60)

This makes the function signatures match the respective docstrings, as
well as that of `Symmetric/Hermitian`.

(cherry picked from commit b4eefd0)

Should fix #52558. `a` should be rooted before the alloc call. I removed
the comment as it seemed to refer to a write barrier that was removed
long ago.

(cherry picked from commit 5977cb0)

…es (#52618)

(cherry picked from commit fe0db7d)

)

https://github.com/JuliaLang/julia/blob/8a69745bdcb06409ab7e4fc84718f34d7d54a7f9/base/lock.jl#L33-L50
this probably also needs a fix, and maybe other places as well

(cherry picked from commit 91ec2bb)

There is no HTML entity `⇔` and accordingly all the usual browsers
(Chrome, Firefox, Safari) don't render it.

My guess is that there is confusion because GitHub supports `⇔` and
shows it as ⇔ (and `↔` as ↔).

But here is for example what Firefox shows:
<img width="853" alt="Screen Shot 2023-11-08 at 14 02 01"
src="https://github.com/JuliaLang/julia/assets/241512/af7d9e27-a5c3-46c3-94d9-82ed52653cb4">

This patch could be backported to 1.9 and 1.10.

(cherry picked from commit 81c4f8e)

(cherry picked from commit 4919dd7)

The earlier test relied on the order of the method match list returned
by `_methods_by_ftype`. However, particularly in cases where the
`ambig=true` option is used, the match list isn't deterministic. This
commit modifies it, similar to other pieces of code, so that it `any` to
ensure the code does not depend on the implementation details of
`ml_matches`.

Fixes #52739.

This particular fix was part of #50805, but it wasn't included in
version 1.10, leading to situations where an incorrect `:nothrow` could
occur in 1.10 (#53062). This commit implements a minimal correction in
1.10 and also added some test cases.

Fixes #53062.

(cherry picked from commit 919c390)

Documenter does not support HTML entities. See discussion in PR #52078
for further background.

Co-authored-by: Dilum Aluthge <dilum@aluthge.com>
(cherry picked from commit 746fad0)

Closes #53054

CC: @giordano @ViralBShah

This was inefficient, though not wrong.

Fixes #53020

This avoid that these files are picked up during julia's build process,
and are instead only used to link pkgimages, as intended.

Co-authored-by: Tim Besard <tim.besard@gmail.com>
(cherry picked from commit 4ef353c)