//===-- 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
-// contain an Opaque type in their structure somehow.
-//
-// Classes must implement this interface so that they may be notified when an
-// abstract type is resolved. Abstract types may be resolved into more concrete
-// types through: linking, parsing, and bytecode reading. When this happens,
-// all of the users of the type must be updated to reference the new, more
-// concrete type. They are notified through the AbstractTypeUser interface.
+//===----------------------------------------------------------------------===//
//
-// In addition to this, AbstractTypeUsers must keep the use list of the
-// potentially abstract type that they reference up-to-date. To do this in a
-// nice, transparent way, the PATypeHandle class is used to hold "Potentially
-// Abstract Types", and keep the use list of the abstract types up-to-date.
+// This file declares the AbstractTypeUser class.
//
//===----------------------------------------------------------------------===//
namespace llvm {
-struct Type;
+class Type;
class DerivedType;
+/// The AbstractTypeUser class is an interface to be implemented by classes who
+/// could possibly use an abstract type. Abstract types are denoted by the
+/// isAbstract flag set to true in the Type class. These are classes that
+/// contain an Opaque type in their structure somewhere.
+///
+/// Classes must implement this interface so that they may be notified when an
+/// abstract type is resolved. Abstract types may be resolved into more
+/// concrete types through: linking, parsing, and bytecode reading. When this
+/// happens, all of the users of the type must be updated to reference the new,
+/// more concrete type. They are notified through the AbstractTypeUser
+/// interface.
+///
+/// In addition to this, AbstractTypeUsers must keep the use list of the
+/// potentially abstract type that they reference up-to-date. To do this in a
+/// nice, transparent way, the PATypeHandle class is used to hold "Potentially
+/// Abstract Types", and keep the use list of the abstract types up-to-date.
+/// @brief LLVM Abstract Type User Representation
class AbstractTypeUser {
protected:
virtual ~AbstractTypeUser(); // Derive from me
/// 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
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();
}
// operator-> - Allow user to dereference handle naturally...
inline const Type *operator->() const { return Ty; }
-
- // removeUserFromConcrete - This function should be called when the User is
- // notified that our type is refined... and the type is being refined to
- // itself, which is now a concrete type. When a type becomes concrete like
- // this, we MUST remove ourself from the AbstractTypeUser list, even though
- // the type is apparently concrete.
- //
- void removeUserFromConcrete();
};