Revert "inference: implement an opt-in interface to cache generated sources (…"

This reverts commit b5d0b90.

Author: vtjnash

base/boot.jl

@@ -750,13 +750,6 @@ function (g::GeneratedFunctionStub)(world::UInt, source::LineNumberNode, @nospec
     end
 end
 
-# If the generator is a subtype of this trait, inference caches the generated unoptimized
-# code, sacrificing memory space to improve the performance of subsequent inferences.
-# This tradeoff is not appropriate in general cases (e.g., for `GeneratedFunctionStub`s
-# generated from the front end), but it can be justified for generators involving complex
-# code transformations, such as a Cassette-like system.
-abstract type CachedGenerator end
-
 NamedTuple() = NamedTuple{(),Tuple{}}(())
 
 eval(Core, :(NamedTuple{names}(args::Tuple) where {names} =

base/compiler/utilities.jl

@@ -138,27 +138,13 @@ use_const_api(li::CodeInstance) = invoke_api(li) == 2
 
 function get_staged(mi::MethodInstance, world::UInt)
     may_invoke_generator(mi) || return nothing
-    cache_ci = (mi.def::Method).generator isa Core.CachedGenerator ?
-        RefValue{CodeInstance}() : nothing
     try
-        return call_get_staged(mi, world, cache_ci)
+        return ccall(:jl_code_for_staged, Ref{CodeInfo}, (Any, UInt, Ptr{Cvoid}), mi, world, C_NULL)
     catch # user code might throw errors – ignore them
         return nothing
     end
 end
 
-# enable caching of unoptimized generated code if the generator is `CachedGenerator`
-function call_get_staged(mi::MethodInstance, world::UInt, cache_ci::RefValue{CodeInstance})
-    token = @_gc_preserve_begin cache_ci
-    cache_ci_ptr = pointer_from_objref(cache_ci)
-    src = ccall(:jl_code_for_staged, Ref{CodeInfo}, (Any, UInt, Ptr{CodeInstance}), mi, world, cache_ci_ptr)
-    @_gc_preserve_end token
-    return src
-end
-function call_get_staged(mi::MethodInstance, world::UInt, ::Nothing)
-    return ccall(:jl_code_for_staged, Ref{CodeInfo}, (Any, UInt, Ptr{Cvoid}), mi, world, C_NULL)
-end
-
 function get_cached_uninferred(mi::MethodInstance, world::UInt)
     ccall(:jl_cached_uninferred, Any, (Any, UInt), mi.cache, world)::CodeInstance
 end

test/staged.jl

@@ -381,31 +381,6 @@ let
     @test length(ir.cfg.blocks) == 1
 end
 
-# Test that `Core.CachedGenerator` works as expected
-struct Generator54916 <: Core.CachedGenerator end
-function (::Generator54916)(world::UInt, source::LineNumberNode, args...)
-    stub = Core.GeneratedFunctionStub(identity, Core.svec(:doit54916, :func, :arg), Core.svec())
-    return stub(world, source, :(func(arg)))
-end
-@eval function doit54916(func, arg)
-    $(Expr(:meta, :generated, Generator54916()))
-    $(Expr(:meta, :generated_only))
-end
-@test doit54916(sin, 1) == sin(1)
-let mi = only(methods(doit54916)).specializations
-    ci = mi.cache::Core.CodeInstance
-    found = false
-    while true
-        if ci.owner === :uninferred && ci.inferred isa Core.CodeInfo
-            found = true
-            break
-        end
-        isdefined(ci, :next) || break
-        ci = ci.next
-    end
-    @test found
-end
-
 # Test that writing a bad cassette-style pass gives the expected error (#49715)
 function generator49715(world, source, self, f, tt)
     tt = tt.parameters[1]