Backwards compatible delete_method

.github/workflows/CI.yaml

@@ -31,6 +31,9 @@ jobs:
             - min  # Project's oldest supported version
             - lts  # Long-Term Stable
             - 1    # Latest release
+            # Versions to validate backwards compatibility logic
+            - 1.11
+            - 1.12
 
   test:
     name: Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }}

Project.toml

@@ -14,7 +14,7 @@ ExprTools = "e2ba6199-217a-4e67-a87a-7c52f15ade04"
 Aqua = "0.8.7"
 Compat = "3.9, 4"
 ExprTools = "0.1"
-julia = "1"
+julia = "1.6"
 
 [extras]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"

src/Mocking.jl

@@ -12,6 +12,7 @@ end
 
 export @patch, @mock, Patch, apply
 
+include("compat.jl")
 include("expr.jl")
 include("dispatch.jl")
 include("debug.jl")

src/compat.jl

@@ -0,0 +1,63 @@
+const MAX_WORLD_AGE = typemax(UInt)
+
+function delete_method(m::Method)
+    @static if VERSION >= v"1.12.0"
+        # On Julia 1.12 deleting a method re-activates the previous version of method
+        Base.delete_method(m)
+    else
+        # The method table associated with the generic function.
+        mt = Base.get_methodtable(m)
+
+        world_age = Base.get_world_counter()
+        current_method = nothing
+        old_method = nothing
+
+        # The `Core.MethodTable` stores each method as a linked list with the newest method
+        # definitions occurring first.
+        def = mt.defs
+        while def !== nothing
+            if def.sig == m.sig
+                if def.min_world == m.primary_world
+                    current_method = def.func
+                elseif current_method !== nothing
+                    old_method = def.func
+                    break
+                end
+            end
+            def = def.next
+        end
+
+        # When the method table contains 2+ methods for the signature we'll restore the
+        # previous method definition. Otherwise, we'll just limit the world age for the only
+        # existing method.
+        if old_method !== nothing
+            # Using `primary_world == 1` causes Julia to increase the world counter
+            replacement_method = deepcopy(old_method)
+
+            @static if VERSION >= v"1.11"
+                @atomic replacement_method.primary_world = 1
+                @atomic replacement_method.deleted_world = MAX_WORLD_AGE
+            else
+                replacement_method.primary_world = 1
+                replacement_method.deleted_world = MAX_WORLD_AGE
+            end
+
+            # Adding a new method into the function's method table will increase world age
+            # (requires `primary_world == 1`) and invalidate backedges.
+            ccall(
+                :jl_method_table_insert,
+                Cvoid,
+                (Any, Any, Any),
+                mt,
+                replacement_method,
+                replacement_method.sig,
+            )
+        else
+            # On Julia versions below 1.12 this simply limits the world age for the
+            # specified method.
+            Base.delete_method(m)
+        end
+    end
+
+    return nothing
+end