[ObjC] Fix non-canonical types preventing type arguments substitution.

[vsapsai]

Summary

QualType::substObjCTypeArgs doesn't go past non-canonical types and as
the result misses some of the substitutions like ObjCTypeParamType.

Update SimpleTransformVisitor to traverse past the type sugar.

[vsapsai]

Ping.

[erik.pilkington]

LGTM!

clang/lib/AST/Type.cpp

public:
   // there are dependent types, so skip dependent types.
 #define TYPE(Class, Base)
 #define DEPENDENT_TYPE(Class, Base) \
   QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
 #include "clang/AST/TypeNodes.def"
 
 #define TRIVIAL_TYPE_CLASS(Class) \
   QualType Visit##Class##Type(const Class##Type *T) { return QualType(T, 0); }
+#define SUGARED_TYPE_CLASS(Class) \
+  QualType Visit##Class##Type(const Class##Type *T) { \
+    if (!T->isSugared()) \
+      return QualType(T, 0); \
+    QualType desugaredType = recurse(T->desugar()); \
+    if (desugaredType.isNull()) \
+      return {}; \
+    if (desugaredType.getAsOpaquePtr() == T->desugar().getAsOpaquePtr()) \
+      return QualType(T, 0); \
+    return desugaredType; \
+  }
 
   TRIVIAL_TYPE_CLASS(Builtin)
 
   QualType VisitComplexType(const ComplexType *T) {
     QualType elementType = recurse(T->getElementType());
     if (elementType.isNull())
       return {};
 
if (innerType.isNull())
       return {};
 
     if (innerType.getAsOpaquePtr() == T->getInnerType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getParenType(innerType);
   }
 
-  TRIVIAL_TYPE_CLASS(Typedef)
-  TRIVIAL_TYPE_CLASS(ObjCTypeParam)
+  SUGARED_TYPE_CLASS(Typedef)
+  SUGARED_TYPE_CLASS(ObjCTypeParam)
 
   QualType VisitAdjustedType(const AdjustedType *T) {
     QualType originalType = recurse(T->getOriginalType());
     if (originalType.isNull())
       return {};
 
     QualType adjustedType = recurse(T->getAdjustedType());
     if (adjustedType.isNull())
QualType VisitDecayedType(const DecayedType *T) {
 
     if (originalType.getAsOpaquePtr()
           == T->getOriginalType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getDecayedType(originalType);
   }
 
-  TRIVIAL_TYPE_CLASS(TypeOfExpr)
-  TRIVIAL_TYPE_CLASS(TypeOf)
-  TRIVIAL_TYPE_CLASS(Decltype)
-  TRIVIAL_TYPE_CLASS(UnaryTransform)
+  SUGARED_TYPE_CLASS(TypeOfExpr)
+  SUGARED_TYPE_CLASS(TypeOf)
+  SUGARED_TYPE_CLASS(Decltype)
+  SUGARED_TYPE_CLASS(UnaryTransform)
   TRIVIAL_TYPE_CLASS(Record)
   TRIVIAL_TYPE_CLASS(Enum)
 
   // FIXME: Non-trivial to implement, but important for C++
-  TRIVIAL_TYPE_CLASS(Elaborated)
+  SUGARED_TYPE_CLASS(Elaborated)
 
   QualType VisitAttributedType(const AttributedType *T) {
     QualType modifiedType = recurse(T->getModifiedType());
     if (modifiedType.isNull())
       return {};
 
     QualType equivalentType = recurse(T->getEquivalentType());
     if (equivalentType.isNull())
if (replacementType.getAsOpaquePtr()
           == T->getReplacementType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getSubstTemplateTypeParmType(T->getReplacedParameter(),
                                             replacementType);
   }
 
   // FIXME: Non-trivial to implement, but important for C++
-  TRIVIAL_TYPE_CLASS(TemplateSpecialization)
+  SUGARED_TYPE_CLASS(TemplateSpecialization)
 
   QualType VisitAutoType(const AutoType *T) {
     if (!T->isDeduced())
       return QualType(T, 0);
 
     QualType deducedType = recurse(T->getDeducedType());
     if (deducedType.isNull())
       return {};
 
     if (deducedType.getAsOpaquePtr()
           == T->getDeducedType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getAutoType(deducedType, T->getKeyword(),
                            T->isDependentType());
   }
 
   // FIXME: Non-trivial to implement, but important for C++
-  TRIVIAL_TYPE_CLASS(PackExpansion)
+  SUGARED_TYPE_CLASS(PackExpansion)
 
   QualType VisitObjCObjectType(const ObjCObjectType *T) {
     QualType baseType = recurse(T->getBaseType());
     if (baseType.isNull())
       return {};
 
     // Transform type arguments.
     bool typeArgChanged = false;
QualType VisitAtomicType(const AtomicType *T) {
     if (valueType.getAsOpaquePtr()
           == T->getValueType().getAsOpaquePtr())
       return QualType(T, 0);
 
     return Ctx.getAtomicType(valueType);
   }
 
 #undef TRIVIAL_TYPE_CLASS
+#undef SUGARED_TYPE_CLASS
 };
 
 } // namespace
 
 /// Perform a simple type transformation that does not change the
 /// semantics of the type.
 template<typename F>
 static QualType simpleTransform(ASTContext &ctx, QualType type, F &&f) {

clang/test/SemaObjC/parameterized_classes_subst.m

 @interface NSControl : NSView
 - (void)toggle;
 @end
 
 @interface NSViewController<ViewType : NSView *> : NSObject
 @property (nonatomic,retain) ViewType view;
 @end
 
+@interface TypedefTypeParam<T> : NSObject
+typedef T AliasT;
+- (void)test:(AliasT)object;
+// expected-note@-1 {{parameter 'object' here}}
+@end
+
 // --------------------------------------------------------------------------
 // Nullability
 // --------------------------------------------------------------------------
 typedef NSControl * _Nonnull Nonnull_NSControl;
 
 @interface NSNullableTest<ViewType : NSView *> : NSObject
 - (ViewType)view;
 - (nullable ViewType)maybeView;

 
 void test_message_send_param(
        NSMutableSet<NSString *> *mutStringSet,
        WidgetSet *widgetSet,
        UntypedMutableSet *untypedMutSet,
        MutableSetOfArrays<NSString *> *mutStringArraySet,
        NSMutableSet *mutSet,
        MutableSetOfArrays *mutArraySet,
+       TypedefTypeParam<NSString *> *typedefTypeParam,
        void (^block)(void)) {
   Window *window;
 
   [mutStringSet addObject: window]; // expected-warning{{parameter of type 'NSString *'}}
   [widgetSet addObject: window]; // expected-warning{{parameter of type 'Widget *'}}
   [untypedMutSet addObject: window]; // expected-warning{{parameter of incompatible type 'id<NSCopying>'}}
   [mutStringArraySet addObject: window]; // expected-warning{{parameter of type 'NSArray<NSString *> *'}}
   [mutSet addObject: window]; // expected-warning{{parameter of incompatible type 'id<NSCopying>'}}
   [mutArraySet addObject: window]; // expected-warning{{parameter of incompatible type 'id<NSCopying>'}}
+  [typedefTypeParam test: window]; // expected-warning{{parameter of type 'NSString *'}}
   [block addObject: window]; // expected-warning{{parameter of incompatible type 'id<NSCopying>'}}
 }
 
 // --------------------------------------------------------------------------
 // Property accesses.
 // --------------------------------------------------------------------------
 void test_property_read(
        NSSet<NSString *> *stringSet,