Skip setName on folded inputs, and ensure
the correct pointer address space is used.

(cherry picked from commit baca8ba)

…54840)

Like #54671, but for
`speccache_eq`.

Saw another segfault with this in the stack trace, hence this fix. I
also looked for other uses of `jl_smallintset_lookup` and there's one in
`idset.c`. That doesn't appear to be racy but I'm not familiar with the
code, so maybe you can take a look at it in case we need to push a fix
for that one too @gbaraldi or @vtjnash?

(cherry picked from commit dd1ed17)

Fixes #57789

(cherry picked from commit 6817691)

Closes #57376
Closes #34037

- Adds a lock in `SimpleLogger` and `ConsoleLogger` for use on maxlog
tracking and stream writes to improve threadsafety.
Closely similar to #54497

- Turns the internal `_min_enabled_level` into a `Threads.Atomic`. There
are [some direct
interactions](https://juliahub.com/ui/Search?type=code&q=_min_enabled_level&w=true)
to this internal in the ecosystem, but they should still work
```
julia> Base.CoreLogging._min_enabled_level[] = Logging.Info+1
LogLevel(1)
```

- Brings tests over from #57448

Performance seems highly similar:

### Master
```
julia> @time for i in 1:10000
          @info "foo" maxlog=10000000
       end
[ Info: foo
...
  0.481446 seconds (1.33 M allocations: 89.226 MiB, 0.49% gc time)
```

### This PR
```
  0.477235 seconds (1.31 M allocations: 79.002 MiB, 1.77% gc time)
```

(cherry picked from commit 9af9650)

…!` (#56673)

(cherry picked from commit 0947114)

(cherry picked from commit 088bb90)

(cherry picked from commit f5e983e)

When this API was added, this function inlined, which is important,
because the API relies on the allocation of the `Ref` being elided. At
some point (I went back to 1.8) this regressed. For example, it is
currently responsible for substantially all non-Expr allocations in
JuliaParser. Before (parsing all of Base with JuliaParser):
```
│     Memory estimate: 76.93 MiB, allocs estimate: 719922.
```
After:
```
│     Memory estimate: 53.31 MiB, allocs estimate: 156.
```

Also add a test to make sure this doesn't regress again.

(cherry picked from commit d6294ba)

(cherry picked from commit 8567a3a)

(cherry picked from commit 7b6065e)

Currently, `similar(::CodeUnits)` works as expected by going through the
generic `AbstractArray` method. However, the fallback method hit by
`similar(::Type{<:CodeUnits}, dims)` does not work, as it assumes the
existence of a constructor that accepts an `UndefInitializer`. This can
be made to work by defining a corresponding `similar` method that
returns an `Array`.

One could make a case that this is a bugfix since it was arguably a bug
that this method didn't work given that `CodeUnits` is an
`AbstractArray` subtype and the other `similar` methods work. If anybody
buys that argument, it could be nice to backport this; it came up in
some internal code that uses Arrow.jl and JSON3.jl together.

(cherry picked from commit 8e524c7)

(cherry picked from commit 2349f43)

(cherry picked from commit 1f6eff1)

[The "parsing" section of the "eval" dev docs
page](https://docs.julialang.org/en/v1/devdocs/eval/#dev-parsing) was
not updated when JuliaSyntax.jl was adopted in 1.10. This updates the
text to reflect that it is the default parser and briefly mentions how
to switch back.

(cherry picked from commit ec27274)

This was originally added as a workaround for the behavior of sh to try
to become the terminal process group leader, but no longer relevant
since #25006 removed that flag again:
```
julia> run(detach(`bash -i -c "sleep 0"`))
bash: cannot set terminal process group (-1): Inappropriate ioctl for device
bash: no job control in this shell
Process(`bash -i -c 'sleep 0'`, ProcessExited(0))
```

Long explanation: Julia recieves SIGTTOU when a process like "sh -i -c"
exits (at least for bash and zsh, but not dash, ksh, or csh),
since "sh -i" sometimes takes over the controlling terminal, causing
julia to stop once the bash process exits. This can be quite annoying,
but julia goes through some pains (in libuv) to ensure it doesn't steal
the controlling terminal from the parent, and apparently bash is not so
careful about it. However, since PR #25006, julia hasn't needed this
workaround for this issue, so we can now follow the intended behavior
when the child is in the same session group and steals the controlling
terminal from the parent. Even if such behavior seems odd, this seems
to be the intended behavior per posix design implementation that it
gets SIGTTOU when julia later tries to change mode (from cooked -> raw
after printing the prompt):
http://curiousthing.org/sigttin-sigttou-deep-dive-linux.

For some background on why this is a useful signal and behavior and
should not be just blocked, see nodejs/node#35536.

According to glibc, there's a half page of code for how to correctly
implement a REPL mode change call:
https://www.gnu.org/software/libc/manual/html_node/Initializing-the-Shell.html

```
$ ./julia -q
shell> bash -i -c "sleep 1"

[1]+  Stopped                 ./julia

julia> run(`zsh -i -c "sleep 0"`)
Process(`zsh -i -c 'sleep 0'`, ProcessExited(0))

julia>
[1]+  Stopped                 ./julia
```

(cherry picked from commit 0cbe466)

The fields of `StringIndexError` are abstractly typed, so there's no
reason to specialize on a concrete type. The change seems like
it could prevent some invalidation on loading user code.

---------

Co-authored-by: Shuhei Kadowaki <40514306+aviatesk@users.noreply.github.com>
(cherry picked from commit bc33a3e)

The current method :jl_type_to_llvm takes a pointer-to-bool parameter
isboxed, which if non-null, is set to true if the Julia Type requires
boxing. However, one may want to know the julia type without boxing and
there is no mechanism for doing so. Now there is `julia_struct_to_llvm`.

(cherry picked from commit 85f1b8c)

…lization (#59511)

Fixes #59510

(cherry picked from commit 8230e8b)

Changes from #43151, github just
didn't want me to re-open it.

As discussed on slack, any `hygienic-scope` within an outer
`hygienic-scope` can read and write variables in the outer one, so it's
not particularly hygienic. The result is that we can't safely nest macro
calls unless they know the contents of all inner macro calls.

Should fix #48910.

Co-authored-by: Michiel Dral <m.c.dral@gmail.com>
(cherry picked from commit ff33305)

…60798)

Backport of #60695 particularly

(cherry picked from d875df4)

That is, if it is called twice (e.g. because precompilation is disabled)
with identical arguments, then this should not trigger an assertion.

This should resolve oscar-system/GAP.jl#1314

(cherry picked from commit 1708d99)

Test suite: switch to `httpbingo.julialang`, fall back to `httpbin.julialang` on failure

(cherry picked from commit 5ab8db3)