// Insert this type.
if (!PointerTypes.insert(Ty))
return false;
-
+
+ QualType PointeeTy;
const PointerType *PointerTy = Ty->getAs<PointerType>();
- assert(PointerTy && "type was not a pointer type!");
-
- QualType PointeeTy = PointerTy->getPointeeType();
+ if (!PointerTy) {
+ if (const ObjCObjectPointerType *PTy = Ty->getAs<ObjCObjectPointerType>())
+ PointeeTy = PTy->getPointeeType();
+ else
+ assert(false && "type was not a pointer type!");
+ }
+ else
+ PointeeTy = PointerTy->getPointeeType();
+
// Don't add qualified variants of arrays. For one, they're not allowed
// (the qualifier would sink to the element type), and for another, the
// only overload situation where it matters is subscript or pointer +- int,
// If we're dealing with an array type, decay to the pointer.
if (Ty->isArrayType())
Ty = SemaRef.Context.getArrayDecayedType(Ty);
-
- if (Ty->getAs<PointerType>()) {
+ if (Ty->isObjCIdType() || Ty->isObjCClassType())
+ PointerTypes.insert(Ty);
+ else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
// Insert our type, and its more-qualified variants, into the set
// of types.
if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
}
+
+// pr7936
+@interface I1 @end
+
+class Wrapper {
+public:
+ operator id() const { return (id)_value; }
+ operator Class() const { return (Class)_value; }
+ operator I1*() const { return (I1*)_value; }
+
+ bool Compare(id obj) { return *this == obj; }
+ bool CompareClass(Class obj) { return *this == obj; }
+ bool CompareI1(I1* obj) { return *this == obj; }
+
+private:
+ long _value;
+};
+