allow constant propagation to break call cycles in inference

base/compiler/abstractinterpretation.jl

@@ -129,7 +129,8 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
     end
     # try constant propagation if only 1 method is inferred to non-Bottom
     # this is in preparation for inlining, or improving the return result
-    if nonbot > 0 && seen == napplicable && !edgecycle && isa(rettype, Type) && InferenceParams(interp).ipo_constant_propagation
+    is_unused = call_result_unused(sv)
+    if nonbot > 0 && seen == napplicable && (!edgecycle || !is_unused) && isa(rettype, Type) && InferenceParams(interp).ipo_constant_propagation
         # if there's a possibility we could constant-propagate a better result
         # (hopefully without doing too much work), try to do that now
         # TODO: it feels like this could be better integrated into abstract_call_method / typeinf_edge
@@ -139,7 +140,7 @@ function abstract_call_gf_by_type(interp::AbstractInterpreter, @nospecialize(f),
             rettype = const_rettype
         end
     end
-    if call_result_unused(sv) && !(rettype === Bottom)
+    if is_unused && !(rettype === Bottom)
         # We're mainly only here because the optimizer might want this code,
         # but we ourselves locally don't typically care about it locally
         # (beyond checking if it always throws).
@@ -268,7 +269,8 @@ function abstract_call_method_with_const_args(interp::AbstractInterpreter, @nosp
         typeinf(interp, frame) || return Any
     end
     result = inf_result.result
-    isa(result, InferenceState) && return Any # TODO: unexpected, is this recursive constant inference?
+    # if constant inference hits a cycle, just bail out
+    isa(result, InferenceState) && return Any
     add_backedge!(inf_result.linfo, sv)
     return result
 end

test/compiler/inference.jl

@@ -2601,3 +2601,25 @@ _use_unstable_kw_2() = _unstable_kw(x = 2, y = rand())
 end
 _construct_structwithsplatnew() = StructWithSplatNew(("",))
 @test Base.return_types(_construct_structwithsplatnew) == Any[StructWithSplatNew]
+
+# case where a call cycle can be broken by constant propagation
+struct NotQRSparse
+    x::Matrix{Float64}
+    n::Int
+end
+@inline function getprop(F::NotQRSparse, d::Symbol)
+    if d === :Q
+        return NotQRSparse(getprop(F, :B), _size_ish(F, 2))
+    elseif d === :A
+        return Dict()
+    elseif d === :B
+        return rand(2,2)
+    elseif d === :C
+        return ""
+    else
+        error()
+    end
+end
+_size_ish(F::NotQRSparse, i::Integer) = size(getprop(F, :B), 1)
+_call_size_ish(x) = _size_ish(x,1)
+@test Base.return_types(_call_size_ish, (NotQRSparse,)) == Any[Int]