Result of @report_opt depends on whether there were previous @report_opt calls

[nsajko]

Firstly: not sure how good the issue title is, probably you'll be able to think of a better one.

I wanted to test a function in my package-to-be with JET, however there's some weird behavior.

I have a file like this (meant to be executed from the source directory of my package):

import JET
push!(LOAD_PATH, "./")
import RealFactorizationFromComplexRoots
const R = RealFactorizationFromComplexRoots

const roots = Complex{BigFloat}[]

function main()
  # show(JET.@report_opt R.squared_error_with_indices(
  #   roots,
  #   (Int8[], (Int8[], Int8[]))))

  # show(JET.@report_opt R.min_error(
  #   roots,
  #   (Int8[], Int8[])))

  # show(JET.@report_opt R.RealFactorization_impl(
  #   roots,
  #   (Int8[], Int8[], Int8[])))

  show(JET.@report_opt R.RealFactorization(
    roots))
end

main()

So there's a single JET.@report_opt call, and three more that are commented out. When the file is executed as-is with Julia 1.8.0-rc1, JET produces ten optimization errors. But if the other three calls are commented out, JET instead proclaims "No errors detected" four times.

You can find the RealFactorizationFromComplexRoots package (just a single file) here: https://gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl

This is the JET output produced when the file above is executed as-is:

═════ 10 possible errors found ═════
┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:195 RealFactorizationFromComplexRoots.RealFactorization_impl(roots, RealFactorizationFromComplexRoots.partition_by_sign(roots))
│┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:166 RealFactorizationFromComplexRoots.min_error(roots, RealFactorizationFromComplexRoots.minmax_by_length(Base.getindex(part_ind, RealFactorizationFromComplexRoots.:(1, 2))))
││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:126 Core.kwfunc(RealFactorizationFromComplexRoots.minimum)(Core.apply_type(Core.NamedTuple, (:init,))(Core.tuple(RealFactorizationFromComplexRoots.ComparisonHelper(_(RealFactorizationFromComplexRoots.Inf), Core.tuple(Base.getindex(RealFactorizationFromComplexRoots.Int8), Core.tuple(Base.getindex(RealFactorizationFromComplexRoots.Int8), Base.getindex(RealFactorizationFromComplexRoots.Int8)))))), RealFactorizationFromComplexRoots.minimum, #7, Combinatorics.permutations(Base.getindex(ind, 2), RealFactorizationFromComplexRoots.length(Base.getindex(ind, 1))))
│││┌ @ reduce.jl:717 Base.#minimum#272(kw..., _3, f, a)
││││┌ @ reduce.jl:717 Core.kwfunc(Base.mapreduce)(Base.merge(Base.NamedTuple(), kw), Base.mapreduce, f, Base.min, a)
│││││┌ @ reduce.jl:294 Base.#mapreduce#263(kw..., _3, f, op, itr)
││││││┌ @ reduce.jl:294 Core.kwfunc(Base.mapfoldl)(Base.merge(Base.NamedTuple(), kw), Base.mapfoldl, f, op, itr)
│││││││┌ @ reduce.jl:162 Base.#mapfoldl#259(init, _3, f, op, itr)
││││││││┌ @ reduce.jl:162 Base.mapfoldl_impl(f, op, init, itr)
│││││││││┌ @ reduce.jl:44 Base.foldl_impl(op′, nt, itr′)
││││││││││┌ @ reduce.jl:48 v = Base._foldl_impl(op, nt, itr)
│││││││││││┌ @ reduce.jl:58 v = op(init, Base.getindex(y, 1))
││││││││││││┌ @ reduce.jl:95 Base.getproperty(op, :f)(x)
│││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:126 RealFactorizationFromComplexRoots.squared_error_with_indices(Core.getfield(#self#, Symbol("#7#roots")), RealFactorizationFromComplexRoots.partitioned_indices(Core.getfield(#self#, Symbol("#8#ind")), perm))
││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:117 RealFactorizationFromComplexRoots.squared_error(roots, ind)
│││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:88 RealFactorizationFromComplexRoots.squared_error_deg1(roots, Base.getindex(ind, 1))
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:79 Core.kwfunc(RealFactorizationFromComplexRoots.sum)(Core.apply_type(Core.NamedTuple, (:init,))(Core.tuple(RealFactorizationFromComplexRoots.zero(_))), RealFactorizationFromComplexRoots.sum, #5, RealFactorizationFromComplexRoots.view(v, ind))
│││││││││││││││││┌ @ reducedim.jl:995 Base.#sum#773(dims, kw..., _3, f, a)
││││││││││││││││││┌ @ reducedim.jl:995 Core.kwfunc(Base._sum)(Base.merge(Base.NamedTuple(), kw), Base._sum, f, a, dims)
│││││││││││││││││││┌ @ reducedim.jl:999 Base.#_sum#775(kw..., _3, f, a, _6)
││││││││││││││││││││┌ @ reducedim.jl:999 Core.kwfunc(Base.mapreduce)(Base.merge(Base.NamedTuple(), kw), Base.mapreduce, f, Base.add_sum, a)
│││││││││││││││││││││┌ @ reducedim.jl:357 Base.#mapreduce#765(dims, init, _3, f, op, A)
││││││││││││││││││││││┌ @ reducedim.jl:357 Base._mapreduce_dim(f, op, init, A, dims)
│││││││││││││││││││││││┌ @ reducedim.jl:362 Base.mapfoldl_impl(f, op, nt, A)
││││││││││││││││││││││││┌ @ reduce.jl:42 Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::BigFloat, ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
│││││││││││││││││││││││││ failed to optimize: Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::BigFloat, ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
││││││││││││││││││││││││└────────────────
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:79 RealFactorizationFromComplexRoots.squared_error_deg1(::Vector{Complex{BigFloat}}, ::Vector{Int8})
│││││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error_deg1(::Vector{Complex{BigFloat}}, ::Vector{Int8})
││││││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:88 RealFactorizationFromComplexRoots.squared_error_deg2(roots, Base.getindex(ind, 2))
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:71 Core.kwfunc(RealFactorizationFromComplexRoots.sum)(Core.apply_type(Core.NamedTuple, (:init,))(Core.tuple(RealFactorizationFromComplexRoots.zero(_))), RealFactorizationFromComplexRoots.sum, #3, RealFactorizationFromComplexRoots.zip(Core.tuple(RealFactorizationFromComplexRoots.view(v, Base.getindex(ind, 1)), RealFactorizationFromComplexRoots.view(v, Base.getindex(ind, 2)))...))
│││││││││││││││││┌ @ reduce.jl:520 Base.#sum#266(kw..., _3, f, a)
││││││││││││││││││┌ @ reduce.jl:520 Core.kwfunc(Base.mapreduce)(Base.merge(Base.NamedTuple(), kw), Base.mapreduce, f, Base.add_sum, a)
│││││││││││││││││││┌ @ reduce.jl:294 Base.#mapreduce#263(kw..., _3, f, op, itr)
││││││││││││││││││││┌ @ reduce.jl:294 Base.merge(Base.NamedTuple(), kw)
│││││││││││││││││││││┌ @ namedtuple.jl:313 Core.apply_type(Base.NamedTuple, Core.tuple(names...))(Core.tuple(vals...))
││││││││││││││││││││││┌ @ boot.jl:603 Core.apply_type(Core.NamedTuple, _, Core.typeof(args))(args)
│││││││││││││││││││││││┌ @ namedtuple.jl:96 _(args)
││││││││││││││││││││││││┌ @ tuple.jl:312 Base.convert(_, x)
│││││││││││││││││││││││││┌ @ essentials.jl:339 Base.Val(_)
││││││││││││││││││││││││││┌ @ essentials.jl:714 %1()
│││││││││││││││││││││││││││ runtime dispatch detected: %1::Type{Val{_A}} where _A()
││││││││││││││││││││││││││└─────────────────────
││││││││││││││││││││┌ @ reduce.jl:294 Base.mapfoldl(f, op, itr)
│││││││││││││││││││││┌ @ reduce.jl:162 Base.#mapfoldl#259(Base._InitialValue(), #self#, f, op, itr)
││││││││││││││││││││││┌ @ reduce.jl:162 Base.mapfoldl_impl(f, op, init, itr)
│││││││││││││││││││││││┌ @ reduce.jl:42 Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base._InitialValue, ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
││││││││││││││││││││││││ failed to optimize: Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base._InitialValue, ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
│││││││││││││││││││││││└────────────────
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:71 RealFactorizationFromComplexRoots.squared_error_deg2(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Vector{Int8}})
│││││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error_deg2(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Vector{Int8}})
││││││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:88 RealFactorizationFromComplexRoots.squared_error(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
││││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
│││││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────
││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:117 RealFactorizationFromComplexRoots.squared_error_with_indices(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
│││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error_with_indices(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
││││││││││││││└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:126 (::RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}})(::Vector{Int8})
││││││││││││││ failed to optimize: (::RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}})(::Vector{Int8})
│││││││││││││└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
││││││││││││┌ @ reduce.jl:95 (::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}})(::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Vector{Int8})
│││││││││││││ failed to optimize: (::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}})(::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Vector{Int8})
││││││││││││└────────────────
│││││││││││┌ @ reduce.jl:53 Base._foldl_impl(::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}}, ::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Combinatorics.Permutations{Vector{Int8}})
││││││││││││ failed to optimize: Base._foldl_impl(::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}}, ::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Combinatorics.Permutations{Vector{Int8}})
│││││││││││└────────────────

[aviatesk]

I think #373 might have fixed this issue. Could you retry this MRE with on the master branch?

[nsajko]

The behavior is mostly the same after updating from v0.5.16 to v0.6.0, except that now JET reports 22 possible errors found instead of just ten.

This is the output:

═════ 22 possible errors found ═════
┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:194 RealFactorizationFromComplexRoots.RealFactorization_impl(roots, RealFactorizationFromComplexRoots.partition_by_sign(roots))
│┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:165 RealFactorizationFromComplexRoots.min_error(roots, RealFactorizationFromComplexRoots.minmax_by_length(part_ind[1 RealFactorizationFromComplexRoots.:(:) 2]))
││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:125 Core.kwfunc(RealFactorizationFromComplexRoots.minimum)(NamedTuple{(:init,)}(tuple(RealFactorizationFromComplexRoots.ComparisonHelper(F(RealFactorizationFromComplexRoots.Inf), tuple(RealFactorizationFromComplexRoots.Int8[], tuple(RealFactorizationFromComplexRoots.Int8[], RealFactorizationFromComplexRoots.Int8[]))))), RealFactorizationFromComplexRoots.minimum, #7, permutations(ind[2], RealFactorizationFromComplexRoots.length(ind[1])))
│││┌ @ reduce.jl:717 Base.:(var"#minimum#272")(kw..., _3, f, a)
││││┌ @ reduce.jl:717 Core.kwfunc(mapreduce)(merge(Base.NamedTuple(), kw), mapreduce, f, min, a)
│││││┌ @ reduce.jl:294 Base.:(var"#mapreduce#263")(kw..., _3, f, op, itr)
││││││┌ @ reduce.jl:294 Core.kwfunc(mapfoldl)(merge(Base.NamedTuple(), kw), mapfoldl, f, op, itr)
│││││││┌ @ reduce.jl:162 Base.:(var"#mapfoldl#259")(init, _3, f, op, itr)
││││││││┌ @ reduce.jl:162 Base.mapfoldl_impl(f, op, init, itr)
│││││││││┌ @ reduce.jl:44 Base.foldl_impl(op′, nt, itr′)
││││││││││┌ @ reduce.jl:48 v = Base._foldl_impl(op, nt, itr)
│││││││││││┌ @ reduce.jl:58 v = op(init, y[1])
││││││││││││┌ @ reduce.jl:95 op.f(x)
│││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:125 RealFactorizationFromComplexRoots.squared_error_with_indices(getfield(#self#, Symbol("#7#roots")), RealFactorizationFromComplexRoots.partitioned_indices(getfield(#self#, Symbol("#8#ind")), perm))
││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:116 RealFactorizationFromComplexRoots.squared_error(roots, ind)
│││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:87 RealFactorizationFromComplexRoots.squared_error_deg1(roots, ind[1])
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:78 Core.kwfunc(RealFactorizationFromComplexRoots.sum)(NamedTuple{(:init,)}(tuple(RealFactorizationFromComplexRoots.zero(F))), RealFactorizationFromComplexRoots.sum, #5, RealFactorizationFromComplexRoots.view(v, ind))
│││││││││││││││││┌ @ reducedim.jl:995 Base.:(var"#sum#773")(dims, kw..., _3, f, a)
││││││││││││││││││┌ @ reducedim.jl:995 Core.kwfunc(Base._sum)(merge(Base.NamedTuple(), kw), Base._sum, f, a, dims)
│││││││││││││││││││┌ @ reducedim.jl:999 Base.:(var"#_sum#775")(kw..., _3, f, a, _6)
││││││││││││││││││││┌ @ reducedim.jl:999 Core.kwfunc(mapreduce)(merge(Base.NamedTuple(), kw), mapreduce, f, Base.add_sum, a)
│││││││││││││││││││││┌ @ reducedim.jl:357 Base.:(var"#mapreduce#765")(dims, init, _3, f, op, A)
││││││││││││││││││││││┌ @ reducedim.jl:357 Base._mapreduce_dim(f, op, init, A, dims)
│││││││││││││││││││││││┌ @ reducedim.jl:362 Base.mapfoldl_impl(f, op, nt, A)
││││││││││││││││││││││││┌ @ reduce.jl:42 Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::BigFloat, ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
│││││││││││││││││││││││││ failed to optimize: Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::BigFloat, ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
││││││││││││││││││││││││└────────────────
│││││││││││││││││││││││┌ @ reducedim.jl:362 Base._mapreduce_dim(::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::BigFloat, ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, ::Colon)
││││││││││││││││││││││││ failed to optimize: Base._mapreduce_dim(::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::BigFloat, ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, ::Colon)
│││││││││││││││││││││││└────────────────────
││││││││││││││││││││││┌ @ reducedim.jl:357 Base.var"#mapreduce#765"(::Colon, ::BigFloat, ::typeof(mapreduce), ::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
│││││││││││││││││││││││ failed to optimize: Base.var"#mapreduce#765"(::Colon, ::BigFloat, ::typeof(mapreduce), ::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
││││││││││││││││││││││└────────────────────
│││││││││││││││││││││┌ @ reducedim.jl:357 (::Base.var"#mapreduce##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(mapreduce), ::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
││││││││││││││││││││││ failed to optimize: (::Base.var"#mapreduce##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(mapreduce), ::RealFactorizationFromComplexRoots.var"#5#6", ::typeof(Base.add_sum), ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
│││││││││││││││││││││└────────────────────
││││││││││││││││││││┌ @ reducedim.jl:999 Base.var"#_sum#775"(::Base.Pairs{Symbol, BigFloat, Tuple{Symbol}, NamedTuple{(:init,), Tuple{BigFloat}}}, ::typeof(Base._sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, ::Colon)
│││││││││││││││││││││ failed to optimize: Base.var"#_sum#775"(::Base.Pairs{Symbol, BigFloat, Tuple{Symbol}, NamedTuple{(:init,), Tuple{BigFloat}}}, ::typeof(Base._sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, ::Colon)
││││││││││││││││││││└────────────────────
│││││││││││││││││││┌ @ reducedim.jl:999 (::Base.var"#_sum##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(Base._sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, ::Colon)
││││││││││││││││││││ failed to optimize: (::Base.var"#_sum##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(Base._sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, ::Colon)
│││││││││││││││││││└────────────────────
││││││││││││││││││┌ @ reducedim.jl:995 Base.var"#sum#773"(::Colon, ::Base.Pairs{Symbol, BigFloat, Tuple{Symbol}, NamedTuple{(:init,), Tuple{BigFloat}}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
│││││││││││││││││││ failed to optimize: Base.var"#sum#773"(::Colon, ::Base.Pairs{Symbol, BigFloat, Tuple{Symbol}, NamedTuple{(:init,), Tuple{BigFloat}}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
││││││││││││││││││└────────────────────
│││││││││││││││││┌ @ reducedim.jl:995 (::Base.var"#sum##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
││││││││││││││││││ failed to optimize: (::Base.var"#sum##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#5#6", ::SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false})
│││││││││││││││││└────────────────────
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:78 RealFactorizationFromComplexRoots.squared_error_deg1(::Vector{Complex{BigFloat}}, ::Vector{Int8})
│││││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error_deg1(::Vector{Complex{BigFloat}}, ::Vector{Int8})
││││││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:87 RealFactorizationFromComplexRoots.squared_error_deg2(roots, ind[2])
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:70 Core.kwfunc(RealFactorizationFromComplexRoots.sum)(NamedTuple{(:init,)}(tuple(RealFactorizationFromComplexRoots.zero(F))), RealFactorizationFromComplexRoots.sum, #3, RealFactorizationFromComplexRoots.zip(tuple(RealFactorizationFromComplexRoots.view(v, ind[1]), RealFactorizationFromComplexRoots.view(v, ind[2]))...))
│││││││││││││││││┌ @ reduce.jl:520 Base.:(var"#sum#266")(kw..., _3, f, a)
││││││││││││││││││┌ @ reduce.jl:520 Core.kwfunc(mapreduce)(merge(Base.NamedTuple(), kw), mapreduce, f, Base.add_sum, a)
│││││││││││││││││││┌ @ reduce.jl:294 Base.:(var"#mapreduce#263")(kw..., _3, f, op, itr)
││││││││││││││││││││┌ @ reduce.jl:294 merge(Base.NamedTuple(), kw)
│││││││││││││││││││││┌ @ namedtuple.jl:313 Core.apply_type(Base.NamedTuple, tuple(names...))(tuple(vals...))
││││││││││││││││││││││┌ @ boot.jl:603 Core.apply_type(NamedTuple, names, typeof(args))(args)
│││││││││││││││││││││││┌ @ namedtuple.jl:96 T(args)
││││││││││││││││││││││││┌ @ tuple.jl:312 convert(T, x)
│││││││││││││││││││││││││┌ @ essentials.jl:339 Val(N)
││││││││││││││││││││││││││┌ @ essentials.jl:714 %1()
│││││││││││││││││││││││││││ runtime dispatch detected: %1::Type{Val{_A}} where _A()::Val
││││││││││││││││││││││││││└─────────────────────
││││││││││││││││││││┌ @ reduce.jl:294 mapfoldl(f, op, itr)
│││││││││││││││││││││┌ @ reduce.jl:162 Base.:(var"#mapfoldl#259")(Base._InitialValue(), #self#, f, op, itr)
││││││││││││││││││││││┌ @ reduce.jl:162 Base.mapfoldl_impl(f, op, init, itr)
│││││││││││││││││││││││┌ @ reduce.jl:42 Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base._InitialValue, ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
││││││││││││││││││││││││ failed to optimize: Base.mapfoldl_impl(::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base._InitialValue, ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
│││││││││││││││││││││││└────────────────
││││││││││││││││││││││┌ @ reduce.jl:162 Base.var"#mapfoldl#259"(::Base._InitialValue, ::typeof(mapfoldl), ::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
│││││││││││││││││││││││ failed to optimize: Base.var"#mapfoldl#259"(::Base._InitialValue, ::typeof(mapfoldl), ::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
││││││││││││││││││││││└─────────────────
│││││││││││││││││││││┌ @ reduce.jl:162 mapfoldl(::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
││││││││││││││││││││││ failed to optimize: mapfoldl(::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
│││││││││││││││││││││└─────────────────
│││││││││││││││││││┌ @ reduce.jl:294 (::Base.var"#mapreduce##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(mapreduce), ::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
││││││││││││││││││││ failed to optimize: (::Base.var"#mapreduce##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(mapreduce), ::RealFactorizationFromComplexRoots.var"#3#4", ::typeof(Base.add_sum), ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
│││││││││││││││││││└─────────────────
││││││││││││││││││┌ @ reduce.jl:520 Base.var"#sum#266"(::Base.Pairs{Symbol, BigFloat, Tuple{Symbol}, NamedTuple{(:init,), Tuple{BigFloat}}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#3#4", ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
│││││││││││││││││││ failed to optimize: Base.var"#sum#266"(::Base.Pairs{Symbol, BigFloat, Tuple{Symbol}, NamedTuple{(:init,), Tuple{BigFloat}}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#3#4", ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
││││││││││││││││││└─────────────────
│││││││││││││││││┌ @ reduce.jl:520 (::Base.var"#sum##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#3#4", ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
││││││││││││││││││ failed to optimize: (::Base.var"#sum##kw")(::NamedTuple{(:init,), Tuple{BigFloat}}, ::typeof(sum), ::RealFactorizationFromComplexRoots.var"#3#4", ::Base.Iterators.Zip{Tuple{SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}, SubArray{Complex{BigFloat}, 1, Vector{Complex{BigFloat}}, Tuple{Vector{Int8}}, false}}})
│││││││││││││││││└─────────────────
││││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:70 RealFactorizationFromComplexRoots.squared_error_deg2(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Vector{Int8}})
│││││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error_deg2(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Vector{Int8}})
││││││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:87 RealFactorizationFromComplexRoots.squared_error(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
││││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
│││││││││││││││└───────────────────────────────────────────────────────────────────────────────────────────────────────────────────
││││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:116 RealFactorizationFromComplexRoots.squared_error_with_indices(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
│││││││││││││││ failed to optimize: RealFactorizationFromComplexRoots.squared_error_with_indices(::Vector{Complex{BigFloat}}, ::Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}})
││││││││││││││└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│││││││││││││┌ @ /home/nsajko/src/gitlab.com/nsajko/RealFactorizationFromComplexRoots.jl/RealFactorizationFromComplexRoots.jl:125 (::RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}})(::Vector{Int8})
││││││││││││││ failed to optimize: (::RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}})(::Vector{Int8})
│││││││││││││└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
││││││││││││┌ @ reduce.jl:95 (::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}})(::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Vector{Int8})
│││││││││││││ failed to optimize: (::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}})(::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Vector{Int8})
││││││││││││└────────────────
│││││││││││┌ @ reduce.jl:53 Base._foldl_impl(::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}}, ::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Combinatorics.Permutations{Vector{Int8}})
││││││││││││ failed to optimize: Base._foldl_impl(::Base.MappingRF{RealFactorizationFromComplexRoots.var"#7#8"{Vector{Complex{BigFloat}}, Tuple{Vector{Int8}, Vector{Int8}}}, Base.BottomRF{typeof(min)}}, ::RealFactorizationFromComplexRoots.ComparisonHelper{BigFloat, Tuple{Vector{Int8}, Tuple{Vector{Int8}, Vector{Int8}}}}, ::Combinatorics.Permutations{Vector{Int8}})
│││││││││││└────────────────

[nsajko]

I wasn't really clear enough about what the issue is (above, in the original report), so I'll summarize, just in case:

I have code similar to this:

a() = ...
b() = ... a(...)
c() = ... b(...)
d() = ... c(...)

That is, there are some functions, each depending on the previous ones.

If I run JET.@report_opt for just the function d, JET reports many potential errors.

If I instead run something like:

JET.@report_opt a()
JET.@report_opt b()
JET.@report_opt c()
JET.@report_opt d()

Then no errors are reported.

[aviatesk]

So now the situation is:

function main()
  show(JET.@report_opt R.squared_error_with_indices( # <- we DON'T get reports on this
    roots,
    (Int8[], (Int8[], Int8[]))))

  show(JET.@report_opt R.min_error( # <- we get reports on this
    roots,
    (Int8[], Int8[])))

  show(JET.@report_opt R.RealFactorization_impl( # <- we get reports on this
    roots,
    (Int8[], Int8[], Int8[])))

  show(JET.@report_opt R.RealFactorization( # <- we get reports on this
    roots))
end

, which is kinda expected, since the "failed to optimize" report is because of recursive calls and seemingly there is no heavy recursion within the squared_error_with_indices call graph but there are in the other call graphs.