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
~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;
}
return get();
}
- const Type *operator=(const PATypeHolder &H) {
+ Type *operator=(const PATypeHolder &H) {
return operator=(H.Ty);
}
/// 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;
}