Make sure a variable is initialized before use to clean up a warning from

[oota-llvm.git] / include / llvm / AbstractTypeUser.h

diff --git a/include/llvm/AbstractTypeUser.h b/include/llvm/AbstractTypeUser.h
index e4096787f438d723b78d5871631744f03ee89188..9e96a99af0be0c83692d7d4f16f26e230271b79a 100644 (file)
--- a/include/llvm/AbstractTypeUser.h
+++ b/include/llvm/AbstractTypeUser.h
@@ -1,5 +1,12 @@
 //===-- llvm/AbstractTypeUser.h - AbstractTypeUser Interface ----*- C++ -*-===//
 //
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
 // The AbstractTypeUser class is an interface to be implemented by classes who
 // could possible use an abstract type.  Abstract types are denoted by the
 // isAbstract flag set to true in the Type class.  These are classes that
@@ -30,12 +37,14 @@
 //
 #include <cassert>
 
+namespace llvm {
+
 class Type;
 class DerivedType;
 
 class AbstractTypeUser {
 protected:
-  virtual ~AbstractTypeUser() {}                        // Derive from me
+  virtual ~AbstractTypeUser();                        // Derive from me
 public:
 
   /// refineAbstractType - The callback method invoked when an abstract type is
@@ -43,7 +52,7 @@ public:
   /// its internal state to reference NewType instead of OldType.
   ///
   virtual void refineAbstractType(const DerivedType *OldTy,
-                                 const Type *NewTy) = 0;
+                                  const Type *NewTy) = 0;
 
   /// The other case which AbstractTypeUsers must be aware of is when a type
   /// makes the transition from being abstract (where it has clients on it's
@@ -70,7 +79,7 @@ class PATypeHandle {
   void removeUser();
 public:
   // ctor - Add use to type if abstract.  Note that Ty must not be null
-  inline PATypeHandle(const Type *ty, AbstractTypeUser *user) 
+  inline PATypeHandle(const Type *ty, AbstractTypeUser *user)
     : Ty(ty), User(user) {
     addUser();
   }
@@ -84,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
@@ -134,14 +143,16 @@ public:
     addRef();
   }
 
-  operator const Type *() const { return get(); }
-  const Type *get() const;
+  ~PATypeHolder() { dropRef(); }
+
+  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;
@@ -149,13 +160,19 @@ public:
     }
     return get();
   }
-  const Type *operator=(const PATypeHolder &H) {
+  Type *operator=(const PATypeHolder &H) {
     return operator=(H.Ty);
   }
 
+  /// getRawType - This should only be used to implement the vmcore library.
+  ///
+  const Type *getRawType() const { return Ty; }
+
 private:
   void addRef();
   void dropRef();
 };
 
+} // End llvm namespace
+
 #endif