[AST] Refactor UnaryTransformType into TransformTraitType supporting non-unary transforms

[EricWF]

Summary

This patch refactors UnaryTransformType into TransformTraitType which accepts an arbitrary number of input arguments, which is needed to support upcoming traits such as __raw_invocation_type

[rsmith]

include/clang/AST/Type.h

3990

You can't store types with non-trivial destructors on AST nodes; the Type destructor will never run, so you'll leak. Instead, consider tail-allocating this list of QualTypes, or performing a separate allocation using the ASTContext slab allocator to hold the list if tail-allocation isn't feasible for some reason.

include/clang/Basic/DiagnosticCommonKinds.td

111–114

Hmm, do you need to touch this diagnostic in this change?

(If so, can you fix the second select to use %plural?)

include/clang/Basic/Specifiers.h

80 ↗

(On Diff #140558)

Not sure what happened here, these whitespace changes look unrelated to your patch.

include/clang/Serialization/ASTBitCodes.h

1088

Please commit the whitespace changes in this file separately.

lib/AST/ASTDumper.cpp

1373

I prefer this as it was before ('s wrapping the thing they're quoting)...

lib/AST/ASTImporter.cpp

812

2 seems unnecessarily low here.

lib/AST/ASTStructuralEquivalence.cpp

512

This should presumably also check the kind...

lib/AST/ItaniumMangle.cpp

3250–3251

We need manglings to be self-delimiting, and we can't tell where the end of the argument list is with this mangling approach. :(

(Eg, f(__raw_invocation_type(T1, T2, T3)) and f(__raw_invocation_type(T1, T2), T3) would mangle the same with this mangling.)

Maybe drop an E on the end? (Or maybe do that only for traits that don't require exactly one argument, but that would create pain for demanglers....)

lib/AST/TypePrinter.cpp

954

This doesn't look right...

lib/Parse/ParseDeclCXX.cpp

1077–1087

This only works if none of the arguments are pack expansions.

lib/Sema/SemaTemplateDeduction.cpp

5367–5368

Marking the transformed type doesn't seem necessary. It can't possibly name template parameters (except via the inputs to the trait).

lib/Sema/SemaType.cpp

1508–1509

Try to avoid default: cases like this, as they suppress the warning notifying the user to update this switch when new traits are added.

8004–8013

Looks like you were half-way through factoring out the commonality between this and the parser's version?

8037–8038

You'll need to deal with the case that the arguments contain unexpanded packs here before assuming that ArgTypes.size() is meaningful.

lib/Sema/TreeTransform.h

625–627

I would drop the "Source" from this. We generally don't shorten "TypeSourceInfo" to "TypeSource", and it's clear enough to just say "Type" here I think. I'd also drop the "AndExpandPacks" because that's just a part of what it means to transform a list.

[EricWF]

include/clang/AST/Type.h

3990

Ack. Tail-allocation seems tricky due to DependentTransformTraitType. I'll go ahead with using ASTContext::Allocate.

include/clang/Basic/DiagnosticCommonKinds.td

111–114

The changes aren't currently needed. I'll remove them for now.

include/clang/Serialization/ASTBitCodes.h

1088

Darn git clang-format being too aggressive.

lib/AST/ItaniumMangle.cpp

3250–3251

Makes sense. Thanks for the explanation. I'll go ahead and drop and E on the end.

However, will this cause ABI issues? Either with existing code or with GCC? If so, perhaps we should maintain the current mangling for __underlying_type.

lib/AST/TypePrinter.cpp

954

Woops, a funky merge + clang-format strike again!

lib/Sema/SemaType.cpp

1508–1509

Understood, but surely this is a case where default: is warranted. We're switching over a range of values much larger than TransformTraitType::TTKind in order to transform it into the TTKind

Do you have suggestions for improving it?

8004–8013

That was my goal, but I wasn't sure where it was appropriate to put this so it could be shared across components.

Any suggestions?

[EricWF]

lib/Parse/ParseDeclCXX.cpp

1077–1087

Hmm. Interesting. The TypeTraitExpr parsing does the same thing.

Is the appropriate fix to delay the diagnostic until pack expansions have been expanded much later?

[EricWF]

lib/AST/ItaniumMangle.cpp

3250–3251

To answer my own question, GCC doesn't mangle __underlying_type yet. And I doubt that people are currently depending on the dependent mangling of __underlying_type. Perhaps I'm wrong about that last assumption though.

[EricWF]

Address all inline comments.

• Dynamically allocate TransformTraitTypes list of argument types; making the node trivially destructible.
• Detect and handle parameter packs when building TransformTraitType.
• Factor out trait arity diagnostics between the parser and sema.
• Rename TransformTypeSourceListAndExpandPacks as suggested.
• Add a terminator character to the mangling to prevent ambiguity.

[EricWF]

Ping.

[rsmith]

include/clang/AST/TypeLoc.h

1992–1993

This assert doesn't make sense: the extra TypeSourceInfo*s are not stored after a TransformTraitTypeLoc. Rather, *TypeLoc is a non-owning veneer around separately-allocated data. ConcreteTypeLoc takes care of adding any necessary padding to get to the right alignment for you.

include/clang/ASTMatchers/ASTMatchers.h

5262–5266

Generally I think we want the primitive AST matchers to pretty directly correspond to the Clang AST. I think it would make sense to replace this matcher with a generalized transformTrait matcher -- but in a separate commit from this one. This is OK for now.

lib/AST/ASTContext.cpp

4630

You can just drop the function name (and hyphen) here; that's an obsolescent style.

lib/AST/ItaniumMangle.cpp

3250–3251

The existing U3eut mangling (with no terminating E) was approximately OK, following http://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangle.qualified-type. It would be better to use U17__underlying_type, though. This is not exactly right, since it treats __underlying_type as a type qualifier rather than a type function, but that's not too far off.

The new mangling doesn't match the Itanium ABI rule for vendor extensions. We basically have a choice between u <source-name> (which doesn't give us a good way to encode the arguments) or U <source-name> <template-args> <type> (which could work, but we'd need to make a somewhat-arbitrary choice of which type we consider to be the "main" type to which the qualifier applies).

We could arbitrarily say:

• the first type in the trait is the "main" type
• the rest of the trait is mangled as a qualifier
• the qualifier is given template-args if and only if there is more than one argument

So:

• __underlying_type(T) would mangle as U17__underlying_type1T (or approximately T __underlying_type)
• __raw_invocation_type(F, A1, A2) would mangle as U21__raw_invocation_typeI2A12A2E1F (or approximately F __raw_invocation_type<A1, A2>)
• __raw_invocation_type(F) would mangle as U21__raw_invocation_type1F (or approximately F __raw_invocation_type)

Or we could track here whether the trait can accept >1 argument, and always use the template-args formulation if so. I have no strong opinions either way.

Or we could suggest an Itanium ABI extension to permit <template-args> for the u... vendor extension type form, for vendor type traits. That'd lead to:

• __underlying_type(T) would mangle as u17__underlying_typeI1TE (or approximately __underlying_type<T>)
• __raw_invocation_type(F, A1, A2) would mangle as u21__raw_invocation_typeI1F2A12A2E (or approximately __raw_invocation_type<F, A1, A2>)
• __raw_invocation_type(F) would mangle as u21__raw_invocation_typeI1FE (or approximately __raw_invocation_type<F>)

... and we could encourage demanglers to use parens instead of angles for those arguments.

The final of the above options seems best to me. What do you think?

lib/AST/Type.cpp

3081–3082

This should come from the transformed type, not the base type. (A transform trait could turn a dependent type into a non-depnedent type.)

3085–3086

Likewise, there's no reason to think that variably-modifiedness of the arguments has anything to do with variably-modifiedness of the transformed type. (Eg, __raw_invocation_type(Fn, VLAType) is not going to be a VLA type.)

3089

(And just for clarity: instantiation-dependence and contains-unexpanded-parameter-pack are concerned with the syntactic form of the type, not the semantics, so those two *should* be based on the corresponding properties of the arguments.)

lib/Lex/PPMacroExpansion.cpp

1245 ↗

(On Diff #141293)

Remove this fixme too, please. (But let's hold off on this change until you land the __raw_invocation_type patch to keep this patch more focused.)

lib/Parse/ParseDeclCXX.cpp

1058

Call DS.SetTypeSpecError() here and at other points where you bail out of this function.

1073–1074

Instead of performing an ad-hoc arity check here, perform the check in the code that converts a kind + list of arguments into a TransformTraitType. That way there's no way to forget these checks and no side channel state to track about whether you've already done them.

lib/Sema/DeclSpec.cpp

373–380

This is going to be problematic down the line -- I expect there are going to be type transform traits that can produce function types. I think this strongly argues that we need to have already converted the trait into a QualType by the time we get here, rather than representing it as a trait kind and a list of types in the DeclSpec and deferring the conversion to later.

lib/Sema/SemaType.cpp

1508–1509

I think you should convert the trait to a QualType when you parse it, rather than waiting until now, which would make this moot.

8014–8022

Do you really need a PartialDiagnostic here? (Could you directly emit the diagnostic instead?)

8027–8029

I think this would be clearer if split into a function that computes and returns the result type of the trait and code to build the trait from that type, rather than this factored-out lambda approach -- this use of a lambda hides the fundamental behavior of this function, which is "first figure out the type and then build a trait producing that type".

8036

This doesn't seem right; you should delay if any of the arguments is dependent, but instantiation-dependent / containing a pack don't seem like they should matter here.

[EricWF]

include/clang/ASTMatchers/ASTMatchers.h

5262–5266

I added a generalized transformTrait matcher, but forgot to declare it.

The reason for keeping the unaryTransformType was simply to avoid breaking existing code which already depends on it.
My plan was to possibly remove this wrapper later, after cleaning up usages in the LLVM code base.

lib/AST/Type.cpp

3089

Thanks for the clarification. I was about to ask.

lib/Sema/SemaType.cpp

1508–1509

Hmm. I'm not quite sure how/where to do that in the parser.

Are you suggesting calling BuildTransformTrait from inside ParseTransformTraitTypeSpecifier, and instead of building the DeclSpec containing the result of BuildTransformTrait instead of the list of argument type?

8014–8022

As it stands now, I believe I do, since the diagnostic needs to be emitted in both the parser and sema. If I'm not mistaken it would be incorrect to use Sema's diagnostic engine inside the parser and vice-versa.

However, if I delay the arity check until we're in SemaType as you suggested elsewhere, then the partial diagnostic is unneeded.

8036

We can't check the arity here as long as any of the arguments contain unexpanded parameter packs, so at least in that case we need to delay.

However, I'll change the isInstantationDependent check to isDependent.

[EricWF]

lib/AST/ItaniumMangle.cpp

3250–3251

Or we could suggest an Itanium ABI extension to permit <template-args> for the u... vendor extension type form,
[...]
The final of the above options seems best to me. What do you think?

I think the final form would also be preferable. I'll go ahead and implement it.
What would it involve to suggest the Itanium ABI extension?

lib/Sema/DeclSpec.cpp

373–380

Ack. Done.

lib/Sema/SemaType.cpp

1508–1509

OK, I've got it all figured out. The requested change has been made.

[EricWF]

Address main review comments.

The TransformTraitType is now built early, and the DeclSpec refers to it and not the list of argument types.

Additionally, the mangling formulation u <source-name> [<template-args>] has been implemented as suggested, despite being non-standard. How do we suggest this extension to Itanium?

I believe this patch should be good to go.

include/clang/AST/ASTContext.h

class ASTContext : public RefCountedBase<ASTContext> {
   mutable llvm::FoldingSet<ElaboratedType> ElaboratedTypes;
   mutable llvm::FoldingSet<DependentNameType> DependentNameTypes;
   mutable llvm::ContextualFoldingSet<DependentTemplateSpecializationType,
                                      ASTContext&>
     DependentTemplateSpecializationTypes;
   llvm::FoldingSet<PackExpansionType> PackExpansionTypes;
   mutable llvm::FoldingSet<ObjCObjectTypeImpl> ObjCObjectTypes;
   mutable llvm::FoldingSet<ObjCObjectPointerType> ObjCObjectPointerTypes;
-  mutable llvm::FoldingSet<DependentUnaryTransformType>
-    DependentUnaryTransformTypes;
+  mutable llvm::FoldingSet<DependentTransformTraitType>
+      DependentTransformTraitTypes;
   mutable llvm::FoldingSet<AutoType> AutoTypes;
   mutable llvm::FoldingSet<DeducedTemplateSpecializationType>
     DeducedTemplateSpecializationTypes;
   mutable llvm::FoldingSet<AtomicType> AtomicTypes;
   llvm::FoldingSet<AttributedType> AttributedTypes;
   mutable llvm::FoldingSet<PipeType> PipeTypes;
 
   mutable llvm::FoldingSet<QualifiedTemplateName> QualifiedTemplateNames;
public:
 
   /// GCC extension.
   QualType getTypeOfExprType(Expr *e) const;
   QualType getTypeOfType(QualType t) const;
 
   /// C++11 decltype.
   QualType getDecltypeType(Expr *e, QualType UnderlyingType) const;
 
-  /// Unary type transforms
-  QualType getUnaryTransformType(QualType BaseType, QualType UnderlyingType,
-                                 UnaryTransformType::UTTKind UKind) const;
+  /// Type trait transformations
+  QualType getTransformTraitType(ArrayRef<QualType> ArgTypes,
+                                 QualType TransformedType,
+                                 TransformTraitType::TTKind TKind) const;
 
   /// C++11 deduced auto type.
   QualType getAutoType(QualType DeducedType, AutoTypeKeyword Keyword,
                        bool IsDependent) const;
 
   /// C++11 deduction pattern for 'auto' type.
   QualType getAutoDeductType() const;
 

include/clang/AST/CanonicalType.h

 
 template<>
 struct CanProxyAdaptor<DecltypeType> : public CanProxyBase<DecltypeType> {
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(Expr *, getUnderlyingExpr)
   LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnderlyingType)
 };
 
 template <>
-struct CanProxyAdaptor<UnaryTransformType>
-    : public CanProxyBase<UnaryTransformType> {
-  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getBaseType)
-  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getUnderlyingType)
-  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(UnaryTransformType::UTTKind, getUTTKind)
+struct CanProxyAdaptor<TransformTraitType>
+    : public CanProxyBase<TransformTraitType> {
+  LLVM_CLANG_CANPROXY_TYPE_ACCESSOR(getTransformedType)
+
+  CanQualType getArg(unsigned i) const {
+    return CanQualType::CreateUnsafe(this->getTypePtr()->getArg(i));
+  }
+
+  LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(TransformTraitType::TTKind, getTTKind)
 };
 
 template<>
 struct CanProxyAdaptor<TagType> : public CanProxyBase<TagType> {
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(TagDecl *, getDecl)
   LLVM_CLANG_CANPROXY_SIMPLE_ACCESSOR(bool, isBeingDefined)
 };
 

include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_TYPE(TypeOfExprType,
                   { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
 
 DEF_TRAVERSE_TYPE(TypeOfType, { TRY_TO(TraverseType(T->getUnderlyingType())); })
 
 DEF_TRAVERSE_TYPE(DecltypeType,
                   { TRY_TO(TraverseStmt(T->getUnderlyingExpr())); })
 
-DEF_TRAVERSE_TYPE(UnaryTransformType, {
-  TRY_TO(TraverseType(T->getBaseType()));
-  TRY_TO(TraverseType(T->getUnderlyingType()));
+DEF_TRAVERSE_TYPE(TransformTraitType, {
+  for (auto Ty : T->getArgs()) {
+    TRY_TO(TraverseType(Ty));
+  }
+  TRY_TO(TraverseType(T->getTransformedType()));
 })
 
 DEF_TRAVERSE_TYPE(AutoType, { TRY_TO(TraverseType(T->getDeducedType())); })
 DEF_TRAVERSE_TYPE(DeducedTemplateSpecializationType, {
   TRY_TO(TraverseTemplateName(T->getTemplateName()));
   TRY_TO(TraverseType(T->getDeducedType()));
 })
 

   TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
 })
 
 // FIXME: location of underlying expr
 DEF_TRAVERSE_TYPELOC(DecltypeType, {
   TRY_TO(TraverseStmt(TL.getTypePtr()->getUnderlyingExpr()));
 })
 
-DEF_TRAVERSE_TYPELOC(UnaryTransformType, {
-  TRY_TO(TraverseTypeLoc(TL.getUnderlyingTInfo()->getTypeLoc()));
+DEF_TRAVERSE_TYPELOC(TransformTraitType, {
+  for (auto *TyInfo : TL.getArgTInfo()) {
+    TRY_TO(TraverseTypeLoc(TyInfo->getTypeLoc()));
+  }
 })
 
 DEF_TRAVERSE_TYPELOC(AutoType, {
   TRY_TO(TraverseType(TL.getTypePtr()->getDeducedType()));
 })
 
 DEF_TRAVERSE_TYPELOC(DeducedTemplateSpecializationType, {
   TRY_TO(TraverseTemplateName(TL.getTypePtr()->getTemplateName()));

include/clang/AST/Type.h

 
     unsigned : NumTypeBits;
 
     /// Was this placeholder type spelled as 'auto', 'decltype(auto)',
     /// or '__auto_type'?  AutoTypeKeyword value.
     unsigned Keyword : 2;
   };
 
+  class TransformTraitTypeBitfields {
+    friend class TransformTraitType;
+
+    unsigned : NumTypeBits;
+
+    /// The transformation trait kind
+    unsigned TTKind : 1;
+
+    /// The number of type arguments
+    unsigned NumArgs : 31 - NumTypeBits;
+  };
+
   union {
     TypeBitfields TypeBits;
     ArrayTypeBitfields ArrayTypeBits;
     AttributedTypeBitfields AttributedTypeBits;
     AutoTypeBitfields AutoTypeBits;
     BuiltinTypeBitfields BuiltinTypeBits;
     FunctionTypeBitfields FunctionTypeBits;
     ObjCObjectTypeBitfields ObjCObjectTypeBits;
     ReferenceTypeBitfields ReferenceTypeBits;
     TypeWithKeywordBitfields TypeWithKeywordBits;
     VectorTypeBitfields VectorTypeBits;
+    TransformTraitTypeBitfields TransformTraitTypeBits;
   };
 
 private:
   template <class T> friend class TypePropertyCache;
 
   /// Set whether this type comes from an AST file.
   void setFromAST(bool V = true) const {
     TypeBits.FromAST = V;

   QualType desugar() const;
 
   /// Returns whether this type directly provides sugar.
   bool isSugared() const;
 
   static bool classof(const Type *T) { return T->getTypeClass() == Decltype; }
 };
 
 /// Internal representation of canonical, dependent
 /// decltype(expr) types.
 ///
 /// This class is used internally by the ASTContext to manage
 /// canonical, dependent types, only. Clients will only see instances
 /// of this class via DecltypeType nodes.
 class DependentDecltypeType : public DecltypeType, public llvm::FoldingSetNode {
   const ASTContext &Context;
 
 public:
   DependentDecltypeType(const ASTContext &Context, Expr *E);
 
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, Context, getUnderlyingExpr());
   }
 
   static void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
                       Expr *E);
 };
 
 /// A unary type transform, which is a type constructed from another.
-class UnaryTransformType : public Type {
+class TransformTraitType : public Type {
 public:
-  enum UTTKind {
-    EnumUnderlyingType
-  };
+  enum TTKind { EnumUnderlyingType };
 
 private:
-  /// The untransformed type.
-  QualType BaseType;
+  QualType *ArgStorage;
 
   /// The transformed type if not dependent, otherwise the same as BaseType.
-  QualType UnderlyingType;
-
-  UTTKind UKind;
+  QualType TransformedType;
 
 protected:
   friend class ASTContext;
 
-  UnaryTransformType(QualType BaseTy, QualType UnderlyingTy, UTTKind UKind,
+  TransformTraitType(const ASTContext &Ctx, ArrayRef<QualType> ArgTy,
+                     QualType TransformedTy, TTKind TKind,
                      QualType CanonicalTy);
 
 public:
   bool isSugared() const { return !isDependentType(); }
-  QualType desugar() const { return UnderlyingType; }
+  QualType desugar() const { return TransformedType; }
 
-  QualType getUnderlyingType() const { return UnderlyingType; }
-  QualType getBaseType() const { return BaseType; }
+  unsigned getNumArgs() const { return TransformTraitTypeBits.NumArgs; }
+  ArrayRef<QualType> getArgs() const {
+    return llvm::makeArrayRef(ArgStorage, getNumArgs());
+  }
 
-  UTTKind getUTTKind() const { return UKind; }
+  QualType getTransformedType() const { return TransformedType; }
+  QualType getArg(unsigned N) const {
+    assert(N < getNumArgs() && "invalid index");
+    return ArgStorage[N];
+  }
+
+  static StringRef getName(TTKind K);
+  StringRef getName() const { return getName(getTTKind()); }
+
+  TTKind getTTKind() const {
+    return static_cast<TTKind>(TransformTraitTypeBits.TTKind);
+  }
 
   static bool classof(const Type *T) {
-    return T->getTypeClass() == UnaryTransform;
+    return T->getTypeClass() == TransformTrait;
   }
 };
 
 /// Internal representation of canonical, dependent
 /// __underlying_type(type) types.
 ///
 /// This class is used internally by the ASTContext to manage
 /// canonical, dependent types, only. Clients will only see instances
-/// of this class via UnaryTransformType nodes.
-class DependentUnaryTransformType : public UnaryTransformType,
+/// of this class via TransformTraitType nodes.
+class DependentTransformTraitType : public TransformTraitType,
                                     public llvm::FoldingSetNode {
 public:
-  DependentUnaryTransformType(const ASTContext &C, QualType BaseType,
-                              UTTKind UKind);
+  DependentTransformTraitType(const ASTContext &C, ArrayRef<QualType> ArgTypes,
+                              TTKind TKind);
 
   void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, getBaseType(), getUTTKind());
+    Profile(ID, getArgs(), getTTKind());
   }
 
-  static void Profile(llvm::FoldingSetNodeID &ID, QualType BaseType,
-                      UTTKind UKind) {
-    ID.AddPointer(BaseType.getAsOpaquePtr());
-    ID.AddInteger((unsigned)UKind);
+  static void Profile(llvm::FoldingSetNodeID &ID, ArrayRef<QualType> ArgTypes,
+                      TTKind TKind) {
+    ID.AddInteger((unsigned)ArgTypes.size());
+    for (auto Ty : ArgTypes)
+      ID.AddPointer(Ty.getAsOpaquePtr());
+    ID.AddInteger((unsigned)TKind);
   }
 };
 
 class TagType : public Type {
   friend class ASTReader;
 
   /// Stores the TagDecl associated with this type. The decl may point to any
   /// TagDecl that declares the entity.

include/clang/AST/TypeLoc.h

     return getTypeArgLocArray()[i];
   }
 
   void setTypeArgTInfo(unsigned i, TypeSourceInfo *TInfo) {
     assert(i < getNumTypeArgs() && "Index is out of bounds!");
     getTypeArgLocArray()[i] = TInfo;
   }
 
+  ArrayRef<TypeSourceInfo *> getTypeArgTInfoRef() const {
+    return llvm::makeArrayRef(getTypeArgLocArray(), getNumTypeArgs());
+  }
+
   SourceLocation getProtocolLAngleLoc() const {
     return this->getLocalData()->ProtocolLAngleLoc;
   }
 
   void setProtocolLAngleLoc(SourceLocation Loc) {
     this->getLocalData()->ProtocolLAngleLoc = Loc;
   }
 

 // FIXME: location of the 'decltype' and parens.
 class DecltypeTypeLoc : public InheritingConcreteTypeLoc<TypeSpecTypeLoc,
                                                          DecltypeTypeLoc,
                                                          DecltypeType> {
 public:
   Expr *getUnderlyingExpr() const { return getTypePtr()->getUnderlyingExpr(); }
 };
 
-struct UnaryTransformTypeLocInfo {
+struct TransformTraitTypeLocInfo {
   // FIXME: While there's only one unary transform right now, future ones may
   // need different representations
   SourceLocation KWLoc, LParenLoc, RParenLoc;
-  TypeSourceInfo *UnderlyingTInfo;
 };
 
-class UnaryTransformTypeLoc : public ConcreteTypeLoc<UnqualTypeLoc,
-                                                    UnaryTransformTypeLoc,
-                                                    UnaryTransformType,
-                                                    UnaryTransformTypeLocInfo> {
+class TransformTraitTypeLoc
+    : public ConcreteTypeLoc<UnqualTypeLoc, TransformTraitTypeLoc,
+                             TransformTraitType, TransformTraitTypeLocInfo> {
+  // TypeSourceInfo*'s are stored after Info, one for each type argument.
+  TypeSourceInfo **getArgLocArray() const {
+    return (TypeSourceInfo **)this->getExtraLocalData();
+  }
+
 public:
   SourceLocation getKWLoc() const { return getLocalData()->KWLoc; }
   void setKWLoc(SourceLocation Loc) { getLocalData()->KWLoc = Loc; }
 
   SourceLocation getLParenLoc() const { return getLocalData()->LParenLoc; }
   void setLParenLoc(SourceLocation Loc) { getLocalData()->LParenLoc = Loc; }
 
   SourceLocation getRParenLoc() const { return getLocalData()->RParenLoc; }
   void setRParenLoc(SourceLocation Loc) { getLocalData()->RParenLoc = Loc; }
 
-  TypeSourceInfo* getUnderlyingTInfo() const {
-    return getLocalData()->UnderlyingTInfo;
+  unsigned getNumArgs() const { return this->getTypePtr()->getNumArgs(); }
+
+  ArrayRef<TypeSourceInfo *> getArgTInfo() const {
+    return llvm::makeArrayRef(getArgLocArray(), getNumArgs());
+  }
+
+  TypeSourceInfo *getArgInfo(unsigned I) {
+    assert(I < getNumArgs());
+    return getArgLocArray()[I];
   }
 
-  void setUnderlyingTInfo(TypeSourceInfo *TInfo) {
-    getLocalData()->UnderlyingTInfo = TInfo;
+  void setArgInfo(unsigned I, TypeSourceInfo *Info) {
+    assert(I < getNumArgs());
+    getArgLocArray()[I] = Info;
+  }
+
+  void setArgTInfo(ArrayRef<TypeSourceInfo *> ArgInfo) {
+    assert(ArgInfo.size() == getNumArgs());
+    for (unsigned I = 0; I < ArgInfo.size(); ++I)
+      setArgInfo(I, ArgInfo[I]);
   }
 
   SourceRange getLocalSourceRange() const {
     return SourceRange(getKWLoc(), getRParenLoc());
   }
 
   SourceRange getParensRange() const {
     return SourceRange(getLParenLoc(), getRParenLoc());
   }
 
   void setParensRange(SourceRange Range) {
     setLParenLoc(Range.getBegin());
     setRParenLoc(Range.getEnd());
   }
 
   void initializeLocal(ASTContext &Context, SourceLocation Loc);
+
+  unsigned getExtraLocalDataSize() const {
+    return this->getNumArgs() * sizeof(TypeSourceInfo *);
+  }
+
+  unsigned getExtraLocalDataAlignment() const {
+    return alignof(TypeSourceInfo *);
+  }
 };
 
 class DeducedTypeLoc
     : public InheritingConcreteTypeLoc<TypeSpecTypeLoc, DeducedTypeLoc,
                                        DeducedType> {};
 
 class AutoTypeLoc
     : public InheritingConcreteTypeLoc<DeducedTypeLoc, AutoTypeLoc, AutoType> {

include/clang/AST/TypeNodes.def

 DEPENDENT_TYPE(UnresolvedUsing, Type)
 NON_CANONICAL_TYPE(Paren, Type)
 NON_CANONICAL_TYPE(Typedef, Type)
 NON_CANONICAL_TYPE(Adjusted, Type)
 NON_CANONICAL_TYPE(Decayed, AdjustedType)
 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOfExpr, Type)
 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TypeOf, Type)
 NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Decltype, Type)
-NON_CANONICAL_UNLESS_DEPENDENT_TYPE(UnaryTransform, Type)
+NON_CANONICAL_UNLESS_DEPENDENT_TYPE(TransformTrait, Type)
+
 ABSTRACT_TYPE(Tag, Type)
 TYPE(Record, TagType)
 TYPE(Enum, TagType)
 NON_CANONICAL_TYPE(Elaborated, Type)
 NON_CANONICAL_TYPE(Attributed, Type)
 DEPENDENT_TYPE(TemplateTypeParm, Type)
 NON_CANONICAL_TYPE(SubstTemplateTypeParm, Type)
 DEPENDENT_TYPE(SubstTemplateTypeParmPack, Type)

include/clang/ASTMatchers/ASTMatchers.h

 ///   typedef int X;
 /// \endcode
 /// typedefType()
 ///   matches "typedef int X"
 extern const AstTypeMatcher<TypedefType> typedefType;
 
 /// Matches enum types.
 ///
 /// Given
 /// \code
 ///   enum C { Green };
 ///   enum class S { Red };
 ///
 ///   C c;
 ///   S s;
 /// \endcode
 //
 /// \c enumType() matches the type of the variable declarations of both \c c and
 /// \c s.
 extern const AstTypeMatcher<EnumType> enumType;
 
 /// Matches template specialization types.
 ///
 /// Given
 /// \code
 ///   template <typename T>
 ///   class C { };
 ///
 ///   template class C<int>;  // A
 ///   C<char> var;            // B
 /// \endcode
 ///
 /// \c templateSpecializationType() matches the type of the explicit
 /// instantiation in \c A and the type of the variable declaration in \c B.
 extern const AstTypeMatcher<TemplateSpecializationType>
     templateSpecializationType;
 
+/// Matches types nodes representing type-trait transformations.
+///
+/// Given:
+/// \code
+///   typedef __underlying_type(T) type;
+/// \endcode
+/// transformTraitType()
+///   matches "__underlying_type(T)"
+extern const AstTypeMatcher<TransformTraitType> transformTraitType;
+
 /// Matches types nodes representing unary type transformations.
 ///
 /// Given:
 /// \code
 ///   typedef __underlying_type(T) type;
 /// \endcode
 /// unaryTransformType()
 ///   matches "__underlying_type(T)"
-extern const AstTypeMatcher<UnaryTransformType> unaryTransformType;
+AST_MATCHER(Type, unaryTransformType) {
+  if (const auto *T = Node.getAs<TransformTraitType>())
+    return T->getNumArgs() == 1;
+  return false;
+}
 
 /// Matches record types (e.g. structs, classes).
 ///
 /// Given
 /// \code
 ///   class C {};
 ///   struct S {};
 ///

include/clang/Basic/DiagnosticCommonKinds.td

def err_module_prebuilt : Error<
   "error in loading module '%0' from prebuilt module path">, DefaultFatal;
 def note_pragma_entered_here : Note<"#pragma entered here">;  
 def note_decl_hiding_tag_type : Note<
   "%1 %0 is hidden by a non-type declaration of %0 here">;
 def err_attribute_not_type_attr : Error<
   "%0 attribute cannot be applied to types">;
 def err_enum_template : Error<"enumeration cannot be a template">;
 
+// Type traits
+def err_type_trait_arity : Error<
+  "type trait requires %0%select{| or more}1 argument%select{|s}2; have "
+  "%3 argument%s3">;
 }
 
 let CategoryName = "Nullability Issue" in {
 
 def warn_nullability_duplicate : Warning<
   "duplicate nullability specifier %0">,
   InGroup<Nullability>;
   

include/clang/Basic/DiagnosticParseKinds.td

def err_external_source_symbol_expected_keyword : Error<
   "expected 'language', 'defined_in', or 'generated_declaration'">;
 def err_external_source_symbol_duplicate_clause : Error<
   "duplicate %0 clause in an 'external_source_symbol' attribute">;
 
 // Type safety attributes
 def err_type_safety_unknown_flag : Error<
   "invalid comparison flag %0; use 'layout_compatible' or 'must_be_null'">;
 
-// Type traits
-def err_type_trait_arity : Error<
-  "type trait requires %0%select{| or more}1 argument%select{|s}2; have "
-  "%3 argument%s3">;
-
 // Language specific pragmas
 // - Generic warnings
 def warn_pragma_expected_lparen : Warning<
   "missing '(' after '#pragma %0' - ignoring">, InGroup<IgnoredPragmas>;
 def warn_pragma_expected_rparen : Warning<
   "missing ')' after '#pragma %0' - ignoring">, InGroup<IgnoredPragmas>;
 def warn_pragma_expected_identifier : Warning<
   "expected identifier in '#pragma %0' - ignored">, InGroup<IgnoredPragmas>;

include/clang/Parse/Parser.h

                                  SourceLocation ScopeLoc,
                                  AttributeList::Syntax Syntax);
 
   void ParseTypeofSpecifier(DeclSpec &DS);
   SourceLocation ParseDecltypeSpecifier(DeclSpec &DS);
   void AnnotateExistingDecltypeSpecifier(const DeclSpec &DS,
                                          SourceLocation StartLoc,
                                          SourceLocation EndLoc);
-  void ParseUnderlyingTypeSpecifier(DeclSpec &DS);
+  void ParseTransformTraitTypeSpecifier(DeclSpec &DS);
   void ParseAtomicSpecifier(DeclSpec &DS);
 
   ExprResult ParseAlignArgument(SourceLocation Start,
                                 SourceLocation &EllipsisLoc);
   void ParseAlignmentSpecifier(ParsedAttributes &Attrs,
                                SourceLocation *endLoc = nullptr);
 
   VirtSpecifiers::Specifier isCXX11VirtSpecifier(const Token &Tok) const;

include/clang/Sema/Sema.h

                              const CXXScopeSpec &SS, QualType T,
                              TagDecl *OwnedTagDecl = nullptr);
 
   QualType BuildTypeofExprType(Expr *E, SourceLocation Loc);
   /// If AsUnevaluated is false, E is treated as though it were an evaluated
   /// context, such as when building a type for decltype(auto).
   QualType BuildDecltypeType(Expr *E, SourceLocation Loc,
                              bool AsUnevaluated = true);
-  QualType BuildUnaryTransformType(QualType BaseType,
-                                   UnaryTransformType::UTTKind UKind,
+
+  TypeResult ActOnTransformTraitType(ArrayRef<ParsedType> ArgTypes,
+                                     TransformTraitType::TTKind Kind,
+                                     SourceLocation KWLoc,
+                                     SourceRange ParenRange);
+
+  QualType ComputeTransformTraitResultType(ArrayRef<QualType> ArgTypes,
+                                           TransformTraitType::TTKind Kind,
+                                           SourceLocation Loc);
+
+  QualType BuildTransformTraitType(ArrayRef<QualType> ArgTypes,
+                                   TransformTraitType::TTKind Kind,
                                    SourceLocation Loc);
 
   //===--------------------------------------------------------------------===//
   // Symbol table / Decl tracking callbacks: SemaDecl.cpp.
   //
 
   struct SkipBodyInfo {
     SkipBodyInfo()

include/clang/Serialization/ASTBitCodes.h

       TYPE_TYPEOF_EXPR              = 17,
 
       /// A TypeOfType record.
       TYPE_TYPEOF                   = 18,
 
       /// A RecordType record.
       TYPE_RECORD                   = 19,
 
       /// An EnumType record.
       TYPE_ENUM                     = 20,
 
       /// An ObjCInterfaceType record.
       TYPE_OBJC_INTERFACE           = 21,
 
       /// An ObjCObjectPointerType record.
       TYPE_OBJC_OBJECT_POINTER      = 22,
 

       TYPE_ATTRIBUTED               = 36,
 
       /// A SubstTemplateTypeParmPackType record.
       TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK = 37,
 
       /// A AutoType record.
       TYPE_AUTO                  = 38,
 
-      /// A UnaryTransformType record.
-      TYPE_UNARY_TRANSFORM       = 39,
+      /// A TransformTraitType record.
+      TYPE_TRANSFORM_TRAIT       = 39,
 
       /// An AtomicType record.
       TYPE_ATOMIC                = 40,
 
       /// A DecayedType record.
       TYPE_DECAYED               = 41,
 
       /// An AdjustedType record.

lib/AST/ASTContext.cpp

   case Type::ObjCInterface:
   case Type::ObjCObjectPointer:
   case Type::Record:
   case Type::Enum:
   case Type::UnresolvedUsing:
   case Type::TypeOfExpr:
   case Type::TypeOf:
   case Type::Decltype:
-  case Type::UnaryTransform:
+  case Type::TransformTrait:
   case Type::DependentName:
   case Type::InjectedClassName:
   case Type::TemplateSpecialization:
   case Type::DependentTemplateSpecialization:
   case Type::TemplateTypeParm:
   case Type::SubstTemplateTypeParmPack:
   case Type::Auto:
   case Type::DeducedTemplateSpecialization:

     DependentTypeOfExprType *Canon
       = DependentTypeOfExprTypes.FindNodeOrInsertPos(ID, InsertPos);
     if (Canon) {
       // We already have a "canonical" version of an identical, dependent
       // typeof(expr) type. Use that as our canonical type.
       toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr,
                                           QualType((TypeOfExprType*)Canon, 0));
     } else {
       // Build a new, canonical typeof(expr) type.
       Canon
         = new (*this, TypeAlignment) DependentTypeOfExprType(*this, tofExpr);
       DependentTypeOfExprTypes.InsertNode(Canon, InsertPos);
       toe = Canon;
     }
   } else {
     QualType Canonical = getCanonicalType(tofExpr->getType());
     toe = new (*this, TypeAlignment) TypeOfExprType(tofExpr, Canonical);

   } else {
     dt = new (*this, TypeAlignment)
         DecltypeType(e, UnderlyingType, getCanonicalType(UnderlyingType));
   }
   Types.push_back(dt);
   return QualType(dt, 0);
 }
 
-/// getUnaryTransformationType - We don't unique these, since the memory
-/// savings are minimal and these are rare.
-QualType ASTContext::getUnaryTransformType(QualType BaseType,
-                                           QualType UnderlyingType,
-                                           UnaryTransformType::UTTKind Kind)
-    const {
-  UnaryTransformType *ut = nullptr;
-
-  if (BaseType->isDependentType()) {
+/// We don't unique these, since the memory savings are minimal and these are
+/// rare.
+QualType
+ASTContext::getTransformTraitType(ArrayRef<QualType> ArgTypes,
+                                  QualType TransformedType,
+                                  TransformTraitType::TTKind Kind) const {
+  assert(!TransformedType.isNull());
+  TransformTraitType *ut = nullptr;
+
+  bool IsDependent = TransformedType->isDependentType();
+
+  if (IsDependent) {
+    SmallVector<QualType, 6> CanonArgs;
+    CanonArgs.reserve(ArgTypes.size());
+    for (auto Ty : ArgTypes)
+      CanonArgs.push_back(getCanonicalType(Ty));
     // Look in the folding set for an existing type.
     llvm::FoldingSetNodeID ID;
-    DependentUnaryTransformType::Profile(ID, getCanonicalType(BaseType), Kind);
+    DependentTransformTraitType::Profile(ID, CanonArgs, Kind);
 
     void *InsertPos = nullptr;
-    DependentUnaryTransformType *Canon
-      = DependentUnaryTransformTypes.FindNodeOrInsertPos(ID, InsertPos);
+    DependentTransformTraitType *Canon =
+        DependentTransformTraitTypes.FindNodeOrInsertPos(ID, InsertPos);
 
     if (!Canon) {
-      // Build a new, canonical __underlying_type(type) type.
+      // Build a new, canonical transformation trait type.
       Canon = new (*this, TypeAlignment)
-             DependentUnaryTransformType(*this, getCanonicalType(BaseType),
-                                         Kind);
-      DependentUnaryTransformTypes.InsertNode(Canon, InsertPos);
+          DependentTransformTraitType(*this, CanonArgs, Kind);
+      DependentTransformTraitTypes.InsertNode(Canon, InsertPos);
     }
-    ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
-                                                        QualType(), Kind,
-                                                        QualType(Canon, 0));
+    ut = new (*this, TypeAlignment) TransformTraitType(
+        *this, ArgTypes, DependentTy, Kind, QualType(Canon, 0));
   } else {
-    QualType CanonType = getCanonicalType(UnderlyingType);
-    ut = new (*this, TypeAlignment) UnaryTransformType (BaseType,
-                                                        UnderlyingType, Kind,
-                                                        CanonType);
+    assert(!TransformedType->isDependentType() &&
+           "dependent transformed type with non-dependent argument types");
+    QualType CanonType = getCanonicalType(TransformedType);
+    ut = new (*this, TypeAlignment)
+        TransformTraitType(*this, ArgTypes, TransformedType, Kind, CanonType);
   }
   Types.push_back(ut);
   return QualType(ut, 0);
 }
 
 /// getAutoType - Return the uniqued reference to the 'auto' type which has been
 /// deduced to the given type, or to the canonical undeduced 'auto' type, or the
 /// canonical deduced-but-dependent 'auto' type.

lib/AST/ASTDumper.cpp

void VisitTypedefType(const TypedefType *T) {
       dumpDeclRef(T->getDecl());
     }
     void VisitTypeOfExprType(const TypeOfExprType *T) {
       dumpStmt(T->getUnderlyingExpr());
     }
     void VisitDecltypeType(const DecltypeType *T) {
       dumpStmt(T->getUnderlyingExpr());
     }
-    void VisitUnaryTransformType(const UnaryTransformType *T) {
-      switch (T->getUTTKind()) {
-      case UnaryTransformType::EnumUnderlyingType:
+    void VisitTransformTraitType(const TransformTraitType *T) {
+      switch (T->getTTKind()) {
+      case TransformTraitType::EnumUnderlyingType:
         OS << " underlying_type";
         break;
       }
-      dumpTypeAsChild(T->getBaseType());
+      for (auto Ty : T->getArgs())
+        dumpTypeAsChild(Ty);
     }
     void VisitTagType(const TagType *T) {
       dumpDeclRef(T->getDecl());
     }
     void VisitAttributedType(const AttributedType *T) {
       // FIXME: AttrKind
       dumpTypeAsChild(T->getModifiedType());
     }
void ASTDumper::VisitUsingDirectiveDecl(const UsingDirectiveDecl *D) {
   dumpBareDeclRef(D->getNominatedNamespace());
 }
 
 void ASTDumper::VisitNamespaceAliasDecl(const NamespaceAliasDecl *D) {
   dumpName(D);
   dumpDeclRef(D->getAliasedNamespace());
 }
 
 void ASTDumper::VisitTypeAliasDecl(const TypeAliasDecl *D) {

lib/AST/ASTImporter.cpp

public:
     QualType VisitFunctionProtoType(const FunctionProtoType *T);
     QualType VisitUnresolvedUsingType(const UnresolvedUsingType *T);
     QualType VisitParenType(const ParenType *T);
     QualType VisitTypedefType(const TypedefType *T);
     QualType VisitTypeOfExprType(const TypeOfExprType *T);
     // FIXME: DependentTypeOfExprType
     QualType VisitTypeOfType(const TypeOfType *T);
     QualType VisitDecltypeType(const DecltypeType *T);
-    QualType VisitUnaryTransformType(const UnaryTransformType *T);
+    QualType VisitTransformTraitType(const TransformTraitType *T);
     QualType VisitAutoType(const AutoType *T);
     QualType VisitInjectedClassNameType(const InjectedClassNameType *T);
     // FIXME: DependentDecltypeType
     QualType VisitRecordType(const RecordType *T);
     QualType VisitEnumType(const EnumType *T);
     QualType VisitAttributedType(const AttributedType *T);
     QualType VisitTemplateTypeParmType(const TemplateTypeParmType *T);
     QualType VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T);
QualType ASTNodeImporter::VisitDecltypeType(const DecltypeType *T) {
   
   QualType UnderlyingType = Importer.Import(T->getUnderlyingType());
   if (UnderlyingType.isNull())
     return {};
 
   return Importer.getToContext().getDecltypeType(ToExpr, UnderlyingType);
 }
 
-QualType ASTNodeImporter::VisitUnaryTransformType(const UnaryTransformType *T) {
-  QualType ToBaseType = Importer.Import(T->getBaseType());
-  QualType ToUnderlyingType = Importer.Import(T->getUnderlyingType());
-  if (ToBaseType.isNull() || ToUnderlyingType.isNull())
+QualType ASTNodeImporter::VisitTransformTraitType(const TransformTraitType *T) {
+  SmallVector<QualType, 6> ToArgTypes;
+  for (auto Ty : T->getArgs()) {
+    QualType ToTy = Importer.Import(Ty);
+    if (ToTy.isNull())
+      return QualType();
+    ToArgTypes.push_back(ToTy);
+  }
+
+  QualType ToTransformedType = Importer.Import(T->getTransformedType());
+  if (ToTransformedType.isNull())
     return {};
 
-  return Importer.getToContext().getUnaryTransformType(ToBaseType,
-                                                       ToUnderlyingType,
-                                                       T->getUTTKind());
+  return Importer.getToContext().getTransformTraitType(
+      ToArgTypes, ToTransformedType, T->getTTKind());
 }
 
 QualType ASTNodeImporter::VisitAutoType(const AutoType *T) {
   // FIXME: Make sure that the "to" context supports C++11!
   QualType FromDeduced = T->getDeducedType();
   QualType ToDeduced;
   if (!FromDeduced.isNull()) {
     ToDeduced = Importer.Import(FromDeduced);

lib/AST/ASTStructuralEquivalence.cpp

static bool IsStructurallyEquivalent(StructuralEquivalenceContext &Context,
 
   case Type::TypeOf:
     if (!IsStructurallyEquivalent(Context,
                                   cast<TypeOfType>(T1)->getUnderlyingType(),
                                   cast<TypeOfType>(T2)->getUnderlyingType()))
       return false;
     break;
 
-  case Type::UnaryTransform:
-    if (!IsStructurallyEquivalent(
-            Context, cast<UnaryTransformType>(T1)->getUnderlyingType(),
-            cast<UnaryTransformType>(T2)->getUnderlyingType()))
+  case Type::TransformTrait: {
+    const TransformTraitType *TT1 = cast<TransformTraitType>(T1);
+    const TransformTraitType *TT2 = cast<TransformTraitType>(T2);
+    if (TT1->getTTKind() != TT2->getTTKind())
+      return false;
+    if (TT1->getNumArgs() != TT2->getNumArgs())
+      return false;
+    for (unsigned I = 0; I < TT1->getNumArgs(); ++I) {
+      if (!IsStructurallyEquivalent(Context, TT1->getArg(I), TT2->getArg(I)))
+        return false;
+    }
+    if (!IsStructurallyEquivalent(Context, TT1->getTransformedType(),
+                                  TT2->getTransformedType()))
       return false;
     break;
-
+  }
   case Type::Decltype:
     if (!IsStructurallyEquivalent(Context,
                                   cast<DecltypeType>(T1)->getUnderlyingExpr(),
                                   cast<DecltypeType>(T2)->getUnderlyingExpr()))
       return false;
     break;
 
   case Type::Auto:

lib/AST/ItaniumMangle.cpp

   // <unresolved-type> ::= <template-param>
   //                   ::= <decltype>
   //                   ::= <template-template-param> <template-args>
   // (this last is not official yet)
   case Type::TypeOfExpr:
   case Type::TypeOf:
   case Type::Decltype:
   case Type::TemplateTypeParm:
-  case Type::UnaryTransform:
+  case Type::TransformTrait:
   case Type::SubstTemplateTypeParm:
   unresolvedType:
     // Some callers want a prefix before the mangled type.
     Out << Prefix;
 
     // This seems to do everything we want.  It's not really
     // sanctioned for a substituted template parameter, though.
     mangleType(Ty);

   // "extension with parameters" mangling.
   Out << "u6typeof";
 }
 
 void CXXNameMangler::mangleType(const DecltypeType *T) {
   Expr *E = T->getUnderlyingExpr();
 
   // type ::= Dt <expression> E  # decltype of an id-expression
   //                             #   or class member access
   //      ::= DT <expression> E  # decltype of an expression
 
   // This purports to be an exhaustive list of id-expressions and
   // class member accesses.  Note that we do not ignore parentheses;
   // parentheses change the semantics of decltype for these
   // expressions (and cause the mangler to use the other form).
   if (isa<DeclRefExpr>(E) ||
       isa<MemberExpr>(E) ||
       isa<UnresolvedLookupExpr>(E) ||
       isa<DependentScopeDeclRefExpr>(E) ||
       isa<CXXDependentScopeMemberExpr>(E) ||
       isa<UnresolvedMemberExpr>(E))
     Out << "Dt";
   else
     Out << "DT";
   mangleExpression(E);
   Out << 'E';
 }
 
-void CXXNameMangler::mangleType(const UnaryTransformType *T) {
-  // If this is dependent, we need to record that. If not, we simply
-  // mangle it as the underlying type since they are equivalent.
-  if (T->isDependentType()) {
-    Out << 'U';
-    
-    switch (T->getUTTKind()) {
-      case UnaryTransformType::EnumUnderlyingType:
-        Out << "3eut";
-        break;
-    }
+void CXXNameMangler::mangleType(const TransformTraitType *T) {
+  // TransformTraitType's uses a non-standard mangling with the intent to
+  // suggest it as a Itanium ABI extension.
+  //
+  // <type-traits-type> ::=
+  //     u <source-name> [<template-args>] # vendor extended type
+
+  // If this type isn't dependent, simply mangle it as the transformed type
+  // since they are equivalent. Otherwise, we need to record the dependent type.
+  if (!T->isDependentType()) {
+    mangleType(T->getTransformedType());
+    return;
   }
 
-  mangleType(T->getBaseType());
+  Out << "u";
+
+  // mangle the source name.
+  StringRef Ident =
+      TransformTraitType::GetTransformTraitIdentifier(T->getTTKind());
+  Out << Ident.size() << Ident;
+
+  assert(T->getNumArgs() && "Empty argument list for transformation trait?");
+
+  Out << "I";
+
+  // mangle each argument type.
+  for (auto Ty : T->getArgs())
+    mangleType(Ty);
+
+  // Disambiguate the end of the argument list.
+  Out << "E";
 }
 
 void CXXNameMangler::mangleType(const AutoType *T) {
   assert(T->getDeducedType().isNull() &&
          "Deduced AutoType shouldn't be handled here!");
   assert(T->getKeyword() != AutoTypeKeyword::GNUAutoType &&
          "shouldn't need to mangle __auto_type!");
   // <builtin-type> ::= Da # auto

lib/AST/MicrosoftMangle.cpp

                                          SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
     "cannot mangle this decltype() yet");
   Diags.Report(Range.getBegin(), DiagID)
     << Range;
 }
 
-void MicrosoftCXXNameMangler::mangleType(const UnaryTransformType *T,
+void MicrosoftCXXNameMangler::mangleType(const TransformTraitType *T,
                                          Qualifiers, SourceRange Range) {
   DiagnosticsEngine &Diags = Context.getDiags();
-  unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,
-    "cannot mangle this unary transform type yet");
-  Diags.Report(Range.getBegin(), DiagID)
-    << Range;
+  unsigned DiagID = Diags.getCustomDiagID(
+      DiagnosticsEngine::Error, "cannot mangle this transform type yet");
+  Diags.Report(Range.getBegin(), DiagID) << Range;
 }
 
 void MicrosoftCXXNameMangler::mangleType(const AutoType *T, Qualifiers,
                                          SourceRange Range) {
   assert(T->getDeducedType().isNull() && "expecting a dependent type!");
 
   DiagnosticsEngine &Diags = Context.getDiags();
   unsigned DiagID = Diags.getCustomDiagID(DiagnosticsEngine::Error,

lib/AST/Type.cpp

       return QualType(T, 0);
 
     return Ctx.getDecayedType(originalType);
   }
 
   TRIVIAL_TYPE_CLASS(TypeOfExpr)
   TRIVIAL_TYPE_CLASS(TypeOf)
   TRIVIAL_TYPE_CLASS(Decltype)
-  TRIVIAL_TYPE_CLASS(UnaryTransform)
   TRIVIAL_TYPE_CLASS(Record)
   TRIVIAL_TYPE_CLASS(Enum)
 
+  QualType VisitTransformTraitType(const TransformTraitType *T) {
+    // Transform type arguments.
+    bool typeArgChanged = false;
+    SmallVector<QualType, 4> typeArgs;
+    for (auto typeArg : T->getArgs()) {
+      QualType newTypeArg = recurse(typeArg);
+      if (newTypeArg.isNull())
+        return {};
+
+      if (newTypeArg.getAsOpaquePtr() != typeArg.getAsOpaquePtr())
+        typeArgChanged = true;
+
+      typeArgs.push_back(newTypeArg);
+    }
+    QualType TransformedType = recurse(T->getTransformedType());
+    if (TransformedType.isNull())
+      return {};
+    if (TransformedType.getAsOpaquePtr() ==
+            T->getTransformedType().getAsOpaquePtr() &&
+        !typeArgChanged)
+      return QualType(T, 0);
+
+    return Ctx.getTransformTraitType(typeArgs, TransformedType, T->getTTKind());
+  }
+
   // FIXME: Non-trivial to implement, but important for C++
   TRIVIAL_TYPE_CLASS(Elaborated)
 
   QualType VisitAttributedType(const AttributedType *T) { 
     QualType modifiedType = recurse(T->getModifiedType());
     if (modifiedType.isNull())
       return {};
 

     return getUnderlyingExpr()->getType();
   
   return QualType(this, 0);
 }
 
 void DependentTypeOfExprType::Profile(llvm::FoldingSetNodeID &ID,
                                       const ASTContext &Context, Expr *E) {
   E->Profile(ID, Context, true);
 }
 
 DecltypeType::DecltypeType(Expr *E, QualType underlyingType, QualType can)
   // C++11 [temp.type]p2: "If an expression e involves a template parameter,
   // decltype(e) denotes a unique dependent type." Hence a decltype type is
   // type-dependent even if its expression is only instantiation-dependent.
     : Type(Decltype, can, E->isInstantiationDependent(),
            E->isInstantiationDependent(),
            E->getType()->isVariablyModifiedType(),
            E->containsUnexpandedParameterPack()),
       E(E), UnderlyingType(underlyingType) {}
 
 bool DecltypeType::isSugared() const { return !E->isInstantiationDependent(); }
 
 QualType DecltypeType::desugar() const {
   if (isSugared())
     return getUnderlyingType();
   
   return QualType(this, 0);
 }
 
 DependentDecltypeType::DependentDecltypeType(const ASTContext &Context, Expr *E)
     : DecltypeType(E, Context.DependentTy), Context(Context) {}
 
 void DependentDecltypeType::Profile(llvm::FoldingSetNodeID &ID,
                                     const ASTContext &Context, Expr *E) {
   E->Profile(ID, Context, true);
 }
 
-UnaryTransformType::UnaryTransformType(QualType BaseType,
-                                       QualType UnderlyingType,
-                                       UTTKind UKind,
+TransformTraitType::TransformTraitType(const ASTContext &Ctx,
+                                       ArrayRef<QualType> ArgTys,
+                                       QualType TransformedTy, TTKind TKind,
                                        QualType CanonicalType)
-    : Type(UnaryTransform, CanonicalType, BaseType->isDependentType(),
-           BaseType->isInstantiationDependentType(),
-           BaseType->isVariablyModifiedType(),
-           BaseType->containsUnexpandedParameterPack()),
-      BaseType(BaseType), UnderlyingType(UnderlyingType), UKind(UKind) {}
+    : Type(TransformTrait, CanonicalType, false, false, false, false),
+      TransformedType(TransformedTy) {
+  TransformTraitTypeBits.TTKind = TKind;
+  TransformTraitTypeBits.NumArgs = ArgTys.size();
+  ArgStorage = (QualType *)Ctx.Allocate(sizeof(QualType) * ArgTys.size(),
+                                        alignof(QualType));
+  assert(!TransformedTy.isNull());
+  this->setDependent(TransformedTy->isDependentType());
+  this->setVariablyModified(TransformedTy->isVariablyModifiedType());
+
+  for (unsigned I = 0, NumArgs = ArgTys.size(); I < NumArgs; ++I) {
+    QualType T = ArgTys[I];
+    new ((void *)(ArgStorage + I)) QualType(T);
+    if (T->isInstantiationDependentType())
+      this->setInstantiationDependent(true);
+    if (T->containsUnexpandedParameterPack())
+      this->setContainsUnexpandedParameterPack(true);
+  }
+}
+
+StringRef TransformTraitType::getName(TTKind Kind) {
+  switch (Kind) {
+  case TransformTraitType::EnumUnderlyingType:
+    return "__underlying_type";
+  }
+  llvm_unreachable("unhandled case");
+}
 
-DependentUnaryTransformType::DependentUnaryTransformType(const ASTContext &C,
-                                                         QualType BaseType,
-                                                         UTTKind UKind)
-     : UnaryTransformType(BaseType, C.DependentTy, UKind, QualType()) {}
+DependentTransformTraitType::DependentTransformTraitType(
+    const ASTContext &C, ArrayRef<QualType> ArgTys, TTKind TKind)
+    : TransformTraitType(C, ArgTys, C.DependentTy, TKind, QualType()) {}
 
 TagType::TagType(TypeClass TC, const TagDecl *D, QualType can)
     : Type(TC, can, D->isDependentType(),
            /*InstantiationDependent=*/D->isDependentType(),
            /*VariablyModified=*/false,
            /*ContainsUnexpandedParameterPack=*/false),
       decl(const_cast<TagDecl*>(D)) {}
 

   case Type::ObjCObjectPointer:
     return true;
 
   // Dependent types that could instantiate to pointer types.
   case Type::UnresolvedUsing:
   case Type::TypeOfExpr:
   case Type::TypeOf:
   case Type::Decltype:
-  case Type::UnaryTransform:
+  case Type::TransformTrait:
   case Type::TemplateTypeParm:
   case Type::SubstTemplateTypeParmPack:
   case Type::DependentName:
   case Type::DependentTemplateSpecialization:
   case Type::Auto:
     return ResultIfUnknown;
 
   // Dependent template specializations can instantiate to pointer

lib/AST/TypeLoc.cpp

 void TypeOfTypeLoc::initializeLocal(ASTContext &Context,
                                        SourceLocation Loc) {
   TypeofLikeTypeLoc<TypeOfTypeLoc, TypeOfType, TypeOfTypeLocInfo>
       ::initializeLocal(Context, Loc);
   this->getLocalData()->UnderlyingTInfo = Context.getTrivialTypeSourceInfo(
       getUnderlyingType(), Loc);
 }
 
-void UnaryTransformTypeLoc::initializeLocal(ASTContext &Context,
+void TransformTraitTypeLoc::initializeLocal(ASTContext &Context,
                                             SourceLocation Loc) {
-    setKWLoc(Loc);
-    setRParenLoc(Loc);
-    setLParenLoc(Loc);
-    this->setUnderlyingTInfo(
-        Context.getTrivialTypeSourceInfo(getTypePtr()->getBaseType(), Loc));
+  for (unsigned I = 0; I < getTypePtr()->getNumArgs(); ++I) {
+    this->setArgInfo(
+        I, Context.getTrivialTypeSourceInfo(getTypePtr()->getArg(I), Loc));
+  }
 }
 
 void ElaboratedTypeLoc::initializeLocal(ASTContext &Context, 
                                         SourceLocation Loc) {
   setElaboratedKeywordLoc(Loc);
   NestedNameSpecifierLocBuilder Builder;
   Builder.MakeTrivial(Context, getTypePtr()->getQualifier(), Loc);
   setQualifierLoc(Builder.getWithLocInContext(Context));

lib/AST/TypePrinter.cpp

switch (TC) {
     case Type::Auto:
     case Type::Builtin:
     case Type::Complex:
     case Type::UnresolvedUsing:
     case Type::Typedef:
     case Type::TypeOfExpr:
     case Type::TypeOf:
     case Type::Decltype:
-    case Type::UnaryTransform:
+    case Type::TransformTrait:
     case Type::Record:
     case Type::Enum:
     case Type::Elaborated:
     case Type::TemplateTypeParm:
     case Type::SubstTemplateTypeParmPack:
     case Type::DeducedTemplateSpecialization:
     case Type::TemplateSpecialization:
     case Type::InjectedClassName:
void TypePrinter::printDecltypeBefore(const DecltypeType *T, raw_ostream &OS) {
   if (T->getUnderlyingExpr())
     T->getUnderlyingExpr()->printPretty(OS, nullptr, Policy);
   OS << ')';
   spaceBeforePlaceHolder(OS);
 }
 
 void TypePrinter::printDecltypeAfter(const DecltypeType *T, raw_ostream &OS) {}
 
-void TypePrinter::printUnaryTransformBefore(const UnaryTransformType *T,
+void TypePrinter::printTransformTraitBefore(const TransformTraitType *T,
                                             raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
-  switch (T->getUTTKind()) {
-    case UnaryTransformType::EnumUnderlyingType:
-      OS << "__underlying_type(";
-      print(T->getBaseType(), OS, StringRef());
-      OS << ')';
-      spaceBeforePlaceHolder(OS);
-      return;
+  OS << T->getName() << "(";
+
+  for (unsigned I = 0; I != T->getNumArgs(); ++I) {
+    print(T->getArg(I), OS, StringRef());
+    if ((I + 1) != T->getNumArgs())
+      OS << ", ";
   }
 
-  printBefore(T->getBaseType(), OS);
+  OS << ')';
+  spaceBeforePlaceHolder(OS);
 }
 
-void TypePrinter::printUnaryTransformAfter(const UnaryTransformType *T,
+void TypePrinter::printTransformTraitAfter(const TransformTraitType *T,
                                            raw_ostream &OS) {
   IncludeStrongLifetimeRAII Strong(Policy);
 
-  switch (T->getUTTKind()) {
-    case UnaryTransformType::EnumUnderlyingType:
-      return;
+  switch (T->getTTKind()) {
+  case TransformTraitType::EnumUnderlyingType:
   }
 
-  printAfter(T->getBaseType(), OS);
+  llvm_unreachable("transformation trait not handled");
 }
 
 void TypePrinter::printAutoBefore(const AutoType *T, raw_ostream &OS) { 
   // If the type has been deduced, do not print 'auto'.
   if (!T->getDeducedType().isNull()) {
     printBefore(T->getDeducedType(), OS);
   } else {
     switch (T->getKeyword()) {

lib/ASTMatchers/ASTMatchersInternal.cpp

 const AstTypeMatcher<PointerType> pointerType;
 const AstTypeMatcher<ObjCObjectPointerType> objcObjectPointerType;
 const AstTypeMatcher<ReferenceType> referenceType;
 const AstTypeMatcher<LValueReferenceType> lValueReferenceType;
 const AstTypeMatcher<RValueReferenceType> rValueReferenceType;
 const AstTypeMatcher<TypedefType> typedefType;
 const AstTypeMatcher<EnumType> enumType;
 const AstTypeMatcher<TemplateSpecializationType> templateSpecializationType;
-const AstTypeMatcher<UnaryTransformType> unaryTransformType;
+const AstTypeMatcher<TransformTraitType> transformTraitType;
 const AstTypeMatcher<RecordType> recordType;
 const AstTypeMatcher<TagType> tagType;
 const AstTypeMatcher<ElaboratedType> elaboratedType;
 const AstTypeMatcher<SubstTemplateTypeParmType> substTemplateTypeParmType;
 const AstTypeMatcher<TemplateTypeParmType> templateTypeParmType;
 const AstTypeMatcher<InjectedClassNameType> injectedClassNameType;
 const AstTypeMatcher<DecayedType> decayedType;
 AST_TYPELOC_TRAVERSE_MATCHER_DEF(hasElementType,

lib/CodeGen/CGDebugInfo.cpp

       T = cast<TypeOfExprType>(T)->getUnderlyingExpr()->getType();
       break;
     case Type::TypeOf:
       T = cast<TypeOfType>(T)->getUnderlyingType();
       break;
     case Type::Decltype:
       T = cast<DecltypeType>(T)->getUnderlyingType();
       break;
-    case Type::UnaryTransform:
-      T = cast<UnaryTransformType>(T)->getUnderlyingType();
+    case Type::TransformTrait:
+      T = cast<TransformTraitType>(T)->getTransformedType();
       break;
     case Type::Attributed:
       T = cast<AttributedType>(T)->getEquivalentType();
       break;
     case Type::Elaborated:
       T = cast<ElaboratedType>(T)->getNamedType();
       break;
     case Type::Paren:

   case Type::Decayed:
   case Type::DeducedTemplateSpecialization:
   case Type::Elaborated:
   case Type::Paren:
   case Type::SubstTemplateTypeParm:
   case Type::TypeOfExpr:
   case Type::TypeOf:
   case Type::Decltype:
-  case Type::UnaryTransform:
+  case Type::TransformTrait:
   case Type::PackExpansion:
     break;
   }
 
   llvm_unreachable("type should have been unwrapped!");
 }
 
 llvm::DICompositeType *CGDebugInfo::getOrCreateLimitedType(const RecordType *Ty,

lib/CodeGen/CodeGenFunction.cpp

 
     case Type::FunctionProto:
     case Type::FunctionNoProto:
       type = cast<FunctionType>(ty)->getReturnType();
       break;
 
     case Type::Paren:
     case Type::TypeOf:
-    case Type::UnaryTransform:
+    case Type::TransformTrait:
     case Type::Attributed:
     case Type::SubstTemplateTypeParm:
     case Type::PackExpansion:
       // Keep walking after single level desugaring.
       type = type.getSingleStepDesugaredType(getContext());
       break;
 
     case Type::Typedef:

lib/Parse/ParseDecl.cpp

       HandlePragmaMSVtorDisp();
       continue;
 
     case tok::annot_pragma_ms_pointers_to_members:
       HandlePragmaMSPointersToMembers();
       continue;
 
     case tok::kw___underlying_type:
-      ParseUnderlyingTypeSpecifier(DS);
+      ParseTransformTraitTypeSpecifier(DS);
       continue;
 
     case tok::kw__Atomic:
       // C11 6.7.2.4/4:
       //   If the _Atomic keyword is immediately followed by a left parenthesis,
       //   it is interpreted as a type specifier (with a type name), not as a
       //   type qualifier.
       if (NextToken().is(tok::l_paren)) {

lib/Parse/ParseDeclCXX.cpp

                     DS.getTypeSpecType() == TST_decltype ? DS.getRepAsExpr() :
                     DS.getTypeSpecType() == TST_decltype_auto ? ExprResult() :
                     ExprError());
   Tok.setAnnotationEndLoc(EndLoc);
   Tok.setLocation(StartLoc);
   PP.AnnotateCachedTokens(Tok);
 }
 
-void Parser::ParseUnderlyingTypeSpecifier(DeclSpec &DS) {
-  assert(Tok.is(tok::kw___underlying_type) &&
-         "Not an underlying type specifier");
 
-  SourceLocation StartLoc = ConsumeToken();
-  BalancedDelimiterTracker T(*this, tok::l_paren);
-  if (T.expectAndConsume(diag::err_expected_lparen_after,
-                       "__underlying_type", tok::r_paren)) {
+void Parser::ParseTransformTraitTypeSpecifier(DeclSpec &DS) {
+  auto Error = [&]() {
+    DS.SetTypeSpecError();
     return;
-  }
+  };
+  auto KindInfo =
+      [&]() -> std::pair<TransformTraitType::TTKind, DeclSpec::TST> {
+    using EnumKind = TransformTraitType::TTKind;
+    switch (Tok.getKind()) {
+    case tok::kw___underlying_type:
+      return {EnumKind::EnumUnderlyingType, clang::TST_underlyingType};
+    default:
+      llvm_unreachable("Not a transformation trait type specifier");
+    }
+  }();
 
-  TypeResult Result = ParseTypeName();
-  if (Result.isInvalid()) {
-    SkipUntil(tok::r_paren, StopAtSemi);
-    return;
+  SourceLocation StartLoc = ConsumeToken();
+  BalancedDelimiterTracker Parens(*this, tok::l_paren);
+  if (Parens.expectAndConsume())
+    return Error();
+
+  SmallVector<ParsedType, 2> Args;
+  if (Tok.isNot(tok::r_paren)) {
+    do {
+      // Parse the next type.
+      TypeResult Ty = ParseTypeName();
+      if (Ty.isInvalid()) {
+        Parens.skipToEnd();
+        return Error();
+      }
+
+      // Parse the ellipsis, if present.
+      if (Tok.is(tok::ellipsis)) {
+        Ty = Actions.ActOnPackExpansion(Ty.get(), ConsumeToken());
+        if (Ty.isInvalid()) {
+          Parens.skipToEnd();
+          return Error();
+        }
+      }
+
+      // Add this type to the list of arguments.
+      Args.push_back(Ty.get());
+    } while (TryConsumeToken(tok::comma));
   }
+  if (Parens.consumeClose())
+    return Error();
 
-  // Match the ')'
-  T.consumeClose();
-  if (T.getCloseLocation().isInvalid())
-    return;
+  TypeResult TyRes = Actions.ActOnTransformTraitType(
+      Args, KindInfo.first, StartLoc, Parens.getRange());
+  if (TyRes.isInvalid())
+    return Error();
 
+  // TST
   const char *PrevSpec = nullptr;
   unsigned DiagID;
-  if (DS.SetTypeSpecType(DeclSpec::TST_underlyingType, StartLoc, PrevSpec,
-                         DiagID, Result.get(),
+  if (DS.SetTypeSpecType(KindInfo.second, StartLoc, PrevSpec, DiagID, TyRes.get(),
                          Actions.getASTContext().getPrintingPolicy()))
     Diag(StartLoc, DiagID) << PrevSpec;
-  DS.setTypeofParensRange(T.getRange());
+  DS.setTypeofParensRange(Parens.getRange());
 }
 
 /// ParseBaseTypeSpecifier - Parse a C++ base-type-specifier which is either a
 /// class name or decltype-specifier. Note that we only check that the result 
 /// names a type; semantic analysis will need to verify that the type names a 
 /// class. The result is either a type or null, depending on whether a type 
 /// name was found.
 ///
 ///       base-type-specifier: [C++11 class.derived]
 ///         class-or-decltype
 ///       class-or-decltype: [C++11 class.derived]
 ///         nested-name-specifier[opt] class-name
 ///         decltype-specifier

lib/Sema/DeclSpec.cpp

case TST_decltype_auto:
       // even if the initializer has function type.
       return false;
 
     case TST_decltype:
     case TST_typeofExpr:
       if (Expr *E = DS.getRepAsExpr())
         return E->getType()->isFunctionType();
       return false;
-     
-    case TST_underlyingType:
+    case TST_underlyingType: {
+      QualType QT = DS.getRepAsType().get();
+      assert(!QT.isNull());
+      return QT->isFunctionType();
+    }
+
     case TST_typename:
     case TST_typeofType: {
       QualType QT = DS.getRepAsType().get();
       if (QT.isNull())
         return false;
       
       if (const LocInfoType *LIT = dyn_cast<LocInfoType>(QT))
         QT = LIT->getType();
 

lib/Sema/SemaExpr.cpp

       break;
     }
     case Type::FunctionProto:
     case Type::FunctionNoProto:
       T = cast<FunctionType>(Ty)->getReturnType();
       break;
     case Type::Paren:
     case Type::TypeOf:
-    case Type::UnaryTransform:
+    case Type::TransformTrait:
     case Type::Attributed:
     case Type::SubstTemplateTypeParm:
     case Type::PackExpansion:
       // Keep walking after single level desugaring.
       T = T.getSingleStepDesugaredType(Context);
       break;
     case Type::Typedef:
       T = cast<TypedefType>(Ty)->desugar();

lib/Sema/SemaTemplate.cpp

 bool UnnamedLocalNoLinkageFinder::VisitTypeOfType(const TypeOfType* T) {
   return Visit(T->getUnderlyingType());
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitDecltypeType(const DecltypeType*) {
   return false;
 }
 
-bool UnnamedLocalNoLinkageFinder::VisitUnaryTransformType(
-                                                    const UnaryTransformType*) {
+bool UnnamedLocalNoLinkageFinder::VisitTransformTraitType(
+    const TransformTraitType *) {
   return false;
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitAutoType(const AutoType *T) {
   return Visit(T->getDeducedType());
 }
 
 bool UnnamedLocalNoLinkageFinder::VisitDeducedTemplateSpecializationType(

lib/Sema/SemaTemplateDeduction.cpp

       return Sema::TDK_NonDeducedMismatch;
     }
 
     case Type::TypeOfExpr:
     case Type::TypeOf:
     case Type::DependentName:
     case Type::UnresolvedUsing:
     case Type::Decltype:
-    case Type::UnaryTransform:
+    case Type::TransformTrait:
     case Type::Auto:
     case Type::DeducedTemplateSpecialization:
     case Type::DependentTemplateSpecialization:
     case Type::PackExpansion:
     case Type::Pipe:
       // No template argument deduction for these types
       return Sema::TDK_Success;
   }

     if (!OnlyDeduced)
       MarkUsedTemplateParameters(Ctx,
                                  cast<TypeOfExprType>(T)->getUnderlyingExpr(),
                                  OnlyDeduced, Depth, Used);
     break;
 
   case Type::Decltype:
     if (!OnlyDeduced)
       MarkUsedTemplateParameters(Ctx,
                                  cast<DecltypeType>(T)->getUnderlyingExpr(),
                                  OnlyDeduced, Depth, Used);
     break;
 
-  case Type::UnaryTransform:
-    if (!OnlyDeduced)
-      MarkUsedTemplateParameters(Ctx,
-                                 cast<UnaryTransformType>(T)->getUnderlyingType(),
-                                 OnlyDeduced, Depth, Used);
+  case Type::TransformTrait: {
+    const TransformTraitType *TT = cast<TransformTraitType>(T);
+    if (!OnlyDeduced) {
+      for (auto Ty : TT->getArgs())
+        MarkUsedTemplateParameters(Ctx, Ty, OnlyDeduced, Depth, Used);
+    }
     break;
-
+  }
   case Type::PackExpansion:
     MarkUsedTemplateParameters(Ctx,
                                cast<PackExpansionType>(T)->getPattern(),
                                OnlyDeduced, Depth, Used);
     break;
 
   case Type::Auto:
   case Type::DeducedTemplateSpecialization:

lib/Sema/SemaType.cpp

     break;
   }
   case DeclSpec::TST_typename: {
     assert(DS.getTypeSpecWidth() == 0 && DS.getTypeSpecComplex() == 0 &&
            DS.getTypeSpecSign() == 0 &&
            "Can't handle qualifiers on typedef names yet!");
     Result = S.GetTypeFromParser(DS.getRepAsType());
     if (Result.isNull()) {
       declarator.setInvalidType(true);
     }
 
     // TypeQuals handled by caller.
     break;
   }
   case DeclSpec::TST_typeofType:
     // FIXME: Preserve type source info.
     Result = S.GetTypeFromParser(DS.getRepAsType());
     assert(!Result.isNull() && "Didn't get a type for typeof?");

     // TypeQuals handled by caller.
     Result = S.BuildDecltypeType(E, DS.getTypeSpecTypeLoc());
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
   }
-  case DeclSpec::TST_underlyingType:
-    Result = S.GetTypeFromParser(DS.getRepAsType());
-    assert(!Result.isNull() && "Didn't get a type for __underlying_type?");
-    Result = S.BuildUnaryTransformType(Result,
-                                       UnaryTransformType::EnumUnderlyingType,
-                                       DS.getTypeSpecTypeLoc());
+  case DeclSpec::TST_underlyingType: {
+    ParsedType ParsedTT = DS.getRepAsType();
+    Result = S.GetTypeFromParser(ParsedTT);
     if (Result.isNull()) {
       Result = Context.IntTy;
       declarator.setInvalidType(true);
     }
     break;
-
+  }
   case DeclSpec::TST_auto:
     Result = Context.getAutoType(QualType(), AutoTypeKeyword::Auto, false);
     break;
 
   case DeclSpec::TST_auto_type:
     Result = Context.getAutoType(QualType(), AutoTypeKeyword::GNUAutoType, false);
     break;
 

       assert(DS.getTypeSpecType() == DeclSpec::TST_typeofType);
       TL.setTypeofLoc(DS.getTypeSpecTypeLoc());
       TL.setParensRange(DS.getTypeofParensRange());
       assert(DS.getRepAsType());
       TypeSourceInfo *TInfo = nullptr;
       Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
       TL.setUnderlyingTInfo(TInfo);
     }
-    void VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
-      // FIXME: This holds only because we only have one unary transform.
+
+    void VisitTransformTraitTypeLoc(TransformTraitTypeLoc TL) {
       assert(DS.getTypeSpecType() == DeclSpec::TST_underlyingType);
-      TL.setKWLoc(DS.getTypeSpecTypeLoc());
-      TL.setParensRange(DS.getTypeofParensRange());
-      assert(DS.getRepAsType());
-      TypeSourceInfo *TInfo = nullptr;
-      Sema::GetTypeFromParser(DS.getRepAsType(), &TInfo);
-      TL.setUnderlyingTInfo(TInfo);
+      TypeSourceInfo *RepTInfo = nullptr;
+      Sema::GetTypeFromParser(DS.getRepAsType(), &RepTInfo);
+      TL.copy(RepTInfo->getTypeLoc());
     }
+
     void VisitBuiltinTypeLoc(BuiltinTypeLoc TL) {
       // By default, use the source location of the type specifier.
       TL.setBuiltinLoc(DS.getTypeSpecTypeLoc());
       if (TL.needsExtraLocalData()) {
         // Set info for the written builtin specifiers.
         TL.getWrittenBuiltinSpecs() = DS.getWrittenBuiltinSpecs();
         // Try to have a meaningful source location.
         if (TL.getWrittenSignSpec() != TSS_unspecified)

   if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {
     const ValueDecl *VD = DRE->getDecl();
     return VD->getType();
   } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
     if (const ValueDecl *VD = ME->getMemberDecl())
       if (isa<FieldDecl>(VD) || isa<VarDecl>(VD))
         return VD->getType();
   } else if (const ObjCIvarRefExpr *IR = dyn_cast<ObjCIvarRefExpr>(E)) {
     return IR->getDecl()->getType();
   } else if (const ObjCPropertyRefExpr *PR = dyn_cast<ObjCPropertyRefExpr>(E)) {
     if (PR->isExplicitProperty())
       return PR->getExplicitProperty()->getType();
   } else if (auto *PE = dyn_cast<PredefinedExpr>(E)) {
     return PE->getType();
   }
   
   // C++11 [expr.lambda.prim]p18:
   //   Every occurrence of decltype((x)) where x is a possibly
   //   parenthesized id-expression that names an entity of automatic
   //   storage duration is treated as if x were transformed into an
   //   access to a corresponding data member of the closure type that
   //   would have been declared if x were an odr-use of the denoted
   //   entity.
   using namespace sema;
   if (S.getCurLambda()) {
     if (isa<ParenExpr>(E)) {
       if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E->IgnoreParens())) {
         if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
           QualType T = S.getCapturedDeclRefType(Var, DRE->getLocation());
           if (!T.isNull())
             return S.Context.getLValueReferenceType(T);
         }
       }
     }
   }
 
 
   // C++11 [dcl.type.simple]p4:
   //   [...]
   QualType T = E->getType();
   switch (E->getValueKind()) {
   //     - otherwise, if e is an xvalue, decltype(e) is T&&, where T is the
   //       type of e;
   case VK_XValue: T = S.Context.getRValueReferenceType(T); break;
   //     - otherwise, if e is an lvalue, decltype(e) is T&, where T is the
   //       type of e;
   case VK_LValue: T = S.Context.getLValueReferenceType(T); break;
   //  - otherwise, decltype(e) is the type of e.
   case VK_RValue: break;
   }
 

     // The expression operand for decltype is in an unevaluated expression
     // context, so side effects could result in unintended consequences.
     Diag(E->getExprLoc(), diag::warn_side_effects_unevaluated_context);
   }
 
   return Context.getDecltypeType(E, getDecltypeForExpr(*this, E));
 }
 
-QualType Sema::BuildUnaryTransformType(QualType BaseType,
-                                       UnaryTransformType::UTTKind UKind,
-                                       SourceLocation Loc) {
-  switch (UKind) {
-  case UnaryTransformType::EnumUnderlyingType:
-    if (!BaseType->isDependentType() && !BaseType->isEnumeralType()) {
-      Diag(Loc, diag::err_only_enums_have_underlying_types);
-      return QualType();
-    } else {
-      QualType Underlying = BaseType;
-      if (!BaseType->isDependentType()) {
-        // The enum could be incomplete if we're parsing its definition or
-        // recovering from an error.
-        NamedDecl *FwdDecl = nullptr;
-        if (BaseType->isIncompleteType(&FwdDecl)) {
-          Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
-          Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl;
-          return QualType();
-        }
+static bool CheckTransformTraitArity(Sema &S, TransformTraitType::TTKind Kind,
+                               unsigned NumArgs, SourceLocation Loc, SourceRange R) {
+  unsigned Arity;
+  bool IsVariadic = false;
+  switch (Kind) {
+  case TransformTraitType::EnumUnderlyingType:
+    Arity = 1;
+    break;
+  }
+
+  struct DiagInfo {
+    unsigned ReqNumArgs;
+    unsigned SelectOne;
+  };
+  auto DiagSelect = [&]() -> Optional<DiagInfo> {
+    if (NumArgs == 0)
+      return DiagInfo{Arity, 0};
+    if (Arity && !IsVariadic && Arity != NumArgs)
+      return DiagInfo{Arity, 0};
+    if (Arity && IsVariadic && NumArgs < Arity)
+      return DiagInfo{Arity, 1};
+    return {};
+  }();
+
+  if (DiagSelect.hasValue()) {
+    auto Info = DiagSelect.getValue();
+    S.Diag(Loc, diag::err_type_trait_arity)
+      << Info.ReqNumArgs << Info.SelectOne << (Info.ReqNumArgs != 1)
+      << (int)NumArgs << R;
+    return true;
+  }
+  return false;
+}
+
+TypeResult Sema::ActOnTransformTraitType(ArrayRef<ParsedType> ParsedArgs,
+                                         TransformTraitType::TTKind Kind,
+                                         SourceLocation KWLoc,
+                                         SourceRange ParenRange) {
+  SmallVector<TypeSourceInfo *, 2> ArgTInfos;
+  SmallVector<QualType, 2> ArgTypes;
+  ArgTInfos.reserve(ParsedArgs.size());
+  ArgTypes.reserve(ParsedArgs.size());
+
+  for (auto &PT : ParsedArgs) {
+    TypeSourceInfo *ArgTypeInfo = nullptr;
+    QualType NewArg = GetTypeFromParser(PT, &ArgTypeInfo);
+    assert(ArgTypeInfo && "No type source info?");
+    ArgTypes.push_back(NewArg);
+    ArgTInfos.push_back(ArgTypeInfo);
+  }
+  QualType Result = BuildTransformTraitType(ArgTypes, Kind, KWLoc);
+  if (Result.isNull())
+    return TypeResult(/*IsInvalid*/true);
 
-        EnumDecl *ED = BaseType->getAs<EnumType>()->getDecl();
-        assert(ED && "EnumType has no EnumDecl");
+  // Create source information for this type.
+  TypeSourceInfo *ResultTInfo = Context.CreateTypeSourceInfo(Result);
+  TypeLoc ResultTL = ResultTInfo->getTypeLoc();
 
-        DiagnoseUseOfDecl(ED, Loc);
+  auto TTT = ResultTL.castAs<TransformTraitTypeLoc>();
+  TTT.setKWLoc(KWLoc);
+  TTT.setParensRange(ParenRange);
+  if (TTT.getNumArgs() > 0) {
+    assert(TTT.getNumArgs() == ArgTInfos.size());
+    TTT.setArgTInfo(ArgTInfos);
+  }
 
-        Underlying = ED->getIntegerType();
-        assert(!Underlying.isNull());
-      }
-      return Context.getUnaryTransformType(BaseType, Underlying,
-                                        UnaryTransformType::EnumUnderlyingType);
+  return CreateParsedType(Result, ResultTInfo);
+}
+
+QualType Sema::ComputeTransformTraitResultType(ArrayRef<QualType> ArgTypes,
+                                               TransformTraitType::TTKind TKind,
+                                               SourceLocation Loc) {
+  auto Error = []() { return QualType(); };
+  bool DelayChecking = llvm::any_of(ArgTypes, [](QualType Ty) {
+    return Ty->isDependentType() ||
+           Ty->containsUnexpandedParameterPack();
+  });
+
+  // Delay all checking while any of the arguments are instantiation dependent.
+  if (DelayChecking)
+    return Context.DependentTy;
+
+  if (CheckTransformTraitArity(*this, TKind, ArgTypes.size(), Loc, SourceRange(Loc)))
+    return Error();
+
+  switch (TKind) {
+  case TransformTraitType::EnumUnderlyingType: {
+    assert(ArgTypes.size() == 1);
+    if (ArgTypes[0]->isDependentType())
+      return Context.DependentTy;
+
+    QualType BaseType = ArgTypes[0];
+    if (!BaseType->isEnumeralType()) {
+      Diag(Loc, diag::err_only_enums_have_underlying_types);
+      return Error();
     }
+    // The enum could be incomplete if we're parsing its definition or
+    // recovering from an error.
+    NamedDecl *FwdDecl = nullptr;
+    if (BaseType->isIncompleteType(&FwdDecl)) {
+      Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;
+      Diag(FwdDecl->getLocation(), diag::note_forward_declaration) << FwdDecl;
+      return Error();
+    }
+
+    EnumDecl *ED = BaseType->getAs<EnumType>()->getDecl();
+    assert(ED && "EnumType has no EnumDecl");
+
+    DiagnoseUseOfDecl(ED, Loc);
+    assert(!ED->getIntegerType().isNull());
+    return ED->getIntegerType();
   }
-  llvm_unreachable("unknown unary transform type");
+  }
+
+  llvm_unreachable("unknown transform type");
+}
+
+QualType Sema::BuildTransformTraitType(ArrayRef<QualType> ArgTypes,
+                                       TransformTraitType::TTKind TKind,
+                                       SourceLocation Loc) {
+  QualType ResultType = ComputeTransformTraitResultType(ArgTypes, TKind, Loc);
+  if (ResultType.isNull())
+    return QualType();
+  return Context.getTransformTraitType(ArgTypes, ResultType, TKind);
 }
 
 QualType Sema::BuildAtomicType(QualType T, SourceLocation Loc) {
   if (!T->isDependentType()) {
     // FIXME: It isn't entirely clear whether incomplete atomic types
     // are allowed or not; for simplicity, ban them for the moment.
     if (RequireCompleteType(Loc, T, diag::err_atomic_specifier_bad_type, 0))
       return QualType();

lib/Sema/TreeTransform.h

                                       DependentTemplateSpecializationTypeLoc TL,
                                                TemplateName Template,
                                                CXXScopeSpec &SS);
 
   QualType TransformDependentTemplateSpecializationType(
       TypeLocBuilder &TLB, DependentTemplateSpecializationTypeLoc TL,
       NestedNameSpecifierLoc QualifierLoc);
 
+  bool TransformTypeList(ArrayRef<TypeSourceInfo *> InArgs, bool &ArgChanged,
+                         SmallVectorImpl<TypeSourceInfo *> &Args);
+
   /// Transforms the parameters of a function type into the
   /// given vectors.
   ///
   /// The result vectors should be kept in sync; null entries in the
   /// variables vector are acceptable.
   ///
   /// Return true on error.
   bool TransformFunctionTypeParams(

   /// Subclasses may override this routine to provide different behavior.
   QualType RebuildTypeOfExprType(Expr *Underlying, SourceLocation Loc);
 
   /// Build a new typeof(type) type.
   ///
   /// By default, builds a new TypeOfType with the given underlying type.
   QualType RebuildTypeOfType(QualType Underlying);
 
-  /// Build a new unary transform type.
-  QualType RebuildUnaryTransformType(QualType BaseType,
-                                     UnaryTransformType::UTTKind UKind,
+  /// Build a new transform trait type.
+  QualType RebuildTransformTraitType(ArrayRef<QualType> ArgTypes,
+                                     TransformTraitType::TTKind TKind,
                                      SourceLocation Loc);
 
   /// Build a new C++11 decltype type.
   ///
   /// By default, performs semantic analysis when building the decltype type.
   /// Subclasses may override this routine to provide different behavior.
   QualType RebuildDecltypeType(Expr *Underlying, SourceLocation Loc);
 

   else E.get();
 
   DecltypeTypeLoc NewTL = TLB.push<DecltypeTypeLoc>(Result);
   NewTL.setNameLoc(TL.getNameLoc());
 
   return Result;
 }
 
-template<typename Derived>
-QualType TreeTransform<Derived>::TransformUnaryTransformType(
-                                                            TypeLocBuilder &TLB,
-                                                     UnaryTransformTypeLoc TL) {
+template <typename Derived>
+QualType
+TreeTransform<Derived>::TransformTransformTraitType(TypeLocBuilder &TLB,
+                                                    TransformTraitTypeLoc TL) {
+  bool AnyChanged = false;
+  SmallVector<TypeSourceInfo *, 6> NewTypeArgInfos;
+  if (getDerived().TransformTypeList(TL.getArgTInfo(), AnyChanged,
+                                     NewTypeArgInfos))
+    return QualType();
+
   QualType Result = TL.getType();
-  if (Result->isDependentType()) {
-    const UnaryTransformType *T = TL.getTypePtr();
-    QualType NewBase =
-      getDerived().TransformType(TL.getUnderlyingTInfo())->getType();
-    Result = getDerived().RebuildUnaryTransformType(NewBase,
-                                                    T->getUTTKind(),
+  if (getDerived().AlwaysRebuild() || AnyChanged) {
+    const TransformTraitType *T = TL.getTypePtr();
+    SmallVector<QualType, 6> Args;
+    Args.reserve(NewTypeArgInfos.size());
+    for (auto *TyInfo : NewTypeArgInfos)
+      Args.push_back(TyInfo->getType());
+
+    Result = getDerived().RebuildTransformTraitType(Args, T->getTTKind(),
                                                     TL.getKWLoc());
     if (Result.isNull())
       return QualType();
   }
 
-  UnaryTransformTypeLoc NewTL = TLB.push<UnaryTransformTypeLoc>(Result);
+  TransformTraitTypeLoc NewTL = TLB.push<TransformTraitTypeLoc>(Result);
+  assert(NewTL.getNumArgs() == NewTypeArgInfos.size());
+
   NewTL.setKWLoc(TL.getKWLoc());
   NewTL.setParensRange(TL.getParensRange());
-  NewTL.setUnderlyingTInfo(TL.getUnderlyingTInfo());
+  for (unsigned I = 0, Size = NewTypeArgInfos.size(); I < Size; ++I)
+    NewTL.setArgInfo(I, NewTypeArgInfos[I]);
+
   return Result;
 }
 
-template<typename Derived>
+template <typename Derived>
 QualType TreeTransform<Derived>::TransformAutoType(TypeLocBuilder &TLB,
                                                    AutoTypeLoc TL) {
   const AutoType *T = TL.getTypePtr();
   QualType OldDeduced = T->getDeducedType();
   QualType NewDeduced;
   if (!OldDeduced.isNull()) {
     NewDeduced = getDerived().TransformType(OldDeduced);
     if (NewDeduced.isNull())

   QualType BaseType = getDerived().TransformType(TLB, TL.getBaseLoc());
   if (BaseType.isNull())
     return QualType();
 
   bool AnyChanged = BaseType != TL.getBaseLoc().getType();
 
   // Transform type arguments.
   SmallVector<TypeSourceInfo *, 4> NewTypeArgInfos;
-  for (unsigned i = 0, n = TL.getNumTypeArgs(); i != n; ++i) {
-    TypeSourceInfo *TypeArgInfo = TL.getTypeArgTInfo(i);
-    TypeLoc TypeArgLoc = TypeArgInfo->getTypeLoc();
-    QualType TypeArg = TypeArgInfo->getType();
-    if (auto PackExpansionLoc = TypeArgLoc.getAs<PackExpansionTypeLoc>()) {
-      AnyChanged = true;
-
-      // We have a pack expansion. Instantiate it.
-      const auto *PackExpansion = PackExpansionLoc.getType()
-                                    ->castAs<PackExpansionType>();
-      SmallVector<UnexpandedParameterPack, 2> Unexpanded;
-      SemaRef.collectUnexpandedParameterPacks(PackExpansion->getPattern(),
-                                              Unexpanded);
-      assert(!Unexpanded.empty() && "Pack expansion without parameter packs?");
-
-      // Determine whether the set of unexpanded parameter packs can
-      // and should be expanded.
-      TypeLoc PatternLoc = PackExpansionLoc.getPatternLoc();
-      bool Expand = false;
-      bool RetainExpansion = false;
-      Optional<unsigned> NumExpansions = PackExpansion->getNumExpansions();
-      if (getDerived().TryExpandParameterPacks(
-            PackExpansionLoc.getEllipsisLoc(), PatternLoc.getSourceRange(),
-            Unexpanded, Expand, RetainExpansion, NumExpansions))
-        return QualType();
-
-      if (!Expand) {
-        // We can't expand this pack expansion into separate arguments yet;
-        // just substitute into the pattern and create a new pack expansion
-        // type.
-        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
-
-        TypeLocBuilder TypeArgBuilder;
-        TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
-        QualType NewPatternType = getDerived().TransformType(TypeArgBuilder, 
-                                                             PatternLoc);
-        if (NewPatternType.isNull())
-          return QualType();
-
-        QualType NewExpansionType = SemaRef.Context.getPackExpansionType(
-                                      NewPatternType, NumExpansions);
-        auto NewExpansionLoc = TLB.push<PackExpansionTypeLoc>(NewExpansionType);
-        NewExpansionLoc.setEllipsisLoc(PackExpansionLoc.getEllipsisLoc());
-        NewTypeArgInfos.push_back(
-          TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewExpansionType));
-        continue;
-      }
-
-      // Substitute into the pack expansion pattern for each slice of the
-      // pack.
-      for (unsigned ArgIdx = 0; ArgIdx != *NumExpansions; ++ArgIdx) {
-        Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), ArgIdx);
-
-        TypeLocBuilder TypeArgBuilder;
-        TypeArgBuilder.reserve(PatternLoc.getFullDataSize());
-
-        QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder,
-                                                         PatternLoc);
-        if (NewTypeArg.isNull())
-          return QualType();
-
-        NewTypeArgInfos.push_back(
-          TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
-      }
-
-      continue;
-    }
-
-    TypeLocBuilder TypeArgBuilder;
-    TypeArgBuilder.reserve(TypeArgLoc.getFullDataSize());
-    QualType NewTypeArg = getDerived().TransformType(TypeArgBuilder, TypeArgLoc);
-    if (NewTypeArg.isNull())
-      return QualType();
-
-    // If nothing changed, just keep the old TypeSourceInfo.
-    if (NewTypeArg == TypeArg) {
-      NewTypeArgInfos.push_back(TypeArgInfo);
-      continue;
-    }
-
-    NewTypeArgInfos.push_back(
-      TypeArgBuilder.getTypeSourceInfo(SemaRef.Context, NewTypeArg));
-    AnyChanged = true;
-  }
+  if (getDerived().TransformTypeList(TL.getTypeArgTInfoRef(), AnyChanged,
+                                     NewTypeArgInfos))
+    return QualType();
 
   QualType Result = TL.getType();
   if (getDerived().AlwaysRebuild() || AnyChanged) {
     // Rebuild the type.
     Result = getDerived().RebuildObjCObjectType(
                BaseType,
                TL.getLocStart(),
                TL.getTypeArgsLAngleLoc(),

     R.clear();
     return ExprError();
   }
 
   return getDerived().RebuildTemplateIdExpr(SS, TemplateKWLoc, R,
                                             Old->requiresADL(), &TransArgs);
 }
 
-template<typename Derived>
-ExprResult
-TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
-  bool ArgChanged = false;
-  SmallVector<TypeSourceInfo *, 4> Args;
-  for (unsigned I = 0, N = E->getNumArgs(); I != N; ++I) {
-    TypeSourceInfo *From = E->getArg(I);
+template <typename Derived>
+bool TreeTransform<Derived>::TransformTypeList(
+    ArrayRef<TypeSourceInfo *> InArgs, bool &ArgChanged,
+    SmallVectorImpl<TypeSourceInfo *> &Args) {
+  for (unsigned I = 0, N = InArgs.size(); I != N; ++I) {
+    TypeSourceInfo *From = InArgs[I];
     TypeLoc FromTL = From->getTypeLoc();
     if (!FromTL.getAs<PackExpansionTypeLoc>()) {
       TypeLocBuilder TLB;
       TLB.reserve(FromTL.getFullDataSize());
       QualType To = getDerived().TransformType(TLB, FromTL);
       if (To.isNull())
-        return ExprError();
+        return true;
 
       if (To == From->getType())
         Args.push_back(From);
       else {
         Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
         ArgChanged = true;
       }
       continue;

     Optional<unsigned> OrigNumExpansions =
         ExpansionTL.getTypePtr()->getNumExpansions();
     Optional<unsigned> NumExpansions = OrigNumExpansions;
     if (getDerived().TryExpandParameterPacks(ExpansionTL.getEllipsisLoc(),
                                              PatternTL.getSourceRange(),
                                              Unexpanded,
                                              Expand, RetainExpansion,
                                              NumExpansions))
-      return ExprError();
+      return true;
 
     if (!Expand) {
       // The transform has determined that we should perform a simple
       // transformation on the pack expansion, producing another pack
       // expansion.
-      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(getSema(), -1);
+      Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, -1);
 
       TypeLocBuilder TLB;
       TLB.reserve(From->getTypeLoc().getFullDataSize());
 
       QualType To = getDerived().TransformType(TLB, PatternTL);
       if (To.isNull())
-        return ExprError();
+        return true;
 
       To = getDerived().RebuildPackExpansionType(To,
                                                  PatternTL.getSourceRange(),
                                                  ExpansionTL.getEllipsisLoc(),
                                                  NumExpansions);
       if (To.isNull())
-        return ExprError();
+        return true;
 
       PackExpansionTypeLoc ToExpansionTL
         = TLB.push<PackExpansionTypeLoc>(To);
       ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
       Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
       continue;
     }
 
     // Expand the pack expansion by substituting for each argument in the
     // pack(s).
     for (unsigned I = 0; I != *NumExpansions; ++I) {
       Sema::ArgumentPackSubstitutionIndexRAII SubstIndex(SemaRef, I);
       TypeLocBuilder TLB;
       TLB.reserve(PatternTL.getFullDataSize());
       QualType To = getDerived().TransformType(TLB, PatternTL);
       if (To.isNull())
-        return ExprError();
+        return true;
 
       if (To->containsUnexpandedParameterPack()) {
         To = getDerived().RebuildPackExpansionType(To,
                                                    PatternTL.getSourceRange(),
                                                    ExpansionTL.getEllipsisLoc(),
                                                    NumExpansions);
         if (To.isNull())
-          return ExprError();
+          return true;
 
         PackExpansionTypeLoc ToExpansionTL
           = TLB.push<PackExpansionTypeLoc>(To);
         ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
       }
 
       Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
     }
 
     if (!RetainExpansion)
       continue;
 
     // If we're supposed to retain a pack expansion, do so by temporarily
     // forgetting the partially-substituted parameter pack.
     ForgetPartiallySubstitutedPackRAII Forget(getDerived());
 
     TypeLocBuilder TLB;
     TLB.reserve(From->getTypeLoc().getFullDataSize());
 
     QualType To = getDerived().TransformType(TLB, PatternTL);
     if (To.isNull())
-      return ExprError();
+      return true;
 
     To = getDerived().RebuildPackExpansionType(To,
                                                PatternTL.getSourceRange(),
                                                ExpansionTL.getEllipsisLoc(),
                                                NumExpansions);
     if (To.isNull())
-      return ExprError();
+      return true;
 
     PackExpansionTypeLoc ToExpansionTL
       = TLB.push<PackExpansionTypeLoc>(To);
     ToExpansionTL.setEllipsisLoc(ExpansionTL.getEllipsisLoc());
     Args.push_back(TLB.getTypeSourceInfo(SemaRef.Context, To));
   }
+  return false;
+}
+
+template <typename Derived>
+ExprResult TreeTransform<Derived>::TransformTypeTraitExpr(TypeTraitExpr *E) {
+  bool ArgChanged = false;
+  SmallVector<TypeSourceInfo *, 4> Args;
+  if (getDerived().TransformTypeList(E->getArgs(), ArgChanged, Args))
+    return ExprError();
 
   if (!getDerived().AlwaysRebuild() && !ArgChanged)
     return E;
 
   return getDerived().RebuildTypeTrait(E->getTrait(),
                                        E->getLocStart(),
                                        Args,
                                        E->getLocEnd());

 }
 
 template<typename Derived>
 QualType TreeTransform<Derived>::RebuildDecltypeType(Expr *E,
                                                      SourceLocation Loc) {
   return SemaRef.BuildDecltypeType(E, Loc);
 }
 
-template<typename Derived>
-QualType TreeTransform<Derived>::RebuildUnaryTransformType(QualType BaseType,
-                                            UnaryTransformType::UTTKind UKind,
-                                            SourceLocation Loc) {
-  return SemaRef.BuildUnaryTransformType(BaseType, UKind, Loc);
+template <typename Derived>
+QualType TreeTransform<Derived>::RebuildTransformTraitType(
+    ArrayRef<QualType> ArgTypes, TransformTraitType::TTKind TKind,
+  return SemaRef.BuildTransformTraitType(ArgTypes, TKind, Loc);
 }
 
 template<typename Derived>
 QualType TreeTransform<Derived>::RebuildTemplateSpecializationType(
                                                       TemplateName Template,
                                              SourceLocation TemplateNameLoc,
                                      TemplateArgumentListInfo &TemplateArgs) {
   return SemaRef.CheckTemplateIdType(Template, TemplateNameLoc, TemplateArgs);

lib/Serialization/ASTReader.cpp

     return Context.getTypeOfType(UnderlyingType);
   }
 
   case TYPE_DECLTYPE: {
     QualType UnderlyingType = readType(*Loc.F, Record, Idx);
     return Context.getDecltypeType(ReadExpr(*Loc.F), UnderlyingType);
   }
 
-  case TYPE_UNARY_TRANSFORM: {
-    QualType BaseType = readType(*Loc.F, Record, Idx);
-    QualType UnderlyingType = readType(*Loc.F, Record, Idx);
-    UnaryTransformType::UTTKind UKind = (UnaryTransformType::UTTKind)Record[2];
-    return Context.getUnaryTransformType(BaseType, UnderlyingType, UKind);
+  case TYPE_TRANSFORM_TRAIT: {
+    SmallVector<QualType, 2> ArgTypes;
+    unsigned NumArgs = (unsigned)Record[Idx++];
+    for (unsigned I = 0; I < NumArgs; ++I)
+      ArgTypes.push_back(readType(*Loc.F, Record, Idx));
+    QualType TransformedType = readType(*Loc.F, Record, Idx);
+    TransformTraitType::TTKind TKind =
+        (TransformTraitType::TTKind)Record[Idx++];
+    return Context.getTransformTraitType(ArgTypes, TransformedType, TKind);
   }
 
   case TYPE_AUTO: {
     QualType Deduced = readType(*Loc.F, Record, Idx);
     AutoTypeKeyword Keyword = (AutoTypeKeyword)Record[Idx++];
     bool IsDependent = Deduced.isNull() ? Record[Idx++] : false;
     return Context.getAutoType(Deduced, Keyword, IsDependent);
   }

   TL.setRParenLoc(ReadSourceLocation());
   TL.setUnderlyingTInfo(GetTypeSourceInfo());
 }
 
 void TypeLocReader::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
   TL.setNameLoc(ReadSourceLocation());
 }
 
-void TypeLocReader::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
+void TypeLocReader::VisitTransformTraitTypeLoc(TransformTraitTypeLoc TL) {
   TL.setKWLoc(ReadSourceLocation());
   TL.setLParenLoc(ReadSourceLocation());
   TL.setRParenLoc(ReadSourceLocation());
-  TL.setUnderlyingTInfo(GetTypeSourceInfo());
+  unsigned Size = Record[Idx++];
+  SmallVector<TypeSourceInfo *, 2> ArgTInfo;
+  for (unsigned I = 0; I < Size; ++I)
+    ArgTInfo.push_back(GetTypeSourceInfo());
+  TL.setArgTInfo(ArgTInfo);
 }
 
 void TypeLocReader::VisitAutoTypeLoc(AutoTypeLoc TL) {
   TL.setNameLoc(ReadSourceLocation());
 }
 
 void TypeLocReader::VisitDeducedTemplateSpecializationTypeLoc(
     DeducedTemplateSpecializationTypeLoc TL) {

lib/Serialization/ASTWriter.cpp

 }
 
 void ASTTypeWriter::VisitDecltypeType(const DecltypeType *T) {
   Record.AddTypeRef(T->getUnderlyingType());
   Record.AddStmt(T->getUnderlyingExpr());
   Code = TYPE_DECLTYPE;
 }
 
-void ASTTypeWriter::VisitUnaryTransformType(const UnaryTransformType *T) {
-  Record.AddTypeRef(T->getBaseType());
-  Record.AddTypeRef(T->getUnderlyingType());
-  Record.push_back(T->getUTTKind());
-  Code = TYPE_UNARY_TRANSFORM;
+void ASTTypeWriter::VisitTransformTraitType(const TransformTraitType *T) {
+  auto ArgTys = T->getArgs();
+  Record.push_back(ArgTys.size());
+  for (auto Ty : ArgTys)
+    Record.AddTypeRef(Ty);
+  Record.AddTypeRef(T->getTransformedType());
+  Record.push_back(T->getTTKind());
+  Code = TYPE_TRANSFORM_TRAIT;
 }
 
 void ASTTypeWriter::VisitAutoType(const AutoType *T) {
   Record.AddTypeRef(T->getDeducedType());
   Record.push_back((unsigned)T->getKeyword());
   if (T->getDeducedType().isNull())
     Record.push_back(T->isDependentType());
   Code = TYPE_AUTO;
void TypeLocWriter::VisitTypeOfTypeLoc(TypeOfTypeLoc TL) {
   Record.AddSourceLocation(TL.getRParenLoc());
   Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
 }
 
 void TypeLocWriter::VisitDecltypeTypeLoc(DecltypeTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
-void TypeLocWriter::VisitUnaryTransformTypeLoc(UnaryTransformTypeLoc TL) {
+void TypeLocWriter::VisitTransformTraitTypeLoc(TransformTraitTypeLoc TL) {
   Record.AddSourceLocation(TL.getKWLoc());
   Record.AddSourceLocation(TL.getLParenLoc());
   Record.AddSourceLocation(TL.getRParenLoc());
-  Record.AddTypeSourceInfo(TL.getUnderlyingTInfo());
+  ArrayRef<TypeSourceInfo *> ArgTInfo = TL.getArgTInfo();
+  Record.push_back(ArgTInfo.size());
+  for (auto *TSI : ArgTInfo)
+    Record.AddTypeSourceInfo(TSI);
 }
 
 void TypeLocWriter::VisitAutoTypeLoc(AutoTypeLoc TL) {
   Record.AddSourceLocation(TL.getNameLoc());
 }
 
 void TypeLocWriter::VisitDeducedTemplateSpecializationTypeLoc(
     DeducedTemplateSpecializationTypeLoc TL) {
#define RECORD(X) EmitRecordID(X, #X, Stream, Record)
   RECORD(TYPE_DEPENDENT_NAME);
   RECORD(TYPE_DEPENDENT_TEMPLATE_SPECIALIZATION);
   RECORD(TYPE_DEPENDENT_SIZED_ARRAY);
   RECORD(TYPE_PAREN);
   RECORD(TYPE_PACK_EXPANSION);
   RECORD(TYPE_ATTRIBUTED);
   RECORD(TYPE_SUBST_TEMPLATE_TYPE_PARM_PACK);
   RECORD(TYPE_AUTO);
-  RECORD(TYPE_UNARY_TRANSFORM);
+  RECORD(TYPE_TRANSFORM_TRAIT);
   RECORD(TYPE_ATOMIC);
   RECORD(TYPE_DECAYED);
   RECORD(TYPE_ADJUSTED);
   RECORD(TYPE_OBJC_TYPE_PARAM);
   RECORD(LOCAL_REDECLARATIONS);
   RECORD(DECL_TYPEDEF);
   RECORD(DECL_TYPEALIAS);
   RECORD(DECL_ENUM);

test/CodeGenCXX/mangle.cpp

 
 namespace test55 {
 enum E { R };
 
 template <typename T>
 void fn(T, __underlying_type(T)) {}
 
 template void fn<E>(E, __underlying_type(E));
-// CHECK-LABEL: @_ZN6test552fnINS_1EEEEvT_U3eutS2_
+// CHECK-LABEL: @_ZN6test552fnINS_1EEEEvT_u17__underlying_typeIS2_E
+
+void fn2(E, __underlying_type(E)) {}
+// CHECK-LABEL: @_ZN6test553fn2ENS_1EEj
 }
 
+
 namespace test56 {
   struct A { A *operator->(); int n; } a;
   template<int N> void f(decltype(a->n + N)) {}
   // CHECK-LABEL: @_ZN6test561fILi0EEEvDTplptL_ZNS_1aEE1nT_E
   template void f<0>(int);
 }
 
 namespace test57 {

test/SemaCXX/underlying_type.cpp

 // RUN: %clang_cc1 -triple %itanium_abi_triple -ffreestanding -fsyntax-only -verify -std=c++11 %s
 
 #include "limits.h"
 
 template<typename T, typename U>
 struct is_same_type {
   static const bool value = false;
 };
 template <typename T>
 struct is_same_type<T, T> {
   static const bool value = true;
 };
-
+__underlying_type() x;         // expected-error {{type trait requires 1 argument; have 0 arguments}}
+__underlying_type(int, int) y; // expected-error {{type trait requires 1 argument; have 2 arguments}}
 __underlying_type(int) a; // expected-error {{only enumeration types}}
 __underlying_type(struct b) c; // expected-error {{only enumeration types}}
 
 enum class f : char;
 static_assert(is_same_type<char, __underlying_type(f)>::value,
               "f has the wrong underlying type");
 
 enum g {d = INT_MIN };
 static_assert(is_same_type<int, __underlying_type(g)>::value,
               "g has the wrong underlying type");
 
 __underlying_type(f) h;
 static_assert(is_same_type<char, decltype(h)>::value,
               "h has the wrong type");
 
+template <class ...Args> struct TypeList {};
+
+template <class ...Args>
+struct TestParse;
+
+template <class ...> struct MyTest {};
+
+template <class ...Args>
+struct TestParse<TypeList<Args...>> {
+  using type = __underlying_type(Args...);
+};
+
+template <class... Args1, class ...Args2>
+struct TestParse<TypeList<Args1...>, TypeList<Args2...>> {
+  // expected-error@+2 2 {{type trait requires 1 argument; have 2 arguments}}
+  // expected-error@+1 {{type trait requires 1 argument; have 0 arguments}}
+  using type = __underlying_type(Args1..., Args2...);
+};
+static_assert(is_same_type<TestParse<TypeList<f>>::type, char>::value, "wrong type");
+static_assert(is_same_type<TestParse<TypeList<f>, TypeList<>>::type, char>::value, "wrong type");
+template struct TestParse<TypeList<>, TypeList<>>; // expected-note {{requested here}}
+template struct TestParse<TypeList<f, f>, TypeList<>>; // expected-note {{requested here}}
+template struct TestParse<TypeList<f>, TypeList<f>>; // expected-note {{requested here}}
+
+
 template <typename T>
 struct underlying_type {
   typedef __underlying_type(T) type; // expected-error {{only enumeration types}}
 };
 
 static_assert(is_same_type<underlying_type<f>::type, char>::value,
               "f has the wrong underlying type in the template");
 
 underlying_type<int>::type e; // expected-note {{requested here}}
 
 using uint = unsigned;
 enum class foo : uint { bar };
- 
 static_assert(is_same_type<underlying_type<foo>::type, unsigned>::value,
               "foo has the wrong underlying type");
 
 namespace PR19966 {
   void PR19966(enum Invalid) { // expected-note 2{{forward declaration of}}
     // expected-error@-1 {{ISO C++ forbids forward references to 'enum'}}
     // expected-error@-2 {{variable has incomplete type}}
     __underlying_type(Invalid) dont_crash;