ObjC: Use a new type for ObjC type parameter (patch 3 out of 3)

[manmanren]

Summary

Depends on https://reviews.llvm.org/D23078 and https://reviews.llvm.org/D23079

We say ObjCTypeParamType is ObjCObjectPointerType, but we assert
fail when trying to call Type::getPointeeType.

We compare the types between declaration and definition for ObjCMethods that
use the type parameter, by using simpleTransform that transforms the
ObjCTypeParamType to the underlying type of the ObjCTypeParamDecl. This matches
our previous behavior.

rdar://24619481
rdar://25060179

[doug.gregor]

I think most of the complexity here will fold away when ObjCTypeParamType becomes sugar for the underlying ObjCObjectPointerType.

lib/AST/Type.cpp

1095

I think we should combine the protocol lists.

1290

I think you won't need this if you take the approach I suggested on the previous patch of making ObjCTypeParamType type sugar for, effectively, the type you're computing here.

lib/Sema/SemaExprObjC.cpp

388

Dropping protocol qualifiers here? Again, I think this would be solved by treating ObjCTypeParamType as sugar.

824

Also unnecessary w/ the desugaring approach?

lib/Sema/SemaType.cpp

901

... same comment about desugaring.

917

Here too :)

3397

... same comment about desugaring.

lib/StaticAnalyzer/Core/CallEvent.cpp

63

... same comment about desugaring.

133

... same comment about desugaring.

[manmanren]

I will update this patch once the 2nd patch is done.

Thanks for reviewing,
Manman

lib/AST/Type.cpp

1095

I did combine the protocol lists in the implementation, but forgot to remove the comments :]

1290

I will update this once we fix the previous patch.

[manmanren]

This patch is now much simpler with the updated version of D23079.

[doug.gregor]

Ahhh, much cleaner. Thanks!

include/clang/AST/Type.h

public:
   /// parameters with their corresponding arguments.
   QualType substObjCMemberType(QualType objectType,
                                const DeclContext *dc,
                                ObjCSubstitutionContext context) const;
 
   /// Strip Objective-C "__kindof" types from the given type.
   QualType stripObjCKindOfType(const ASTContext &ctx) const;
 
+  QualType handleObjCTypeParamType(ASTContext &ctx) const;
+
   /// Remove all qualifiers including _Atomic.
   QualType getAtomicUnqualifiedType() const;
 
 private:
   // These methods are implemented in a separate translation unit;
   // "static"-ize them to avoid creating temporary QualTypes in the
   // caller.
   static bool isConstant(QualType T, const ASTContext& Ctx);

 }
 inline bool Type::isVectorType() const {
   return isa<VectorType>(CanonicalType);
 }
 inline bool Type::isExtVectorType() const {
   return isa<ExtVectorType>(CanonicalType);
 }
 inline bool Type::isObjCObjectPointerType() const {
-  return isa<ObjCObjectPointerType>(CanonicalType);
+  return isa<ObjCObjectPointerType>(CanonicalType) ||
+         isa<ObjCTypeParamType>(CanonicalType);
 }
 inline bool Type::isObjCObjectType() const {
   return isa<ObjCObjectType>(CanonicalType);
 }
 inline bool Type::isObjCObjectOrInterfaceType() const {
   return isa<ObjCInterfaceType>(CanonicalType) ||
     isa<ObjCObjectType>(CanonicalType);
 }

lib/AST/DeclObjC.cpp

 ObjCTypeParamDecl *ObjCTypeParamDecl::Create(ASTContext &ctx, DeclContext *dc,
                                              ObjCTypeParamVariance variance,
                                              SourceLocation varianceLoc,
                                              unsigned index,
                                              SourceLocation nameLoc,
                                              IdentifierInfo *name,
                                              SourceLocation colonLoc,
                                              TypeSourceInfo *boundInfo) {
-  return new (ctx, dc) ObjCTypeParamDecl(ctx, dc, variance, varianceLoc, index,
-                                         nameLoc, name, colonLoc, boundInfo);
+  auto *TPDecl =
+    new (ctx, dc) ObjCTypeParamDecl(ctx, dc, variance, varianceLoc, index,
+  QualType TPType = ctx.getObjCTypeParamType(TPDecl, {});
+  TPDecl->setTypeForDecl(TPType.getTypePtr());
+  return TPDecl;
 }
 
 ObjCTypeParamDecl *ObjCTypeParamDecl::CreateDeserialized(ASTContext &ctx,
                                                          unsigned ID) {
   return new (ctx, ID) ObjCTypeParamDecl(ctx, nullptr,
                                          ObjCTypeParamVariance::Invariant,
                                          SourceLocation(), 0, SourceLocation(),
                                          nullptr, SourceLocation(), nullptr);

lib/AST/Type.cpp

QualType Type::getPointeeType() const {
   if (const BlockPointerType *BPT = getAs<BlockPointerType>())
     return BPT->getPointeeType();
   if (const ReferenceType *RT = getAs<ReferenceType>())
     return RT->getPointeeType();
   if (const MemberPointerType *MPT = getAs<MemberPointerType>())
     return MPT->getPointeeType();
   if (const DecayedType *DT = getAs<DecayedType>())
     return DT->getPointeeType();
+  assert(!isa<ObjCTypeParamType>(this) &&
+         "do not call getPointeeType on ObjCTypeParamType");
   return QualType();
 }
 
 const RecordType *Type::getAsStructureType() const {
   // If this is directly a structure type, return it.
   if (const RecordType *RT = dyn_cast<RecordType>(this)) {
     if (RT->getDecl()->isStruct())
       return RT;
QualType QualType::substObjCTypeArgs(
            ArrayRef<QualType> typeArgs,
            ObjCSubstitutionContext context) const {
   return simpleTransform(ctx, *this,
                          [&](QualType type) -> QualType {
     SplitQualType splitType = type.split();
 
     // Replace an Objective-C type parameter reference with the corresponding
     // type argument.
-    if (const auto *typedefTy = dyn_cast<TypedefType>(splitType.Ty)) {
-      if (auto *typeParam = dyn_cast<ObjCTypeParamDecl>(typedefTy->getDecl())) {
+    if (const auto *OTPTy = dyn_cast<ObjCTypeParamType>(splitType.Ty)) {
+      if (auto *typeParam = dyn_cast<ObjCTypeParamDecl>(OTPTy->getDecl())) {
         // If we have type arguments, use them.
         if (!typeArgs.empty()) {
           // FIXME: Introduce SubstObjCTypeParamType ?
           QualType argType = typeArgs[typeParam->getIndex()];
+          if (OTPTy->qual_empty())
             return ctx.getQualifiedType(argType, splitType.Quals);
+          // Apply protocol lists if exists. Should we combine protocol list?
+          if (const auto *objcPtr = dyn_cast<ObjCObjectPointerType>(argType)) {
+            if (const auto *objcObjectType = objcPtr->getObjectType()) {
+              SmallVector<ObjCProtocolDecl*, 8> protocolsVec;
+              protocolsVec.append(objcObjectType->qual_begin(),
+                                  objcObjectType->qual_end());
+              protocolsVec.append(OTPTy->qual_begin(),
+                                  OTPTy->qual_end());
+              ArrayRef<ObjCProtocolDecl *> protocols = protocolsVec;
+              // We should refactor applyObjCProtocolQualifiers.
+              QualType resultTy = ctx.getObjCObjectType(
+                       objcObjectType->getBaseType(),
+                       objcObjectType->getTypeArgsAsWritten(),
+                       protocols,
+                       objcObjectType->isKindOfTypeAsWritten());
+              // Rebuild object pointer type.
+              resultTy = ctx.getObjCObjectPointerType(resultTy);
+              return ctx.getQualifiedType(resultTy, splitType.Quals);
+            }
+          }
+          llvm_unreachable("substitute ObjC type param T<protocol> with a non ObjC object type");
         }
 
         switch (context) {
         case ObjCSubstitutionContext::Ordinary:
         case ObjCSubstitutionContext::Parameter:
         case ObjCSubstitutionContext::Superclass:
           // Substitute the bound.
           return ctx.getQualifiedType(typeParam->getUnderlyingType(),
QualType QualType::substObjCMemberType(QualType objectType,
                                        const DeclContext *dc,
                                        ObjCSubstitutionContext context) const {
   if (auto subs = objectType->getObjCSubstitutions(dc))
     return substObjCTypeArgs(dc->getParentASTContext(), *subs, context);
 
   return *this;
 }
 
+/// This function replaces ObjCTypeParamType with its underlying type so we
+/// can check if a ObjCMethod declaration in @interface matches the definition
+/// in @implementation. @implementation does not take type parameters.
+QualType QualType::handleObjCTypeParamType(ASTContext &ctx) const {
+  return simpleTransform(ctx, *this,
+           [&](QualType type) -> QualType {
+             SplitQualType splitType = type.split();
+             if (auto *TPT = splitType.Ty->getAs<ObjCTypeParamType>()) {
+               QualType result = TPT->getDecl()->getUnderlyingType();
+               return ctx.getQualifiedType(
+                        result, splitType.Quals);
+             }
+             return type;
+           });
+}
+
 QualType QualType::stripObjCKindOfType(const ASTContext &constCtx) const {
   // FIXME: Because ASTContext::getAttributedType() is non-const.
   auto &ctx = const_cast<ASTContext &>(constCtx);
   return simpleTransform(ctx, *this,
            [&](QualType type) -> QualType {
              SplitQualType splitType = type.split();
              if (auto *objType = splitType.Ty->getAs<ObjCObjectType>()) {
                if (!objType->isKindOfType())

lib/Sema/SemaDeclObjC.cpp

auto nullabilityMethodDecl =
              ((MethodDecl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
                 != 0));
       S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
   }
     
   if (S.Context.hasSameUnqualifiedType(MethodImpl->getReturnType(),
                                        MethodDecl->getReturnType()))
     return true;
+
+  // We need to transfer the types if they contain ObjCTypeParamType.
+  QualType ModifiedImplTy =
+    MethodImpl->getReturnType().handleObjCTypeParamType(S.Context);
+  QualType ModifiedIfaceTy =
+    MethodDecl->getReturnType().handleObjCTypeParamType(S.Context);
+  if (S.Context.hasSameUnqualifiedType(ModifiedImplTy, ModifiedIfaceTy))
+    return true;
+
   if (!Warn)
     return false;
 
   unsigned DiagID = 
     IsOverridingMode ? diag::warn_conflicting_overriding_ret_types 
                      : diag::warn_conflicting_ret_types;
 
   // Mismatches between ObjC pointers go into a different warning
S.Diag(ImplVar->getLocation(),
       << DiagNullabilityKind(
            *IfaceTy->getNullability(S.Context),
            ((IfaceVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
             != 0));
     S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration);
   }
   if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
     return true;
-  
+  // We need to transfer the types if they contain ObjCTypeParamType.
+  QualType ModifiedImplTy = ImplTy.handleObjCTypeParamType(S.Context);
+  QualType ModifiedIfaceTy = IfaceTy.handleObjCTypeParamType(S.Context);
+  if (S.Context.hasSameUnqualifiedType(ModifiedImplTy, ModifiedIfaceTy))
+    return true;
+
   if (!Warn)
     return false;
   unsigned DiagID = 
     IsOverridingMode ? diag::warn_conflicting_overriding_param_types 
                      : diag::warn_conflicting_param_types;
 
   // Mismatches between ObjC pointers go into a different warning
   // category, and sometimes they're even completely whitelisted.

lib/Sema/SemaExprObjC.cpp

ExprResult Sema::ActOnObjCBoolLiteral(SourceLocation AtLoc,
   return BuildObjCNumericLiteral(AtLoc, Inner.get());
 }
 
 /// \brief Check that the given expression is a valid element of an Objective-C
 /// collection literal.
 static ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element, 
                                                     QualType T,
                                                     bool ArrayLiteral = false) {
+  if (auto *TPT = T->getAs<ObjCTypeParamType>())
+    T = TPT->getDecl()->getUnderlyingType();
+
   // If the expression is type-dependent, there's nothing for us to do.
   if (Element->isTypeDependent())
     return Element;
 
   ExprResult Result = S.CheckPlaceholderExpr(Element);
   if (Result.isInvalid())
     return ExprError();
   Element = Result.get();
if (!ArrayWithObjectsMethod) {
     }
 
     if (!validateBoxingMethod(*this, Loc, NSArrayDecl, Sel, Method))
       return ExprError();
 
     // Dig out the type that all elements should be converted to.
     QualType T = Method->parameters()[0]->getType();
     const PointerType *PtrT = T->getAs<PointerType>();
+    // It is okay for the pointee type to be ObjCTypeParamType.
     if (!PtrT || 
-        !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT)) {
+        (!isa<ObjCTypeParamType>(PtrT->getPointeeType()) &&
+         !Context.hasSameUnqualifiedType(PtrT->getPointeeType(), IdT))) {
       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
         << Sel;
       Diag(Method->parameters()[0]->getLocation(),
            diag::note_objc_literal_method_param)
         << 0 << T 
         << Context.getPointerType(IdT.withConst());
       return ExprError();
     }
if (!DictionaryWithObjectsMethod) {
     if (!validateBoxingMethod(*this, SR.getBegin(), NSDictionaryDecl, Sel,
                               Method))
        return ExprError();
 
     // Dig out the type that all values should be converted to.
     QualType ValueT = Method->parameters()[0]->getType();
     const PointerType *PtrValue = ValueT->getAs<PointerType>();
     if (!PtrValue || 
-        !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT)) {
+        (!isa<ObjCTypeParamType>(PtrValue->getPointeeType()) &&
+         !Context.hasSameUnqualifiedType(PtrValue->getPointeeType(), IdT))) {
       Diag(SR.getBegin(), diag::err_objc_literal_method_sig)
         << Sel;
       Diag(Method->parameters()[0]->getLocation(),
            diag::note_objc_literal_method_param)
         << 0 << ValueT
         << Context.getPointerType(IdT.withConst());
       return ExprError();
     }
 
     // Dig out the type that all keys should be converted to.
     QualType KeyT = Method->parameters()[1]->getType();
     const PointerType *PtrKey = KeyT->getAs<PointerType>();
     if (!PtrKey || 
+        (!isa<ObjCTypeParamType>(PtrKey->getPointeeType()) &&
          !Context.hasSameUnqualifiedType(PtrKey->getPointeeType(),
-                                        IdT)) {
+                                        IdT))) {
       bool err = true;
       if (PtrKey) {
         if (QIDNSCopying.isNull()) {
           // key argument of selector is id<NSCopying>?
           if (ObjCProtocolDecl *NSCopyingPDecl =
               LookupProtocol(&Context.Idents.get("NSCopying"), SR.getBegin())) {
             ObjCProtocolDecl *PQ[] = {NSCopyingPDecl};
             QIDNSCopying = 

lib/Sema/SemaType.cpp

if (!anyPackExpansions) {
         if (failOnError)
           return QualType();
 
         return type;
       }
     }
 
     // Objective-C object pointer types must be substitutable for the bounds.
-    if (const auto *typeArgObjC = typeArg->getAs<ObjCObjectPointerType>()) {
+    if (typeArg->getAs<ObjCObjectPointerType>() ||
+        isa<ObjCTypeParamType>(typeArg)) {
       // If we don't have a type parameter to match against, assume
       // everything is fine. There was a prior pack expansion that
       // means we won't be able to match anything.
       if (!typeParam) {
         assert(anyPackExpansions && "Too many arguments?");
         continue;
       }
 
       // Retrieve the bound.
       QualType bound = typeParam->getUnderlyingType();
       const auto *boundObjC = bound->getAs<ObjCObjectPointerType>();
 
+      // For ObjCTypeParamType, we use the Decl's underlying type.
+      const ObjCObjectPointerType *typeArgObjC = nullptr;
+      if (isa<ObjCTypeParamType>(typeArg)) {
+        typeArgObjC = typeArg->getAs<ObjCTypeParamType>()->getDecl()->
+                      getUnderlyingType()->getAs<ObjCObjectPointerType>(); 
+      } else {
+        typeArgObjC = typeArg->getAs<ObjCObjectPointerType>();
+      }
       // Determine whether the type argument is substitutable for the bound.
       if (typeArgObjC->isObjCIdType()) {
         // When the type argument is 'id', the only acceptable type
         // parameter bound is 'id'.
         if (boundObjC->isObjCIdType())
           continue;
       } else if (S.Context.canAssignObjCInterfaces(boundObjC, typeArgObjC)) {
         // Otherwise, we follow the assignability rules.

 
 /// Apply Objective-C protocol qualifiers to the given type.
 static QualType applyObjCProtocolQualifiers(
                   Sema &S, SourceLocation loc, SourceRange range, QualType type,
                   ArrayRef<ObjCProtocolDecl *> protocols,
                   const SourceLocation *protocolLocs,
                   bool failOnError = false) {
   ASTContext &ctx = S.Context;
+  if (const ObjCTypeParamType *objT =
+      dyn_cast<ObjCTypeParamType>(type.getTypePtr())) {
+    return ctx.getObjCTypeParamType(objT->getDecl(), protocols);
+  }
+
   if (const ObjCObjectType *objT = dyn_cast<ObjCObjectType>(type.getTypePtr())){
     // FIXME: Check for protocols to which the class type is already
     // known to conform.
 
     return ctx.getObjCObjectType(objT->getBaseType(),
                                  objT->getTypeArgsAsWritten(),
                                  protocols,
                                  objT->isKindOfTypeAsWritten());
TypeResult Sema::actOnObjCTypeArgsAndProtocolQualifiers(
   // For id<Proto1, Proto2> or Class<Proto1, Proto2>, we'll have an
   // object pointer type. Fill in source information for it.
   if (auto ObjCObjectPointerTL = ResultTL.getAs<ObjCObjectPointerTypeLoc>()) {
     // The '*' is implicit.
     ObjCObjectPointerTL.setStarLoc(SourceLocation());
     ResultTL = ObjCObjectPointerTL.getPointeeLoc();
   }
 
+  if (auto OTPTL = ResultTL.getAs<ObjCTypeParamTypeLoc>()) {
+    // Protocol qualifier information.
+    if (OTPTL.getNumProtocols() > 0) {
+      assert(OTPTL.getNumProtocols() == Protocols.size());
+      OTPTL.setProtocolLAngleLoc(ProtocolLAngleLoc);
+      OTPTL.setProtocolRAngleLoc(ProtocolRAngleLoc);
+      for (unsigned i = 0, n = Protocols.size(); i != n; ++i)
+        OTPTL.setProtocolLoc(i, ProtocolLocs[i]);
+    } else {
+      OTPTL.setProtocolLAngleLoc(SourceLocation());
+      OTPTL.setProtocolRAngleLoc(SourceLocation());
+    }
+
+    // We're done. Return the completed type to the parser.
+    return CreateParsedType(Result, ResultTInfo);
+  }
+
   auto ObjCObjectTL = ResultTL.castAs<ObjCObjectTypeLoc>();
 
   // Type argument information.
   if (ObjCObjectTL.getNumTypeArgs() > 0) {
     assert(ObjCObjectTL.getNumTypeArgs() == ActualTypeArgInfos.size());
     ObjCObjectTL.setTypeArgsLAngleLoc(TypeArgsLAngleLoc);
     ObjCObjectTL.setTypeArgsRAngleLoc(TypeArgsRAngleLoc);
     for (unsigned i = 0, n = ActualTypeArgInfos.size(); i != n; ++i)
do {
 
     // Decompose member pointers.
     if (type->getAs<MemberPointerType>()) {
       return numNormalPointers > 0 ? PointerDeclaratorKind::MultiLevelPointer
                                    : PointerDeclaratorKind::SingleLevelPointer;
     }
 
     // Look at Objective-C object pointers.
-    if (auto objcObjectPtr = type->getAs<ObjCObjectPointerType>()) {
+    if (type->getAs<ObjCObjectPointerType>() ||
+        isa<ObjCTypeParamType>(type)) {
+      const ObjCObjectPointerType *objcObjectPtr = nullptr;
+      if (isa<ObjCTypeParamType>(type))
+        objcObjectPtr = type->getAs<ObjCTypeParamType>()->getDecl()->
+                        getUnderlyingType()->getAs<ObjCObjectPointerType>();
+      else
+        objcObjectPtr = type->getAs<ObjCObjectPointerType>();
       ++numNormalPointers;
       ++numTypeSpecifierPointers;
 
       // If this is NSError**, report that.
       if (auto objcClassDecl = objcObjectPtr->getInterfaceDecl()) {
         if (objcClassDecl->getIdentifier() == S.getNSErrorIdent() &&
             numNormalPointers == 2 && numTypeSpecifierPointers < 2) {
           return PointerDeclaratorKind::NSErrorPointerPointer;
if (!desugared->canHaveNullability()) {
     Diag(nullabilityLoc, diag::err_nullability_nonpointer)
       << DiagNullabilityKind(nullability, isContextSensitive) << type;
     return true;
   }
   
   // For the context-sensitive keywords/Objective-C property
   // attributes, require that the type be a single-level pointer.
   if (isContextSensitive) {
+    if (!isa<ObjCTypeParamType>(desugared)) {
       // Make sure that the pointee isn't itself a pointer type.
       QualType pointeeType = desugared->getPointeeType();
       if (pointeeType->isAnyPointerType() ||
           pointeeType->isObjCObjectPointerType() ||
           pointeeType->isMemberPointerType()) {
         Diag(nullabilityLoc, diag::err_nullability_cs_multilevel)
           << DiagNullabilityKind(nullability, true)
           << type;
         Diag(nullabilityLoc, diag::note_nullability_type_specifier)
           << DiagNullabilityKind(nullability, false)
           << type
           << FixItHint::CreateReplacement(nullabilityLoc,
                                           getNullabilitySpelling(nullability));
         return true;
       }
     }
+  }
 
   // Form the attributed type.
   type = Context.getAttributedType(
            AttributedType::getNullabilityAttrKind(nullability), type, type);
   return false;
 }
 
 bool Sema::checkObjCKindOfType(QualType &type, SourceLocation loc) {
+  if (isa<ObjCTypeParamType>(type)) {
+    // Build the attributed type to record where __kindof occurred.
+    type = Context.getAttributedType(AttributedType::attr_objc_kindof,
+                                     type, type);
+    return false;
+  }
+
   // Find out if it's an Objective-C object or object pointer type;
   const ObjCObjectPointerType *ptrType = type->getAs<ObjCObjectPointerType>();
   const ObjCObjectType *objType = ptrType ? ptrType->getObjectType() 
                                           : type->getAs<ObjCObjectType>();
 
   // If not, we can't apply __kindof.
   if (!objType) {
     // FIXME: Handle dependent types that aren't yet object types.

lib/StaticAnalyzer/Checkers/DynamicTypePropagation.cpp

 static bool isObjCTypeParamDependent(QualType Type) {
   // It is illegal to typedef parameterized types inside an interface. Therfore
   // an Objective-C type can only be dependent on a type parameter when the type
   // parameter structurally present in the type itself.
   class IsObjCTypeParamDependentTypeVisitor
       : public RecursiveASTVisitor<IsObjCTypeParamDependentTypeVisitor> {
   public:
     IsObjCTypeParamDependentTypeVisitor() : Result(false) {}
-    bool VisitTypedefType(const TypedefType *Type) {
+    bool VisitObjCTypeParamType(const ObjCTypeParamType *Type) {
       if (isa<ObjCTypeParamDecl>(Type->getDecl())) {
         Result = true;
         return false;
       }
       return true;
     }
 
     bool Result;

lib/StaticAnalyzer/Core/CallEvent.cpp

static bool isCallback(QualType T) {
   if (T->isBlockPointerType() ||
       T->isFunctionPointerType() ||
       T->isObjCSelType())
     return true;
 
   // Check if a callback is passed inside a struct (for both, struct passed by
   // reference and by value). Dig just one level into the struct for now.
 
-  if (T->isAnyPointerType() || T->isReferenceType())
+  if ((T->isAnyPointerType() && !isa<ObjCTypeParamType>(T)) ||
+      T->isReferenceType())
     T = T->getPointeeType();
 
   if (const RecordType *RT = T->getAsStructureType()) {
     const RecordDecl *RD = RT->getDecl();
     for (const auto *I : RD->fields()) {
       QualType FieldT = I->getType();
       if (FieldT->isBlockPointerType() || FieldT->isFunctionPointerType())
         return true;
if (!FD)
     return false;
 
   return CheckerContext::isCLibraryFunction(FD, FunctionName);
 }
 
 /// \brief Returns true if a type is a pointer-to-const or reference-to-const
 /// with no further indirection.
 static bool isPointerToConst(QualType Ty) {
+  if (isa<ObjCTypeParamType>(Ty))
+    return false;
   QualType PointeeTy = Ty->getPointeeType();
   if (PointeeTy == QualType())
     return false;
   if (!PointeeTy.isConstQualified())
     return false;
   if (PointeeTy->isAnyPointerType())
     return false;
   return true;

test/SemaObjC/kindof.m

 - (void)test:(__kindof id)T;
 @end
 @implementation A2
 - (void)test:(id)T {
 }
 @end
 
 @interface NSGeneric<ObjectType> : NSObject
-- (void)test:(__kindof ObjectType)T;
+- (void)test:(__kindof ObjectType)T; // expected-note{{passing argument to parameter 'T' here}}
 - (void)mapUsingBlock:(id (^)(__kindof ObjectType))block;
 @end
 @implementation NSGeneric
 - (void)test:(id)T {
 }
 - (void)mapUsingBlock:(id (^)(id))block {
 }
 @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];
+}
+
 // 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

test/SemaObjC/parameterized_classes.m

 @end
 
 @interface PC22<T : NSObject *> : PC1<T> // expected-error{{too few type arguments for class 'PC1' (have 1, expected 2)}}
 @end
 
 @interface PC23<T : NSObject *> : PC1<T, U> // expected-error{{unknown type name 'U'}}
 @end
 
-@interface PC24<T> : PC1<T, T> // expected-error{{type argument 'T' (aka 'id') does not satisfy the bound ('NSObject *') of type parameter 'U'}}
+@interface PC24<T> : PC1<T, T> // expected-error{{type argument 'T' does not satisfy the bound ('NSObject *') of type parameter 'U'}}
 @end
 
 @interface NSFoo : PC1<NSObject *, NSObject *> // okay
 @end
 
 // --------------------------------------------------------------------------
 // Co- and contra-variance.
 // --------------------------------------------------------------------------

test/SemaObjC/parameterized_classes_subst.m

+ (void)useSuperMethod {
   ip = [super array]; // expected-warning{{from 'NSArray<NSString *> *'}}
 }
 @end
 
 // --------------------------------------------------------------------------
 // warning about likely protocol/class name typos.
 // --------------------------------------------------------------------------
 typedef NSArray<NSObject> ArrayOfNSObjectWarning; // expected-warning{{parameterized class 'NSArray' already conforms to the protocols listed; did you forget a '*'?}}
+
+// rdar://25060179
+@interface MyMutableDictionary<KeyType, ObjectType> : NSObject
+- (void)setObject:(ObjectType)obj forKeyedSubscript:(KeyType <NSCopying>)key; // expected-note{{passing argument to parameter 'obj' here}} \
+    // expected-note{{passing argument to parameter 'key' here}}
+@end
+
+void bar(MyMutableDictionary<NSString *, NSString *> *stringsByString,
+                             NSNumber *n1, NSNumber *n2) {
+  // We warn here when the key types do not match.
+  stringsByString[n1] = n2; // expected-warning{{incompatible pointer types sending 'NSNumber *' to parameter of type 'NSString *'}} \
+    // expected-warning{{incompatible pointer types sending 'NSNumber *' to parameter of type 'NSString<NSCopying> *'}}
+}
+
+@interface MyTest<K, V> : NSObject <NSCopying>
+- (V)test:(K)key;
+- (V)test2:(K)key; // expected-note{{previous definition is here}}
+- (void)mapUsingBlock:(id (^)(V))block;
+- (void)mapUsingBlock2:(id (^)(V))block; // expected-note{{previous definition is here}}
+@end
+
+@implementation MyTest
+- (id)test:(id)key {
+  return key;
+}
+- (int)test2:(id)key{ // expected-warning{{conflicting return type in implementation}}
+  return 0;
+}
+- (void)mapUsingBlock:(id (^)(id))block {
+}
+- (void)mapUsingBlock2:(id)block { // expected-warning{{conflicting parameter types in implementation}}
+}
+@end