v1.10: Possible improvements in constant-folding in all for Tuples

[jishnub]

julia> f() = all(in(('N', 'T', 'C')), ('N','T'))
f (generic function with 1 method)

julia> @descend_code_warntype f()
f() @ Main REPL[6]:1
1 f()::Bool = all(in(('N', 'T', 'C'::Tuple{Char, Char, Char})), ('N','T'))
Select a call to descend into or ↩ to ascend. [q]uit. [b]ookmark.
Toggles: [w]arn, [h]ide type-stable statements, [t]ype annotations, [s]yntax highlight for Source/LLVM/Native, [j]ump to source always.
Show: [S]ource code, [A]ST, [T]yped code, [L]LVM IR, [N]ative code
Actions: [E]dit source code, [R]evise and redisplay
 • %2 = < concrete eval > in(::Core.Const(('N', 'T', 'C')))::Core.Const(Base.Fix2{typeof(in), Tuple{Char, Char, Char}}(in, ('N', 'T', 'C')))
   all(in(('N', 'T', 'C'::Tuple{Char, Char, Char})), ('N','T'))
   ↩

julia> versioninfo()
Julia Version 1.10.0-beta3
Commit 404750f8586 (2023-10-03 12:53 UTC)
Build Info:
  Official https://julialang.org/ release
Platform Info:
  OS: Linux (x86_64-linux-gnu)
  CPU: 8 × 11th Gen Intel(R) Core(TM) i5-1135G7 @ 2.40GHz
  WORD_SIZE: 64
  LIBM: libopenlibm
  LLVM: libLLVM-15.0.7 (ORCJIT, tigerlake)
  Threads: 1 on 8 virtual cores
Environment:
  LD_LIBRARY_PATH = :/usr/lib/x86_64-linux-gnu/gtk-3.0/modules
  JULIA_EDITOR = subl

This seems to have improved on nightly v"1.11.0-DEV.595", where this is now evaluated at compile time:

julia> @descend_code_warntype f()
f() @ Main REPL[1]:1
1 f()::Core.Const(true) = all(in(('N', 'T', 'C'::Tuple{Char, Char, Char})), ('N', 'T'))
Select a call to descend into or ↩ to ascend. [q]uit. [b]ookmark.
Toggles: [w]arn, [h]ide type-stable statements, [t]ype annotations, [s]yntax highlight for Source/LLVM/Native, [j]ump to source always.
Show: [S]ource code, [A]ST, [T]yped code, [L]LVM IR, [N]ative code
Actions: [E]dit source code, [R]evise and redisplay
 • %2 = < concrete eval > in(::Core.Const(('N', 'T', 'C')))::Core.Const(Base.Fix2{typeof(in), Tuple{Char, Char, Char}}(in, ('N', 'T', 'C')))
   all(in(('N', 'T', 'C'::Tuple{Char, Char, Char})), ('N', 'T'))
   ↩

I wonder if this may be backported? I'll try to find the commit, but perhaps it's known already

[jakobnissen]

Probably #51002

I don't think ordinary non-bugfix improvements like this is usually packported. Backports tend to make the release process slower.

[jishnub]

Thanks for looking into this! I understand that it may not be possible to backport this, but the following JET report on v1.10.0-beta3 makes me a bit sad:

julia> @report_opt ignored_modules=(Base,) fill(2.0,3,3) * fill(2.0,3,3)'
═════ 34 possible errors found ═════
┌ *(A::Matrix{Float64}, B::Adjoint{Float64, Matrix{Float64}}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:113
│┌ mul!(C::Matrix{Float64}, A::Matrix{Float64}, B::Adjoint{Float64, Matrix{Float64}}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:237
││┌ mul!(C::Matrix{Float64}, A::Matrix{Float64}, B::Adjoint{Float64, Matrix{Float64}}, α::Bool, β::Bool) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:263
│││┌ generic_matmatmul!(C::Matrix{Float64}, tA::Char, tB::Char, A::Matrix{Float64}, B::Matrix{Float64}, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:367
││││┌ _generic_matmatmul!(C::Matrix{Float64}, tA::Char, tB::Char, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S}, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool}) where {T, S} @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:818
│││││┌ (::Colon)(a::Int64, b::Real) @ Base ./range.jl:3
││││││┌ promote(x::Int64, y::Real) @ Base ./promotion.jl:394
│││││││┌ not_sametype(x::T, y::T) where T<:Tuple{Int64, Real} @ Base ./promotion.jl:411
││││││││┌ sametype_error(input::Tuple{Int64, Real}) @ Base ./promotion.jl:417
│││││││││┌ map(f::Base.var"#46#47", t::Tuple{Int64, Real}) @ Base ./tuple.jl:292
││││││││││┌ (::Base.var"#46#47")(x::Int64) @ Base ./promotion.jl:418
│││││││││││┌ string(xs::Type{Int64}) @ Base ./strings/io.jl:189
││││││││││││┌ print_to_string(xs::Type{Int64}) @ Base ./strings/io.jl:148
│││││││││││││┌ print(io::IOBuffer, x::Type{Int64}) @ Base ./strings/io.jl:35
││││││││││││││┌ show(io::IOBuffer, x::Type{Int64}) @ Base ./show.jl:953
│││││││││││││││┌ _show_type(io::IOBuffer, x::Type) @ Base ./show.jl:956
││││││││││││││││┌ show_type_name(io::IOBuffer, tn::Core.TypeName) @ Base ./show.jl:1043
│││││││││││││││││┌ show(io::IOBuffer, m::Module) @ Base ./show.jl:1237
││││││││││││││││││┌ is_root_module(m::Module) @ Base ./lock.jl:269
│││││││││││││││││││┌ print(::IO, ::Char, ::Char) @ Base ./strings/io.jl:46
││││││││││││││││││││┌ print(io::IO, c::Char) @ Base ./char.jl:252
│││││││││││││││││││││┌ write(limiter::WidthLimitedIO.TextWidthLimiter, c::Char) @ WidthLimitedIO /home/jishnu/.julia/packages/WidthLimitedIO/KRQgd/src/WidthLimitedIO.jl:36
││││││││││││││││││││││ runtime dispatch detected: WidthLimitedIO.print(%19::IO, c::Char)::Any
│││││││││││││││││││││└────────────────────
│││││││││││││││││││││┌ write(limiter::WidthLimitedIO.TextWidthLimiter, c::Char) @ WidthLimitedIO /home/jishnu/.julia/packages/WidthLimitedIO/KRQgd/src/WidthLimitedIO.jl:54
││││││││││││││││││││││ runtime dispatch detected: WidthLimitedIO.print(%72::IO, …)::Any
│││││││││││││││││││││└────────────────────
│││││││││││││││││││││┌ write(limiter::WidthLimitedIO.TextWidthLimiter, c::Char) @ WidthLimitedIO /home/jishnu/.julia/packages/WidthLimitedIO/KRQgd/src/WidthLimitedIO.jl:50
││││││││││││││││││││││ runtime dispatch detected: WidthLimitedIO.print(%102::IO, c::Char)::Any
│││││││││││││││││││││└────────────────────
│││││┌ copy_transpose!(B::Matrix, ir_dest::AbstractUnitRange{Int64}, jr_dest::AbstractUnitRange{Int64}, tM::Char, M::AbstractVecOrMat, ir_src::AbstractUnitRange{Int64}, jr_src::AbstractUnitRange{Int64}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:673
││││││┌ conj!(A::SubArray{T, 2} where T<:Number) @ Base ./abstractarraymath.jl:120
│││││││┌ broadcast!(f::typeof(conj), dest::SubArray{T, 2} where T<:Number, As::SubArray{T, 2} where T<:Number) @ Base.Broadcast ./broadcast.jl:880
││││││││┌ broadcasted(::typeof(conj), ::SubArray{T, 2} where T<:Number) @ Base.Broadcast ./broadcast.jl:1341
│││││││││┌ broadcasted(style::Base.Broadcast.DefaultArrayStyle{2}, f::typeof(conj), args::SubArray{T, 2} where T<:Number) @ Base.Broadcast ./broadcast.jl:1349
││││││││││ runtime dispatch detected: Base.Broadcast.Broadcasted(style::Base.Broadcast.DefaultArrayStyle{2}, f::typeof(conj), args::Tuple{SubArray{T, 2} where T<:Number})::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}
│││││││││└────────────────────
││││││││┌ materialize!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:911
│││││││││┌ materialize!(::Base.Broadcast.DefaultArrayStyle{2}, dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:914
││││││││││┌ instantiate(bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:309
│││││││││││┌ check_broadcast_axes(shp::Tuple, A::SubArray{T, 2} where T<:Number) @ Base.Broadcast ./broadcast.jl:582
││││││││││││ runtime dispatch detected: Base.Broadcast.check_broadcast_shape(shp::Tuple, %2::Tuple)::Any
│││││││││││└────────────────────
││││││││││┌ copyto!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:956
│││││││││││┌ copyto!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:1000
││││││││││││┌ preprocess(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:983
│││││││││││││┌ preprocess_args(dest::SubArray{T, 2} where T<:Number, args::Tuple{SubArray{T, 2} where T<:Number}) @ Base.Broadcast ./broadcast.jl:987
││││││││││││││┌ preprocess(dest::SubArray{T, 2} where T<:Number, x::SubArray{T, 2} where T<:Number) @ Base.Broadcast ./broadcast.jl:984
│││││││││││││││┌ extrude(x::SubArray{T, 2} where T<:Number) @ Base.Broadcast ./broadcast.jl:676
││││││││││││││││┌ newindexer(A::SubArray{T, 2} where T<:Number) @ Base.Broadcast ./broadcast.jl:625
│││││││││││││││││┌ shapeindexer(ax::Tuple) @ Base.Broadcast ./broadcast.jl:626
││││││││││││││││││ runtime dispatch detected: Base.Broadcast._newindexer(ax::Tuple)::Tuple{Tuple, Tuple}
│││││││││││││││││└────────────────────
│││││││││││││┌ preprocess_args(dest::SubArray{T, 2} where T<:Number, args::Tuple{SubArray{T, 2} where T<:Number}) @ Base.Broadcast ./broadcast.jl:987
││││││││││││││ runtime dispatch detected: Base.Broadcast.preprocess(dest::SubArray{T, 2} where T<:Number, %1::SubArray{T, 2} where T<:Number)::Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}
│││││││││││││└────────────────────
││││││││││││┌ preprocess(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:983
│││││││││││││ runtime dispatch detected: Base.Broadcast.Broadcasted(nothing, conj, %4::Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}, %5::Tuple)::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}
││││││││││││└────────────────────
│││││││││││┌ copyto!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./simdloop.jl:69
││││││││││││┌ eachindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}) @ Base.Broadcast ./broadcast.jl:249
│││││││││││││ runtime dispatch detected: Base.Broadcast._eachindex(%1::Tuple)::Any
││││││││││││└────────────────────
│││││││││││┌ copyto!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:1004
││││││││││││┌ getindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Union{Integer, CartesianIndex}) @ Base.Broadcast ./broadcast.jl:635
│││││││││││││┌ checkbounds(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Integer) @ Base.Broadcast ./broadcast.jl:647
││││││││││││││ runtime dispatch detected: Base.checkbounds_indices(Base.Broadcast.Bool, %1::Tuple, %2::Tuple{Integer})::Union{Missing, Bool}
│││││││││││││└────────────────────
│││││││││││││┌ checkbounds(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Integer) @ Base.Broadcast ./broadcast.jl:647
││││││││││││││ runtime dispatch detected: Base.throw_boundserror(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, %6::Tuple{Integer})
│││││││││││││└────────────────────
││││││││││││┌ getindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Union{Integer, CartesianIndex}) @ Base.Broadcast ./broadcast.jl:636
│││││││││││││┌ _broadcast_getindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Integer) @ Base.Broadcast ./broadcast.jl:681
││││││││││││││┌ _getindex(args::Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}, I::Integer) @ Base.Broadcast ./broadcast.jl:706
│││││││││││││││┌ _broadcast_getindex(b::Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}, i::Integer) @ Base.Broadcast ./broadcast.jl:675
││││││││││││││││┌ newindex(i::Integer, keep::Tuple, idefault::Tuple) @ Base.Broadcast ./broadcast.jl:615
│││││││││││││││││ runtime dispatch detected: Base.Broadcast.ifelse(%1::Any, i::Integer, %2::Any)::Any
││││││││││││││││└────────────────────
││││││││││││││││┌ getindex(V::SubArray{T, 2, P, I, true} where {T<:Number, P, I<:Union{Tuple{Vararg{Real}}, Tuple{AbstractUnitRange, Vararg{Any}}}}, i::Int64) @ Base ./subarray.jl:306
│││││││││││││││││┌ checkbounds(A::SubArray{T, 2, P, I, true} where {T<:Number, P, I<:Union{Tuple{Vararg{Real}}, Tuple{AbstractUnitRange, Vararg{Any}}}}, I::Int64) @ Base ./abstractarray.jl:699
││││││││││││││││││┌ checkbounds(::Type{Bool}, A::SubArray{T, 2, P, I, true} where {T<:Number, P, I<:Union{Tuple{Vararg{Real}}, Tuple{AbstractUnitRange, Vararg{Any}}}}, i::Int64) @ Base ./abstractarray.jl:684
│││││││││││││││││││┌ eachindex(::IndexLinear, A::SubArray{T, 2, P, I, true} where {T<:Number, P, I<:Union{Tuple{Vararg{Real}}, Tuple{AbstractUnitRange, Vararg{Any}}}}) @ Base ./abstractarray.jl:385
││││││││││││││││││││┌ oneto(r::Any) @ Base ./range.jl:469
│││││││││││││││││││││┌ Base.OneTo(r::AbstractRange{T}) where T<:Integer @ Base ./range.jl:468
││││││││││││││││││││││┌ Base.OneTo{T}(r::Base.OneTo) where T<:Integer @ Base ./range.jl:1301
│││││││││││││││││││││││┌ (::Type{Base.OneTo{T}} where T<:Integer)(stop::Integer) @ Base ./range.jl:453
││││││││││││││││││││││││┌ (::Base.var"#throwbool#81")(r::Integer) @ Base ./range.jl:452
│││││││││││││││││││││││││┌ string(::String, ::Integer, ::String) @ Base ./strings/io.jl:189
││││││││││││││││││││││││││┌ print_to_string(::String, ::Integer, ::String) @ Base ./strings/io.jl:148
│││││││││││││││││││││││││││┌ print(io::IOBuffer, n::Unsigned) @ Base ./show.jl:1197
││││││││││││││││││││││││││││┌ string(n::Unsigned) @ Base ./intfuncs.jl:833
│││││││││││││││││││││││││││││┌ string(n::Unsigned; base::Int64, pad::Int64) @ Base ./intfuncs.jl:837
││││││││││││││││││││││││││││││┌ bin(x::Unsigned, pad::Int64, neg::Bool) @ Base ./intfuncs.jl:715
│││││││││││││││││││││││││││││││┌ setindex!(::Vector{UInt8}, ::UInt8, ::Union{Integer, CartesianIndex}) @ Base ./multidimensional.jl:698
││││││││││││││││││││││││││││││││┌ to_indices(A::Vector{UInt8}, I::Tuple{Union{Integer, CartesianIndex}}) @ Base ./multidimensional.jl:859
│││││││││││││││││││││││││││││││││┌ to_indices(A::Vector{UInt8}, inds::Tuple{}, I::Tuple{Union{Integer, CartesianIndex}}) @ Base ./indices.jl:355
││││││││││││││││││││││││││││││││││┌ _cutdim(inds::Tuple{}, I1::CartesianIndex) @ Base ./multidimensional.jl:863
│││││││││││││││││││││││││││││││││││┌ split(t::Tuple{}, V::Val) @ Base.IteratorsMD ./multidimensional.jl:487
││││││││││││││││││││││││││││││││││││ runtime dispatch detected: Base.IteratorsMD.ntuple(Returns{Bool}(true), V::Val)::Any
│││││││││││││││││││││││││││││││││││└────────────────────
│││││││││││││││││││││││││││││┌ string(n::Unsigned; base::Int64, pad::Int64) @ Base ./intfuncs.jl:848
││││││││││││││││││││││││││││││┌ _base(base::Int64, x::Integer, pad::Int64, neg::Bool) @ Base ./intfuncs.jl:796
│││││││││││││││││││││││││││││││┌ kwcall(::@NamedTuple{base::Int64, pad::Int64}, ::typeof(ndigits), x::Integer) @ Base ./intfuncs.jl:700
││││││││││││││││││││││││││││││││┌ ndigits(x::Integer; base::Int64, pad::Int64) @ Base ./intfuncs.jl:700
│││││││││││││││││││││││││││││││││┌ ndigits0z(x::Integer, b::Int64) @ Base ./intfuncs.jl:661
││││││││││││││││││││││││││││││││││┌ ndigits0zpb(x::BigInt, b::Int64) @ Base.GMP ./gmp.jl:813
│││││││││││││││││││││││││││││││││││┌ ^(x::BigInt, y::Int64) @ Base.GMP ./gmp.jl:654
││││││││││││││││││││││││││││││││││││┌ bigint_pow(x::BigInt, y::Int64) @ Base.GMP ./gmp.jl:647
│││││││││││││││││││││││││││││││││││││┌ (::Base.GMP.var"#throw1#3")(y::Int64) @ Base.GMP ./gmp.jl:632
││││││││││││││││││││││││││││││││││││││ failed to optimize due to recursion: (::Base.GMP.var"#throw1#3")(::Int64)
│││││││││││││││││││││││││││││││││││││└────────────────────
││││││││││││││┌ _getindex(args::Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}, I::Integer) @ Base.Broadcast ./broadcast.jl:706
│││││││││││││││ runtime dispatch detected: Base.Broadcast._broadcast_getindex(%1::Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}, I::Integer)::Any
││││││││││││││└────────────────────
│││││││││││││┌ _broadcast_getindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Integer) @ Base.Broadcast ./broadcast.jl:682
││││││││││││││┌ _broadcast_getindex_evalf(f::typeof(conj), args::Any) @ Base.Broadcast ./broadcast.jl:709
│││││││││││││││ runtime dispatch detected: f::typeof(conj)(%1::Any)::Any
││││││││││││││└────────────────────
││││││││││││┌ getindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Union{Integer, CartesianIndex}) @ Base.Broadcast ./broadcast.jl:635
│││││││││││││ runtime dispatch detected: Base.Broadcast.checkbounds(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Union{Integer, CartesianIndex})::Any
││││││││││││└────────────────────
││││││││││││┌ getindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Union{Integer, CartesianIndex}) @ Base.Broadcast ./broadcast.jl:636
│││││││││││││ runtime dispatch detected: Base.Broadcast._broadcast_getindex(bc::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{Base.Broadcast.Extruded{T, K, D} where {T<:(SubArray{T, 2} where T<:Number), K<:Tuple, D<:Tuple}}}, I::Union{Integer, CartesianIndex})::Any
││││││││││││└────────────────────
││││││││││┌ copyto!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:956
│││││││││││ runtime dispatch detected: Base.Broadcast.convert(::Base.Broadcast.Broadcasted{Nothing}, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}})::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}
││││││││││└────────────────────
││││││││││┌ copyto!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:956
│││││││││││ runtime dispatch detected: Base.Broadcast.copyto!(dest::SubArray{T, 2} where T<:Number, %1::Base.Broadcast.Broadcasted{Nothing, <:Tuple, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}})::SubArray{T, 2} where T<:Number
││││││││││└────────────────────
││││││││┌ materialize!(dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}}) @ Base.Broadcast ./broadcast.jl:911
│││││││││ runtime dispatch detected: Base.Broadcast.materialize!([quote]::Base.Broadcast.DefaultArrayStyle{2}, dest::SubArray{T, 2} where T<:Number, bc::Base.Broadcast.Broadcasted{Base.Broadcast.DefaultArrayStyle{2}, Nothing, typeof(conj), <:Tuple{SubArray{T, 2} where T<:Number}})::SubArray{T, 2} where T<:Number
││││││││└────────────────────
││││┌ _generic_matmatmul!(C::Matrix{Float64}, tA::Char, tB::Char, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S}, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool}) where {T, S} @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:828
│││││┌ _modify!(p::LinearAlgebra.MulAddMul{true, true, Bool, Bool}, x::Any, C::Matrix{Float64}, idx′::Tuple{Any, Any}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/generic.jl:89
││││││┌ CartesianIndex(index::Tuple{Union{Integer, CartesianIndex}, Union{Integer, CartesianIndex}}) @ Base.IteratorsMD ./multidimensional.jl:90
│││││││┌ CartesianIndex(::CartesianIndex, ::Integer) @ Base.IteratorsMD ./multidimensional.jl:86
││││││││┌ flatten(I::Tuple{CartesianIndex, Integer}) @ Base.IteratorsMD ./multidimensional.jl:89
│││││││││ runtime dispatch detected: Base.IteratorsMD.Tuple(%1::CartesianIndex)::Tuple
││││││││└────────────────────
││││││││┌ flatten(I::Tuple{CartesianIndex, Integer}) @ Base.IteratorsMD ./multidimensional.jl:89
│││││││││ runtime dispatch detected: Base.IteratorsMD.flatten(%4::Tuple{Integer})::Tuple
││││││││└────────────────────
│││││┌ _modify!(p::LinearAlgebra.MulAddMul{true, true, Bool, Bool}, x::Any, C::Matrix{Float64}, idx′::Tuple{Any, Any}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/generic.jl:89
││││││ runtime dispatch detected: LinearAlgebra.CartesianIndex(idx′::Tuple{Any, Any})::Any
│││││└────────────────────
│││││┌ _modify!(p::LinearAlgebra.MulAddMul{true, true, Bool, Bool}, x::Any, C::Matrix{Float64}, idx′::Tuple{Any, Any}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/generic.jl:91
││││││ runtime dispatch detected: ((C::Matrix{Float64})[%1::Any] = x::Any::Any)
│││││└────────────────────
││││┌ _generic_matmatmul!(C::Matrix{Float64}, tA::Char, tB::Char, A::AbstractVecOrMat{T}, B::AbstractVecOrMat{S}, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool}) where {T, S} @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:860
│││││┌ dotview(::Matrix{Float64}, ::Any, ::Any) @ Base.Broadcast ./broadcast.jl:1244
││││││ runtime dispatch detected: Base.maybeview(%1::Matrix{Float64}, %2::Any, %3::Any)::Any
│││││└────────────────────
│││││┌ broadcasted(::LinearAlgebra.MulAddMul{true, true, Bool, Bool}, ::Any, ::Any) @ Base.Broadcast ./broadcast.jl:1347
││││││┌ broadcasted(::Base.Broadcast.BroadcastStyle, ::LinearAlgebra.MulAddMul{true, true, Bool, Bool}, ::Any, ::Any) @ Base.Broadcast ./broadcast.jl:1349
│││││││ runtime dispatch detected: Base.Broadcast.Broadcasted(style::Base.Broadcast.BroadcastStyle, f::LinearAlgebra.MulAddMul{true, true, Bool, Bool}, args::Tuple{Any, Any})::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}
││││││└────────────────────
│││││┌ materialize!(B::Base.Broadcast.BitMaskedBitArray, bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:1218
││││││┌ materialize!(dest::SubArray, bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:911
│││││││┌ materialize!(::Base.Broadcast.BroadcastStyle, dest::SubArray, bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:914
││││││││┌ instantiate(bc::Base.Broadcast.Broadcasted{Base.Broadcast.Style{Tuple}, <:Tuple, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:317
│││││││││┌ check_broadcast_axes(shp::Tuple, A::Any, As::Any) @ Base.Broadcast ./broadcast.jl:585
││││││││││┌ check_broadcast_axes(shp::Tuple, A::Any) @ Base.Broadcast ./broadcast.jl:582
│││││││││││ runtime dispatch detected: Base.Broadcast.axes(A::Any)::Any
││││││││││└────────────────────
││││││││││┌ check_broadcast_axes(shp::Tuple, A::Any) @ Base.Broadcast ./broadcast.jl:582
│││││││││││ runtime dispatch detected: Base.Broadcast.check_broadcast_shape(shp::Tuple, %1::Any)::Any
││││││││││└────────────────────
││││││││┌ instantiate(bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, <:Tuple, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:309
│││││││││ runtime dispatch detected: Base.Broadcast.check_broadcast_axes(%2::Tuple, %4::Any, %5::Any)::Any
││││││││└────────────────────
││││││││┌ instantiate(bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, <:Tuple, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:311
│││││││││ runtime dispatch detected: Base.Broadcast.Broadcasted(%7::Base.Broadcast.BroadcastStyle, %8::LinearAlgebra.MulAddMul{true, true, Bool, Bool}, %9::Tuple{Any, Any}, %2::Tuple)::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, <:Tuple, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}
││││││││└────────────────────
││││││┌ materialize!(dest::SubArray, bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:911
│││││││ runtime dispatch detected: Base.Broadcast.combine_styles(dest::SubArray, bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}})::Any
││││││└────────────────────
││││││┌ materialize!(dest::SubArray, bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}}) @ Base.Broadcast ./broadcast.jl:911
│││││││ runtime dispatch detected: Base.Broadcast.materialize!(%1::Any, dest::SubArray, bc::Base.Broadcast.Broadcasted{<:Base.Broadcast.BroadcastStyle, Nothing, LinearAlgebra.MulAddMul{true, true, Bool, Bool}, <:Tuple{Any, Any}})::Any
││││││└────────────────────
│││┌ generic_matmatmul!(C::Matrix{Float64}, tA::Char, tB::Char, A::Matrix{Float64}, B::Matrix{Float64}, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool}) @ LinearAlgebra /cache/build/default-amdci5-7/julialang/julia-release-1-dot-10/usr/share/julia/stdlib/v1.10/LinearAlgebra/src/matmul.jl:367
││││ runtime dispatch detected: LinearAlgebra._generic_matmatmul!(C::Matrix{Float64}, N, N, %77::Any, %78::Any, _add::LinearAlgebra.MulAddMul{true, true, Bool, Bool})::Matrix{Float64}
│││└────────────────────

On v1.11, on the other hand, there are no issues reported.

julia> @report_opt fill(2.0,3,3) * fill(2.0,3,3)'
No errors detected

This difference primarily arises from the constant-folding of all, although it may not be a performance concern in practice.

[aviatesk]

We've done all the things that need to be done in Julia base, so I'm gonna close this issue. As for JET, it's gonna be a tough call to backport this enhancement to v1.10, but if we can sort out #51080, it might work out.