IR verification error during testing of UnicodePlots.jl

[maleadt]

As seen during testing of UnicodePlots.jl with -g2:

Edge 33 of φ node 94 not in predecessor list
216 1 ── %1   = Base.sitofp(Float64, _6)::Float64
    │    %2   = Base.div_float(%1, 4.0)::Float64
217 │    %3   = Base.sitofp(Float64, _7)::Float64
    │    %4   = Base.div_float(%3, 2.0)::Float64
221 │    %5   = Base.div_float(%4, %2)::Float64
225 │    %6   = Base.ceil_llvm(%2)::Float64
    │    %7   = Base.le_float(-9.223372036854776e18, %6)::Bool
    └───        goto #3 if not %7
    2 ── %9   = Base.lt_float(%6, 9.223372036854776e18)::Bool
    └───        goto #4
    3 ──        nothing::Nothing
    4 ┄─ %12  = φ (#2 => %9, #3 => false)::Bool
    └───        goto #7 if not %12
    5 ── %14  = Base.trunc_llvm(%6)::Float64
    │    %15  = Base.sub_float(%6, %14)::Float64
    │    %16  = Base.eq_float(%15, 0.0)::Bool
    │    %17  = Base.and_int(%16, true)::Bool
    │    %18  = Base.and_int(%17, true)::Bool
    └───        goto #7 if not %18
    6 ──        goto #8
    7 ┄─ %21  = invoke Base.InexactError(:Int64::Symbol, Int64::Any, %6::Vararg{Any})::InexactError
    │           Base.throw(%21)::Union{}
    └───        unreachable
    8 ──        goto #9
    9 ──        goto #10
    10 ─        goto #11
226 11 ─ %27  = Base.ceil_llvm(%4)::Float64
    │    %28  = Base.le_float(-9.223372036854776e18, %27)::Bool
    └───        goto #13 if not %28
    12 ─ %30  = Base.lt_float(%27, 9.223372036854776e18)::Bool
    └───        goto #14
    13 ─        nothing::Nothing
    14 ┄ %33  = φ (#12 => %30, #13 => false)::Bool
    └───        goto #17 if not %33
    15 ─ %35  = Base.trunc_llvm(%27)::Float64
    │    %36  = Base.sub_float(%27, %35)::Float64
    │    %37  = Base.eq_float(%36, 0.0)::Bool
    │    %38  = Base.and_int(%37, true)::Bool
    │    %39  = Base.and_int(%38, true)::Bool
    └───        goto #17 if not %39
    16 ─        goto #18
    17 ┄ %42  = invoke Base.InexactError(:Int64::Symbol, Int64::Any, %27::Vararg{Any})::InexactError
    │           Base.throw(%42)::Union{}
    └───        unreachable
    18 ─        goto #19
    19 ─        goto #20
    20 ─        goto #21
229 21 ─ %48  = UnicodePlots.string::Core.Const(string)
    │    %49  = invoke Base.:(var"#string#518")(10::Int64, 1::Int64, %48::typeof(string), _7::Int64)::String
    │    %50  = invoke UnicodePlots.length(%49::String)::Int64
    │    %51  = Base.add_int(_12, _13)::Int64
    │    %52  = Base.add_int(%51, %50)::Int64
    │    %53  = Base.add_int(%52, _3)::Int64
231 │    %54  = invoke UnicodePlots.displaysize()::Tuple{Int64, Int64}
    │    %55  = Base.getfield(%54, 1)::Int64
    │    %56  = Base.getfield(%54, 2)::Int64
232 │    %57  = Base.slt_int(0, _8)::Bool
    └───        goto #23 if not %57
    22 ─        goto #24
    23 ─ %60  = Base.sub_int(%55, _2)::Int64
    24 ┄ %61  = φ (#22 => _8, #23 => %60)::Int64
233 │    %62  = Base.slt_int(0, _9)::Bool
    └───        goto #26 if not %62
    25 ─        goto #27
    26 ─ %65  = Base.sub_int(%56, %53)::Int64
    27 ┄ %66  = φ (#25 => _9, #26 => %65)::Int64
235 │    %67  = (_6 === 0)::Bool
    └───        goto #31 if not %67
    28 ─ %69  = (_7 === 0)::Bool
    └───        goto #30 if not %69
    29 ─ %71  = Core.tuple(0, 0, %66, %61)::Core.PartialStruct(NTuple{4, Int64}, Any[Core.Const(0), Core.Const(0), Int64, Int64])
    └───        return %71
    30 ─        nothing::Nothing
    31 ┄        nothing::Nothing
    32 ─        nothing::Nothing
    33 ─        nothing::Nothing
259 34 ─ %77  = Base.slt_int(0, _11)::Bool
    └───        goto #36 if not %77
260 35 ─ %79  = Base.sitofp(Float64, _11)::Float64
    │    %80  = Base.div_float(%79, %5)::Float64
    │    %81  = Base.sitofp(Float64, %61)::Float64
    │    %82  = Base.sub_float(%80, %81)::Float64
    │    %83  = Base.bitcast(Base.Int64, %82)::Int64
    │    %84  = Base.slt_int(%83, 0)::Bool
    │    %85  = Core.ifelse(%84, %80, %81)::Float64
    │    %86  = Core.ifelse(%84, true, true)::Bool
    │    %87  = Core.ifelse(%84, true, true)::Bool
    │    %88  = Base.ne_float(%80, %80)::Bool
    │    %89  = Base.ne_float(%81, %81)::Bool
    │    %90  = Base.or_int(%88, %89)::Bool
    │    %91  = Core.ifelse(%90, %82, %85)::Float64
    │    %92  = Core.ifelse(%90, true, %86)::Bool
    └─── %93  = Core.ifelse(%90, true, %87)::Bool
263 36 ┄ %94  = φ (#35 => %92, #34 => false, #33 => false)::Bool
    │    %95  = φ (#35 => %93, #34 => false, #33 => false)::Bool
    │    %96  = φ (#35 => %91, #34 => _10, #33 => _10)::Union{Nothing, Float64}
    └───        goto #38 if not _15
    37 ─ %98  = UnicodePlots.ASPECT_RATIO::Core.Const(Base.RefValue{Float64}(1.3333333333333333))
    │    %99  = Base.getfield(%98, :x)::Float64
    └───        goto #39
    38 ─        nothing::Nothing
    39 ┄ %102 = φ (#37 => true, #38 => false)::Bool
    │    %103 = φ (#37 => false, #38 => true)::Bool
    │    %104 = φ (#37 => %99, #38 => 1)::Union{Float64, Int64}
    │    %105 = (Core.Intrinsics.and_int)(%94, %102)::Bool
    └───        goto #41 if not %105
    40 ─ %107 = π (%96, Float64)
    │    %108 = π (%104, Float64)
    │    %109 = Base.div_float(%107, %108)::Float64
    └───        goto #44
    41 ─ %111 = (Core.Intrinsics.and_int)(%95, %103)::Bool
    └───        goto #43 if not %111
    42 ─ %113 = π (%96, Float64)
    │    %114 = π (%104, Int64)
    │    %115 = Base.sitofp(Float64, %114)::Float64
    │    %116 = Base.div_float(%113, %115)::Float64
    └───        goto #44
    43 ─ %118 = (%96 / %104)::Float64
    └───        goto #44
    44 ┄ %120 = φ (#40 => %109, #42 => %116, #43 => %118)::Float64
    │    %121 = Base.rint_llvm(%120)::Float64
    │    %122 = Base.le_float(-9.223372036854776e18, %121)::Bool
    └───        goto #46 if not %122
    45 ─ %124 = Base.lt_float(%121, 9.223372036854776e18)::Bool
    └───        goto #47
    46 ─        nothing::Nothing
    47 ┄ %127 = φ (#45 => %124, #46 => false)::Bool
    └───        goto #50 if not %127
    48 ─ %129 = Base.trunc_llvm(%121)::Float64
    │    %130 = Base.sub_float(%121, %129)::Float64
    │    %131 = Base.eq_float(%130, 0.0)::Bool
    │    %132 = Base.and_int(%131, true)::Bool
    │    %133 = Base.and_int(%132, true)::Bool
    └───        goto #50 if not %133
    49 ─ %135 = Base.fptosi(Int64, %121)::Int64
    └───        goto #51
    50 ┄ %137 = invoke Base.InexactError(:Int64::Symbol, Int64::Any, %121::Vararg{Any})::InexactError
    │           Base.throw(%137)::Union{}
    └───        unreachable
    51 ─        goto #52
    52 ─        goto #53
    53 ─        goto #54
267 54 ─ %143 = Core.tuple(%135, _11, %61, %66)::NTuple{4, Int64}
    └───        return %143
    

Reduced to:

function foo(max_height=0, height=nothing)
    if height === nothing && width > 0
        height = min(1, max_height)
    end
    height / 0
end
foo()

Edge 1 of φ node 8 not in predecessor list
  1 ─       nothing::Nothing
2 2 ─ %2  = Main.width::Any
  │   %3  = (%2 > 0)::Any
  └──       goto #4 if not %3
3 3 ─ %5  = Base.slt_int(_2, 1)::Bool
  │   %6  = Core.ifelse(%5, _2, 1)::Int64
  └── %7  = Core.ifelse(%5, true, true)::Bool
5 4 ┄ %8  = φ (#3 => %7, #2 => false, #1 => false)::Bool
  │   %9  = φ (#3 => %6, #2 => _3, #1 => _3)::Union{Nothing, Int64}
  └──       goto #6 if not %8
  5 ─ %11 = π (%9, Int64)
  │   %12 = Base.sitofp(Float64, %11)::Float64
  │   %13 = Base.div_float(%12, 0.0)::Float64
  └──       goto #7
  6 ─ %15 = (%9 / 0)::Float64
  └──       goto #7
  7 ┄ %17 = φ (#5 => %13, #6 => %15)::Float64
  └──       return %17

Bisected to #51754; cc @Keno. This is a different issue than #52846, and #52853 does not fix it.

[Keno]

At least in the reproducer this is a bug in CompactPeekIterator. I'll try to fix it.