Make PATypeHolder and friends return non-const pointers to the types they

hold.  Because types are basically immutable anyway, they should not be
referenced as "const Type*" everywhere.  Just "Type*" should suffice!

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14824 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index b936b4555403cacdfba301de80f064c4396200a7..a06252dc73d13cbc74b38e884da351f644095884 100644 (file)
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -93,17 +93,17 @@ public:
   inline ~PATypeHandle() { removeUser(); }
 
   // Automatic casting operator so that the handle may be used naturally
-  inline operator const Type *() const { return Ty; }
-  inline const Type *get() const { return Ty; }
+  inline operator Type *() const { return const_cast<Type*>(Ty); }
+  inline Type *get() const { return const_cast<Type*>(Ty); }
 
   // operator= - Allow assignment to handle
-  inline const Type *operator=(const Type *ty) {
+  inline Type *operator=(const Type *ty) {
     if (Ty != ty) {   // Ensure we don't accidentally drop last ref to Ty
       removeUser();
       Ty = ty;
       addUser();
     }
-    return Ty;
+    return get();
   }
 
   // operator= - Allow assignment to handle
@@ -145,14 +145,14 @@ public:
 
   ~PATypeHolder() { dropRef(); }
 
-  operator const Type *() const { return get(); }
-  const Type *get() const;
+  operator Type *() const { return get(); }
+  Type *get() const;
 
   // operator-> - Allow user to dereference handle naturally...
-  const Type *operator->() const { return get(); }
+  Type *operator->() const { return get(); }
 
   // operator= - Allow assignment to handle
-  const Type *operator=(const Type *ty) {
+  Type *operator=(const Type *ty) {
     if (Ty != ty) {   // Don't accidentally drop last ref to Ty.
       dropRef();
       Ty = ty;
@@ -160,7 +160,7 @@ public:
     }
     return get();
   }
-  const Type *operator=(const PATypeHolder &H) {
+  Type *operator=(const PATypeHolder &H) {
     return operator=(H.Ty);
   }
 

diff --git a/include/llvm/Type.h b/include/llvm/Type.h
index c6a95b5dadf4eabedfb049d2e818e242597290f0..fab69aa7b64309c55b80900ee6828230ab3ec52e 100644 (file)
--- a/include/llvm/Type.h
+++ b/include/llvm/Type.h
@@ -347,9 +347,9 @@ inline void PATypeHolder::dropRef() {
 /// type we are pointing to is forwarding to a new type.  If so, we drop our
 /// reference to the type.
 ///
-inline const Type* PATypeHolder::get() const {
+inline Type* PATypeHolder::get() const {
   const Type *NewTy = Ty->getForwardedType();
-  if (!NewTy) return Ty;
+  if (!NewTy) return const_cast<Type*>(Ty);
   return *const_cast<PATypeHolder*>(this) = NewTy;
 }