From ec90d8f80d0ad5614c14db74dd22f5e3f100f2cb Mon Sep 17 00:00:00 2001
From: Chris Lattner <sabre@nondot.org>
Date: Wed, 14 Jul 2004 20:10:26 +0000
Subject: [PATCH] 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
---
 include/llvm/AbstractTypeUser.h | 18 +++++++++---------
 include/llvm/Type.h             |  4 ++--
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index b936b455540..a06252dc73d 100644
--- 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 c6a95b5dadf..fab69aa7b64 100644
--- 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;
 }
 
-- 
2.34.1