Add invokelatest barrier to string(...) in @assert

[topolarity]

This change protects @assert from invalidations to Base.string(...) by adding an invokelatest barrier.

A common source of invalidations right now is print(io, join(args...)). The problem is:

1. Inference concludes that join(::Any...) returns Union{String,AnnotatedString}
2. The print call is union-split to String and AnnotatedString
3. This code is now invalidated when StyledStrings defines print(io, ::AnnotatedString)

The invalidation chain for @assert is similar: @assert 1 == 1 calls into string(::Expr) which calls into print(io, join(args::Any...)). Unfortunately that leads to the invalidation of almost all @asserts without an explicit error message

Similar to #55583 (comment)

[IanButterworth]

Great! This fixes the Artifacts._artifact_str invalidation seen here JuliaPackaging/LazyArtifacts.jl#1 (comment)

Master with JuliaPackaging/LazyArtifacts.jl#1

% ./julia --start=no --trace-compile=stderr --trace-compile-timing -e "using InteractiveUtils; @time @time_imports using MicroMamba"
      0.5 ms  Printf
     15.0 ms  Dates
      0.3 ms  Scratch
     10.0 ms  LazyArtifacts
      1.0 ms  TOML
      7.2 ms  Preferences
      0.5 ms  JLLWrappers
               ┌ 545.2 ms micromamba_jll.__init__() 99.93% compilation time (88% recompilation)
    545.7 ms  micromamba_jll 99.84% compilation time (88% recompilation)
      0.4 ms  MicroMamba
  0.586889 seconds (763.19 k allocations: 40.931 MiB, 5.56% gc time, 92.84% compilation time: 88% of which was recompilation)

Full detail:

% ./julia --start=no --trace-compile=stderr --trace-compile-timing -e "using InteractiveUtils; @time @time_imports using MicroMamba"
      0.5 ms  Printf
     15.0 ms  Dates
      0.3 ms  Scratch
     10.0 ms  LazyArtifacts
      1.0 ms  TOML
      7.2 ms  Preferences
      0.5 ms  JLLWrappers
#=    0.0 ms =# precompile(Tuple{typeof(micromamba_jll.__init__)})
#=    0.0 ms =# precompile(Tuple{typeof(micromamba_jll.find_artifact_dir)})
#=    2.4 ms =# precompile(Tuple{Type{Base.Val{x} where x}, Module})
#=    2.0 ms =# precompile(Tuple{Type{NamedTuple{(:honor_overrides,), T} where T<:Tuple}, Tuple{Bool}})
#=  439.9 ms =# precompile(Tuple{typeof(Artifacts._artifact_str), Module, String, Base.SubString{String}, String, Base.Dict{String, Any}, Base.SHA1, Base.BinaryPlatforms.Platform, Base.Val{LazyArtifacts}})
#=   24.4 ms =# precompile(Tuple{typeof(Base.unique!), Array{String, 1}})
#=    1.3 ms =# precompile(Tuple{typeof(Base.invokelatest), Any})
#=    0.0 ms =# precompile(Tuple{typeof(JLLWrappers.get_julia_libpaths)})
#=    7.8 ms =# precompile(Tuple{typeof(Base.vcat), Array{String, 1}, Array{String, 1}})
               ┌ 545.2 ms micromamba_jll.__init__() 99.93% compilation time (88% recompilation)
    545.7 ms  micromamba_jll 99.84% compilation time (88% recompilation)
      0.4 ms  MicroMamba
#=    2.0 ms =# precompile(Tuple{Type{NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), T} where T<:Tuple}, Tuple{Nothing, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}})
#=    2.9 ms =# precompile(Tuple{typeof(Base.getproperty), NamedTuple{(:value, :time, :bytes, :gctime, :gcstats, :lock_conflicts, :compile_time, :recompile_time), Tuple{Nothing, Float64, Int64, Float64, Base.GC_Diff, Int64, Float64, Float64}}, Symbol})
#=   26.4 ms =# precompile(Tuple{typeof(Core.kwcall), NamedTuple{(:msg,), Tuple{Nothing}}, typeof(Base.time_print), Base.TTY, Float64, Int64, Int64, Int64, Int64, Float64, Float64, Bool})
  0.586889 seconds (763.19 k allocations: 40.931 MiB, 5.56% gc time, 92.84% compilation time: 88% of which was recompilation)

This PR with JuliaPackaging/LazyArtifacts.jl#1

% ./julia --start=no -e "using InteractiveUtils; @time @time_imports using MicroMamba"
      0.7 ms  Printf
     21.5 ms  Dates
      0.5 ms  Scratch
     14.9 ms  LazyArtifacts
      0.9 ms  TOML
      8.7 ms  Preferences
      0.5 ms  JLLWrappers
               ┌ 44.7 ms micromamba_jll.__init__() 99.60% compilation time (3% recompilation)
     45.3 ms  micromamba_jll 98.17% compilation time (3% recompilation)
      0.4 ms  MicroMamba
  0.129260 seconds (177.54 k allocations: 9.573 MiB, 34.42% compilation time: 3% of which was recompilation)

More info & improvement at #55740

[aviatesk]

I think this is a great idea. The 1-arg @assert often leads to poor type inference due to recursive extended inference (xref: #55625). Using invokelatest would eliminate that concern too.

[vtjnash]

I don't know if we want to do invokelatest here, as it could do some very weird things if Core.Compiler runs into an asserts if the resulting string code then does anything unexpected. Should we try to separate that so that Core.Compiler uses a slightly different asserts macro?

[vtjnash]

We could also use invokeinworld with tls_world_age, or an inferencebarrier to achieve similar effects?