IR: Fix const-correctness of SwitchInst::CaseIterator and CaseHandle

[dexonsmith]

Summary

Fix some confusion between the two types of const a pointer/iterator
can have. Users of a SwitchInst::CaseIterator should not (and do not!)
manually mutate the SwitchInst::CaseHandle that tracks its internal
state. Change operator*() to return const CaseHandle&, remove the
non-const-qualified operator*(), and const-qualify
CaseHandle::setValue() and CaseHandle::setSuccessor().

[dexonsmith]

(This is a follow up to https://reviews.llvm.org/D113158)

[dexonsmith]

Rebase on top of 8b3e1adf2b4a69b6055dc4e07b4e97817208c904, which removed the duplication of findCaseValue().

[dblaikie]

Looks good

llvm/include/llvm/IR/Instructions.h

public:
   class CaseHandle
       : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
     friend class SwitchInst::CaseIteratorImpl<CaseHandle>;
 
   public:
     CaseHandle(SwitchInst *SI, ptrdiff_t Index) : CaseHandleImpl(SI, Index) {}
 
     /// Sets the new value for current case.
-    void setValue(ConstantInt *V) {
+    void setValue(ConstantInt *V) const {
       assert((unsigned)Index < SI->getNumCases() &&
              "Index out the number of cases.");
       SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
     }
 
     /// Sets the new successor for current case.
-    void setSuccessor(BasicBlock *S) {
+    void setSuccessor(BasicBlock *S) const {
       SI->setSuccessor(getSuccessorIndex(), S);
     }
   };
 
   template <typename CaseHandleT>
   class CaseIteratorImpl
       : public iterator_facade_base<CaseIteratorImpl<CaseHandleT>,
                                     std::random_access_iterator_tag,
-                                    CaseHandleT> {
+                                    const CaseHandleT> {
     using SwitchInstT = typename CaseHandleT::SwitchInstType;
 
     CaseHandleT Case;
 
   public:
     /// Default constructed iterator is in an invalid state until assigned to
     /// a case for a particular switch.
     CaseIteratorImpl() = default;
public:
     }
     bool operator==(const CaseIteratorImpl &RHS) const {
       return Case == RHS.Case;
     }
     bool operator<(const CaseIteratorImpl &RHS) const {
       assert(Case.SI == RHS.Case.SI && "Incompatible operators.");
       return Case.Index < RHS.Case.Index;
     }
-    CaseHandleT &operator*() { return Case; }
     const CaseHandleT &operator*() const { return Case; }
   };
 
   using CaseIt = CaseIteratorImpl<CaseHandle>;
   using ConstCaseIt = CaseIteratorImpl<ConstCaseHandle>;
 
   static SwitchInst *Create(Value *Value, BasicBlock *Default,
                             unsigned NumCases,
ConstCaseIt case_default() const {
     return ConstCaseIt(this, DefaultPseudoIndex);
   }
 
   /// Search all of the case values for the specified constant. If it is
   /// explicitly handled, return the case iterator of it, otherwise return
   /// default case iterator to indicate that it is handled by the default
   /// handler.
   CaseIt findCaseValue(const ConstantInt *C) {
-    CaseIt I = llvm::find_if(
-        cases(), [C](CaseHandle &Case) { return Case.getCaseValue() == C; });
+    CaseIt I = llvm::find_if(cases(), [C](const CaseHandle &Case) {
+      return Case.getCaseValue() == C;
+    });
     if (I != case_end())
       return I;
 
     return case_default();
   }
   ConstCaseIt findCaseValue(const ConstantInt *C) const {
-    ConstCaseIt I = llvm::find_if(cases(), [C](ConstCaseHandle &Case) {
+    ConstCaseIt I = llvm::find_if(cases(), [C](const ConstCaseHandle &Case) {
       return Case.getCaseValue() == C;
     });
     if (I != case_end())
       return I;
 
     return case_default();
   }