[llvm] [SandboxIR] Remove tight-coupling with LLVM's SwitchInst::CaseHandle (PR #167093)

[Jorge Gorbe Moya via llvm-commits]

================
@@ -1884,45 +1884,96 @@ class SwitchInst : public SingleLLVMInstructionImpl<llvm::SwitchInst> {
     return cast<llvm::SwitchInst>(Val)->getNumCases();
   }
 
-  using CaseHandle =
-      llvm::SwitchInst::CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock>;
-  using ConstCaseHandle =
-      llvm::SwitchInst::CaseHandleImpl<const SwitchInst, const ConstantInt,
-                                       const BasicBlock>;
-  using CaseIt = llvm::SwitchInst::CaseIteratorImpl<CaseHandle>;
-  using ConstCaseIt = llvm::SwitchInst::CaseIteratorImpl<ConstCaseHandle>;
+  class CaseIt;
+  class CaseHandle {
+    Context &Ctx;
+    llvm::SwitchInst::CaseIt LLVMCaseIt;
+    friend class CaseIt;
+
+  public:
+    CaseHandle(Context &Ctx, llvm::SwitchInst::CaseIt LLVMCaseIt)
+        : Ctx(Ctx), LLVMCaseIt(LLVMCaseIt) {}
+    LLVM_ABI ConstantInt *getCaseValue() const;
+    BasicBlock *getCaseSuccessor() const;
+    unsigned getCaseIndex() const {
+      const auto &LLVMCaseHandle = *LLVMCaseIt;
+      return LLVMCaseHandle.getCaseIndex();
+    }
+    unsigned getSuccessorIndex() const {
+      const auto &LLVMCaseHandle = *LLVMCaseIt;
+      return LLVMCaseHandle.getSuccessorIndex();
+    }
+  };
+
+  class CaseIt
+      : public iterator_facade_base<CaseIt, std::random_access_iterator_tag,
+                                    CaseHandle> {
+    CaseHandle CH;
+
+  public:
+    CaseIt(Context &Ctx, llvm::SwitchInst::CaseIt It) : CH(Ctx, It) {}
+    CaseIt(SwitchInst *SI, ptrdiff_t CaseNum)
+        : CH(SI->getContext(), llvm::SwitchInst::CaseIt(
+                                   cast<llvm::SwitchInst>(SI->Val), CaseNum)) {}
+    CaseIt &operator+=(ptrdiff_t N) {
+      CH.LLVMCaseIt.operator+=(N);
+      return *this;
+    }
+    CaseIt &operator-=(ptrdiff_t N) {
+      CH.LLVMCaseIt.operator-=(N);
+      return *this;
+    }
+    ptrdiff_t operator-(const CaseIt &Other) const {
+      return CH.LLVMCaseIt - Other.CH.LLVMCaseIt;
+    }
+    bool operator==(const CaseIt &Other) const {
+      return CH.LLVMCaseIt == Other.CH.LLVMCaseIt;
+    }
+    bool operator<(const CaseIt &Other) const {
+      return CH.LLVMCaseIt < Other.CH.LLVMCaseIt;
+    }
+    CaseHandle &operator*() const { return const_cast<CaseIt *>(this)->CH; }
+  };
+
+  // TODO: Implement a proper ConstCaseIt.
----------------
slackito wrote:

It should be possible to templatize `CaseHandle` and `CaseIt` similar to what the implementation in LLVM IR does to handle the const case, right?

https://github.com/llvm/llvm-project/pull/167093