add missing setting of inferred field when setting inference result (#55081)

This previously could confuse inference, which expects that the field is
set to indicate that the rettype has been computed, and cannot tolerate
putting objects in the cache for which that is not true. This was
causing Nanosoldier to fail.

Also cleanup `sv.unreachable` after IR modification so that it remains
(mostly) consistent, even though unused (except for the unreachable
nodes themselves), as this was confusing me in debugging.

Author: vtjnash

base/compiler/optimize.jl

@@ -1178,20 +1178,19 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
                 # Any statements from here to the end of the block have been wrapped in Core.Const(...)
                 # by type inference (effectively deleting them). Only task left is to replace the block
                 # terminator with an explicit `unreachable` marker.
-                if block_end > idx
-                    code[block_end] = ReturnNode()
-                    codelocs[3block_end-2], codelocs[3block_end-1], codelocs[3block_end-0] = (codelocs[3idx-2], codelocs[3idx-1], codelocs[3idx-0])
-                    ssavaluetypes[block_end] = Union{}
-                    stmtinfo[block_end] = NoCallInfo()
-                    ssaflags[block_end] = IR_FLAG_NOTHROW
 
-                    # Verify that type-inference did its job
+                if block_end > idx
                     if is_asserts()
+                        # Verify that type-inference did its job
                         for i = (oldidx + 1):last(sv.cfg.blocks[block].stmts)
                             @assert i in sv.unreachable
                         end
                     end
-
+                    code[block_end] = ReturnNode()
+                    codelocs[3block_end-2], codelocs[3block_end-1], codelocs[3block_end-0] = (codelocs[3idx-2], codelocs[3idx-1], codelocs[3idx-0])
+                    ssavaluetypes[block_end] = Union{}
+                    stmtinfo[block_end] = NoCallInfo()
+                    ssaflags[block_end] = IR_FLAG_NOTHROW
                     idx += block_end - idx
                 else
                     insert!(code, idx + 1, ReturnNode())
@@ -1221,6 +1220,7 @@ function convert_to_ircode(ci::CodeInfo, sv::OptimizationState)
         idx += 1
         oldidx += 1
     end
+    empty!(sv.unreachable)
 
     if ssachangemap !== nothing && labelchangemap !== nothing
         renumber_ir_elements!(code, ssachangemap, labelchangemap)

base/compiler/typeinfer.jl

@@ -369,20 +369,17 @@ function cache_result!(interp::AbstractInterpreter, result::InferenceResult)
         # we can now widen our applicability in the global cache too
         result.valid_worlds = WorldRange(first(result.valid_worlds), typemax(UInt))
     end
+    @assert isdefined(result.ci, :inferred)
     # check if the existing linfo metadata is also sufficient to describe the current inference result
     # to decide if it is worth caching this right now
     mi = result.linfo
     cache_results = true
     cache = WorldView(code_cache(interp), result.valid_worlds)
     if cache_results && haskey(cache, mi)
         ci = cache[mi]
-        # Even if we already have a CI for this, it's possible that the new CI has more
-        # information (E.g. because the source was limited before, but is no longer - this
-        # happens during bootstrap). In that case, allow the result to be recached.
         # n.b.: accurate edge representation might cause the CodeInstance for this to be constructed later
-        if isdefined(ci, :inferred)
-            cache_results = false
-        end
+        @assert isdefined(ci, :inferred)
+        cache_results = false
     end
 
     if cache_results
@@ -1205,6 +1202,7 @@ function typeinf_ext(interp::AbstractInterpreter, mi::MethodInstance, source_mod
     if source_mode == SOURCE_MODE_ABI && frame.cache_mode != CACHE_MODE_GLOBAL
         # XXX: jl_type_infer somewhat ambiguously assumes this must be cached, while jl_ci_cache_lookup sort of ambiguously re-caches it
         # XXX: this should be using the CI from the cache, if possible instead: haskey(cache, mi) && (ci = cache[mi])
+        @assert isdefined(ci, :inferred) "interpreter did not fulfill its requirements"
         code_cache(interp)[mi] = ci
     end
     if source_mode == SOURCE_MODE_FORCE_SOURCE && use_const_api(ci)

src/gf.c

@@ -609,6 +609,7 @@ JL_DLLEXPORT void jl_fill_codeinst(
     codeinst->analysis_results = analysis_results;
     assert(jl_atomic_load_relaxed(&codeinst->min_world) == 1);
     assert(jl_atomic_load_relaxed(&codeinst->max_world) == 0);
+    jl_atomic_store_release(&codeinst->inferred, jl_nothing);
     jl_atomic_store_release(&codeinst->min_world, min_world);
     jl_atomic_store_release(&codeinst->max_world, max_world);
 }