[ObjC generics] Fix applying `__kindof` to the type parameter.

[vsapsai]

Summary

Fixes the warning about incompatible pointer types on assigning to a
subclass of type argument an expression of type __kindof TypeParam.

We already have a mechanism in ASTContext::canAssignObjCInterfaces
that handles ObjCObjectType with __kindof. But it wasn't triggered
because during type substitution __kindof TypeParam was represented as
AttributedType with attribute ObjCKindOf and equivalent type
TypeArg. For assignment type checking we use canonical types so
attributed type was desugared and the attribute was ignored.

The fix is in checking transformed AttributedType and pushing
__kindof down into ObjCObjectType when necessary.

rdar://problem/38514910

[jordan_rose]

I think this is reasonable but Doug was the one who worked on this. I wonder if it also helps with the test cases in rdar://problem/24619481.

[vsapsai]

In D57076#1368407, @jordan_rose wrote:

I think this is reasonable but Doug was the one who worked on this. I wonder if it also helps with the test cases in rdar://problem/24619481.

Yep, it helps with the test cases in rdar://problem/24619481. As soon as ObjCObjectType has IsKindOf, ASTContext::canAssignObjCInterfaces takes care of everything. It checks that LHS is a superclass of RHS or when RHS has __kindof that LHS is a subclass of RHS. My change doesn't deal with inheritance, so I didn't add those test cases.

[vsapsai]

• Add a test that __kindof works with type sugar such as typedef.
• Use early return to reduce nesting. Also it's consistent with the previous early returns.

[vsapsai]

Update diff to ignore parent patch.

[doug.gregor]

One minor request about regarding a dyn_cast, but this looks like the right approach. Thank you!

clang/lib/AST/Type.cpp

1293 ↗

(On Diff #183216)

Either this should be a cast<AttributedType> or the next if should check for !newAttrType. I suspect the latter is safer.

[vsapsai]

• Address review comment: don't crash when AttributedType is transformed to another type class.

[vsapsai]

clang/lib/AST/Type.cpp

1293 ↗

(On Diff #183216)

You are right. Thanks for the catch. Currently it shouldn't happen, as far as I can tell, so no test for the case when AttributedType is transformed to something else.

lib/AST/Type.cpp

if (objcObjectType->isSpecializedAsWritten()) {
         return Ctx.getObjCObjectType(objcObjectType->getBaseType(), newTypeArgs,
                                      protocols,
                                      objcObjectType->isKindOfTypeAsWritten());
       }
     }
 
     return BaseType::VisitObjCObjectType(objcObjectType);
   }
+
+  QualType VisitAttributedType(const AttributedType *attrType) {
+    QualType newType = BaseType::VisitAttributedType(attrType);
+    if (newType.isNull())
+      return {};
+
+    const auto *newAttrType = dyn_cast<AttributedType>(newType.getTypePtr());
+    if (!newAttrType || newAttrType->getAttrKind() != attr::ObjCKindOf)
+      return newType;
+
+    // Find out if it's an Objective-C object or object pointer type;
+    QualType newEquivType = newAttrType->getEquivalentType();
+    const ObjCObjectPointerType *ptrType =
+        newEquivType->getAs<ObjCObjectPointerType>();
+    const ObjCObjectType *objType = ptrType
+                                        ? ptrType->getObjectType()
+                                        : newEquivType->getAs<ObjCObjectType>();
+    if (!objType)
+      return newType;
+
+    // Rebuild the "equivalent" type, which pushes __kindof down into
+    // the object type.
+    newEquivType = Ctx.getObjCObjectType(
+        objType->getBaseType(), objType->getTypeArgsAsWritten(),
+        objType->getProtocols(),
+        // There is no need to apply kindof on an unqualified id type.
+        /*isKindOf=*/objType->isObjCUnqualifiedId() ? false : true);
+
+    // If we started with an object pointer type, rebuild it.
+    if (ptrType)
+      newEquivType = Ctx.getObjCObjectPointerType(newEquivType);
+
+    // Rebuild the attributed type.
+    return Ctx.getAttributedType(newAttrType->getAttrKind(),
+                                 newAttrType->getModifiedType(), newEquivType);
+  }
 };
 
 struct StripObjCKindOfTypeVisitor
     : public SimpleTransformVisitor<StripObjCKindOfTypeVisitor> {
   using BaseType = SimpleTransformVisitor<StripObjCKindOfTypeVisitor>;
 
   explicit StripObjCKindOfTypeVisitor(ASTContext &ctx) : BaseType(ctx) {}
 

test/SemaObjC/kindof.m

 @interface A2 : NSObject
 - (void)test:(__kindof id)T;
 @end
 @implementation A2
 - (void)test:(id)T {
 }
 @end
 
+// ---------------------------------------------------------------------------
+// __kindof on type parameters
+// ---------------------------------------------------------------------------
+
 @interface NSGeneric<ObjectType> : NSObject
 - (void)test:(__kindof ObjectType)T; // expected-note{{passing argument to parameter 'T' here}}
 - (void)mapUsingBlock:(id (^)(__kindof ObjectType))block;
+@property (copy) ObjectType object;
+@property (copy) __kindof ObjectType kindof_object;
+
+@property (copy) __kindof ObjectType _Nonnull nonnull_kindof_object;
 @end
 @implementation NSGeneric
 - (void)test:(id)T {
 }
 - (void)mapUsingBlock:(id (^)(id))block {
 }
 @end
 
+@interface NSDefaultGeneric<ObjectType : NSString *> : NSObject
+@property (copy) ObjectType object;
+@property (copy) __kindof ObjectType kindof_object;
+@end
+
 void testGeneric(NSGeneric<NSString*> *generic) {
   NSObject *NSObject_obj;
   // Assign from NSObject_obj to __kindof NSString*.
   [generic test:NSObject_obj]; // expected-warning{{incompatible pointer types sending 'NSObject *' to parameter of type '__kindof NSString *'}}
   NSString *NSString_str;
   [generic test:NSString_str];
 }
 
+void testGenericAssignment() {
+  NSMutableString *NSMutableString_str;
+  NSNumber *NSNumber_obj;
+
+  NSGeneric<NSString*> *generic;
+  NSMutableString_str = generic.object; // expected-warning{{incompatible pointer types}}
+  NSNumber_obj = generic.object; // expected-warning{{incompatible pointer types}}
+  NSMutableString_str = generic.kindof_object;
+  NSNumber_obj = generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof NSString *'}}
+
+  NSGeneric<__kindof NSString*> *kindof_generic;
+  NSMutableString_str = kindof_generic.object;
+  NSNumber_obj = kindof_generic.object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof NSString *'}}
+  NSMutableString_str = kindof_generic.kindof_object;
+  NSNumber_obj = kindof_generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof __kindof NSString *'}}
+
+  NSDefaultGeneric *default_generic;
+  NSMutableString_str = default_generic.object;
+  NSNumber_obj = default_generic.object; // expected-warning{{incompatible pointer types}}
+  NSMutableString_str = default_generic.kindof_object;
+  NSNumber_obj = default_generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof __kindof NSString *'}}
+
+  typedef NSString *Typedef_NSString;
+  NSGeneric<Typedef_NSString> *typedef_generic;
+  NSMutableString_str = typedef_generic.object; // expected-warning{{incompatible pointer types}}
+  NSNumber_obj = typedef_generic.object; // expected-warning{{incompatible pointer types}}
+  NSMutableString_str = typedef_generic.kindof_object;
+  NSNumber_obj = typedef_generic.kindof_object; // expected-warning{{incompatible pointer types assigning to 'NSNumber *' from '__kindof Typedef_NSString'}}
+}
+
+void testKindofNonObjectType() {
+  typedef void (^BlockType)(int);
+  NSGeneric<BlockType> *generic;
+}
+
+void testKindofNullability(NSGeneric<NSString*> *generic) {
+  generic.nonnull_kindof_object = 0; // expected-warning{{null passed to a callee that requires a non-null argument}}
+}
+
 // Check that clang doesn't crash when a type parameter is illegal.
 @interface Array1<T> : NSObject
 @end
 
 @interface I1 : NSObject
 @end
 
 @interface Array1<__kindof I1*>(extensions1) // expected-error{{expected type parameter name}}
 @end
 
 @interface Array2<T1, T2, T3> : NSObject
 @end
 
 @interface Array2<T, T, __kindof I1*>(extensions2) // expected-error{{expected type parameter name}} expected-error{{redeclaration of type parameter 'T'}}
 @end