diff --git a/src/Module.zig b/src/Module.zig
index f4bf487128..8174778f48 100644
--- a/src/Module.zig
+++ b/src/Module.zig
@@ -5773,9 +5773,8 @@ pub fn analyzeFnBody(mod: *Module, func: *Fn, arena: Allocator) SemaError!Air {
 
     // Similarly, resolve any queued up types that were requested to be resolved for
     // the backends.
-    for (sema.types_to_resolve.items) |inst_ref| {
-        const ty = sema.getTmpAir().getRefType(inst_ref);
-        sema.resolveTypeFully(ty) catch |err| switch (err) {
+    for (sema.types_to_resolve.keys()) |ty| {
+        sema.resolveTypeFully(ty.toType()) catch |err| switch (err) {
             error.NeededSourceLocation => unreachable,
             error.GenericPoison => unreachable,
             error.ComptimeReturn => unreachable,
diff --git a/src/Sema.zig b/src/Sema.zig
index 13a1c1cb3d..866c242f15 100644
--- a/src/Sema.zig
+++ b/src/Sema.zig
@@ -66,11 +66,14 @@ comptime_args_fn_inst: Zir.Inst.Index = 0,
 /// extra hash table lookup in the `monomorphed_funcs` set.
 /// Sema will set this to null when it takes ownership.
 preallocated_new_func: ?*Module.Fn = null,
-/// The key is `constant` AIR instructions to types that must be fully resolved
-/// after the current function body analysis is done.
-/// TODO: after upgrading to use InternPool change the key here to be an
-/// InternPool value index.
-types_to_resolve: std.ArrayListUnmanaged(Air.Inst.Ref) = .{},
+/// The key is types that must be fully resolved prior to machine code
+/// generation pass. Types are added to this set when resolving them
+/// immediately could cause a dependency loop, but they do need to be resolved
+/// before machine code generation passes process the AIR.
+/// It would work fine if this were an array list instead of an array hash map.
+/// I chose array hash map with the intention to save time by omitting
+/// duplicates.
+types_to_resolve: std.AutoArrayHashMapUnmanaged(InternPool.Index, void) = .{},
 /// These are lazily created runtime blocks from block_inline instructions.
 /// They are created when an break_inline passes through a runtime condition, because
 /// Sema must convert comptime control flow to runtime control flow, which means
@@ -34085,8 +34088,7 @@ fn anonStructFieldIndex(
 }
 
 fn queueFullTypeResolution(sema: *Sema, ty: Type) !void {
-    const inst_ref = try sema.addType(ty);
-    try sema.types_to_resolve.append(sema.gpa, inst_ref);
+    try sema.types_to_resolve.put(sema.gpa, ty.toIntern(), {});
 }
 
 fn intAdd(sema: *Sema, lhs: Value, rhs: Value, ty: Type) !Value {