Try to not use dicts (#1459)

* Try to not use dicts

* fix

Author: wsmoses

src/utils.jl

@@ -499,7 +499,7 @@ function make_oc_ref(
 )::Core.OpaqueClosure
     if Base.isassigned(oc_captures)
         return oc_captures[]
-    else
+    else     
         ores = ccall(
             :jl_new_opaque_closure_from_code_info,
             Any,
@@ -553,6 +553,37 @@ function rewrite_insts!(ir, interp, guaranteed_error)
     return ir, any_changed
 end
 
+function rewrite_argnumbers_by_one!(ir)
+    # Add one dummy argument at the beginning
+    pushfirst!(ir.argtypes, Nothing)
+
+    # Re-write all references to existing arguments to their new index (N + 1)
+    for idx = 1:length(ir.stmts)
+        urs = Core.Compiler.userefs(ir.stmts[idx][:inst])
+        changed = false
+        it = Core.Compiler.iterate(urs)
+        while it !== nothing
+            (ur, next) = it
+            old = Core.Compiler.getindex(ur)
+            if old isa Core.Argument
+                # Replace the Argument(n) with Argument(n + 1)
+                Core.Compiler.setindex!(ur, Core.Argument(old.n + 1))
+                changed = true
+            end
+            it = Core.Compiler.iterate(urs, next)
+        end
+        if changed
+            @static if VERSION < v"1.11"
+                Core.Compiler.setindex!(ir.stmts[idx], Core.Compiler.getindex(urs), :inst)
+            else
+                Core.Compiler.setindex!(ir.stmts[idx], Core.Compiler.getindex(urs), :stmt)
+            end
+        end
+    end
+
+    return nothing
+end
+
 # Generator function which ensures that all calls to the function are executed within the ReactantInterpreter
 # In particular this entails two pieces:
 #   1) We enforce the use of the ReactantInterpreter method table when generating the original methodinstance
@@ -666,6 +697,9 @@ function call_with_reactant_generator(
     ) || guaranteed_error
         ir, any_changed = rewrite_insts!(ir, interp, guaranteed_error)
     end
+  
+
+    rewrite_argnumbers_by_one!(ir)  
 
     src = ccall(:jl_new_code_info_uninit, Ref{CC.CodeInfo}, ())
     src.slotnames = fill(:none, length(ir.argtypes) + 1)
@@ -674,6 +708,7 @@ function call_with_reactant_generator(
     src.rettype = rt
     src = CC.ir_to_codeinf!(src, ir)
 
+
     if DEBUG_INTERP[]
         safe_print("src", src)
     end
@@ -784,38 +819,34 @@ function call_with_reactant_generator(
 
     ocva = false # method.isva
 
-    ocnargs = method.nargs - 1
+    ocnargs = Int(method.nargs)
     # octup = Tuple{mi.specTypes.parameters[2:end]...}
     # octup = Tuple{method.sig.parameters[2:end]...}
-    octup = Tuple{tys[2:end]...}
+    octup = Tuple{tys[1:end]...}
     ocva = false
 
     # jl_new_opaque_closure forcibly executes in the current world... This means that we won't get the right
     # inner code during compilation without special handling (i.e. call_in_world_total).
     # Opaque closures also require taking the function argument. We can work around the latter
     # if the function is stateless. But regardless, to work around this we sadly create/compile the opaque closure
 
-    dict, make_oc = if Base.issingletontype(fn)
-        Base.Ref{Core.OpaqueClosure}(), make_oc_ref
-    else
-        Dict{fn,Core.OpaqueClosure}(), make_oc_dict
-    end
+    dict, make_oc = (Base.Ref{Core.OpaqueClosure}(), make_oc_ref)
 
     push!(oc_capture_vec, dict)
 
     oc = if false && Base.issingletontype(fn)
         res = Core._call_in_world_total(
             world, make_oc, dict, octup, rt, src, ocnargs, ocva, fn.instance
         )::Core.OpaqueClosure
-
     else
         farg = fn_args[1]
+        farg = nothing
         rep = Expr(:call, make_oc, dict, octup, rt, src, ocnargs, ocva, farg)
         push_inst!(rep)
         Core.SSAValue(length(overdubbed_code))
     end
 
-    push_inst!(Expr(:call, oc, fn_args[2:end]...))
+    push_inst!(Expr(:call, oc, fn_args[1:end]...))
 
     ocres = Core.SSAValue(length(overdubbed_code))